Struct InteractiveBrokersInstrumentProvider 

pub struct InteractiveBrokersInstrumentProvider { /* private fields */ }

Interactive Brokers instrument provider.

This provider fetches contract details from Interactive Brokers using the rust-ibapi library and converts them to NautilusTrader instruments.

Implementations

impl InteractiveBrokersInstrumentProvider

pub fn new(config: InteractiveBrokersInstrumentProviderConfig) -> Self

Create a new InteractiveBrokersInstrumentProvider.

pub async fn initialize(&self) -> Result<()>

Initialize the provider by loading cache if configured.

This is equivalent to Python’s provider.initialize() method. It loads instruments from cache if cache_path is configured and cache is valid.

Errors

Returns an error if cache loading fails.

pub async fn initialize_with_client( &self, client: &Client, ) -> Result<Vec<InstrumentId>>

Initializes the provider and resolves every configured startup input.

Successful initialization is idempotent. A failed attempt remains retryable.

Errors

Returns an error if initialization fails or any configured input cannot be loaded.

pub fn add_cached_instruments<I>(&self, instruments: I) -> usize

where I: IntoIterator<Item = InstrumentAny>,

Adds instruments already held by the Nautilus cache into the provider cache.

This mirrors the Python provider’s use of client._cache for venue resolution and for recovering stored IB contract metadata from instrument.info["contract"].

pub fn determine_venue( &self, contract: &Contract, contract_details: Option<&ContractDetails>, ) -> Venue

Determine venue from contract using provider configuration.

This is equivalent to Python’s determine_venue_from_contract method. It uses the config’s symbol-to-venue mapping and exchange-to-venue conversion settings.

Returns

The determined venue.

pub fn symbology_method(&self) -> SymbologyMethod

Get the symbology method from the provider configuration.

pub fn find(&self, instrument_id: &InstrumentId) -> Option<InstrumentAny>

Get an instrument by its ID.

Returns

Returns the instrument if found, None otherwise.

pub fn find_by_contract_id(&self, contract_id: i32) -> Option<InstrumentAny>

Get an instrument by contract ID.

Returns

Returns the instrument if found, None otherwise.

pub fn get_instrument_id_by_contract_id( &self, contract_id: i32, ) -> Option<InstrumentId>

Get an instrument ID by contract ID.

Returns

Returns the instrument ID if found, None otherwise.

pub fn resolve_instrument_id_for_contract( &self, contract: &Contract, ) -> Result<InstrumentId>

Resolve an instrument ID from an IB contract using provider symbology and venue rules.

This first checks the provider’s contract ID cache, then derives the instrument ID using the configured symbology method and determine_venue.

Errors

Returns an error if the contract cannot be converted to an instrument ID.

pub fn spread_instrument_id_for_contract( &self, contract: &Contract, ) -> Result<InstrumentId>

Returns the spread instrument ID of a BAG contract from its cached leg instruments.

Errors

Returns an error if the contract has no combo legs, a leg is not cached, or a leg action is invalid.

pub fn is_filtered_sec_type(&self, sec_type: &str) -> bool

Check if a security type should be filtered.

Returns

Returns true if the security type should be filtered.

pub fn get_all(&self) -> Vec<InstrumentAny>

Get all cached instruments.

Returns

Returns a vector of all cached instruments.

pub fn count(&self) -> usize

Get the number of cached instruments.

Returns

Returns the number of cached instruments.

pub fn get_price_magnifier(&self, instrument_id: &InstrumentId) -> i32

Get price magnifier for an instrument ID.

Price magnifier allows execution and strike prices to be reported consistently with market data and historical data.

This method first checks the dedicated price magnifier cache for fast lookup. If not found, it falls back to checking contract details. If still not found, it returns the default value of 1 and logs a warning if the instrument exists.

Returns

Returns the price magnifier if found, otherwise 1.

pub async fn get_instrument( &self, client: &Client, contract: &Contract, ) -> Result<Option<InstrumentAny>>

Get an instrument by IB Contract.

This is equivalent to Python’s get_instrument method. Supports BAG contracts by auto-loading legs.

Returns

Returns the instrument if found, None otherwise.

Errors

Returns an error if fetching fails.

pub fn instrument_id_to_ib_contract_details( &self, instrument_id: &InstrumentId, ) -> Option<ContractDetails>

Convert an instrument ID to IB contract details.

This is equivalent to Python’s instrument_id_to_ib_contract_details method.

Returns

Returns the contract details if found, None otherwise.

pub fn instrument_id_to_ib_contract( &self, instrument_id: &InstrumentId, ) -> Option<Contract>

pub fn resolve_contract_for_instrument( &self, instrument_id: InstrumentId, ) -> Result<Contract>

pub async fn resolve_contract_for_instrument_async( &self, client: &Client, instrument_id: InstrumentId, ) -> Result<Contract>

pub async fn load_with_return_async( &self, client: &Client, instrument_id: InstrumentId, filters: Option<HashMap<String, String>>, ) -> Result<Option<InstrumentId>>

Load a single instrument and return the loaded instrument ID.

This is equivalent to Python’s load_with_return_async method.

Returns

Returns the loaded instrument ID if successful, None otherwise.

Errors

Returns an error if loading fails.

pub async fn load_ids_with_return_async( &self, client: &Client, instrument_ids: Vec<InstrumentId>, filters: Option<HashMap<String, String>>, ) -> Result<Vec<InstrumentId>>

Load multiple instruments and return the loaded instrument IDs.

This is equivalent to Python’s load_ids_with_return_async method.

Returns

Returns a vector of successfully loaded instrument IDs.

Errors

Returns an error if loading fails.

pub async fn fetch_spread_instrument( &self, client: &Client, spread_instrument_id: InstrumentId, force_instrument_update: bool, filters: Option<HashMap<String, String>>, ) -> Result<bool>

Fetch a spread instrument by loading its individual legs.

This is equivalent to Python’s _fetch_spread_instrument method. It parses the spread instrument ID to extract leg tuples, loads each leg, and then creates the spread instrument.

Returns

Returns true if the spread instrument was successfully loaded, false otherwise.

Errors

Returns an error if parsing or loading fails.

pub async fn load_all_async( &self, client: &Client, instrument_ids: Option<Vec<InstrumentId>>, contracts: Option<Vec<Contract>>, force_instrument_update: bool, ) -> Result<Vec<InstrumentId>>

Load all instruments from provided IDs and contracts.

This is equivalent to Python’s load_all_async method. Python version loads from config’s _load_ids_on_start and _load_contracts_on_start. Rust version accepts these as parameters for flexibility.

Errors

Returns an error if loading fails.

impl InteractiveBrokersInstrumentProvider

pub async fn fetch_contract_details( &self, client: &Client, instrument_id: InstrumentId, force_instrument_update: bool, filters: Option<HashMap<String, String>>, ) -> Result<()>

Fetch and cache contract details for an instrument ID using the provided IB client.

Errors

Returns an error if fetching fails.

pub async fn batch_load( &self, client: &Client, instrument_ids: Vec<InstrumentId>, filters: Option<&[String]>, ) -> Result<Vec<InstrumentId>>

Batch load multiple instrument IDs.

This method fetches and caches contract details for multiple instrument IDs in parallel.

Returns

Returns a vector of successfully loaded instrument IDs.

Errors

Returns an error if fetching fails.

pub async fn fetch_option_chain_by_range( &self, client: &Client, underlying: &Contract, expiry_min: Option<&str>, expiry_max: Option<&str>, option_chain_exchange: Option<&str>, ) -> Result<usize>

Fetch option chain for a given underlying contract with expiry filtering.

This is equivalent to Python’s get_option_chain_details_by_range. It uses contract_details to fetch options with precise expiry filtering, which is more flexible than the basic option_chain API.

Returns

Returns the number of option instruments loaded.

Errors

Returns an error if fetching fails.

pub async fn fetch_futures_chain( &self, client: &Client, symbol: &str, exchange: &str, currency: &str, trading_class: Option<&str>, include_expired: bool, min_expiry_days: Option<u32>, max_expiry_days: Option<u32>, ) -> Result<usize>

Fetch and cache futures chain (all futures contracts for a symbol).

This method fetches all futures contracts for a given underlying symbol and populates the cache with all individual futures instruments.

Returns

Returns the number of futures instruments loaded.

Errors

Returns an error if fetching fails.

pub async fn fetch_bag_contract( &self, client: &Client, bag_contract: &Contract, ) -> Result<usize>

Fetch and cache a BAG (spread) contract.

This method fetches contract details for a spread contract by requesting contract details with a BAG contract. The BAG contract should have its combo_legs populated with the individual leg contract IDs.

Returns

Returns the number of spread instruments loaded (0 or 1).

Errors

Returns an error if fetching fails.

Notes

This method now auto-loads all leg instruments from combo_legs and creates a proper spread instrument, matching Python’s _load_bag_contract behavior.

pub async fn save_cache(&self, cache_path: &str) -> Result<()>

Save the current instrument cache to disk.

Errors

Returns an error if serialization or file I/O fails.

pub async fn load_cache(&self, cache_path: &str) -> Result<bool>

Load instrument cache from disk if valid.

Returns

Returns true if cache was loaded successfully and is valid, false otherwise.

Errors

Returns an error if deserialization or file I/O fails (but treats missing file as non-error).

Trait Implementations

impl Clone for InteractiveBrokersInstrumentProvider

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InteractiveBrokersInstrumentProvider

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl DerefToPyAny for InteractiveBrokersInstrumentProvider

impl<'a, 'py> FromPyObject<'a, 'py> for InteractiveBrokersInstrumentProvider

where Self: Clone,

type Error = PyClassGuardError<'a, 'py>

The type returned in the event of a conversion error.

fn extract( obj: Borrowed<'a, 'py, PyAny>, ) -> Result<Self, <Self as FromPyObject<'a, 'py>>::Error>

Extracts Self from the bound smart pointer obj.

impl<'py> IntoPyObject<'py> for InteractiveBrokersInstrumentProvider

type Target = InteractiveBrokersInstrumentProvider

The Python output type

type Output = Bound<'py, <InteractiveBrokersInstrumentProvider as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for InteractiveBrokersInstrumentProvider

const NAME: &str = "InteractiveBrokersInstrumentProvider"

Name of the class.

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for InteractiveBrokersInstrumentProvider

const MODULE: Option<&str>

Module which the class will be associated with.

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// Interactive Brokers instrument provider. /// /// This provider fetches contract details from Interactive Brokers using the `rust-ibapi` library /// and converts them to NautilusTrader instruments.

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type Layout = <<InteractiveBrokersInstrumentProvider as PyClassImpl>::BaseNativeType as PyClassBaseType>::Layout<InteractiveBrokersInstrumentProvider>

Description of how this class is laid out in memory

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerImpl

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForInteractiveBrokersInstrumentProvider

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<PyObjectOffset>

Used to provide the dictoffset slot (equivalent to tp_dictoffset)

fn weaklist_offset() -> Option<PyObjectOffset>

Used to provide the weaklistoffset slot (equivalent to tp_weaklistoffset

impl PyClassNewTextSignature for InteractiveBrokersInstrumentProvider

const TEXT_SIGNATURE: &'static str = "(config)"

impl PyStubType for InteractiveBrokersInstrumentProvider

fn type_output() -> TypeInfo

The type to be used in the output signature, i.e. return type of the Python function or methods.

fn type_input() -> TypeInfo

The type to be used in the input signature, i.e. the arguments of the Python function or methods.

impl PyTypeInfo for InteractiveBrokersInstrumentProvider

const NAME: &str = <Self as ::pyo3::PyClass>::NAME

👎Deprecated since 0.28.0:

prefer using ::type_object(py).name() to get the correct runtime value

Class name.

const MODULE: Option<&str> = <Self as ::pyo3::impl_::pyclass::PyClassImpl>::MODULE

👎Deprecated since 0.28.0:

prefer using ::type_object(py).module() to get the correct runtime value

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.