def subscribe(self):
if self.marketSession is None:
self.logger.info(
"FIXSIM-CLIENT Market session is none, skip subscribing")
return
for subscription in self.subscriptions:
message = self.fixVersion.MarketDataRequest()
message.setField(quickfix.MDReqID(self.idGen.reqID()))
message.setField(
quickfix.SubscriptionRequestType(
quickfix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES))
message.setField(
quickfix.MDUpdateType(quickfix.MDUpdateType_FULL_REFRESH))
message.setField(quickfix.MarketDepth(0))
message.setField(quickfix.MDReqID(self.idGen.reqID()))
relatedSym = self.fixVersion.MarketDataRequest.NoRelatedSym()
relatedSym.setField(quickfix.Product(quickfix.Product_CURRENCY))
relatedSym.setField(
quickfix.SecurityType(
quickfix.SecurityType_FOREIGN_EXCHANGE_CONTRACT))
relatedSym.setField(quickfix.Symbol(subscription.symbol))
message.addGroup(relatedSym)
group = self.fixVersion.MarketDataRequest.NoMDEntryTypes()
group.setField(quickfix.MDEntryType(quickfix.MDEntryType_BID))
message.addGroup(group)
group.setField(quickfix.MDEntryType(quickfix.MDEntryType_BID))
message.addGroup(group)
self.sendToTarget(message, self.marketSession)
def compose_market_data_request(self):
market_data_request = quickfix44.MarketDataRequest()
market_data_request.setField(quickfix.MDReqID('1'))
market_data_request.setField(quickfix.SubscriptionRequestType(quickfix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES))
market_data_request.setField(quickfix.MarketDepth(0))
market_data_request.setField(quickfix.NoMDEntryTypes(2))
market_data_request.setField(quickfix.MDUpdateType(quickfix.MDUpdateType_INCREMENTAL_REFRESH))
group = quickfix44.MarketDataRequest().NoMDEntryTypes()
group.setField(quickfix.MDEntryType(quickfix.MDEntryType_BID))
market_data_request.addGroup(group)
group.setField(quickfix.MDEntryType(quickfix.MDEntryType_OFFER))
market_data_request.addGroup(group)
market_data_request.setField(quickfix.NoRelatedSym(self.reference_data.get_count()))
symbol = quickfix44.MarketDataRequest().NoRelatedSym()
for instrument in self.reference_data.get_instruments():
symbol.setField(quickfix.SecurityExchange(instrument.exchange))
symbol.setField(quickfix.Symbol(instrument.symbol))
market_data_request.addGroup(symbol)
return market_data_request
def on_market_data_request(self, message):
print('Market Data REQUEST!')
message_fields = {
'md_reqID': fix.MDReqID(),
'depth': fix.MarketDepth(),
'subscription_type': fix.SubscriptionRequestType(),
}
message_details = {}
for k, v in message_fields.items():
message_details[k] = self.get_field_value(message, v)
message_details['entry_types'] = {}
message_details['symbols'] = {}
n_entry_types = self.get_field_value(message, fix.NoMDEntryTypes())
group = fix44.MarketDataRequest().NoMDEntryTypes()
for i in range(n_entry_types):
message.getGroup(i + 1, group)
message_details['entry_types'][i] = self.get_field_value(
group, fix.MDEntryType())
n_symbols = self.get_field_value(message, fix.NoRelatedSym())
group = fix44.MarketDataRequest().NoRelatedSym()
for i in range(n_symbols):
message.getGroup(i + 1, group)
message_details['symbols'][i] = self.get_field_value(
group, fix.Symbol())
orderID = self.gen_orderID()
self.orders[orderID] = message_details
# testing
self.test_snaps(message_details, full=True)
self.test_snaps(message_details, full=False)
def suscribeMD(self):
print(
"SUSCRIBE MD***************************************************************************"
)
if len(self.tickers) == 0 or len(self.entries) == 0:
return
allowed_entries = ['0', '1', '2', '4', '5', '6', '7', '8', 'B', 'C']
if not all(elem in allowed_entries for elem in self.entries):
return
msg = fix50.MarketDataRequest()
header = msg.getHeader()
header.setField(fix.SenderCompID(self.usrID))
header.setField(fix.TargetCompID(self.targetCompID))
# ---------------------
msg.setField(fix.MDReqID("ListaMktData"))
msg.setField(fix.SubscriptionRequestType('1'))
msg.setField(fix.MarketDepth(1))
msg.setField(fix.MDUpdateType(0))
msg.setField(fix.AggregatedBook(True))
# BlockMDReqGrp
group = fix50.MarketDataRequest().NoMDEntryTypes()
for field in self.entries:
group.setField(fix.MDEntryType(str(field)))
msg.addGroup(group)
# Symbols
norelatedsym = fix50.MarketDataRequest().NoRelatedSym()
for ticker in self.tickers:
norelatedsym.setField(fix.Symbol(ticker))
logfix.warning("--> Suscribe Ticker >> (%s)" % ticker)
msg.addGroup(norelatedsym)
fix.Session.sendToTarget(msg)
def publishMarketData(self):
self.logger.info("FixServer: publishMarketData %s", self.subscriptions)
for subscription in self.subscriptions:
if not subscription.hasSessions():
self.logger.info(
"FixServer:No session subscribed, skip publish symbol %s",
subscription.symbol)
continue
message = self.fixVersion.MarketDataSnapshotFullRefresh()
message.setField(quickfix.Symbol(subscription.symbol))
message.setField(quickfix.MDReqID(self.idGen.reqID()))
group = self.fixVersion.MarketDataSnapshotFullRefresh(
).NoMDEntries()
subscription.createOrderBook()
for quote in subscription.orderbook:
self.logger.info('FixServer:add quote to fix message %s',
str(quote))
group.setField(quickfix.MDEntryType(quote.side))
group.setField(quickfix.MDEntryPx(quote.price))
group.setField(quickfix.MDEntrySize(quote.size))
group.setField(quickfix.QuoteEntryID(quote.id))
group.setField(quickfix.Currency(subscription.currency))
group.setField(
quickfix.QuoteCondition(
quickfix.QuoteCondition_OPEN_ACTIVE))
message.addGroup(group)
for sessionID in subscription:
self.sendToTarget(message, sessionID)
def market_data_request(self, sender_comp_id, target_comp_id, symbols):
md_types = [
fix.MDEntryType_BID, fix.MDEntryType_OFFER, fix.MDEntryType_TRADE
]
message = fix42.MarketDataRequest()
header = message.getHeader()
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
message.setField(fix.MDReqID(self._generate_id()))
message.setField(
fix.SubscriptionRequestType(
fix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES))
message.setField(fix.MarketDepth(10))
group = fix42.MarketDataRequest().NoMDEntryTypes()
for md_type in md_types:
group.setField(fix.MDEntryType(md_type))
message.addGroup(group)
group = fix42.MarketDataRequest().NoRelatedSym()
for symbol in symbols:
group.setField(fix.Symbol(symbol))
message.addGroup(group)
try:
fix.Session.sendToTarget(message)
except fix.SessionNotFound:
raise Exception(f"No session found {message}, exiting...")
def createOrderBookRequest(self):
orderBookRequest = fix44.MarketDataRequest()
noRelatedSym = fix44.MarketDataRequest.NoRelatedSym()
noRelatedSym.setField(fix.Symbol('BTC/CNY'))
orderBookRequest.addGroup(noRelatedSym)
orderBookRequest.setField(
fix.MDReqID("123")) # Unique ID assigned to this request
orderBookRequest.setField(
fix.SubscriptionRequestType('1')) # 0 = Snapshot
# 1 = Snapshot + Subscribe
# 2 Unsubscribe
orderBookRequest.setField(
fix.MDUpdateType(1)) # 0 = full refresh, 1: incremental refresh
orderBookRequest.setField(fix.MarketDepth(0)) # 0 = full book,
group1 = fix44.MarketDataRequest.NoMDEntryTypes()
group1.setField(fix.MDEntryType('0')) # bids
orderBookRequest.addGroup(group1)
group2 = fix44.MarketDataRequest.NoMDEntryTypes()
group2.setField(fix.MDEntryType('1')) # asks
orderBookRequest.addGroup(group2)
return orderBookRequest
def send_mkt_data_req(self, symbol):
"""
:param symbol: str
"""
print("send_mkt_data_req: ", symbol)
message = fix44.MarketDataRequest()
message.setField(fix.MDReqID(self.next_id()))
message.setField(
fix.SubscriptionRequestType(
fix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES))
message.setField(fix.MarketDepth(3))
message.setField(fix.MDUpdateType(
fix.MDUpdateType_INCREMENTAL_REFRESH))
symbol_group = fix44.MarketDataRequest.NoRelatedSym()
symbol_group.setField(fix.Symbol(symbol))
message.addGroup(symbol_group)
types = fix44.MarketDataRequest.NoMDEntryTypes()
types.setField(fix.MDEntryType(fix.MDEntryType_BID))
message.addGroup(types)
types = fix44.MarketDataRequest.NoMDEntryTypes()
types.setField(fix.MDEntryType(fix.MDEntryType_OFFER))
message.addGroup(types)
fix.Session_sendToTarget(message, self.sessionID)
def onLogon(self, sessionID):
self.sessionID = sessionID
print("onLogon - sessionID: " + sessionID.toString())
currency_pairs = ['GBP/USD', 'EUR/USD']
for ccy in currency_pairs:
mdr = fix.Message()
mdr.getHeader().setField(fix.BeginString(fix.BeginString_FIX44))
mdr.getHeader().setField(fix.MsgType(fix.MsgType_MarketDataRequest))
current_milli_time = lambda: int(round(time.time() * 1000))
mdr.setField(fix.MDReqID(str(current_milli_time()))) # a random string
mdr.setField(fix.SubscriptionRequestType(fix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES)) # what stater required
mdr.setField(fix.MarketDepth(1)) # what stater required
mdr.setField(fix.AggregatedBook(True))
mdr.setField(fix.NoMDEntryTypes(1)) # what stater required
mdr.setField(fix.MDUpdateType(fix.MDUpdateType_INCREMENTAL_REFRESH)) # what stater required
group = fix44.MarketDataRequest().NoMDEntryTypes()
group.setField(fix.MDEntryType(fix.MDEntryType_BID))
mdr.addGroup(group)
group.setField(fix.MDEntryType(fix.MDEntryType_OFFER))
mdr.addGroup(group)
mdr.setField(fix.NoRelatedSym(1))
symbol = fix44.MarketDataRequest().NoRelatedSym()
symbol.setField(fix.Symbol(ccy))
mdr.addGroup(symbol)
fix.Session.sendToTarget(mdr, sessionID)
def market_data_request(self, sender_comp_id, target_comp_id, symbols):
md_types = [
fix.MDEntryType_BID, fix.MDEntryType_OFFER, fix.MDEntryType_TRADE
]
message = fix44.MarketDataRequest()
header = message.getHeader()
header.setField(fix.SenderCompID(sender_comp_id))
header.setField(fix.TargetCompID(target_comp_id))
message.setField(fix.MDReqID(self._generate_id()))
message.setField(
fix.SubscriptionRequestType(
fix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES))
# message.setField(
# fix.SubscriptionRequestType(
# fix.SubscriptionRequestType_SNAPSHOT
# )
# )
"""
Valid values:
0 = Full Book
1 = Top of Book
N>1 = Report best N price tiers of data
"""
message.setField(fix.MarketDepth(0))
"""
Valid values:
0 = Full Refresh
1 = Incremental Refresh
"""
message.setField(fix.MDUpdateType(
fix.MDUpdateType_INCREMENTAL_REFRESH))
group = fix44.MarketDataRequest().NoMDEntryTypes()
for md_type in md_types:
group.setField(fix.MDEntryType(md_type))
message.addGroup(group)
group = fix44.MarketDataRequest().NoRelatedSym()
for symbol in symbols:
group.setField(fix.Symbol(symbol))
message.addGroup(group)
try:
fix.Session.sendToTarget(message)
except fix.SessionNotFound:
raise Exception(f"No session found {message}, exiting...")
def handle_market_data_respond(self, message):
"""Handles market data respond
Args:
message (FIX::Message): Market data message to be handled.
Returns:
TODO how does the return value look like
"""
# Retrieve Market Data Response Type Full Refresh/Snapshot
md_req_id_fix = fix.MDReqID()
no_md_entries_fix = fix.NoMDEntries()
symbol_fix = fix.Symbol()
total_volume_traded_fix = fix.TotalVolumeTraded()
md_entry_type_fix = fix.MDEntryType()
md_entry_px_fix = fix.MDEntryPx()
md_entry_size_fix = fix.MDEntrySize()
md_entry_date_fix = fix.MDEntryDate()
md_entry_time_fix = fix.MDEntryTime()
md_entry_type_list = []
md_entry_px_list = []
md_entry_size_list = []
md_entry_date_list = []
md_entry_time_list = []
message.getField(md_req_id_fix)
message.getField(no_md_entries_fix)
message.getField(symbol_fix)
message.getField(total_volume_traded_fix)
groupMD = fix42.MarketDataSnapshotFullRefresh.NoMDEntries()
for MDIndex in range(no_md_entries_fix.getValue()):
message.getGroup(MDIndex + 1, groupMD)
groupMD.getField(md_entry_type_fix)
groupMD.getField(md_entry_px_fix)
groupMD.getField(md_entry_size_fix)
groupMD.getField(md_entry_date_fix)
groupMD.getField(md_entry_time_fix)
md_entry_type_list.append(md_entry_type_fix.getValue())
md_entry_px_list.append(md_entry_px_fix.getValue())
md_entry_size_list.append(md_entry_size_fix.getValue())
md_entry_date_list.append(TradingClass.FIXDate.from_fix_date_stamp_string(md_entry_date_fix.getString()))
md_entry_time_list.append(TradingClass.FIXTime.from_fix_time_stamp_string(md_entry_time_fix.getString()))
# Encapsulate data into market data response object
market_data = TradingClass.MarketDataResponse(md_req_id_fix.getValue(), no_md_entries_fix.getValue(),
symbol_fix.getValue()
, md_entry_type_list, md_entry_px_list, md_entry_size_list,
md_entry_date_list,
md_entry_time_list, total_volume_traded_fix.getValue())
self.client_logic.process_market_data_respond(market_data)
pass
def main():
sessionID = fix.SessionID('FIX.4.4', SENDERCOMPID, 'PAYMIUM')
params = fix.Dictionary()
params.setString('ConnectionType', 'initiator')
params.setString('StartTime', '00:00:00')
params.setString('EndTime', '00:00:00')
params.setString('HeartBtInt', '30')
params.setString('CheckLatency', 'Y')
params.setString('SocketConnectHost', '195.154.171.115')
params.setString('SocketConnectPort', '8359')
params.setString('DataDictionary', FIX44FILE)
params.setString('EncryptMethod', '0')
settings = fix.SessionSettings()
settings.set(sessionID, params)
application = MyApplication()
factory = fix.FileStoreFactory("store")
acceptor = fix.SocketInitiator(application, factory, settings,
fix.ScreenLogFactory(DEBUG, DEBUG, DEBUG))
acceptor.start()
time.sleep(2)
mdr = fixMsg.MarketDataRequest()
mdr.setField(fix.MDReqID("MDRQ-%d" % (time.time() * 1000000)))
# We want the full book here, not just the top
mdr.setField(fix.MarketDepth(1))
# We want to get a snapshot and also subscribe to the market depth updates
mdr.setField(
fix.SubscriptionRequestType(
fix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES))
# We'll want only incremental refreshes when new data is available
mdr.setField(fix.MDUpdateType(fix.MDUpdateType_INCREMENTAL_REFRESH))
# Specify the currency
instruments = fixMsg.MarketDataRequest().NoRelatedSym()
instruments.setField(fix.Symbol("EUR/XBT"))
mdr.addGroup(instruments)
# Specify that we'll want the bids and asks
mdr.setField(fix.NoMDEntryTypes(2))
group = fixMsg.MarketDataRequest().NoMDEntryTypes()
group.setField(fix.MDEntryType(fix.MDEntryType_BID))
group.setField(fix.MDEntryType(fix.MDEntryType_OFFER))
mdr.addGroup(group)
fix.Session.sendToTarget(mdr, sessionID)
while True:
time.sleep(10)
acceptor.stop()
def createLiveTradesRequest(self):
liveTradesRequest = fix44.MarketDataRequest()
noRelatedSym = fix44.MarketDataRequest.NoRelatedSym()
noRelatedSym.setField(fix.Symbol("BTC/CNY"))
liveTradesRequest.addGroup(noRelatedSym)
liveTradesRequest.setField(fix.MDReqID("123"))
liveTradesRequest.setField(fix.SubscriptionRequestType('1'))
liveTradesRequest.setField(fix.MarketDepth(0))
group = fix44.MarketDataRequest.NoMDEntryTypes()
group.setField(fix.MDEntryType('2')) # trade
liveTradesRequest.addGroup(group)
return liveTradesRequest
def send_MarketDataRequest(self, symbol='EURUSD'):
# If no symbols provided, exit with error.
if len(symbol) is 0:
raise RuntimeError('No symbol specified for MarketDataRequest')
reqid = self.app.check_new_symbol(
symbol) # fffff: ok to reference it here?
self.app.add_symbol_to_positions(symbol)
# Create new message of type MarketDataRequest
message = fix.Message()
header = message.getHeader()
# Set message type to MarketDataRequest (35=V)
header.setField(fix.MsgType(fix.MsgType_MarketDataRequest))
# Assign request ID (262)
header.setField(fix.MDReqID(str(reqid)))
# Set Subscription Request Type (263) to SNAPSHOT + UPDATES (1)
header.setField(
fix.SubscriptionRequestType(
fix.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES))
# Set MDUpdateType (required when SubscribtionRequestType is S+U)
header.setField(fix.MDUpdateType(fix.MDUpdateType_INCREMENTAL_REFRESH))
# Set market depth (264)
header.setField(fix.MarketDepth(0)) # 0 = full book, 1 = top of book
# Create NoRelatedSym group (to place 146=1 before Symbol)
group = fix44.MarketDataRequest.NoRelatedSym()
group.setField(fix.Symbol(symbol))
message.addGroup(group)
# Set Currency (15). not really needed?
# message.setField(fix.Currency(_currency))
# Send message to Counter-Party and await response.
if self.sessionID_Quote is not None:
fix.Session.sendToTarget(message, self.sessionID_Quote)
else:
print(
'[ERROR] send_MassQuoteAcknowledgement() failed. sessionID_Quote is None!'
)
def market_data_request(self):
request = fix44.MarketDataRequest()
request.setField(fix.MDReqID(self.gen_mdReqID()))
request.setField(fix.MarketDepth(0))
request.setField(fix.SubscriptionRequestType('0'))
group = fix44.MarketDataRequest().NoMDEntryTypes()
group.setField(fix.MDEntryType('0'))
request.addGroup(group)
group.setField(fix.MDEntryType('1'))
request.addGroup(group)
group = fix44.MarketDataRequest().NoRelatedSym()
group.setField(fix.Symbol('SNAP'))
request.addGroup(group)
fix.Session.sendToTarget(request, self.sessionID)
def GetMarketData(self):
message = fix.Message()
header = message.getHeader()
header.setField(fix.MsgType(fix.MsgType_MarketDataRequest))
noRelatedSym = fix44.MarketDataRequest().NoRelatedSym()
noRelatedSym.setField(fix.Symbol('XBTCNY'))
message.addGroup(noRelatedSym)
message.setField(fix.NoRelatedSym(1))
message.setField(fix.MDReqID('1'))
message.setField(fix.SubscriptionRequestType('0'))
message.setField(fix.MarketDepth(10))
group = fix44.MarketDataRequest().NoMDEntryTypes()
group.setField(fix.MDEntryType('0'))
message.addGroup(group)
group.setField(fix.MDEntryType('1'))
message.addGroup(group)
group.setField(fix.MDEntryType('2'))
message.addGroup(group)
group.setField(fix.MDEntryType('3'))
message.addGroup(group)
group.setField(fix.MDEntryType('4'))
message.addGroup(group)
group.setField(fix.MDEntryType('5'))
message.addGroup(group)
group.setField(fix.MDEntryType('6'))
message.addGroup(group)
group.setField(fix.MDEntryType('7'))
message.addGroup(group)
group.setField(fix.MDEntryType('8'))
message.addGroup(group)
group.setField(fix.MDEntryType('9'))
message.addGroup(group)
group.setField(fix.MDEntryType('A'))
message.addGroup(group)
group.setField(fix.MDEntryType('B'))
message.addGroup(group)
group.setField(fix.MDEntryType('C'))
message.addGroup(group)
fix.Session.sendToTarget(message, self.sessionID)
def send_market_data_request(self, symbol):
"""Sends a market data request to server
Args:
symbol (string): the ticker symbol of a stock
Returns:
"""
# Create Fix Message for Market Data Request
message = fix.Message();
header = message.getHeader();
header.setField(fix.MsgType(fix.MsgType_MarketDataRequest))
header.setField(fix.SendingTime())
message.setField(fix.MDReqID(str(self.client_database_handler.generate_market_data_request_id())))
message.setField(fix.SubscriptionRequestType(fix.SubscriptionRequestType_SNAPSHOT))
message.setField(fix.MarketDepth(1))
message.setField(fix.NoMDEntryTypes(10))
group_md_entry = fix42.MarketDataRequest().NoMDEntryTypes()
group_md_entry.setField(fix.MDEntryType(fix.MDEntryType_BID))
message.addGroup(group_md_entry)
group_md_entry.setField(fix.MDEntryType(fix.MDEntryType_OFFER))
message.addGroup(group_md_entry)
group_md_entry.setField(fix.MDEntryType(fix.MDEntryType_TRADE))
message.addGroup(group_md_entry)
group_md_entry.setField(fix.MDEntryType(fix.MDEntryType_OPENING_PRICE))
message.addGroup(group_md_entry)
group_md_entry.setField(fix.MDEntryType(fix.MDEntryType_CLOSING_PRICE))
message.addGroup(group_md_entry)
group_md_entry.setField(fix.MDEntryType(fix.MDEntryType_TRADING_SESSION_HIGH_PRICE))
message.addGroup(group_md_entry)
group_md_entry.setField(fix.MDEntryType(fix.MDEntryType_TRADING_SESSION_LOW_PRICE))
message.addGroup(group_md_entry)
group_symbol = fix42.MarketDataRequest().NoRelatedSym()
group_symbol.setField(fix.Symbol(symbol))
message.addGroup(group_symbol)
# Send Fix Message to Server
fix.Session.sendToTarget(message, self.fix_application.sessionID)
return
def onMarketDataRequest(self, message, sessionID):
requestID = quickfix.MDReqID()
try:
message.getField(requestID)
except Exception as e:
raise quickfix.IncorrectTagValue(requestID)
try:
relatedSym = self.fixVersion.MarketDataRequest.NoRelatedSym()
symbolFix = quickfix.Symbol()
product = quickfix.Product()
message.getGroup(1, relatedSym)
relatedSym.getField(symbolFix)
relatedSym.getField(product)
if product.getValue() != quickfix.Product_CURRENCY:
self.sendMarketDataReject(
requestID,
" product.getValue() != quickfix.Product_CURRENCY:",
sessionID)
return
# bid
entryType = self.fixVersion.MarketDataRequest.NoMDEntryTypes()
message.getGroup(1, entryType)
# ask
message.getGroup(2, entryType)
symbol = symbolFix.getValue()
subscription = self.subscriptions.get(symbol)
if subscription is None:
self.sendMarketDataReject(requestID,
"Unknown symbol: %s" % str(symbol),
sessionID)
return
subscription.addSession(sessionID)
except Exception as e:
print e, e.args
self.sendMarketDataReject(requestID, str(e), sessionID)
def marketDataRequest(self):
# pag 63
msg = fix50.MarketDataRequest()
header = msg.getHeader()
# header.setField(fix.BeginString(fix.BeginString_FIXT11))
# header.setField(fix.MsgType(msgType))
header.setField(fix.SenderCompID("pjseoane232"))
header.setField(fix.TargetCompID("ROFX"))
# msg = self.buildMsgHeader("V")
msg.setField(fix.MDReqID("ListaMktData2"))
msg.setField(fix.SubscriptionRequestType('2'))
msg.setField(fix.MarketDepth(1))
msg.setField(fix.MDUpdateType(0))
msg.setField(fix.AggregatedBook(True))
# msg.setField(fix.NoMDEntryTypes(2))
# ---- define Group
group = fix50.MarketDataRequest().NoMDEntryTypes()
group.setField(fix.MDEntryType('0'))
msg.addGroup(group)
# group = fix50.MarketDataRequest().NoMDEntryTypes()
group.setField(fix.MDEntryType('1'))
msg.addGroup(group)
# group3 = fix50.MarketDataRequest().NoMDEntryTypes()
# group3.setField(fix.MDEntryType('2'))
# msg.addGroup(group3)
# -----------------------------------------
msg.setField(fix.NoRelatedSym(1))
group = fix50.MarketDataRequest().NoRelatedSym()
group.setField(fix.Symbol("RFX20Sep19"))
msg.addGroup(group)
fix.Session.sendToTarget(msg)
def send_market_data_incremental(self, md_update_list, md_reqID=None):
increment = fix44.MarketDataIncrementalRefresh()
if md_reqID:
increment.setField(fix.MDReqID(md_reqID))
group = fix44.MarketDataIncrementalRefresh().NoMDEntries()
group_fields = {
'default': {
fix.MDEntryID: 'md_entryID',
fix.MDEntryRefID: 'md_entryRefID',
fix.Symbol: 'symbol',
fix.MDUpdateAction: 'update_action',
},
'action_specific': {
0: {
fix.MDEntryType: 'entry_type',
fix.MDEntryPx: 'price',
fix.MDEntrySize: 'quantity',
},
1: {
fix.MDEntryType: 'entry_type',
fix.MDEntryPx: 'price',
fix.MDEntrySize: 'quantity',
},
2: {
fix.DeleteReason: 'delete_reason',
},
},
}
for i in range(len(md_update_list)):
updates = md_update_list[i]
for k, v in group_fields['default'].items():
group.setField(k(updates[v]))
update_action = updates['update_action']
for k, v in group_fields['action_specific'][update_action].items():
group.setField(k(updates[v]))
increment.addGroup(group)
fix.Session.sendToTarget(increment, self.sessionID)
return increment
def marketDataRequest(self, ticker, subscription_type):
mdr = fix.Message()
mdr.getHeader().setField(fix.BeginString(fix.BeginString_FIX44))
mdr.getHeader().setField(fix.MsgType(fix.MsgType_MarketDataRequest))
group = fix44.MarketDataRequest().NoRelatedSym()
group.setField(fix.Symbol(ticker))
mdr.addGroup(group)
mdr.setField(fix.MDReqID('1'))
mdr.setField(fix.SubscriptionRequestType(subscription_type))
mdr.setField(fix.MarketDepth(0))
mdr.setField(fix.NoMDEntryTypes(3))
group = fix44.MarketDataRequest().NoMDEntryTypes()
group.setField(fix.MDEntryType(fix.MDEntryType_BID))
mdr.addGroup(group)
group.setField(fix.MDEntryType(fix.MDEntryType_OFFER))
mdr.addGroup(group)
group.setField(fix.MDEntryType(fix.MDEntryType_TRADE))
mdr.addGroup(group)
fix.Session.sendToTarget(mdr, self.sessionID)
return
def send_market_snapshot_full(self,
md_order_list,
symbol=None,
md_reqID=None):
snapshot = fix44.MarketDataSnapshotFullRefresh()
if md_reqID:
snapshot.setField(fix.MDReqID(md_reqID))
if symbol:
snapshot.setField(fix.Symbol(symbol))
group = fix44.MarketDataSnapshotFullRefresh().NoMDEntries()
group_fields = {
fix.MDEntryType: 'entry_type',
fix.MDEntryPx: 'price',
fix.Currency: 'currency',
fix.MDEntrySize: 'quantity',
fix.OrderID: 'orderID',
}
for i in range(len(md_order_list)):
data = md_order_list[i]
for k, v in group_fields.items():
group.setField(k(data[v]))
snapshot.addGroup(group)
fix.Session.sendToTarget(snapshot, self.sessionID)
return snapshot
