move ib contract details into master client

Author: rob

sysbrokers/IB/client/ib_client.py

@@ -4,12 +4,17 @@
 from ib_insync import IB
 
 from sysbrokers.IB.ib_connection import connectionIB
+from sysbrokers.IB.ib_contracts import ibContract
 from sysbrokers.IB.config.ib_instrument_config import (
     IBconfig,
     read_ib_config_from_file,
     get_instrument_code_from_broker_code,
 )
 
+from syscore.constants import arg_not_supplied
+from syscore.cache import Cache
+from syscore.exceptions import missingContract
+
 from syslogdiag.logger import logger
 from syslogdiag.log_to_screen import logtoscreen
 
@@ -75,6 +80,11 @@ def __init__(
 
         self._ib_connnection = ibconnection
         self._log = log
+        self._cache = Cache(self)
+
+    @property
+    def cache(self):
+        return self._cache
 
     @property
     def ib_connection(self) -> connectionIB:
@@ -105,13 +115,35 @@ def error_handler(
         :param contract: IB contract or None
         :return: success
         """
+
+        msg = "Reqid %d: %d %s" % (reqid, error_code, error_string)
+
+        log_to_use = self._get_log_for_contract(contract)
+
+        iserror = error_code in IB_IS_ERROR
+        if iserror:
+            # Serious requires some action
+            myerror_type = IB_ERROR_TYPES.get(error_code, "generic")
+            self.broker_error(msg=msg, myerror_type=myerror_type, log=log_to_use)
+
+        else:
+            # just a general message
+            self.broker_message(msg=msg, log=log_to_use)
+
+    def _get_log_for_contract(self, contract: Contract) -> logger:
         if contract is None:
-            ib_contract_str = ""
             log_to_use = self.log.setup()
         else:
             ib_instrument_code = contract.symbol
             ib_expiry_str = contract.lastTradeDateOrContractMonth
-            ib_contract_str = str("%s %s" % (ib_instrument_code, ib_expiry_str))
+
+            contract_details = self.contract_details(
+                contract, allow_expired=False, allow_multiple_contracts=False
+            )
+
+            ## FIXME: REPLACE WITH GET EXTENDED CONTRACT DETAILS?
+            ib_exchange = arg_not_supplied
+            ib_multiplier = arg_not_supplied
 
             instrument_code = self.get_instrument_code_from_broker_code(
                 ib_instrument_code
@@ -120,17 +152,7 @@ def error_handler(
             futures_contract = futuresContract(instrument_code, ib_expiry_str)
             log_to_use = futures_contract.specific_log(self.log)
 
-        msg = "Reqid %d: %d %s %s" % (reqid, error_code, error_string, ib_contract_str)
-
-        iserror = error_code in IB_IS_ERROR
-        if iserror:
-            # Serious requires some action
-            myerror_type = IB_ERROR_TYPES.get(error_code, "generic")
-            self.broker_error(msg=msg, myerror_type=myerror_type, log=log_to_use)
-
-        else:
-            # just a general message
-            self.broker_message(msg=msg, log=log_to_use)
+        return log_to_use
 
     def broker_error(self, msg, log, myerror_type):
         log.warn(msg)
@@ -141,9 +163,18 @@ def broker_message(self, log, msg):
     def refresh(self):
         self.ib.sleep(0.00001)
 
-    def get_instrument_code_from_broker_code(self, ib_code: str) -> str:
+    def get_instrument_code_from_broker_code(
+        self,
+        ib_code: str,
+        ib_multiplier: float = arg_not_supplied,
+        ib_exchange: str = arg_not_supplied,
+    ) -> str:
         instrument_code = get_instrument_code_from_broker_code(
-            log=self.log, ib_code=ib_code, config=self.ib_config
+            log=self.log,
+            ib_code=ib_code,
+            config=self.ib_config,
+            ib_multiplier=ib_multiplier,
+            ib_exchange=ib_exchange,
         )
         return instrument_code
 
@@ -160,3 +191,31 @@ def _get_and_set_ib_config_from_file(self) -> IBconfig:
         config_data = read_ib_config_from_file(log=self.log)
 
         return config_data
+
+    def contract_details(
+        self,
+        ib_contract_pattern: ibContract,
+        allow_expired: bool = False,
+        allow_multiple_contracts: bool = False,
+    ):
+        contract_details = self.cache.get(
+            self._contract_details, ib_contract_pattern, allow_expired=allow_expired
+        )
+
+        if len(contract_details) == 0:
+            raise missingContract
+
+        if allow_multiple_contracts:
+            return contract_details
+
+        elif len(contract_details) > 1:
+            self.log.critical("Multiple contracts and only expected one")
+
+        return contract_details[0]
+
+    def _contract_details(
+        self, ib_contract_pattern: ibContract, allow_expired: bool = False
+    ):
+        ib_contract_pattern.includeExpired = allow_expired
+
+        return self.ib.reqContractDetails(ib_contract_pattern)

sysbrokers/IB/client/ib_contracts_client.py

@@ -588,8 +588,12 @@ def ib_get_contract_chain(
         :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)
+
+        new_contract_details_list = self.contract_details(
+            ibcontract_pattern,
+            allow_expired=allow_expired,
+            allow_multiple_contracts=True,
+        )
 
         ibcontract_list = [
             contract_details.contract for contract_details in new_contract_details_list

sysbrokers/IB/config/ib_instrument_config.py

@@ -5,7 +5,7 @@
     NOT_REQUIRED_FOR_IB,
     ibInstrumentConfigData,
 )
-from syscore.constants import missing_file, missing_instrument
+from syscore.constants import missing_file, missing_instrument, arg_not_supplied
 from syscore.fileutils import resolve_path_and_filename_for_package
 from syscore.genutils import return_another_value_if_nan
 from syslogdiag.log_to_screen import logtoscreen
@@ -99,7 +99,11 @@ def _get_instrument_object_from_valid_config(
 
 
 def get_instrument_code_from_broker_code(
-    config: IBconfig, ib_code: str, log: logger = logtoscreen("")
+    config: IBconfig,
+    ib_code: str,
+    log: logger = logtoscreen(""),
+    ib_exchange: str = arg_not_supplied,
+    ib_multiplier: float = arg_not_supplied,
 ) -> str:
 
     config_row = config[config.IBSymbol == ib_code]
@@ -110,17 +114,27 @@ def get_instrument_code_from_broker_code(
 
     if len(config_row) > 1:
         ## need to resolve with multiplier
-        instrument_code = get_instrument_code_from_broker_code_with_multiplier(
-            ib_code=ib_code, config=config, log=log
+        instrument_code = (
+            get_instrument_code_from_broker_code_with_multiple_possibilities(
+                ib_code=ib_code,
+                config=config,
+                log=log,
+                ib_exchange=ib_exchange,
+                ib_multiplier=ib_multiplier,
+            )
         )
     else:
         instrument_code = config_row.iloc[0].Instrument
 
     return instrument_code
 
 
-def get_instrument_code_from_broker_code_with_multiplier(
-    config: IBconfig, ib_code: str, log: logger = logtoscreen("")
+def get_instrument_code_from_broker_code_with_multiple_possibilities(
+    config: IBconfig,
+    ib_code: str,
+    log: logger = logtoscreen(""),
+    ib_exchange: str = arg_not_supplied,
+    ib_multiplier: float = arg_not_supplied,
 ) -> str:
 
     # FIXME PATCH

sysbrokers/IB/ib_contract_position_data.py

@@ -79,20 +79,29 @@ def _get_contract_position_for_raw_entry(self, position_entry) -> contractPositi
         if position == 0:
             raise missingContract
 
-        ib_code = position_entry["symbol"]
-        ib_multiplier = position_entry["multiplier"]
-        instrument_code = (
-            self.futures_instrument_data.get_instrument_code_from_broker_code(ib_code)
-        )
-
         expiry = position_entry["expiry"]
-
+        instrument_code = self._get_instrument_code_from_ib_position_entry(
+            position_entry
+        )
         contract = futuresContract(instrument_code, expiry)
 
         contract_position_object = contractPosition(position, contract)
 
         return contract_position_object
 
+    def _get_instrument_code_from_ib_position_entry(self, position_entry) -> str:
+
+        ib_code = position_entry["symbol"]
+        ib_multiplier = position_entry["multiplier"]
+        ib_exchange = position_entry["exchange"]
+        instrument_code = (
+            self.futures_instrument_data.get_instrument_code_from_broker_code(
+                ib_code, ib_exchange=ib_exchange, ib_multiplier=ib_multiplier
+            )
+        )
+
+        return instrument_code
+
     def _get_all_futures_positions_as_raw_list(
         self, account_id: str = arg_not_supplied
     ) -> list:

sysbrokers/IB/ib_instruments_data.py

@@ -11,6 +11,9 @@
 )
 from sysbrokers.IB.ib_connection import connectionIB
 from sysbrokers.broker_instrument_data import brokerFuturesInstrumentData
+
+from syscore.constants import arg_not_supplied
+
 from sysdata.data_blob import dataBlob
 
 from syslogdiag.log_to_screen import logtoscreen
@@ -41,10 +44,19 @@ def __repr__(self):
     def ibconnection(self) -> connectionIB:
         return self._ibconnection
 
-    def get_instrument_code_from_broker_code(self, ib_code: str) -> str:
+    def get_instrument_code_from_broker_code(
+        self,
+        ib_code: str,
+        ib_multiplier: float = arg_not_supplied,
+        ib_exchange: str = arg_not_supplied,
+    ) -> str:
         config = self.ib_config
         broker_code = get_instrument_code_from_broker_code(
-            config=config, ib_code=ib_code, log=self.log
+            config=config,
+            ib_code=ib_code,
+            log=self.log,
+            ib_multiplier=ib_multiplier,
+            ib_exchange=ib_exchange,
         )
 
         return broker_code

sysbrokers/IB/ib_orders.py

@@ -210,9 +210,22 @@ def _create_broker_control_order_object(
         """
         try:
             try:
+                ## FIXME THIS IS HORRIFIC
+                ib_contract = (
+                    trade_with_contract_from_ib.ibcontract_with_legs.ibcontract
+                )
+                ib_instrument_code = trade_with_contract_from_ib.ib_instrument_code
+
+                contract_details = self.ib_client.ib.reqContractDetails(ib_contract)
+
+                ib_exchange = contract_details[0].validExchanges
+                ib_multiplier = contract_details[0].evMultiplier  # is this right?
+
                 instrument_code = (
                     self.futures_instrument_data.get_instrument_code_from_broker_code(
-                        trade_with_contract_from_ib.ib_instrument_code
+                        ib_instrument_code,
+                        ib_exchange=ib_exchange,
+                        ib_multiplier=ib_multiplier,
                     )
                 )
             except:

sysbrokers/IB/ib_translate_broker_order_objects.py

@@ -5,7 +5,7 @@
 from dateutil.tz import tz
 
 from ib_insync import Trade as ibTrade
-from sysbrokers.IB.ib_contracts import ibcontractWithLegs
+from sysbrokers.IB.ib_contracts import ibcontractWithLegs, ibContract
 from sysbrokers.broker_trade import brokerTrade
 from syscore.exceptions import missingData
 from syscore.constants import arg_not_supplied
@@ -41,6 +41,10 @@ def trade(self) -> ibTrade:
     def ib_instrument_code(self):
         return self.trade.contract.symbol
 
+    @property
+    def ib_contract(self) -> ibContract:
+        return self.trade.contract
+
 
 class ibBrokerOrder(brokerOrder):
     @classmethod

sysbrokers/broker_instrument_data.py

@@ -17,7 +17,7 @@ def __init__(self, data: dataBlob, log=logtoscreen("brokerFuturesInstrumentData"
         super().__init__(log=log)
         self._data = data
 
-    def get_instrument_code_from_broker_code(self, broker_code: str) -> str:
+    def get_instrument_code_from_broker_code(self, broker_code: str, **kwargs) -> str:
         raise NotImplementedError
 
     def get_list_of_instruments(self) -> list: