async def positions(instance):
instance = int(instance)
with await IB().connectAsync(connections[instance]['host'],
connections[instance]['port'],
connections[instance]['client_id']) as ibi:
_positions = ibi.positions()
resp = json.dumps(util.tree(_positions))
return resp
async def open_trades(instance):
instance = int(instance)
with await IB().connectAsync(connections[instance]['host'],
connections[instance]['port'],
connections[instance]['client_id']) as ibi:
_trades = ibi.openTrades()
resp = json.dumps(util.tree(_trades))
return resp
async def summary_for_account(instance, account):
instance = int(instance)
with await IB().connectAsync(connections[instance]['host'],
connections[instance]['port'],
connections[instance]['client_id']) as ibi:
_summary = ibi.accountValues(account)
resp = json.dumps(util.tree(_summary))
return resp
async def completed_orders(instance):
instance = int(instance)
with await IB().connectAsync(connections[instance]['host'],
connections[instance]['port'],
connections[instance]['client_id']) as ibi:
_orders = ibi.reqCompletedOrders(False)
resp = json.dumps(util.tree(_orders))
return resp
async def pnl_for_account(instance, account):
instance = int(instance)
with await IB().connectAsync(connections[instance]['host'],
connections[instance]['port'],
connections[instance]['client_id']) as ibi:
pnl = ibi.reqPnL(account)
await ibi.pnlEvent
resp = json.dumps(util.tree(pnl))
return resp
async def pnl(instance):
instance = int(instance)
with await IB().connectAsync(connections[instance]['host'],
connections[instance]['port'],
connections[instance]['client_id']) as ibi:
acct = ibi.managedAccounts()[0]
pnl = ibi.reqPnL(acct)
await ibi.pnlEvent
resp = json.dumps(util.tree(pnl))
return resp
async def req_mkt_data(instance):
instance = int(instance)
data = request.args.to_dict()
with await IB().connectAsync(connections[instance]['host'],
connections[instance]['port'],
connections[instance]['client_id']) as ibi:
ticker = ibi.reqMktData(Contract(**data))
ib.sleep(2)
resp = json.dumps(util.tree(ticker))
return resp
def order_values(self, order_id):
price = 0
commission = 0
if len(self.ib.fills()) > 0:
for trade in util.tree(self.ib.fills()):
if ('OrderId' and 'clientId') in trade[1]['Execution']:
if ((nested_lookup('orderId',trade)[0] == order_id) and (nested_lookup('clientId',trade)[0] == self.client)):
commission = nested_lookup('commission',trade)[0]
price = nested_lookup('price',trade)[0]
return (price, commission)
async def main():
print('Running testbed.py')
ib = IB()
with await ib.connectAsync(host=os.getenv('IB_GATEWAY_URLNAME', 'tws'),
port=int(os.getenv('IB_GATEWAY_URLPORT',
'4004')),
clientId=int(
os.getenv('EFP_CLIENT_ID',
(5 + random.randint(0, 4)))),
timeout=15,
readonly=True):
portfolio = util.tree(ib.portfolio())
tg.outbound("Test successful.")
return portfolio
async def req_historical_ticks(instance):
instance = int(instance)
data = request.args.to_dict()
start_date_time = get_and_exclude(data, 'startDateTime')
end_date_time = get_and_exclude(data, 'endDateTime')
number_of_ticks = to_int(get_and_exclude(data, 'numberOfTicks'))
what_to_show = get_and_exclude(data, 'whatToShow')
use_rth = bool(get_and_exclude(data, 'useRTH'))
ignore_size = bool(get_and_exclude(data, 'ignoreSize'))
with await IB().connectAsync(connections[instance]['host'],
connections[instance]['port'],
connections[instance]['client_id']) as ibi:
_tickers = ibi.reqHistoricalTicks(Contract(**data), start_date_time,
end_date_time, number_of_ticks,
what_to_show, use_rth, ignore_size)
ib.sleep(2)
resp = json.dumps(util.tree(_tickers))
return resp
def onPendingTickers(tickers):
ticks = []
for t in tickers:
encodedTick = json.dumps(util.tree(t))
ticks.append({"Data": encodedTick})
firehose.put_record_batch(DeliveryStreamName=firehoseStream, Records=ticks)
def main(ib_gw, trading_mode):
# query config
config = db.collection('config').document(trading_mode).get().to_dict()
# activity log for Firestore
activity_log = {
'agent': K_REVISION,
'config': config,
'exception': None,
'tradingMode': trading_mode
}
main_e = None
try:
# log open orders/trades
activity_log['openOrders'] = [{
'contract':
t.contract.nonDefaults(),
'orderStatus':
t.orderStatus.nonDefaults()
} for t in ib_gw.trades()]
# reconcile trades
fills = []
for fill in ib_gw.fills():
contract_id = fill.contract.conId
order_doc = db.collection('positions').document(
trading_mode).collection('openOrders').document(
str(fill.execution.permId))
order = order_doc.get().to_dict()
# update holdings if fully executed
side = 1 if fill.execution.side == 'BOT' else -1
if order is not None and side * fill.execution.cumQty == sum(
order['source'].values()):
fills.append({
'contract':
fill.contract.nonDefaults(),
'execution':
util.tree(fill.execution.nonDefaults())
})
for strategy, quantity in order['source'].items():
holdings_doc = db.collection('positions').document(
trading_mode).collection('holdings').document(strategy)
holdings = holdings_doc.get().to_dict() or {}
position = holdings.get(str(contract_id), 0)
with db.transaction() as tx:
action = tx.update if holdings_doc.get(
).exists else tx.create
action(
holdings_doc, {
str(contract_id):
position + quantity or firestore.DELETE_FIELD
})
tx.delete(order_doc)
activity_log['fills'] = fills
# double-check with IB portfolio
ib_portfolio = ib_gw.portfolio()
portfolio = {
item.contract.conId: item.position
for item in ib_portfolio
}
activity_log['portfolio'] = {
item.contract.localSymbol: item.position
for item in ib_portfolio
}
holdings = [
doc.to_dict() for doc in db.collection('positions').document(
trading_mode).collection('holdings').stream()
]
holdings_consolidated = {}
for h in holdings:
for k, v in h.items():
k = int(k)
if k in holdings_consolidated:
holdings_consolidated[k] += v
else:
holdings_consolidated[k] = v
activity_log['consolidatedHoldings'] = {
ib_gw.reqContractDetails(
Contract(conId=k))[0].contract.localSymbol: v
for k, v in holdings_consolidated.items()
}
assert portfolio == holdings_consolidated, 'Holdings in Firestore do not match the ones in IB portfolio!'
except Exception as e:
logging.error(e)
activity_log['exception'] = str(e)
main_e = e
finally:
try:
activity_log['timestamp'] = datetime.now(timezone.utc)
db.collection('activity').document().set(activity_log)
except Exception as e:
logging.error(e)
logging.info(activity_log)
if main_e is not None:
# raise main exception so that main.py returns 500 response
raise main_e
logging.info('Done.')
return {**activity_log, 'timestamp': activity_log['timestamp'].isoformat()}
def OptionChainToJson(c: OptionChain) -> str:
o = util.tree(c)
return json.dumps(o)
def StockToJson(s: Stock) -> str:
o = util.tree(s)
return json.dumps(o)