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 new_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)) #35=D
trade.setField(fix.ClOrdID(self.genOrderID())) #11=Unique order id
trade.setField(fix.HandlInst(fix.HandlInst_MANUAL_ORDER_BEST_EXECUTION)
) #21=3 (Manual order, best executiona)
trade.setField(fix.Symbol("ethbtc")) #55=ethbtc
trade.setField(fix.Side(fix.Side_BUY)) #54=1 Buy
trade.setField(fix.OrdType(fix.OrdType_LIMIT)) #40=2 Limit order
trade.setField(fix.OrderQty(9)) #38=9
trade.setField(fix.Price(1.5)) #44=1.5
trade.setField(
fix.StringField(
60, (datetime.utcnow().strftime("%Y%m%d-%H:%M:%S.%f"))[:-3])
) #60 TransactTime, not supported in python, so use tag number
trade.setField(fix.Text("New Order")) #58 text
print(trade.toString())
try:
fix.Session.sendToTarget(trade, self.sessionID)
except (fix.ConfigError, fix.RuntimeError) as e:
print(e)
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 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 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 put_order(self):
print("Creating the following order: ")
trade = fix.Message()
trade.setField(fix.ClOrdID(self.genExecID())) # 11=Unique order
trade.setField(fix.HandlInst(fix.HandlInst_MANUAL_ORDER_BEST_EXECUTION))
trade.setField(fix.Symbol('SMBL'))
trade.setField(fix.Side(fix.Side_BUY))
trade.setField(fix.OrdType(fix.OrdType_LIMIT))
trade.setField(fix.OrderQty(100))
trade.setField(fix.Price(10))
print trade.toString()
fix.Session.sendToTarget(trade, self.sessionID)
def sendHelloWorldMessage(sessionID):
message = fix.Message()
header = message.getHeader()
header.setField(fix.BeginString("FIX.4.1"))
header.setField(fix.SenderCompID("HELLOWORLD_TRADER"))
header.setField(fix.TargetCompID("HELLOWORLD_EXCHANGE"))
header.setField(fix.MsgType(fix.MsgType_NewOrderSingle))
message.setField(fix.ClOrdID('1'))
message.setField(fix.HandlInst('1'))
message.setField(fix.Symbol('BMLL'))
message.setField(fix.Side(fix.Side_BUY))
message.setField(fix.OrdType(fix.OrdType_MARKET))
message.setField(fix.Text("Hello Exchange! How are you?"))
fix.Session.sendToTarget(message, sessionID)
def put_order(self):
print("Creating the following order: ")
trade = fix.Message()
trade.getHeader().setField(fix.BeginString(fix.BeginString_FIX50)) #
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))
print trade.toString()
fix.Session.sendToTarget(trade, self.sessionID)
def generate_message_fields(self, message_type):
message_fields = {
'client_orderID': fix.ClOrdID(),
'symbol': fix.Symbol(),
'side': fix.Side(),
'quantity': fix.OrderQty(),
}
if message_type in ['new', 'replace']:
extra_message_fields = {
'type': fix.OrdType(),
'price': fix.Price(),
'handlInst': fix.HandlInst(),
}
message_fields.update(extra_message_fields)
if message_type == 'replace':
message_fields['original_orderID'] = fix.OrigClOrdID()
return message_fields
def on_new_order(self, message):
print('New Order!')
message_fields = {
'client_orderID': fix.ClOrdID(),
'symbol': fix.Symbol(),
'type': fix.OrdType(),
'side': fix.Side(),
'quantity': fix.OrderQty(),
'price': fix.Price(),
'handlInst': fix.HandlInst(),
}
message_details = {}
for k, v in message_fields.items():
message_details[k] = self.get_field_value(message, v)
orderID = self.gen_orderID()
self.orders[orderID] = message_details
# add error checking here
# testing
self.test_replies(orderID, fix.OrdStatus_NEW, fix.ExecType_NEW,
message_details)
def on_replace_request(self, message):
print('replace!')
message_fields = {
'client_orderID': fix.ClOrdID(),
'original_clientID': fix.OrigClOrdID(),
'symbol': fix.Symbol(),
'type': fix.OrdType(),
'side': fix.Side(),
'quantity': fix.OrderQty(),
'price': fix.Price(),
'handlInst': fix.HandlInst(),
}
message_details = {}
for k, v in message_fields.items():
message_details[k] = self.get_field_value(message, v)
orderID = self.gen_orderID()
self.orders[orderID] = message_details
# testing
self.test_replies(orderID, fix.OrdStatus_PENDING_REPLACE,
fix.ExecType_REPLACE, message_details)
def order_cancel_replace(self,account,symbol,side,quantity,order_type,price):
print("Creating order_cancel_replace message... ")
cancel_replace_message = fix.Message()
cancel_replace_message.getHeader().setField(fix.BeginString(fix.BeginString_FIX42)) #
cancel_replace_message.getHeader().setField(fix.MsgType('G')) #39=D
cancel_replace_message.getHeader().setField(fix.SendingTime(1))
cancel_replace_message.setField(fix.Account(str(account))) #1
cancel_replace_message.setField(fix.HandlInst(fix.HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK)) #21=3 (Manual order), 21=2 automated execution only supported value
cancel_replace_message.setField(fix.ClOrdID(str('order_cancel_replace'+self.genOrderID()))) #11
cancel_replace_message.setField(fix.OrigClOrdID(str(self.orders[0]))) #41
cancel_replace_message.setField(fix.Symbol(str(symbol))) #55
cancel_replace_message.setField(fix.Side(str(side))) #54
cancel_replace_message.setField(fix.OrderQty(quantity)) #38
cancel_replace_message.setField(fix.OrdType(str(order_type))) #40
cancel_replace_message.setField(fix.Price(price)) #44
print('sending order_cancel_replace message...')
print(f'order_cancel_replace message: {cancel_replace_message.toString()}')
fix.Session.sendToTarget(cancel_replace_message, self.sessionID)
print('order_cancel_replace message sent!')
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 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)
header.setField(fix.BodyLength())
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)
def send_parent_order(self, setting: dict):
""""""
vt_symbol = setting["vt_symbol"]
volume = setting["volume"]
price = setting["price"]
order_type = OrderType(setting["order_type"])
direction = Direction(setting["direction"])
offset = Offset(setting["offset"])
template_name = setting["template_name"]
algo_type = template_name.replace("Genus", "")
message = new_message(fix.MsgType_NewOrderSingle)
symbol, exchange = extract_vt_symbol(vt_symbol)
genus_exchange = EXCHANGE_VT2GNS[exchange]
genus_symbol = f"{symbol}.{genus_exchange}"
side = DIRECTION_VT2GNS[direction]
genus_type = ORDERTYPE_VT2GNS[order_type]
self.parent_orderid += 1
parent_orderid = f"{template_name}_{self.parent_orderid}"
message.setField(fix.ClOrdID(parent_orderid))
message.setField(fix.HandlInst("2"))
message.setField(fix.Currency("CNY"))
message.setField(fix.ExDestination(genus_exchange))
message.setField(fix.Symbol(genus_symbol))
message.setField(fix.Side(side))
message.setField(fix.OrdType(genus_type))
message.setField(fix.OrderQty(volume))
message.setField(526, parent_orderid)
message.setField(fix.Text("vnpy"))
if order_type == OrderType.LIMIT:
message.setField(fix.Price(price))
seconds = setting["time"]
dt = datetime.now() + timedelta(seconds=seconds)
local_dt = CHINA_TZ.localize(dt)
utc_dt = local_dt.astimezone(pytz.utc)
utc_end = utc_dt.strftime("%Y%m%d-%H:%M:%S")
parameters = f"EndTime;{utc_end}"
message.setField(847, algo_type)
message.setField(848, parameters)
fix.Session.sendToTarget(message, self.session_id)
self.algo_settings[parent_orderid] = {
"symbol": genus_symbol,
"side": side,
"algo_type": algo_type
}
self.client.set_parent_offset(parent_orderid, offset)
self.client.put_parameters_event(parent_orderid, setting)
return parent_orderid
def put_order(self,security_type,symbol,currency,quantity,side,order_type,account,time_id,price=None):
if quantity != 0 :
trade = fix.Message()
'''
STANDARD MESSAGE HEADER
Required Tags: 8(BeginString) - 9(BodyLength) - 35(MsgType) - 49(SenderCompID) - 56(TargetCompID) - 34(MsgSeqNum) - 52(SendingTime)
'''
trade.getHeader().setField(fix.BeginString(fix.BeginString_FIX42)) #
trade.getHeader().setField(fix.MsgType(fix.MsgType_NewOrderSingle)) #39=D
trade.getHeader().setField(fix.SendingTime(1))
# unique_order_id = self.genExecID()
# print(f'Unique Order ID: {unique_order_id}')
# trade.setField(fix.ClOrdID(unique_order_id)) #11=Unique order
trade.setField(fix.HandlInst(fix.HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK)) #21=3 (Manual order), 21=2 automated execution only supported value
trade.setField(fix.Symbol(str(symbol))) #55
trade.setField(fix.Currency(str(currency))) #15
trade.setField(fix.SecurityType(str(security_type))) #167
trade.setField(fix.Side(str(side))) #54=1 Buy
trade.setField(fix.OrdType(str(order_type))) #40=2 Limit order, 40=1 Market
trade.setField(fix.OrderQty(quantity)) #38
if order_type != 1: #not market
trade.setField(fix.Price(price)) # if market, this tag should be absent
else:
price = None
trade.setField(fix.Account(str(account)))
trade.setField(fix.ExDestination('IDEALPRO'))
trade.setField(fix.CustomerOrFirm(0))
trade.setField(fix.ClOrdID(time_id+trade.getField(55)+trade.getField(15)+trade.getField(54))) #11=
# trade.setField(fix.ClOrdID(datetime.datetime.utcnow().strftime('%Y%m%d%H%M%S')+trade.getField(55)+trade.getField(15)+trade.getField(54))) #11=
# dnow = datetime.utcnow().strftime('%Y%m%d-%H:%M:%S')
# tag = fix.TransactTime() #default = current time, SendingTime does the same thing
# tag.setString(dnow.strftime('%Y%m%d-%H:%M:%S'))
# trade.setField(tag)
print(f'CREATING THE FOLLOWING ORDER:\n {trade.toString()}')
fix.Session.sendToTarget(trade, self.sessionID)
self.orders_dict[trade.getField(11)] = {#'id':trade.getField(11),
#'datetime': trade.getField(11)[:12],
'account':trade.getField(1),
'symbol':trade.getField(55)+'.' + trade.getField(15),
'qty':trade.getField(38),
'ord_type':trade.getField(40),
'side':trade.getField(54),
'price':price,
'status':'sent'
}
else:
print(f'QUANTITY IS 0!\nCHECK FOR STATUS OF LAST ORDER')
if os.path.exists(f'{self.write_path}fix_orders.csv'):
temp_orders = pd.read_csv(f'{self.write_path}fix_orders.csv',index_col=0)
symbol_entries = temp_orders[temp_orders['symbol'] == symbol]
last_symbol_entry = symbol_entries.iloc[-1]
new_entry = last_symbol_entry
new_id = time_id + last_symbol_entry.name[6:]
new_entry.name = new_id
temp_orders = temp_orders.append(last_symbol_entry,ignore_index=False)
temp_orders.to_csv(f'{self.write_path}fix_orders.csv',)
self.order_status_request(cl_ord_id=last_symbol_entry)
# self.order_status_request(cl_ord_id=temp_orders.index[-1])
else:
print(f'QUANTITY IS 0!\n FIX ORDERS FIRST RUN')
time.sleep(100)
