async def test_subscribe_trade_ticks(self, event_loop): # Arrange instrument_aapl = IBTestStubs.instrument(symbol="AAPL") self.data_client.instrument_provider.contract_details[ instrument_aapl.id] = IBTestStubs.contract_details("AAPL") # Act with patch.object(self.data_client, "_client") as mock: self.data_client.subscribe_trade_ticks( instrument_id=instrument_aapl.id) # Assert mock_call = mock.method_calls[0] assert mock_call[0] == "reqMktData" assert mock_call[1] == () assert mock_call[2] == { "contract": Contract( secType="STK", conId=265598, symbol="AAPL", exchange="SMART", primaryExchange="NASDAQ", currency="USD", localSymbol="AAPL", tradingClass="NMS", ), }
def test_place_order(self): # Arrange instrument = IBTestStubs.instrument("AAPL") contract_details = IBTestStubs.contract_details("AAPL") self.instrument_setup(instrument=instrument, contract_details=contract_details) order = TestExecStubs.limit_order(instrument_id=instrument.id, ) command = TestCommandStubs.submit_order_command(order=order) # Act with patch.object(self.exec_client._client, "placeOrder") as mock: self.exec_client.submit_order(command=command) # Assert expected = { "contract": Contract( secType="STK", conId=265598, symbol="AAPL", exchange="SMART", primaryExchange="NASDAQ", currency="USD", localSymbol="AAPL", tradingClass="NMS", ), "order": LimitOrder(action="BUY", totalQuantity=100.0, lmtPrice=55.0), } name, args, kwargs = mock.mock_calls[0] # Can't directly compare kwargs for some reason? assert kwargs["contract"] == expected["contract"] assert kwargs["order"].action == expected["order"].action assert kwargs["order"].totalQuantity == expected["order"].totalQuantity assert kwargs["order"].lmtPrice == expected["order"].lmtPrice
async def test_subscribe_order_book_deltas(self, event_loop): # Arrange instrument = IBTestStubs.instrument(symbol="AAPL") self.instrument_setup(instrument, IBTestStubs.contract_details("AAPL")) # Act with patch.object(self.data_client, "_client") as mock: self.data_client.subscribe_order_book_snapshots( instrument_id=instrument.id, book_type=BookType.L2_MBP) # Assert mock_call = mock.method_calls[0] assert mock_call[0] == "reqMktDepth" assert mock_call[1] == () assert mock_call[2] == { "contract": Contract( secType="STK", conId=265598, symbol="AAPL", exchange="SMART", primaryExchange="NASDAQ", currency="USD", localSymbol="AAPL", tradingClass="NMS", ), "numRows": 5, }
def test_cancel_order(self): # Arrange instrument = IBTestStubs.instrument("AAPL") contract_details = IBTestStubs.contract_details("AAPL") contract = contract_details.contract order = IBTestStubs.create_order() self.instrument_setup(instrument=instrument, contract_details=contract_details) self.exec_client._ib_insync_orders[ TestIdStubs.client_order_id()] = Trade(contract=contract, order=order) # Act command = TestCommandStubs.cancel_order_command( instrument_id=instrument.id) with patch.object(self.exec_client._client, "cancelOrder") as mock: self.exec_client.cancel_order(command=command) # Assert expected = { "contract": Contract( secType="STK", conId=265598, symbol="AAPL", exchange="SMART", primaryExchange="NASDAQ", currency="USD", localSymbol="AAPL", tradingClass="NMS", ), "order": LimitOrder(action="BUY", totalQuantity=100_000, lmtPrice=105.0), }
def generate_contract(sec_type, filename: str, **kwargs): ib = get_cached_ib_client(os.environ["TWS_USERNAME"], os.environ["TWS_PASSWORD"]) [contract ] = ib.qualifyContracts(Contract.create(secType=sec_type, **kwargs)) [details] = ib.reqContractDetails(contract=contract) with open(CONTRACT_PATH / f"{filename}.pkl".lower(), "wb") as f: f.write(pickle.dumps(details))
def lookup_futures(self, obj: List[Future]) -> List[Future]: futures = [] for o in obj: o.update(includeExpired=True) futures.append( [Contract.create(**c.contract.dict()) for c in self.ib.reqContractDetails(o)] ) return list(itertools.chain(*futures))
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
async def req_fundamental_data(instance): instance = int(instance) data = request.args.to_dict() report_type = get_and_exclude(data, 'reportType') with await IB().connectAsync(connections[instance]['host'], connections[instance]['port'], connections[instance]['client_id']) as ibi: fundamentals = ibi.reqFundamentalData(Contract(**data), report_type) ib.sleep(2) return fundamentals
async def calculate_implied_volatility(instance): instance = int(instance) data = request.args.to_dict() option_price = to_float(get_and_exclude(data, 'optionPrice')) under_price = to_float(get_and_exclude(data, 'underPrice')) with await IB().connectAsync(connections[instance]['host'], connections[instance]['port'], connections[instance]['client_id']) as ibi: volatility = ibi.calculateImpliedVolatility(Contract(**data), option_price, under_price) return volatility
async def calculate_option_price(instance): instance = int(instance) data = request.args.to_dict() volatility = to_float(get_and_exclude(data, 'volatility')) under_price = to_float(get_and_exclude(data, 'underPrice')) with await IB().connectAsync(connections[instance]['host'], connections[instance]['port'], connections[instance]['client_id']) as ibi: price = ibi.calculateOptionPrice(Contract(**data), volatility, under_price) return price
def makecontract(self, symbol, sectype, exch, curr, expiry='', strike=0.0, right='', mult=1): '''returns a contract from the parameters without check''' contract = Contract() contract.symbol = symbol contract.secType = sectype contract.exchange = exch if curr: contract.currency = curr if sectype in ['FUT', 'OPT', 'FOP']: contract.lastTradeDateOrContractMonth = expiry if sectype in ['OPT', 'FOP']: contract.strike = strike contract.right = right if mult: contract.multiplier = mult return contract
async def exercise_options(instance): instance = int(instance) data = request.args.to_dict() exercise_action = to_int(get_and_exclude(data, 'exerciseAction')) exercise_quantity = to_int(get_and_exclude(data, 'exerciseQuantity')) _account = get_and_exclude(data, 'account') _override = to_int(get_and_exclude(data, 'override')) with await IB().connectAsync(connections[instance]['host'], connections[instance]['port'], connections[instance]['client_id']) as ibi: ibi.exerciseOptions(Contract(**data), exercise_action, exercise_quantity, _account, _override) return 'OK'
def create_objects(self) -> None: self.objects = [Contract.create(**s) for s in self.symbols] self.non_futures = [ obj for obj in self.objects if not isinstance(obj, Future)] log.debug(f'non-futures: {self.non_futures}') self.futures = [obj for obj in self.objects if isinstance(obj, Future)] log.debug(f'futures: {self.futures}') # converting Futures to ContFutures self.contFutures = [] for obj in self.futures: params = obj.nonDefaults() del params['secType'] self.contFutures.append(ContFuture(**params)) log.debug(f'contfutures: {self.contFutures}')
def _add_legs_to_ib_contract(ibcontract: Contract, trade_list_for_multiple_legs: tradeQuantity, resolved_legs: list) -> ibcontractWithLegs: ratio_list = list_of_ints_with_highest_common_factor_positive_first( trade_list_for_multiple_legs ) ibcontract_legs = [ _get_ib_combo_leg(ratio, resolved_leg) for ratio, resolved_leg in zip(ratio_list, resolved_legs) ] ibcontract.comboLegs = ibcontract_legs ibcontract_with_legs = ibcontractWithLegs(ibcontract, resolved_legs) return ibcontract_with_legs
def ib_get_contract_chain(self, ibcontract_pattern: Contract, allow_expired: bool = False) -> list: """ Get all the IB contracts matching a pattern. :param ibcontract_pattern: ibContract which may not fully specify the contract :return: list of ibContracts """ ibcontract_pattern.includeExpired = allow_expired new_contract_details_list = self.ib.reqContractDetails( ibcontract_pattern) ibcontract_list = [ contract_details.contract for contract_details in new_contract_details_list] return ibcontract_list
def get_contract_data(contract_ids=()): """ Requests contract details and price (tick) data :param contract_ids: iterable of IB contract IDs :return: contract data (dict) """ contract_data = {} for con_id in contract_ids: contract_details = ib_gw.reqContractDetails(Contract(conId=con_id))[0].nonDefaults() contract = contract_details.pop('contract') contract_data[con_id] = { 'contract': contract, 'contract_details': contract_details, 'ticker': get_tickers(contract) } return contract_data
def test_update_order(self): # Arrange instrument = IBTestStubs.instrument("AAPL") contract_details = IBTestStubs.contract_details("AAPL") contract = contract_details.contract order = IBTestStubs.create_order() self.instrument_setup(instrument=instrument, contract_details=contract_details) self.exec_client._ib_insync_orders[ TestIdStubs.client_order_id()] = Trade(contract=contract, order=order) # Act command = TestCommandStubs.modify_order_command( instrument_id=instrument.id, price=Price.from_int(10), quantity=Quantity.from_str("100"), ) with patch.object(self.exec_client._client, "placeOrder") as mock: self.exec_client.modify_order(command=command) # Assert expected = { "contract": Contract( secType="STK", conId=265598, symbol="AAPL", exchange="SMART", primaryExchange="NASDAQ", currency="USD", localSymbol="AAPL", tradingClass="NMS", ), "order": LimitOrder(action="BUY", totalQuantity=100, lmtPrice=10.0), } name, args, kwargs = mock.mock_calls[0] # Can't directly compare kwargs for some reason? assert kwargs["contract"] == expected["contract"] assert kwargs["order"].action == expected["order"].action assert kwargs["order"].totalQuantity == expected["order"].totalQuantity assert kwargs["order"].lmtPrice == expected["order"].lmtPrice
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 getQualifiedContractFromConId(ib, conId, timeOutTime=10): # ib must exist and connected if not (isinstance(ib, IB) and ib.isConnected()): return (None) c = Contract(conId=conId) qcs = None try: req = ib.qualifyContractsAsync(c) qcs = ib.run(asyncio.wait_for(req, timeOutTime)) except asyncio.TimeoutError: a = (f'Timeout while requesting the qualification of contract: {c}') _logger.warn(a) except Exception as excp: pass if qcs is None or len(qcs) != 1: raise exceptions.CouldNotQualifyContract(c) else: qc = qcs[0] pass return (qc)
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 make_contract(self, **kwargs) -> Contract: return Contract.create(**kwargs)
def contract(secType="STK", symbol="AAPL", exchange="NASDAQ", **kwargs): return Contract(secType=secType, symbol=symbol, exchange=exchange, **kwargs)
def runProg(): """run program""" util.patchAsyncio() # log to a file utils.logToFile(f'getRecentHistoricalData4.log', level=logging.INFO) # utils.logToConsole() # set pandas option pd.set_option('display.width', 200) # specify connection details host = '127.0.0.1' port = 4002 ibcIni = '/home/bn/IBController/configPaper.ini' tradingMode = 'paper' clientId = 12 # start watchdog ibc = IBC(970, gateway=True, tradingMode=tradingMode, ibcIni=ibcIni) ib = IB() watchdogApp = ibcontroller.Watchdog(ibc, ib=ib,appStartupTime=15, host=host, port=port, clientId=clientId) watchdogApp.start() # create some contracts qcs = [] c = Contract(symbol='EUR',currency='CHF',exchange='IDEALPRO',secType='CASH') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='EUR',currency='CNH',exchange='IDEALPRO',secType='CASH') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='EUR',currency='GBP',exchange='IDEALPRO',secType='CASH') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='EUR', currency='JPY', exchange='IDEALPRO', secType='CASH') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='EUR', currency='RUB', exchange='IDEALPRO', secType='CASH') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='EUR', currency='USD', exchange='IDEALPRO', secType='CASH') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='IBDE30',currency='EUR',exchange='SMART',secType='CFD') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='DAX',currency='EUR',exchange='DTB',secType='IND') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='HSC50',currency='HKD',exchange='HKFE',secType='IND') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='INDU',currency='USD',exchange='CME',secType='IND') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='N225',currency='JPY',exchange='OSE.JPN',secType='IND') qc = ib.qualifyContracts(c)[0] qcs.append(qc) c = Contract(symbol='SPX',currency='USD',exchange='CBOE',secType='IND') qc = ib.qualifyContracts(c)[0] qcs.append(qc) # qcs = [qc for qc in qcs if qc.localSymbol in ['N225','EUR.USD','IBDE30','DJI']] # qcs = [qc for qc in qcs if qc.localSymbol in ['N225','DJI']] qcs = [qc for qc in qcs if qc.localSymbol in ['N225','DAX','DJI']] # function to request historical bars def requestHistoricalBars(qcs): # request historical bars barss = [] for qc in qcs: whatToShow = 'TRADES' if qc.secType == 'IND' else 'MIDPOINT' bars = ib.reqHistoricalData( qc, endDateTime='', durationStr='1 W', barSizeSetting='1 min', whatToShow=whatToShow, useRTH=False, formatDate=2, keepUpToDate=True) barss.append(bars) pass return barss barss = requestHistoricalBars(qcs) print('er', barss[0][-1]) print('er2', barss[1][-1]) print('er2', barss[2][-1]) def requestMarketData(qcs): for qc in qcs: ib.reqMktData(contract=qc, genericTickList='', snapshot=False, regulatorySnapshot=False, mktDataOptions=None) pass pass def requestRealTimeBars(qcs): barss = [] for qc in qcs: bars = ib.reqRealTimeBars(contract=qc, barSize='', whatToShow='MIDPOINT', useRTH=False, realTimeBarsOptions=None) barss.append(bars) pass return (barss) # define some callback def onBarUpdate(bars, hasNewBar): localSymbol = bars.contract.localSymbol secType = bars.contract.secType b0 = bars[0] if isinstance(b0, objects.RealTimeBar): dateTimeAttributeName = 'time' barType = 'RealTimeBar' else: dateTimeAttributeName = 'date' barType = 'BarData' pass dt0 = pd.to_datetime(getattr(b0,dateTimeAttributeName)).tz_localize(None) bm1 = bars[-1] dtm1 = pd.to_datetime(getattr(bm1,dateTimeAttributeName)).tz_localize(None) nowUTC = pd.to_datetime(pd.datetime.utcnow()).tz_localize(None) diffDateTIme = (nowUTC - dtm1) / pd.Timedelta('1 sec') if (hasNewBar or localSymbol in ['N225','DAX']): print(f'local Symbol: {localSymbol}, hasNewBar: {hasNewBar}; barType: {barType}, nBars: {len(bars)}, diffDateTime: {diffDateTIme}, close: {bm1.close}') def onPendingTickers(tickers): for t in tickers: localSymbol = t.contract.localSymbol if localSymbol == "EUR.USD": nowUTC = pd.to_datetime(pd.datetime.utcnow()).tz_localize(None) nowUTCRounded = nowUTC.floor('1 min') dateTime = pd.to_datetime(t.time).tz_localize(None) print(localSymbol, nowUTCRounded, ((dateTime - nowUTCRounded)/pd.Timedelta('1 sec')),t.close) pass pass pass def myErrorCallback(reqId, errorCode, errorString, contract): print("myErrorCallback", reqId,errorCode,errorString,contract) if False: # if errorCode == 322: print("myErrorCallback", reqId, errorCode, errorString, contract) # more than 50 simultaneous historical data requests app.ib.client.cancelHistoricalData(reqId) def onConnectedCallback(): print('connected') barss = requestHistoricalBars(qcs) # barss = requestRealTimeBars(qcs) ib.barUpdateEvent.clear() ib.barUpdateEvent += onBarUpdate print('connected 2') # requestMarketData(qcs) # ib.pendingTickersEvent.clear() # ib.pendingTickersEvent += onPendingTickers print('connected 3') pass def onDisconnectedCallback(): print ('disconnected') def myTimeoutCallback(timeout): print (f'timeout {timeout}') # request the bars barss = requestHistoricalBars(qcs) # request market data # requestMarketData(qcs) # request real time bars # requestRealTimeBars(qcs) # register the callbacks with ib ib.connectedEvent.clear() ib.connectedEvent += onConnectedCallback ib.disconnectedEvent.clear ib.disconnectedEvent = onDisconnectedCallback ib.barUpdateEvent.clear() ib.barUpdateEvent += onBarUpdate ib.pendingTickersEvent.clear() # ib.pendingTickersEvent += onPendingTickers ib.errorEvent.clear() ib.errorEvent += myErrorCallback ib.timeoutEvent.clear() ib.timeoutEvent += myTimeoutCallback def mySoftTimeoutCallback(watchdogApp): print (f'soft time out {watchdogApp}') def myHardTimeoutCallback(watchdogApp): print (f'hard time out {watchdogApp}') watchdogApp.flush() # def myStoppingCallback(sthg): # print (f'Stopping Event {sthg}') # def myStoppedCallback(sthg): # print (f'Stopped Event {sthg}') # watchdogApp.softTimeoutEvent.clear() watchdogApp.softTimeoutEvent += mySoftTimeoutCallback # watchdogApp.hardTimeoutEvent.clear() watchdogApp.hardTimeoutEvent += myHardTimeoutCallback # watchdogApp.stoppingEvent.clear() # watchdogApp.stoppingEvent += myStoppingCallback # # watchdogApp.stoppedEvent.clear() # watchdogApp.stoppedEvent += myStoppedCallback # run and never stop ib.run()
def deserialize_contract(d: Dict[str, Any]) -> Contract: return Contract(**d)
def _parse_contract(**kwargs) -> Contract: sec_type = kwargs.pop("secType", None) return Contract(secType=sec_type, **kwargs)
def fundamental_data(self, contract): """Load fundamental data from Interactive Brokers""" ib_contract = Contract(**contract) fundamental_data = self.ib_gateway.reqFundamentalData( ib_contract, reportType="ReportsFinStatements") return xmltodict.parse(fundamental_data)
def runProg(): """run program""" util.patchAsyncio() # log to a file util.logToFile(f'getRecentHistoricalData2.log') # util.logToConsole() # set pandas option pd.set_option('display.width', 200) # specify connection details host = '127.0.0.1' port = 4002 ibcIni = '/home/bn/IBController/configPaper.ini' tradingMode = 'paper' clientId = 12 # start watchdog ibc = IBC(970, gateway=True, tradingMode=tradingMode, ibcIni=ibcIni) ib = IB() watchdogApp = ibcontroller.Watchdog(ibc, ib=ib, appStartupTime=15, host=host, port=port, clientId=clientId) watchdogApp.start() pass # create some contracts qcs = [] c = Contract(symbol='EUR', currency='USD', exchange='IDEALPRO', secType='CASH') qc = ib.qualifyContracts(c)[0] qcs.append(qc) # request market data for qc in qcs: ib.reqMktData(contract=qc, genericTickList='', snapshot=False, regulatorySnapshot=False, mktDataOptions=None) pass # define some callback def onPendingTickers(tickers): for t in tickers: localSymbol = t.contract.localSymbol if localSymbol == "EUR.USD": nowUTC = pd.to_datetime(pd.datetime.utcnow()).tz_localize(None) nowUTCRounded = nowUTC.floor('1 min') dateTime = pd.to_datetime(t.time).tz_localize(None) print(localSymbol, nowUTCRounded, ((dateTime - nowUTCRounded) / pd.Timedelta('1 sec')), t.close) pass pass pass def myErrorCallback(reqId, errorCode, errorString, contract): # print("myErrorCallback", reqId,errorCode,errorString,contract) if errorCode == 322: print("myErrorCallback", reqId, errorCode, errorString, contract) # more than 50 simultaneous historical data requests app.ib.client.cancelHistoricalData(reqId) # register the callbacks with ib ib.setCallback('error', myErrorCallback) ib.setCallback('pendingTickers', onPendingTickers) # run and never stop ib.run()
def serialize_contract(contract: Contract) -> Dict[str, Any]: return cast(Dict[str, Any], contract.dict())
def findConIds(**kwargs): """prints a list of conIds for a hard-coded list of currencies""" ib = IB() ib.errorEvent += myErrorCallback clientId = kwargs.get('clientId'.lower()) ib.connect('127.0.0.1', 4002, clientId=clientId) # build a list of valid contracts # define contracts ForexStrs = [ # 'AUD', # 'CAD', 'CHF', 'CNH', 'GBP', 'JPY', 'USD', 'RUB', # 'CZK', # 'DKK', # 'HUF', # 'ILS', # 'MXN', # 'NOK', # 'NZD', # 'PLN', # 'SEK', # 'SGD', # 'TRY', # 'ZAR', ] # Indices and CFDs others = [ # { # 'secType': 'IND', # 'symbol': 'DAX', # 'exchange': 'DTB', # 'currency': 'EUR' # }, # { # 'secType': 'IND', # 'symbol': 'INDU', # 'exchange': 'CME', # 'currency': 'USD' # }, # { # 'secType': 'IND', # 'symbol': 'HSC50', # 'exchange': 'HKFE', # 'currency': 'HKD' # }, # { # 'secType': 'IND', # 'symbol': 'N225', # 'exchange': 'OSE.JPN', # 'currency': 'JPY' # }, # { # 'secType': 'IND', # 'symbol': 'SPX', # 'exchange': 'CBOE', # 'currency': 'USD' # }, { 'secType': 'CFD', 'symbol': 'IBCH20', 'exchange': 'SMART', 'currency': 'CHF' }, { 'secType': 'CFD', 'symbol': 'IBDE30', 'exchange': 'SMART', 'currency': 'EUR' }, { 'secType': 'CFD', 'symbol': 'IBEU50', 'exchange': 'SMART', 'currency': 'EUR' }, { 'secType': 'CFD', 'symbol': 'IBFR40', 'exchange': 'SMART', 'currency': 'EUR' }, { 'secType': 'CFD', 'symbol': 'IBGB100', 'exchange': 'SMART', 'currency': 'GBP' }, { 'secType': 'CFD', 'symbol': 'IBJP225', 'exchange': 'SMART', 'currency': 'JPY' }, { 'secType': 'CFD', 'symbol': 'IBHK50', 'exchange': 'SMART', 'currency': 'HKD' }, { 'secType': 'CFD', 'symbol': 'IBUS30', 'exchange': 'SMART', 'currency': 'USD' }, { 'secType': 'CFD', 'symbol': 'IBUS500', 'exchange': 'SMART', 'currency': 'USD' }, ] contractsQualified = [] # Forex for s in ForexStrs: try: contractsQualified.append( ib.qualifyContracts( Contract(secType='CASH', symbol='EUR', exchange='IDEALPRO', currency=s))[0]) pass except: print('could not qualify the contract for {}'.format(s)) pass pass # others for d in others: try: contractsQualified.append(ib.qualifyContracts(Contract(**d))[0]) pass except: print('could not qualify the contract for {}'.format(s)) pass pass # get contract information conIds = [] for c in contractsQualified: if c.secType in ['CASH', 'CFD']: whatToShow = 'MIDPOINT' else: whatToShow = 'TRADES' eDT = None try: req = ib.reqHeadTimeStampAsync(c, whatToShow=whatToShow, useRTH=False, formatDate=2) try: eDT = ib.run(asyncio.wait_for(req, 10)) except asyncio.TimeoutError: print('timeout') pass pass except: pass print(c.symbol, c.currency, c.localSymbol, c.exchange, c.conId, c.secType, eDT) # cD = ib.reqContractDetails(c)[0] # secType=cD.summary.secType # print (c.symbol, c.currency, c.localSymbol, c.exchange, c.conId, eDT, c.secType) conIds.append(c.conId) print(conIds)