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)