def ib_futures_instrument( futures_instrument_with_ib_data: futuresInstrumentWithIBConfigData): """ Get an IB contract which is NOT specific to a contract date Used for getting expiry chains :param futures_instrument_with_ib_data: instrument with .metadata suitable for IB :return: IBcontract """ ib_data = futures_instrument_with_ib_data.ib_data ibcontract = Future(ib_data.symbol, exchange=ib_data.exchange) if ib_data.ibMultiplier is NOT_REQUIRED_FOR_IB: pass else: ibcontract.multiplier = int(ib_data.ibMultiplier) if ib_data.currency is NOT_REQUIRED_FOR_IB: pass else: ibcontract.currency = ib_data.currency return ibcontract
def get_contract(self): if self.market == 'futures': expiration = self.ib.reqContractDetails(Future(self.symbol,self.exchange))[0].contract.lastTradeDateOrContractMonth self.contract = Future(symbol=self.symbol, exchange=self.exchange, lastTradeDateOrContractMonth=expiration) elif self.market == 'forex': self.contract = Forex(self.symbol) elif self.market == 'stocks': self.contract = Stock(symbol=self.symbol, exchange=self.exchange, currency='USD')
def c_order(self, buy_sell): '''click buy button''' if self.check_login(): return prod = self.box_product.currentText()[0:3] prodM = self.box_month.currentText()[0:6] price = self.box_price.value() qty = self.box_qty.value() hsi = Future(prod, prodM) if web_trade.ib.qualifyContracts(hsi): if buy_sell == 'B': order = LimitOrder('BUY', qty, price, outsideRth=self.c_t1.isChecked(), orderRef=f"PY_{self.pwd_id[-1]}") else: order = LimitOrder('SELL', qty, price, outsideRth=self.c_t1.isChecked(), orderRef=f"PY_{self.pwd_id[-1]}") web_trade.ib.placeOrder(hsi, order) print("%s%s %d@%d" % (prod, prodM, qty if buy_sell == 'B' else -qty, price)) if web_trade.status == 2: w.statusBar().showMessage(web_trade.error)
def __init__(self): self.ib = IB() self.ib.connect('127.0.0.1', 7497, clientId=np.random.randint(10, 1000)) self.tickers_ret = {} self.endDateTime = '' self.No_days = '43200 S' self.interval = '30 secs' self.tickers_signal = "Hold" self.ES = Future(symbol='ES', lastTradeDateOrContractMonth='20200619', exchange='GLOBEX', currency='USD') self.ib.qualifyContracts(self.ES) self.ES_df = self.ib.reqHistoricalData(contract=self.ES, endDateTime=self.endDateTime, durationStr=self.No_days, barSizeSetting=self.interval, whatToShow='TRADES', useRTH=False, keepUpToDate=True) self.tickers_ret = [] self.options_ret = [] self.option = {'call': FuturesOption, 'put': FuturesOption} self.options_history = {} self.trade_options = {'call': [], 'put': []} self.price = 0 self.i = -1 self.ES_df.updateEvent += self.make_clean_df self.Buy = True self.Sell = False self.ib.positionEvent += self.order_verify self.waitTimeInSeconds = 120 self.tradeTime = 0
def get_contracts(ib_gw, series, n): contract_years = [str(datetime.now().year + i)[-1] for i in range(2)] contract_symbols = [ series + m + y for y in contract_years for m in CONTRACT_SPECS[series]['months'] ] logging.info( 'Requesting contract details for {}...'.format(contract_symbols)) contract_details = {} for symbol in contract_symbols: cd = ib_gw.reqContractDetails( Future(localSymbol=symbol, exchange=CONTRACT_SPECS[series]['exchange'], currency=CONTRACT_SPECS[series]['currency'])) contract_details[symbol] = cd[0].contract if len(cd) > 0 else None contracts = { k: v for k, v in contract_details.items() if v is not None and v.lastTradeDateOrContractMonth > (datetime.now() + timedelta(days=6)).strftime('%Y%m%d') } return [ contracts[k] for k in [k for k in contract_symbols if k in contracts.keys()][:n] ]
def c_stop(self, buy_sell): if self.check_login(): return prod = self.box_product.currentText()[0:3] prodM = self.box_month.currentText()[0:6] qty = self.box_qty.value() stop_price = self.box_stop_price.value() stop_type = self.box_stop_type.currentText()[0:1] addon = self.box_add2.value() # print(prod, prodM, qty, stop_price, stop_type, addon) hsi = Future(prod, prodM) if web_trade.ib.qualifyContracts(hsi): if buy_sell == 'B': order = StopLimitOrder('BUY', qty, stop_price + addon, stop_price, outsideRth=self.c_t1.isChecked(), orderRef=f"PY_{self.pwd_id[-1]}") else: order = StopLimitOrder('SELL', qty, stop_price - addon, stop_price, outsideRth=self.c_t1.isChecked(), orderRef=f"PY_{self.pwd_id[-1]}") web_trade.ib.placeOrder(hsi, order) if web_trade.status == 2: w.statusBar().showMessage(web_trade.error)
def cb_close1(self): if self.check_login(): return getLots = self.box_lot2.value() if getLots == 0: return Lots, Price = self.calc_close() if Lots is None or Price is None: return prod = self.set1['合约'] web_trade.ib.waitOnUpdate(0.1) able_lots = web_trade.get_lots('LMT') if prod not in able_lots or able_lots[prod] == 0: return if abs(Lots) > abs(able_lots[prod]): Lots = able_lots[prod] # prod_code=prod[0:3] # prod_month=prod[3:5] # web_trade.orderdata['prod_code'] = prod_code # web_trade.orderdata['contract_mth'] = prod_month lotsList = self.getList(abs(int(Lots))) # print(getLots,prod,Lots,Price,lotsList,self.c_close1.isChecked()) hsi = Future(localSymbol=prod) if web_trade.ib.qualifyContracts(hsi): if Lots > 0: for x in lotsList: # web_trade.order_buy(Price, x, prod_code=prod_code) zy, thereAre = self.zszyGroup('zy') order = LimitOrder('BUY', x, Price, ocaGroup=zy, ocaType=2, outsideRth=self.c_close1.isChecked(), orderRef=f"PY_{self.pwd_id[-1]}") web_trade.ib.placeOrder(hsi, order) print("%s %d@%d" % (prod, x, Price)) else: for x in lotsList: # web_trade.order_sell(Price, x, prod_code=prod_code) zy, thereAre = self.zszyGroup('zy') order = LimitOrder('SELL', x, Price, ocaGroup=zy, ocaType=2, outsideRth=self.c_close1.isChecked(), orderRef=f"PY_{self.pwd_id[-1]}") web_trade.ib.placeOrder(hsi, order) print("%s -%d@%d" % (prod, x, Price)) self.box_lot2.setValue(0) self.c_orderlist()
def c_gostop(self): if self.check_login(): return getLots = self.box_lot1.value() if getLots == 0: return Lots, StopPrice = self.calc_stop() if Lots is None or StopPrice is None: return addon = self.box_add.value() prod = self.set1['合约'] web_trade.ib.waitOnUpdate(0.1) able_lots = web_trade.get_lots('STP LMT') if prod not in able_lots or able_lots[prod] == 0: return if abs(Lots) > abs(able_lots[prod]): Lots = able_lots[prod] lotsList = self.getList(abs(int(Lots))) # print(getLots,Lots,StopPrice,addon,prod,lotsList) hsi = Future(localSymbol=prod) if web_trade.ib.qualifyContracts(hsi): if Lots > 0: for i in lotsList: # web_trade.order_stopS(StopPrice,i,prod,addon) zs, thereAre = self.zszyGroup('zs') order = StopLimitOrder('BUY', i, StopPrice + addon, StopPrice, ocaGroup=zs, ocaType=2, orderRef=f"PY_{self.pwd_id[-1]}") web_trade.ib.placeOrder(hsi, order) print("%d@%d-%s" % (i, StopPrice, prod)) else: for i in lotsList: # web_trade.order_stopB(StopPrice,i, prod,addon) zs, thereAre = self.zszyGroup('zs') order = StopLimitOrder('SELL', i, StopPrice - addon, StopPrice, ocaGroup=zs, ocaType=2, orderRef=f"PY_{self.pwd_id[-1]}") web_trade.ib.placeOrder(hsi, order) print("%d@%d-%s" % (-i, StopPrice, prod)) self.box_lot1.setValue(0) self.c_orderlist()
def lookup_futures(self, obj: List[Future]) -> List[Future]: futures = [] for o in obj: o.update(includeExpired=True) futures.append([ Future(**c.contract.dict()) for c in self.ib.reqContractDetails(o) ]) return list(itertools.chain(*futures))
def ib_futures_instrument(futures_instrument_object): """ Get an IB contract which is NOT specific to a contract date Used for getting expiry chains :param futures_instrument_object: instrument with .metadata suitable for IB :return: IBcontract """ meta_data = futures_instrument_object.meta_data ibcontract = Future(meta_data['symbol'], exchange=meta_data['exchange']) if meta_data['ibMultiplier'] is NOT_REQUIRED: pass else: ibcontract.multiplier = int(meta_data['ibMultiplier']) if meta_data['currency'] is NOT_REQUIRED: pass else: ibcontract.currency = meta_data['currency'] return ibcontract
def contract_details_cl(): # Write pickled CL contract details to a file client = ib_insync.IB() client.connect() contract = Future( instrument_id="CL", lastTradeDateOrContractMonth="20211119", exchange="NYMEX", currency="USD", ) details = client.reqContractDetails(contract) with open("contract_details_cl.pickle", "wb") as file: pickle.dump(details[0], file)
def fnCreateIBSymbol(ticker_tk=None, ticker_at=None): if not ticker_tk: ticker_tk = 'SPY' if not ticker_at: ticker_at = 'EQT' symIB = None if ticker_at == 'EQT': symIB = [ticker_tk, Stock(ticker_tk, 'SMART', 'USD')] elif ticker_at == 'FUT': symIB = [ticker_tk, Future(ticker_tk, 'SMART', 'USD')] elif ticker_at == 'FX': symIB = [ticker_tk, Forex(ticker_tk, 'IDEALPRO')] return symIB
def get_contract(self): if self.market == 'futures': local = self._local_symbol_selection() self.contract = Future(symbol=self.symbol, exchange=self.exchange, localSymbol=local) print( self.ib.reqContractDetails( self.contract)[0].contract.lastTradeDateOrContractMonth) '''expiration = self.ib.reqContractDetails(Future(self.symbol,self.exchange))[0].contract.lastTradeDateOrContractMonth self.contract = Future(symbol=self.symbol, exchange=self.exchange, lastTradeDateOrContractMonth=expiration)''' elif self.market == 'forex': self.contract = Forex(self.symbol) elif self.market == 'stocks': self.contract = Stock(symbol=self.symbol, exchange=self.exchange, currency='USD')
def get_futures(contract_str, remove_weekly=False): ibw = IbWrapper() ib = ibw.ib vix = Future(contract_str, includeExpired=False) cds = ib.reqContractDetails(vix) contracts = [cd.contract for cd in cds] if remove_weekly: contracts = [ contract for contract in contracts if len(contract.localSymbol) <= 4 ] bars_list = [] for contract in contracts: bars = ib.reqHistoricalData(contract, endDateTime='', durationStr='5 D', barSizeSetting='1 day', whatToShow='TRADES', useRTH=True, formatDate=1) if bars: bars_list.append(util.df(bars)) ib.disconnect() contract_df = util.df(contracts) close_list = [item.loc[:, ['date', 'close']] for item in bars_list] close_list = [item.set_index('date') for item in close_list] close_list = [ item.rename(index=str, columns={'close': name}) for item, name in zip( close_list, pd.to_datetime(contract_df['lastTradeDateOrContractMonth'])) ] future_series = pd.concat(close_list, axis=1, sort=False) future_series = future_series.transpose().sort_index() future_series.columns = pd.to_datetime(future_series.columns) return future_series, contract_df
def get_contracts(series, n): """ Requests contract details for a series of futures :param series: ticker symbol (str) :param n: number of consecutive contracts (int) :return: list of Contract """ contract_years = [str(datetime.now().year + i)[-1] for i in range(2)] contract_symbols = [ series + m + y for y in contract_years for m in CONTRACT_SPECS[series]['months'] ] module_logger.info( 'Requesting contract details for {}...'.format(contract_symbols)) contract_details = {} for symbol in contract_symbols: cd = ib_gw.reqContractDetails( Future(localSymbol=symbol, exchange=CONTRACT_SPECS[series]['exchange'], currency=CONTRACT_SPECS[series]['currency'])) contract_details[symbol] = cd[0].contract if len(cd) > 0 else None contracts = { k: v for k, v in contract_details.items() # roll over 6 days prior to expiry if v is not None and v.lastTradeDateOrContractMonth > (datetime.now() + timedelta(days=6)).strftime('%Y%m%d') } return [ contracts[k] for k in [k for k in contract_symbols if k in contracts.keys()][:n] ]
"FB", "AAPL", "NFLX", "MSFT", "BABA", "INTC", "TSLA", ] FUTURES = [ "ES", "NQ", "RTY", "CL", "NG", "ZB", "ZN", "GC", "MXP", "EUR", "JPY", "GBP" ] stockContracts = [Stock(s, "SMART", "USD") for s in STOCK] ib.qualifyContracts(*stockContracts) futures = [ib.reqContractDetails(Future(f)) for f in FUTURES] futuresContracts = [c.contract for f in futures for c in f] futuresContracts = [ c for c in futuresContracts if c.tradingClass == c.symbol and c.lastTradeDateOrContractMonth.startswith("2019") ] for contract in stockContracts + futuresContracts: ib.reqMktData(contract, "", False, False) def onPendingTickers(tickers): ticks = [] for t in tickers: encodedTick = json.dumps(util.tree(t)) ticks.append({"Data": encodedTick})
class TestIBInstrumentProvider: def setup(self): self.ib = MagicMock() self.loop = asyncio.get_event_loop() self.clock = LiveClock() self.logger = LiveLogger( loop=self.loop, clock=self.clock, level_stdout=LogLevel.DEBUG, ) self.provider = InteractiveBrokersInstrumentProvider( client=self.ib, logger=self.logger, config=InstrumentProviderConfig()) @staticmethod def async_return_value(value: object) -> asyncio.Future: future: asyncio.Future = asyncio.Future() future.set_result(value) return future @pytest.mark.parametrize( "filters, expected", [ ( { "secType": "STK", "symbol": "AMD", "exchange": "SMART", "currency": "USD" }, Stock("AMD", "SMART", "USD"), ), ( { "secType": "STK", "symbol": "INTC", "exchange": "SMART", "primaryExchange": "NASDAQ", "currency": "USD", }, Stock("INTC", "SMART", "USD", primaryExchange="NASDAQ"), ), ( { "secType": "CASH", "symbol": "EUR", "currency": "USD", "exchange": "IDEALPRO" }, Forex(symbol="EUR", currency="USD"), ), # EUR/USD, ({ "secType": "CFD", "symbol": "IBUS30" }, CFD("IBUS30")), ( { "secType": "FUT", "symbol": "ES", "exchange": "GLOBEX", "lastTradeDateOrContractMonth": "20180921", }, Future("ES", "20180921", "GLOBEX"), ), ( { "secType": "OPT", "symbol": "SPY", "exchange": "SMART", "lastTradeDateOrContractMonth": "20170721", "strike": 240, "right": "C", }, Option("SPY", "20170721", 240, "C", "SMART"), ), ( { "secType": "BOND", "secIdType": "ISIN", "secId": "US03076KAA60" }, Bond(secIdType="ISIN", secId="US03076KAA60"), ), ( { "secType": "CRYPTO", "symbol": "BTC", "exchange": "PAXOS", "currency": "USD" }, Crypto("BTC", "PAXOS", "USD"), ), ], ) def test_parse_contract(self, filters, expected): result = self.provider._parse_contract(**filters) fields = [ f.name for f in expected.__dataclass_fields__.values() if getattr(expected, f.name) ] for f in fields: assert getattr(result, f) == getattr(expected, f) @pytest.mark.asyncio async def test_load_equity_contract_instrument(self, mocker): # Arrange instrument_id = InstrumentId.from_str("AAPL.NASDAQ") contract = IBTestStubs.contract(symbol="AAPL") contract_details = IBTestStubs.contract_details("AAPL") mocker.patch.object( self.provider._client, "reqContractDetailsAsync", return_value=self.async_return_value([contract_details]), ) mocker.patch.object( self.provider._client, "qualifyContractsAsync", return_value=self.async_return_value([contract]), ) # Act await self.provider.load(secType="STK", symbol="AAPL", exchange="NASDAQ") equity = self.provider.find(instrument_id) # Assert assert InstrumentId(symbol=Symbol("AAPL"), venue=Venue("NASDAQ")) == equity.id assert equity.asset_class == AssetClass.EQUITY assert equity.asset_type == AssetType.SPOT assert 100 == equity.multiplier assert Price.from_str("0.01") == equity.price_increment assert 2, equity.price_precision @pytest.mark.asyncio async def test_load_futures_contract_instrument(self, mocker): # Arrange instrument_id = InstrumentId.from_str("CLZ2.NYMEX") contract = IBTestStubs.contract(symbol="CLZ2", exchange="NYMEX") contract_details = IBTestStubs.contract_details("CLZ2") mocker.patch.object( self.provider._client, "reqContractDetailsAsync", return_value=self.async_return_value([contract_details]), ) mocker.patch.object( self.provider._client, "qualifyContractsAsync", return_value=self.async_return_value([contract]), ) # Act await self.provider.load(symbol="CLZ2", exchange="NYMEX") future = self.provider.find(instrument_id) # Assert assert future.id == instrument_id assert future.asset_class == AssetClass.INDEX assert future.multiplier == 1000 assert future.price_increment == Price.from_str("0.01") assert future.price_precision == 2 @pytest.mark.asyncio async def test_load_options_contract_instrument(self, mocker): # Arrange instrument_id = InstrumentId.from_str("AAPL211217C00160000.SMART") contract = IBTestStubs.contract(secType="OPT", symbol="AAPL211217C00160000", exchange="NASDAQ") contract_details = IBTestStubs.contract_details("AAPL211217C00160000") mocker.patch.object( self.provider._client, "reqContractDetailsAsync", return_value=self.async_return_value([contract_details]), ) mocker.patch.object( self.provider._client, "qualifyContractsAsync", return_value=self.async_return_value([contract]), ) # Act await self.provider.load(secType="OPT", symbol="AAPL211217C00160000", exchange="SMART") option = self.provider.find(instrument_id) # Assert assert option.id == instrument_id assert option.asset_class == AssetClass.EQUITY assert option.multiplier == 100 assert option.expiry_date == datetime.date(2021, 12, 17) assert option.strike_price == Price.from_str("160.0") assert option.kind == OptionKind.CALL assert option.price_increment == Price.from_str("0.01") assert option.price_precision == 2 @pytest.mark.asyncio async def test_load_forex_contract_instrument(self, mocker): # Arrange instrument_id = InstrumentId.from_str("EUR/USD.IDEALPRO") contract = IBTestStubs.contract(secType="CASH", symbol="EURUSD", exchange="IDEALPRO") contract_details = IBTestStubs.contract_details("EURUSD") mocker.patch.object( self.provider._client, "reqContractDetailsAsync", return_value=self.async_return_value([contract_details]), ) mocker.patch.object( self.provider._client, "qualifyContractsAsync", return_value=self.async_return_value([contract]), ) # Act await self.provider.load(secType="CASH", symbol="EURUSD", exchange="IDEALPRO") fx = self.provider.find(instrument_id) # Assert assert fx.id == instrument_id assert fx.asset_class == AssetClass.FX assert fx.multiplier == 1 assert fx.price_increment == Price.from_str("0.00005") assert fx.price_precision == 5 @pytest.mark.asyncio async def test_contract_id_to_instrument_id(self, mocker): # Arrange contract = IBTestStubs.contract(symbol="CLZ2", exchange="NYMEX") contract_details = IBTestStubs.contract_details("CLZ2") mocker.patch.object( self.provider._client, "qualifyContractsAsync", return_value=self.async_return_value([contract]), ) mocker.patch.object( self.provider._client, "reqContractDetailsAsync", return_value=self.async_return_value([contract_details]), ) # Act await self.provider.load(symbol="CLZ2", exchange="NYMEX") # Assert expected = {138979238: InstrumentId.from_str("CLZ2.NYMEX")} assert self.provider.contract_id_to_instrument_id == expected def test_filters(self): pass
from kafka import KafkaProducer import json from time import sleep def json_serializer(data): return json.dumps(data).encode("utf-8") ib = IB() print(ib.connect('127.0.0.1', 7497, 5)) symbol = 'MNQ' exchange = 'GLOBEX' expiration = ib.reqContractDetails(Future( symbol, exchange))[0].contract.lastTradeDateOrContractMonth contract = Future(symbol=symbol, exchange=exchange, lastTradeDateOrContractMonth=expiration) sleep(20) bars = ib.reqRealTimeBars(contract, 5, 'MIDPOINT', False) print(bars) producer = KafkaProducer(bootstrap_servers=['localhost:9092'], value_serializer=json_serializer) while True: print(bars[-1]) producer.send('first_topic', bars[-1])
def ib_futures_instrument_just_symbol(symbol): ibcontract = Future(symbol=symbol) return ibcontract
def parse_contract(ticker): """ Backtrader contract specification (https://www.backtrader.com/docu/live/ib/ib.html): TICKER # Stock type and SMART exchange TICKER-STK # Stock and SMART exchange TICKER-STK-EXCHANGE # Stock TICKER-STK-EXCHANGE-CURRENCY # Stock TICKER-CFD # CFD and SMART exchange TICKER-CFD-EXCHANGE # CFD TICKER-CDF-EXCHANGE-CURRENCY # Stock TICKER-IND-EXCHANGE # Index TICKER-IND-EXCHANGE-CURRENCY # Index TICKER-YYYYMM-EXCHANGE # Future TICKER-YYYYMM-EXCHANGE-CURRENCY # Future TICKER-YYYYMM-EXCHANGE-CURRENCY-MULT # Future TICKER-FUT-EXCHANGE-CURRENCY-YYYYMM-MULT # Future TICKER-YYYYMM-EXCHANGE-CURRENCY-STRIKE-RIGHT # FOP TICKER-YYYYMM-EXCHANGE-CURRENCY-STRIKE-RIGHT-MULT # FOP TICKER-FOP-EXCHANGE-CURRENCY-YYYYMM-STRIKE-RIGHT # FOP TICKER-FOP-EXCHANGE-CURRENCY-YYYYMM-STRIKE-RIGHT-MULT # FOP CUR1.CUR2-CASH-IDEALPRO # Forex TICKER-YYYYMMDD-EXCHANGE-CURRENCY-STRIKE-RIGHT # OPT TICKER-YYYYMMDD-EXCHANGE-CURRENCY-STRIKE-RIGHT-MULT # OPT TICKER-OPT-EXCHANGE-CURRENCY-YYYYMMDD-STRIKE-RIGHT # OPT TICKER-OPT-EXCHANGE-CURRENCY-YYYYMMDD-STRIKE-RIGHT-MULT # OPT :return: """ contract_type, symbol, exchange, currency, expire, multiplier = \ AsyncIBDataProvider.exctract_symbol(ticker) if contract_type == 'FX': return Forex(pair=symbol) if contract_type == 'IND': return Index(symbol, exchange, currency) if contract_type == 'FUT': return Future(symbol, expire, exchange, currency=currency, multiplier=multiplier) else: return Stock(symbol, exchange, currency)
str(datetime.datetime.now())) logs.write(str(zs[:2] + [ccl]) + '\n') ccl = 0 else: ccl += zs[2] xiadan(zs[1], zs[2]) print(zs, '下单时间:', str(datetime.datetime.now())) logs.write(str(zs) + '\n') logs.flush() print(f'持仓:{ccl}') # print(data[-2:]) # time.sleep(0.05) time.sleep(30) ib = IB() CODE = 'HSIH9' ib.connect('192.168.2.204', 7496, clientId=8, timeout=3) hsi = Future(localSymbol=CODE) ib.qualifyContracts(hsi) if __name__ == '__main__': argv = sys.argv ccl = 0 # 持仓量 if len(argv) > 1: try: ccl = int(argv[1]) except: pass main(ccl)
conexionBBDD.execute( "UPDATE CLIENT_ID SET CLIENT_ID = %s WHERE USUARIO = %s", (clientId, usuario)) return clientId engine = c.engine conexionBBDD = engine.connect() clientID = getClientId() conexionBBDD.close() ib = IB() ib.connect(host="127.0.0.1", port=7496, clientId=clientID) '''FUTURO 1''' '''Descargamos todos los datos del futuro continuo''' details = ib.reqContractDetails(Future(futuro1, exchange1, includeExpired=True)) '''Cogemos solo los contratos, y filtramos los que tengan fecha superior a hoy''' contracts = [ d.contract for d in details if d.contract.lastTradeDateOrContractMonth > fDesde and d.contract.exchange == exchange1 ] '''Necesitamos hacer esta chapu para poder ordenar y quedarnos con los N primeros''' '''Creamos una lista de listas, que luego sí podemos ordenar''' lista1 = [] for contract in contracts: lista2 = [] lista2.append(contract.conId) lista2.append(contract.localSymbol) lista2.append(contract.lastTradeDateOrContractMonth)
logger.debug("Hit take profit") logger.debug(f"{self.take_profit}") logger.debug( "----------------------------------------------") self.cancel_order(self.stop_loss.order) if __name__ == "__main__": import logging import sys logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) logger.addHandler(logging.StreamHandler(sys.stdout)) logger.addHandler(logging.FileHandler("trades.log")) ib = IB() ib.connect("127.0.0.1", 4002, clientId=1) # TWS=7496, PAPER=7497, GTW=4001 ib.reqMarketDataType(1) # this isn't a proper way to roll the f*****g futures ES = ib.reqContractDetails(Future(symbol="ES", exchange="GLOBEX"))[0].contract MES = ib.reqContractDetails(Future(symbol="MES", exchange="GLOBEX"))[0].contract ds = DocStrat(ib=ib, es=ES, mes=MES) logger.debug("Doc Strategy instantiated") ds.run()