def cancel(self, message, sessionID):
symbol = fix.Symbol()
side = fix.Side()
orderQty = fix.OrderQty()
clOrdID = fix.ClOrdID()
org = fix.OrigClOrdID()
message.getField(symbol)
message.getField(side)
message.getField(orderQty)
message.getField(clOrdID)
message.getField(org)
log.info("cancel:\nsymbol:{},side:{},orderQty:{},clOrdID:{},org:{} -----"\
.format(symbol, side, orderQty, clOrdID, org))
cancel = fix44.OrderCancelReject()
cancel.setField(clOrdID)
cancel.setField(fix.OrderID(self.genOrderID()))
cancel.setField(fix.OrdStatus(fix.OrdStatus_NEW))
cancel.setField(fix.OrigClOrdID(org.getValue()))
cancel.setField(fix.Text('order completed'))
cancel.setField(fix.TransactTime())
cancel.setField(fix.CxlRejReason(fix.CxlRejReason_BROKER))
cancel.setField(
fix.CxlRejResponseTo(fix.CxlRejResponseTo_ORDER_CANCEL_REQUEST))
fix.Session.sendToTarget(cancel, sessionID)
def queryNewOrderSingle42(self):
ordType = fix.OrdType()
message = fix.Message()
message.setField(self.queryClOrdID())
message.setField(fix.HandlInst('1'))
message.setField(self.querySymbol())
message.setField(self.querySide())
message.setField(fix.TransactTime())
ordType = self.queryOrdType()
message.setField(ordType)
message.setField(self.queryOrderQty())
message.setField(self.queryTimeInForce())
if abc.getValue() == fix.OrdType_LIMIT or abc.getValue(
) == fix.OrdType_STOP_LIMIT:
message.setField(self.queryPrice())
if abc.getValue() == fix.OrdType_STOP or abc.getValue(
) == fix.OrdType_STOP_LIMIT:
message.setField(self.queryStopPx())
header = message.getHeader()
self.queryHeader(header)
newOrderSingle = fix42.NewOrderSingle(message)
return newOrderSingle
def newOrderSingle(self):
try:
LOG_EVENT("New Order Single")
orderMsg = fix.Message()
orderMsg.getHeader().setField(self.sessionID.getBeginString())
orderMsg.getHeader().setField(
fix.MsgType(fix.MsgType_NewOrderSingle))
orderMsg.getHeader().setField(self.sessionID.getSenderCompID())
orderMsg.getHeader().setField(self.sessionID.getTargetCompID())
orderMsg.getHeader().setField(fix.MsgSeqNum(self.genOrderID()))
sendingTime = fix.SendingTime()
sendingTime.setString(
datetime.utcnow().strftime("%Y%m%d-%H:%M:%S.%f"))
orderMsg.getHeader().setField(sendingTime)
orderMsg.setField(fix.Account("17018382"))
orderMsg.setField(fix.ClOrdID(self.genExecID()))
orderMsg.setField(fix.OrderQty(100))
orderMsg.setField(fix.OrdType(fix.TriggerOrderType_LIMIT))
orderMsg.setField(fix.Price(1.216))
orderMsg.setField(fix.Symbol("X.US.OREURUSD"))
orderMsg.setField(fix.Side(fix.Side_BUY))
tranactionTime = fix.TransactTime()
tranactionTime.setString(
datetime.utcnow().strftime("%Y%m%d-%H:%M:%S.%f"))
orderMsg.setField(tranactionTime)
orderMsg.setField(fix.OpenClose(fix.OpenClose_OPEN))
LOG_PACKET(orderMsg.toString())
fix.Session.sendToTarget(orderMsg, self.sessionID)
except Exception as e:
print(e)
def __init__(self, symbol, maturity, qty):
super(FutureOrder, self).__init__()
self.CFICode = fix.CFICode('FXXXXS')
self.Symbol = fix.Symbol(symbol)
self.Maturity = fix.MaturityMonthYear(maturity)
self.Quantity = fix.OrderQty(qty)
self.TransactionTime = fix.TransactTime()
def cancel_order(self, execution_report):
message = quickfix44.OrderCancelRequest()
orig_cl_ord_id = quickfix.OrigClOrdID()
order_id = quickfix.OrderID()
symbol_field = quickfix.Symbol()
security_exchange_field = quickfix.SecurityExchange()
execution_report.getField(symbol_field)
execution_report.getField(security_exchange_field)
execution_report.getField(order_id)
orig_cl_ord_id.setValue(order_id.getValue())
message.setField(symbol_field)
message.setField(security_exchange_field)
message.setField(orig_cl_ord_id)
message.setField(quickfix.ClOrdID(self.genExecID()))
side = quickfix.Side()
execution_report.getField(side)
message.setField(side)
trstime = quickfix.TransactTime()
trstime.setString(
datetime.utcnow().strftime("%Y%m%d-%H:%M:%S.%f")[:-3])
message.setField(trstime)
quickfix.Session.sendToTarget(message, self.sessionID)
def makeOrder(self, snapshot):
self.logger.info("FIXSIM-CLIENT Snapshot received %s", str(snapshot))
quote = snapshot.getRandomQuote()
self.logger.info("FIXSIM-CLIENT make order for quote %s", str(quote))
order = self.fixVersion.NewOrderSingle()
order.setField(
quickfix.HandlInst(
quickfix.
HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK
))
order.setField(
quickfix.SecurityType(
quickfix.SecurityType_FOREIGN_EXCHANGE_CONTRACT))
order.setField(quickfix.OrdType(quickfix.OrdType_PREVIOUSLY_QUOTED))
order.setField(quickfix.ClOrdID(self.idGen.orderID()))
order.setField(quickfix.QuoteID(quote.id))
order.setField(quickfix.SecurityDesc("SPOT"))
order.setField(quickfix.Symbol(snapshot.symbol))
order.setField(quickfix.Currency(quote.currency))
order.setField(quickfix.Side(quote.side))
order.setField(quickfix.OrderQty(quote.size))
order.setField(quickfix.FutSettDate("SP"))
order.setField(quickfix.Price(quote.price))
order.setField(quickfix.TransactTime())
order.setField(
quickfix.TimeInForce(quickfix.TimeInForce_IMMEDIATE_OR_CANCEL))
self.sendToTarget(order, self.orderSession)
def put_new_order(self, instrument, side, price, size):
"""Request sample new order single"""
message = quickfix44.NewOrderSingle()
header = message.getHeader()
print("Executing : " + str(instrument) + ":" + str(side) + ":" +
str(price) + ":" + str(size))
message.setField(quickfix.ClOrdID(self.genExecID()))
message.setField(quickfix.Side(side))
message.setField(quickfix.Symbol(instrument.symbol))
message.setField(quickfix.SecurityExchange(instrument.exchange))
message.setField(quickfix.OrderQty(size))
message.setField(quickfix.Price(int(price)))
message.setField(quickfix.OrdType(quickfix.OrdType_LIMIT))
message.setField(quickfix.TimeInForce('0'))
message.setField(quickfix.Text("NewOrderSingle"))
trstime = quickfix.TransactTime()
trstime.setString(
datetime.utcnow().strftime("%Y%m%d-%H:%M:%S.%f")[:-3])
message.setField(trstime)
msg = message.toString().replace(__SOH__, "|")
print("New Order Single: " + msg)
quickfix.Session.sendToTarget(message, self.sessionID)
def new_order(sender_comp_id, target_comp_id, symbol, quantity, price, side,
order_type):
if side.lower() == "buy":
side = fix.Side_BUY
else:
side = fix.Side_SELL
message = Message()
header = message.getHeader()
header.setField(fix.BeginString("FIX.4.2"))
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
header.setField(fix.MsgType("D"))
ord_id = get_order_id(sender_comp_id, symbol)
message.setField(fix.ClOrdID(ord_id))
message.setField(fix.Symbol(symbol))
message.setField(fix.Side(side))
message.setField(fix.Price(float(price)))
if order_type.lower() == "market":
message.setField(fix.OrdType(fix.OrdType_MARKET))
else:
message.setField(fix.OrdType(fix.OrdType_LIMIT))
message.setField(fix.HandlInst(fix.HandlInst_MANUAL_ORDER_BEST_EXECUTION))
message.setField(fix.TransactTime())
message.setField(fix.OrderQty(float(quantity)))
message.setField(fix.Text(f"{side} {symbol} {quantity}@{price}"))
return message
def sendOrder(self, ticker, side, type, px, qty):
nos = fix.Message()
nos.getHeader().setField(fix.BeginString(fix.BeginString_FIX44))
nos.getHeader().setField(fix.MsgType(fix.MsgType_NewOrderSingle))
symbol = fix.Symbol(ticker)
nos.setField(symbol)
if side == "BUY":
side = fix.Side(fix.Side_BUY)
if side == "SELL":
side = fix.Side(fix.Side_SELL)
nos.setField(side)
if type == "MARKET":
ordType = fix.OrdType(fix.OrdType_MARKET)
px = fix.Price(0)
if type == "LIMIT":
ordType = fix.OrdType(fix.OrdType_MARKET)
px = fix.Price(px)
nos.setField(ordType)
nos.setField(px)
orderQty = fix.OrderQty(qty)
clOrdID = fix.ClOrdID(self.genOrderID())
nos.setField(orderQty)
nos.setField(clOrdID)
TimeInForce = fix.TimeInForce(fix.TimeInForce_GOOD_TILL_CANCEL)
TransactTime = fix.TransactTime()
nos.setField(TimeInForce)
nos.setField(TransactTime)
fix.Session.sendToTarget(nos, self.sessionID)
def queryNewOrderSingle44(self):
ordType = fix.OrdType()
message = fix44.NewOrderSingle()
message.setField(self.queryClOrdID())
message.setField(fix.HandlInst('1'))
message.setField(self.querySymbol())
message.setField(self.querySide())
message.setField(fix.TransactTime())
ordType = self.queryOrdType()
message.setField(ordType)
message.setField(self.queryOrderQty())
message.setField(self.queryTimeInForce())
message.setField(self.querySecurityExchange())
message.setField(self.queryAccount())
if ordType.getValue() == fix.OrdType_LIMIT or ordType.getValue(
) == fix.OrdType_STOP_LIMIT:
message.setField(self.queryPrice())
if ordType.getValue() == fix.OrdType_STOP or ordType.getValue(
) == fix.OrdType_STOP_LIMIT:
message.setField(self.queryStopPx())
header = message.getHeader()
self.queryHeader(header)
return message
def start_new_message(self, msg_type):
new_message = fix.Message()
message_fields = [
fix.BeginString(fix.BeginString_FIX44),
fix.MsgType(msg_type),
fix.TransactTime()
]
for field in message_fields:
new_message.getHeader().setField(field)
return new_message
def fromApp(self, message, sessionID): beginString = fix.BeginString() msgType = fix.MsgType() message.getHeader().getField( beginString ) message.getHeader().getField( msgType ) symbol = fix.Symbol() side = fix.Side() ordType = fix.OrdType() orderQty = fix.OrderQty() price = fix.Price() clOrdID = fix.ClOrdID() message.getField( ordType ) if ordType.getValue() != fix.OrdType_LIMIT: raise fix.IncorrectTagValue( ordType.getField() ) message.getField( symbol ) message.getField( side ) message.getField( orderQty ) message.getField( price ) message.getField( clOrdID ) executionReport = fix.Message() executionReport.getHeader().setField( beginString ) executionReport.getHeader().setField( fix.MsgType(fix.MsgType_ExecutionReport) ) executionReport.setField( fix.OrderID(str(self.genOrderID())) ) executionReport.setField( fix.ExecID(str(self.genExecID())) ) executionReport.setField( fix.OrdStatus(fix.OrdStatus_FILLED) ) executionReport.setField( symbol ) executionReport.setField( side ) executionReport.setField( fix.CumQty(orderQty.getValue()) ) executionReport.setField( fix.AvgPx(price.getValue()) ) executionReport.setField( fix.LastShares(orderQty.getValue()) ) executionReport.setField( fix.LastPx(price.getValue()) ) executionReport.setField( clOrdID ) executionReport.setField( orderQty ) executionReport.setField( message.getField( price )) executionReport.setField( fix.TransactTime() ) if beginString.getValue() == fix.BeginString_FIX40 or beginString.getValue() == fix.BeginString_FIX41 or beginString.getValue() == fix.BeginString_FIX42: executionReport.setField( fix.ExecTransType(fix.ExecTransType_NEW) ) if beginString.getValue() >= fix.BeginString_FIX41: executionReport.setField( fix.ExecType(fix.ExecType_FILL) ) executionReport.setField( fix.LeavesQty(0) ) time.sleep(5) try: fix.Session.sendToTarget( executionReport, sessionID ) except SessionNotFound as e: return
def msgtofix_quote(quote_msg):
"""
Converte Quote (message) para Quote (fix).
"""
quoterequest_msg, quoterequest_fix = get_quoterequest(quote_msg.QuoteReqID)
quote = fix44.Quote()
quote.reverseRoute(quoterequest_fix.getHeader())
if quoterequest_msg.SecurityType == messages.EnumSecurityType.SPOT:
set_field(quote, fix.SecurityType, "FXSPOT")
elif quoterequest_msg.SecurityType == messages.EnumSecurityType.NDF:
set_field(quote, fix.SecurityType, "FXNDF")
set_field(quote, fix.QuoteReqID, quote_msg.QuoteReqID)
set_field(quote, fix.QuoteID, quote_msg.QuoteID)
set_field(quote, fix.OfferPx, quote_msg.OfferPx)
set_field(quote, fix.OfferSpotRate, quote_msg.OfferSpotRate)
set_field(quote, fix.BidPx, quote_msg.BidPx)
set_field(quote, fix.BidSpotRate, quote_msg.BidSpotRate)
set_field(quote, fix.QuoteCondition, "A")
quote.setField(5082, "2")
set_field(quote, fix.Symbol, quoterequest_fix.getField(fix.Symbol().getField()))
set_field(quote, fix.Account, quoterequest_fix.getField(fix.Account().getField()))
copy_field(quoterequest_fix, quote, fix.FutSettDate)
copy_field(quoterequest_fix, quote, fix.FutSettDate2)
copy_field(quoterequest_fix, quote, 6215)
copy_field(quoterequest_fix, quote, 6216)
transact_time = fix.TransactTime()
time_str = get_utc_time().strftime("%Y%m%d-%H:%M:%S.%f")[:-3]
transact_time.setString(time_str)
quote.setField(transact_time)
quote_msg.TransactTime = time_str
if quoterequest_msg.SecurityType == messages.EnumSecurityType.NDF:
copy_field(quoterequest_fix, quote, fix.OrdType)
copy_field(quoterequest_fix, quote, fix.TradeDate)
copy_field(quoterequest_fix, quote, fix.SettlCurrency)
copy_field(quoterequest_fix, quote, 5974) # FixingSource
copy_field(quoterequest_fix, quote, 6203) # FixingDate
taker_side = str(quoterequest_fix.getField(fix.Side().getField()))
if taker_side == '1':
set_field(quote, fix.OfferForwardPoints, quote_msg.Details.get('forward_points'))
elif taker_side == '2':
set_field(quote, fix.BidForwardPoints, quote_msg.Details.get('forward_points'))
return quote
def test_order(self):
cid = fix.ClOrdID('100')
requestTime = fix.TransactTime()
requestTime.setString('20170606-03:52:34.924')
request = fix44.NewOrderSingle()
request.setField(requestTime)
request.setField(cid)
responseTime = fix.TransactTime()
responseTime.setString('20170606-03:52:14.824')
response = fix44.ExecutionReport()
response.setField(responseTime)
response.setField(cid)
currentLag = {}
def receive(event):
currentLag[0] = event.CurrentTimeLag
self.Store.addTimeLagListener(receive)
self.Store.addRequest(request)
self.Store.addResponse(response)
self.assertEqual(currentLag[0], 20.1)
def replace_order(sender_comp_id, target_comp_id, quantity, price,
orig_client_order_id):
symbol = ORDERS[orig_client_order_id][0].getValue()
side = ORDERS[orig_client_order_id][3].getValue()
message = fix42.OrderCancelReplaceRequest()
header = message.getHeader()
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
ord_id = get_order_id(sender_comp_id, symbol)
message.setField(fix.OrigClOrdID(orig_client_order_id))
message.setField(fix.ClOrdID(ord_id))
message.setField(fix.Symbol(symbol))
message.setField(fix.Side(side))
message.setField(fix.Price(float(price)))
message.setField(fix.OrdType(fix.OrdType_LIMIT))
message.setField(fix.HandlInst(fix.HandlInst_MANUAL_ORDER_BEST_EXECUTION))
message.setField(fix.TransactTime())
message.setField(fix.TransactTime())
message.setField(fix.OrderQty(float(quantity)))
message.setField(fix.Text(f"{side} {symbol} {quantity}@{price}"))
return message
def msgtofix_execreport(execreport_msg):
"""
Converte ExecReport (message) para ExecReport (fix).
"""
_, newordersingle_fix = get_newordersingle(execreport_msg.ClOrderID)
execreport_fix = fix44.ExecutionReport()
execreport_fix.reverseRoute(newordersingle_fix.getHeader())
set_field(execreport_fix, fix.ExecID, execreport_msg.ExecID)
set_field(execreport_fix, fix.OrderID, execreport_msg.OrderID)
if execreport_msg.Type == messages.ExecReportType.ACCEPT:
set_field(execreport_fix, fix.ExecType, "2")
set_field(execreport_fix, fix.OrdStatus, "2")
else:
set_field(execreport_fix, fix.ExecType, "8")
set_field(execreport_fix, fix.OrdStatus, "8")
set_field(execreport_fix, fix.ExecTransType, "0")
set_field(execreport_fix, fix.LeavesQty, 0)
copy_field(newordersingle_fix, execreport_fix, fix.Price, fix.AvgPx)
copy_field(newordersingle_fix, execreport_fix, fix.OrderQty, fix.CumQty)
transact_time = fix.TransactTime()
time_str = get_utc_time().strftime("%Y%m%d-%H:%M:%S.%f")[:-3]
transact_time.setString(time_str)
execreport_fix.setField(transact_time)
execreport_msg.TransactTime = time_str
def copy(field):
copy_field(newordersingle_fix, execreport_fix, field)
copy(fix.SecurityType)
copy(fix.ClOrdID)
copy(fix.Account)
copy(fix.Symbol)
copy(fix.OrderQty)
copy(fix.Price)
copy(fix.Side)
copy(fix.Currency)
copy(fix.LastSpotRate)
copy(fix.FutSettDate)
copy(fix.FutSettDate2)
copy(6215) # TenorValue
copy(6216) # TenorValue2
return execreport_fix
def startFIXString(self, orderID):
message = quickfix.Message()
message.getHeader().setField(quickfix.BeginString(quickfix.BeginString_FIX42))
message.getHeader().setField(quickfix.MsgType(quickfix.MsgType_ExecutionReport))
message.getHeader().setField(quickfix.SendingTime())
message.getHeader().setField(quickfix.TransactTime())
message.setField(quickfix.ClOrdID(self.orders[orderID]['clOrdID']))
message.setField(quickfix.OrderQty(self.orders[orderID]['quantity']))
message.setField(quickfix.Symbol(self.orders[orderID]['symbol']))
message.setField(quickfix.Side(self.orders[orderID]['side']))
message.setField(quickfix.ExecID(str(self.getNextExecID(self.orders[orderID]['target']))))
if 'exchangeID' not in self.orders[orderID]:
self.orders[orderID]['exchangeID'] = self.getNextExchangeID(self.orders[orderID]['target'])
message.setField(quickfix.OrderID(str(self.orders[orderID]['exchangeID'])))
return message
def new_order(self, message, beginString, sessionID):
symbol = fix.Symbol()
side = fix.Side()
ordType = fix.OrdType()
orderQty = fix.OrderQty()
price = fix.Price(50)
clOrdID = fix.ClOrdID()
message.getField(ordType)
message.getField(symbol)
message.getField(side)
message.getField(orderQty)
message.getField(price)
message.getField(clOrdID)
log.info("new_order:\nordType:{},symbol:{},side:{},orderQty:{},price:{},clOrdID:{} -----"\
.format(ordType, symbol, side, orderQty, price, clOrdID))
executionReport = fix.Message()
executionReport.getHeader().setField(beginString)
executionReport.getHeader().setField(
fix.MsgType(fix.MsgType_ExecutionReport))
executionReport.setField(fix.TransactTime())
executionReport.setField(fix.OrderID(self.genOrderID()))
executionReport.setField(fix.ExecID(self.genExecID()))
executionReport.setField(fix.OrdStatus(fix.OrdStatus_NEW))
executionReport.setField(symbol)
executionReport.setField(side)
executionReport.setField(fix.CumQty(orderQty.getValue()))
executionReport.setField(fix.AvgPx(price.getValue()))
executionReport.setField(fix.LastShares(orderQty.getValue()))
executionReport.setField(fix.LastPx(price.getValue()))
executionReport.setField(clOrdID)
executionReport.setField(orderQty)
executionReport.setField(fix.ExecType(fix.ExecType_NEW))
executionReport.setField(fix.LeavesQty(orderQty.getValue()))
try:
fix.Session.sendToTarget(executionReport, sessionID)
time.sleep(1)
if ordType.getValue() == fix.OrdType_MARKET:
executionReport.setField(fix.OrdStatus(fix.OrdStatus_FILLED))
executionReport.setField(fix.ExecType(fix.ExecType_TRADE))
fix.Session.sendToTarget(executionReport, sessionID)
except fix.SessionNotFound as e:
return
def delete_order(sender_comp_id, target_comp_id, orig_client_order_id):
symbol = ORDERS[orig_client_order_id][0].getValue()
side = ORDERS[orig_client_order_id][3].getValue()
message = fix44.OrderCancelRequest()
header = message.getHeader()
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
ord_id = get_order_id(sender_comp_id, symbol)
message.setField(fix.OrigClOrdID(orig_client_order_id))
message.setField(fix.ClOrdID(ord_id))
message.setField(fix.Symbol(symbol))
message.setField(fix.Side(side))
message.setField(fix.TransactTime())
message.setField(fix.Text(f"Delete {orig_client_order_id}"))
return message
def requestForPositions(self):
clrDate = datetime.now().strftime("%Y%m%d")
inqId = self.SocketInitiator.application.genInquiryID()
account = self.SocketInitiator.application.Settings.get().getString(
'Account')
message = fix44.RequestForPositions()
message.setField(fix.Account(account))
message.setField(fix.TransactTime())
message.setField(
fix.AccountType(
fix.AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS))
message.setField(fix.ClearingBusinessDate(clrDate))
message.setField(fix.PosReqType(fix.PosReqType_POSITIONS))
message.setField(fix.PosReqID(inqId))
self.SocketInitiator.application.send(message)
return inqId
def __uncorkValue(message):
msgType = fix.MsgType()
message.getHeader().getField(msgType)
val = msgType.getValue()
if val == fix.MsgType_Logon or val == fix.MsgType_Logout or val == fix.MsgType_Heartbeat:
sndTime = fix.SendingTime()
message.getHeader().getField(sndTime)
return sndTime.getString()
if val == fix.MsgType_NewOrderSingle or val == fix.MsgType_ExecutionReport \
or val == fix.MsgType_OrderCancelRequest or val == fix.MsgType_OrderCancelReject:
transTime = fix.TransactTime()
message.getField(transTime)
return transTime.getString()
if val == fix.MsgType_CollateralInquiry or val == fix.MsgType_CollateralReport \
or val == fix.MsgType_RequestForPositions or val == fix.MsgType_PositionReport \
or val == fix.MsgType_RequestForPositionsAck:
return datetime.now().strftime("%Y%m%d-%H:%M:%S")
return None
def put_order(self):
print("Creating the following order: ")
trade = fix.Message()
trade.getHeader().setField(fix.BeginString(fix.BeginString_FIX42)) #
trade.getHeader().setField(fix.MsgType(
fix.MsgType_NewOrderSingle)) #39=D
trade.setField(fix.ClOrdID(self.genExecID())) #11=Unique order
trade.setField(fix.HandlInst(fix.HandlInst_MANUAL_ORDER_BEST_EXECUTION)
) #21=3 (Manual order, best executiona)
trade.setField(fix.Symbol('SMBL')) #55=SMBL ?
trade.setField(fix.Side(fix.Side_BUY)) #43=1 Buy
trade.setField(fix.OrdType(fix.OrdType_LIMIT)) #40=2 Limit order
trade.setField(fix.OrderQty(100)) #38=100
trade.setField(fix.Price(10))
trade.setField(fix.TransactTime(int(datetime.utcnow().strftime("%s"))))
print(trade.toString())
fix.Session.sendToTarget(trade, self.sessionID)
def queryEnterOrder(self):
print("\nTradeCaptureReport (AE)\n")
trade = fix.Message()
trade.getHeader().setField(fix.BeginString(fix.BeginString_FIX44))
trade.getHeader().setField(fix.MsgType(fix.MsgType_TradeCaptureReport))
trade.setField(fix.TradeReportTransType(
fix.TradeReportTransType_NEW)) # 487
trade.setField(fix.TradeReportID(self.genTradeReportID())) # 571
trade.setField(fix.TrdSubType(4)) # 829
trade.setField(fix.SecondaryTrdType(2)) # 855
trade.setField(fix.Symbol("MYSYMBOL")) # 55
trade.setField(fix.LastQty(22)) # 32
trade.setField(fix.LastPx(21.12)) # 31
trade.setField(fix.TradeDate(
(datetime.now().strftime("%Y%m%d")))) # 75
trade.setField(
fix.TransactTime(
(datetime.now().strftime("%Y%m%d-%H:%M:%S.%f"))[:-3])) # 60
trade.setField(fix.PreviouslyReported(False)) # 570
group = fix44.TradeCaptureReport().NoSides()
group.setField(fix.Side(fix.Side_SELL)) # 54
group.setField(fix.OrderID(self.genOrderID())) # 37
group.setField(fix.NoPartyIDs(1)) # 453
group.setField(
fix.PartyIDSource(
fix.PartyIDSource_PROPRIETARY_CUSTOM_CODE)) # 447
group.setField(fix.PartyID("CLEARING")) # 448
group.setField(fix.PartyRole(fix.PartyRole_CLEARING_ACCOUNT)) # 452
trade.addGroup(group)
group.setField(fix.Side(fix.Side_BUY)) # 54
group.setField(fix.OrderID(self.genOrderID())) # 37
group.setField(fix.NoPartyIDs(1)) # 453
group.setField(
fix.PartyIDSource(
fix.PartyIDSource_PROPRIETARY_CUSTOM_CODE)) # 447
group.setField(fix.PartyID("CLEARING")) # 448
group.setField(fix.PartyRole(fix.PartyRole_CLEARING_ACCOUNT)) # 452
trade.addGroup(group)
fix.Session.sendToTarget(trade, self.sessionID)
def cancel(self, trade):
orderId = self.SocketInitiator.application.genOrderID()
account = self.SocketInitiator.application.Settings.get().getString(
'Account')
cancel = fix44.OrderCancelRequest()
cancel.setField(fix.Account(account))
cancel.setField(fix.ClOrdID(orderId))
cancel.setField(fix.OrigClOrdID(trade.OrderId))
cancel.setField(trade.CFICode)
cancel.setField(fix.TransactTime())
cancel.setField(fix.OrderQty(trade.Quantity))
cancel.setField(
fix.Side(fix.Side_BUY if trade.OrderSide ==
OrderSide.Buy else fix.Side_SELL))
cancel.setField(fix.Symbol(trade.Symbol))
cancel.setField(fix.MaturityMonthYear(trade.Maturity))
self.SocketInitiator.application.send(cancel)
def send_order_cancel_request(self, order_cancel_request):
"""
Args:
order_cancel_request (TradingClass.OrderCancelRequest)
Returns:
None
"""
# Create Fix Message for Order Cancel Request
message = fix.Message()
header = message.getHeader()
header.setField(fix.MsgType(fix.MsgType_OrderCancelRequest))
transact_time_fix = fix.TransactTime()
transact_time_fix.setString(order_cancel_request.transact_time.__str__())
message.setField(fix.OrigClOrdID(order_cancel_request.orig_cl_ord_id))
message.setField(fix.ClOrdID(order_cancel_request.cl_ord_id))
message.setField(fix.Symbol(order_cancel_request.symbol))
message.setField(fix.Side(order_cancel_request.side))
message.setField(transact_time_fix)
message.setField(fix.OrderQty(order_cancel_request.order_qty))
# Send Fix Message to Server
fix.Session.sendToTarget(message, self.fix_application.sessionID)
def put_new_order(self):
"""Request sample new order single"""
message = fix.Message()
header = message.getHeader()
header.setField(fix.MsgType(fix.MsgType_NewOrderSingle)) #39 = D
message.setField(fix.ClOrdID(
self.genExecID())) #11 = Unique Sequence Number
message.setField(fix.Side(fix.Side_BUY)) #43 = 1 BUY
message.setField(fix.Symbol("MSFT")) #55 = MSFT
message.setField(fix.OrderQty(10000)) #38 = 1000
message.setField(fix.Price(100))
message.setField(fix.OrdType(fix.OrdType_LIMIT)) #40=2 Limit Order
message.setField(
fix.HandlInst(fix.HandlInst_MANUAL_ORDER_BEST_EXECUTION)) #21 = 3
message.setField(fix.TimeInForce('0'))
message.setField(fix.Text("NewOrderSingle"))
trstime = fix.TransactTime()
trstime.setString(
datetime.utcnow().strftime("%Y%m%d-%H:%M:%S.%f")[:-3])
message.setField(trstime)
fix.Session.sendToTarget(message, self.sessionID)
def test_setString(self):
strGood = "8=FIX.4.2\0019=45\00135=0\00134=3\00149=TW\00152=20000426-12:05:06\00156=ISLD\00110=218\001"
strNull = "8=FIX.4.2\0019=46\00135=0\00134=3\00149=TW\00152=20000426-12:05:06\00156=ISLD\000\00110=219\001"
strTrailingCharacter = "8=FIX.4.2\0019=45\00135=0\00134=3\00149=TW\00152=20000426-12:05:06\00156=ISLD\00110=218\001 "
strNoChk = "8=FIX.4.2\0019=45\00135=0\00134=3\00149=TW\00152=20000426-12:05:06\00156=ISLD\001"
strBadChk = "8=FIX.4.2\0019=45\00135=0\00134=3\00149=TW\00152=20000426-12:05:06\00156=ISLD\00110=000\001"
strBad = "8=FIX.4.2\0019=45\00135=0\00134=3\00149garbled=TW\00152=20000426-12:05:06\00156=ISLD\00110=000\001"
strBadHeaderOrder = "8=FIX.4.2\00135=0\0019=45\00134=3\00149=TW\00152=20000426-12:05:06\00156=ISLD\00110=218\001"
strBodyFields = "8=FIX.4.2\0019=60\00135=D\00111=ORDERID\00121=3\00140=2\00154=1\00155=MSFT\00160=19000101-00:00:00\00110=226\001"
strNoLengthAndChk = "8=FIX.4.2\00135=0\00134=3\00149=TW\00152=20000426-12:05:06\00156=ISLD\001";
strJunk = "paste your FIX message here, then hit ENTER"
strEmpty = ""
try:
self.object.setString( strGood )
self.object.setString( strNull )
self.object.setString( strNoLengthAndChk, False )
except fix.InvalidMessage as e:
self.assertTrue( 0 )
try:
self.object.setString( strTrailingCharacter )
self.assertTrue(0)
except fix.InvalidMessage as e:
self.assertTrue(1)
try:
self.object.setString( strNoChk )
self.assertTrue(0)
except fix.InvalidMessage as e:
self.assertTrue(1)
try:
self.object.setString( strBadChk )
self.assertTrue(0)
except fix.InvalidMessage as e:
self.assertTrue(1)
try:
self.object.setString( strBad )
self.assertTrue(0)
except fix.InvalidMessage as e:
self.assertTrue(1)
try:
self.object.setString( strBadHeaderOrder )
self.assertTrue(0)
except fix.InvalidMessage as e:
self.assertTrue(1)
try:
self.object.setString( strNoLengthAndChk )
self.assertTrue(0)
except fix.InvalidMessage as e:
self.assertTrue(1)
try:
self.object.setString( strJunk )
self.assertTrue(0)
except fix.InvalidMessage as e:
self.assertTrue(1)
try:
self.object.setString( strEmpty )
self.assertTrue(0)
except fix.InvalidMessage as e:
self.assertTrue(1)
dataDictionary = fix.DataDictionary()
dataDictionary.addHeaderField( 11, False )
dataDictionary.addTrailerField( 60, False )
clOrdID = fix.ClOrdID()
transactTime = fix.TransactTime()
symbol = fix.Symbol()
try:
self.object.setString( strBodyFields, True, dataDictionary )
except fix.InvalidMessage as e:
self.assertTrue( 0 )
assert( self.object.getHeader().isSetField( clOrdID ) )
assert( self.object.getTrailer().isSetField( transactTime ) )
assert( self.object.isSetField( symbol ) )
header.setField(fix.MsgType(fix.MsgType_NewOrderSingle))
header.setField(fix.SendingTime())
header.setField(fix.SenderSubID("SG1"))
header.setField(fix.TargetSubID("BARCA"))
header.setField(fix.MsgSeqNum())
header.setField(fix.DefaultApplVerID(fix.ApplVerID_FIX42))
message.setField(fix.ClOrdID("ClOrdID"))
message.setField(
fix.AccountType(
fix.
AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_BOOKS))
message.setField(fix.Symbol("APPL"))
message.setField(
fix.HandlInst(
fix.
HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION
))
message.setField(fix.ReceivedDeptID("I"))
message.setField(fix.Side(fix.Side_BUY))
message.setField(fix.TransactTime())
message.setField(fix.OrderQty(1000))
message.setField(fix.OrdType(fix.OrdType_MARKET))
message.setField(fix.Price(2000))
trailer.setField(fix.CheckSum())
application.send(message)
message_flag = False
except (fix.ConfigError, fix.RuntimeError) as e:
print(e)
# Send an order
m = fix44.NewOrderSingle()
m.setField(fix.ClOrdID(str(uuid.uuid4())))
m.setField(fix.SecurityID('25'))
m.setField(
fix.SecurityIDSource(
fix.SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER))
m.setField(fix.Side(fix.Side_BUY))
m.setField(fix.OrderQty(0.01))
m.setField(fix.Price(123))
m.setField(fix.OrdType(fix.OrdType_LIMIT))
# Python QuickFIX UtcTimeStampField doesn't accept a `datetime` object, we
# provide an easy helper function for you
t = fix.TransactTime()
t.setString(easyfix.fix_utctimestamp(datetime.datetime.utcnow()))
m.setField(t)
fix.Session.sendToTarget(m, app.session_id)
# Some sort of main loop
while m := app.incoming_messages.get():
# Get field(s) by name
#
# Note that this does not consider repeating group hierarchies and dump
# all fields matching the tag of the name
print(app.get_fields_by_name(m, 'MsgType'))
print(app.get_fields_by_name(m, 'Symbol'))
# Get "nicely" formatted FIX message dump. Enums are automatically converted to descriptions
#
def _process_execution_report(self, message):
cl_ord_id = self._extract_field(fix.ClOrdID(), message)
exec_type = self._extract_field(fix.ExecType(), message)
market_order_id = self._extract_optional_field(fix.OrderID(), message)
order = self.order_store.find_order(cl_ord_id, market_order_id)
# We only update the market order if it's changed
self.order_store.store_market_order_id(market_order_id, order.order_id)
order.order_id = self.order_store.find_order_id(cl_ord_id)
if exec_type == fix.ExecType_NEW:
order.status = OrdStatus.NEW
self.order_handler.on_new_ack(order)
elif exec_type == fix.ExecType_DONE_FOR_DAY:
pass
elif exec_type == fix.ExecType_CANCELED:
order.status = OrdStatus.CANCELED
self.order_handler.on_cancel_ack(order)
elif exec_type == fix.ExecType_REPLACE:
order.status = OrdStatus.REPLACED
self.order_handler.on_replace_ack(order)
elif exec_type == fix.ExecType_PENDING_CANCEL:
self.log.info(
'Received pending cancel for order [order id: {}]'.format(
order.order_id))
elif exec_type == fix.ExecType_STOPPED:
pass
elif exec_type == fix.ExecType_REJECTED:
ord_rej_reason = self._extract_field(fix.OrdRejReason(), message)
self.log.error('Submission rejected, ({}) {}'.format(
OrdRejReason[ord_rej_reason], ord_rej_reason))
order.status = OrdStatus.NEW_REJECT
self.order_handler.on_new_rej(order)
elif exec_type == fix.ExecType_SUSPENDED:
pass
elif exec_type == fix.ExecType_PENDING_NEW:
self.log.info(
'Received pending new for order [order id: {}]'.format(
order.order_id))
elif exec_type == fix.ExecType_CALCULATED:
pass
elif exec_type == fix.ExecType_EXPIRED:
pass
elif exec_type == fix.ExecType_RESTATED:
pass
elif exec_type == fix.ExecType_PENDING_REPLACE:
self.log.info(
'Received pending replace for order [order id: {}]'.format(
order.order_id))
elif exec_type == fix.ExecType_TRADE:
exec_id = self._extract_field(fix.ExecID(), message)
transact_time = self._extract_date_field(fix.TransactTime(),
message)
remaining_qty = self._extract_field(fix.LeavesQty(), message)
executed_qty = self._extract_field(fix.CumQty(), message)
last_qty = self._extract_field(fix.LastQty(), message)
last_px = self._extract_field(fix.LastPx(), message)
order.executed_qty = executed_qty
execution = Execution(order.order_id)
execution.exec_id = exec_id
execution.transact_time = transact_time
execution.last_price = last_px
execution.last_qty = last_qty
if remaining_qty == 0:
order.status = OrdStatus.FULLY_FILLED
else:
order.status = OrdStatus.PARTIALLY_FILLED
self.order_store.store_exec_id(exec_id, execution)
self.order_handler.on_execution(order, execution)
elif exec_type == fix.ExecType_TRADE_CORRECT:
pass
elif exec_type == fix.ExecType_TRADE_CANCEL:
pass
elif exec_type == fix.ExecType_ORDER_STATUS:
pass
else:
self.log.error('Unknown execType: {}'.format(exec_type))
