Qubx 0.5.0__cp311-cp311-manylinux_2_35_x86_64.whl → 0.5.1__cp311-cp311-manylinux_2_35_x86_64.whl

qubx/__init__.py

@@ -1,10 +1,13 @@
+import os
+import sys
 from typing import Callable
-from qubx.utils import set_mpl_theme, runtime_env
-from qubx.utils.misc import install_pyx_recompiler_for_dev
 
+import stackprinter
 from loguru import logger
-import os, sys, stackprinter
+
 from qubx.core.lookups import FeesLookup, GlobalLookup, InstrumentsLookup
+from qubx.utils import runtime_env, set_mpl_theme
+from qubx.utils.misc import install_pyx_recompiler_for_dev
 
 # - TODO: import some main methods from packages
 
@@ -66,8 +69,8 @@ lookup = GlobalLookup(InstrumentsLookup(), FeesLookup())
 
 # registering magic for jupyter notebook
 if runtime_env() in ["notebook", "shell"]:
-    from IPython.core.magic import Magics, magics_class, line_magic, line_cell_magic
     from IPython.core.getipython import get_ipython
+    from IPython.core.magic import Magics, line_cell_magic, line_magic, magics_class
 
     @magics_class
     class QubxMagics(Magics):
@@ -136,7 +139,8 @@ if runtime_env() in ["notebook", "shell"]:
 
             """
             import multiprocessing as m
-            import time, re
+            import re
+            import time
 
             # create ext args
             name = None
@@ -151,7 +155,7 @@ if runtime_env() in ["notebook", "shell"]:
                         return
 
                 ipy = get_ipython()
-                for a in [x for x in re.split("[\ ,;]", line.strip()) if x]:
+                for a in [x for x in re.split(r"[\ ,;]", line.strip()) if x]:
                     ipy.push({a: self._get_manager().Value(None, None)})
 
             # code to run

qubx/_nb_magic.py

@@ -32,60 +32,60 @@ if runtime_env() in ["notebook", "shell"]:
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
     # - - - - Common stuff - - - -
+    from datetime import time, timedelta
+
     import numpy as np
     import pandas as pd
-    from datetime import time, timedelta
+
+    # - - - - Charting stuff - - - -
+    from matplotlib import pyplot as plt
     from tqdm.auto import tqdm
 
     # - - - - TA stuff and indicators - - - -
     import qubx.pandaz.ta as pta
     import qubx.ta.indicators as ta
+    from qubx.backtester.optimization import variate
+
+    # - - - - Simulator stuff - - - -
+    from qubx.backtester.simulator import simulate
 
     # - - - - Portfolio analysis - - - -
     from qubx.core.metrics import (
-        tearsheet,
         chart_signals,
-        get_symbol_pnls,
-        get_equity,
-        portfolio_metrics,
-        pnl,
         drop_symbols,
+        get_symbol_pnls,
         pick_symbols,
+        pnl,
+        portfolio_metrics,
+        tearsheet,
     )
+    from qubx.data.helpers import loader
 
     # - - - - Data reading - - - -
     from qubx.data.readers import (
-        CsvStorageDataReader,
-        MultiQdbConnector,
-        QuestDBConnector,
         AsOhlcvSeries,
         AsPandasFrame,
         AsQuotes,
         AsTimestampedRecords,
+        CsvStorageDataReader,
+        MultiQdbConnector,
+        QuestDBConnector,
         RestoreTicksFromOHLC,
     )
-    from qubx.data.helpers import loader
-
-    # - - - - Simulator stuff - - - -
-    from qubx.backtester.simulator import simulate
-    from qubx.backtester.optimization import variate
-
-    # - - - - Charting stuff - - - -
-    from matplotlib import pyplot as plt
-    from qubx.utils.charting.mpl_helpers import fig, subplot, sbp, plot_trends, ohlc_plot
-    from qubx.utils.charting.lookinglass import LookingGlass
 
     # - - - - Utils - - - -
     from qubx.pandaz.utils import (
-        scols,
-        srows,
-        ohlc_resample,
         continuous_periods,
-        generate_equal_date_ranges,
         drop_duplicated_indexes,
+        generate_equal_date_ranges,
+        ohlc_resample,
         retain_columns_and_join,
         rolling_forward_test_split,
+        scols,
+        srows,
     )
+    from qubx.utils.charting.lookinglass import LookingGlass
+    from qubx.utils.charting.mpl_helpers import fig, ohlc_plot, plot_trends, sbp, subplot
 
     # - setup short numpy output format
     np_fmt_short()

qubx/backtester/account.py

@@ -3,15 +3,17 @@ from qubx.backtester.ome import OrdersManagementEngine
 from qubx.core.account import BasicAccountProcessor
 from qubx.core.basics import (
     ZERO_COSTS,
+    BatchEvent,
     CtrlChannel,
     Instrument,
     Order,
     Position,
+    Timestamped,
     TransactionCostsCalculator,
     dt_64,
 )
 from qubx.core.interfaces import ITimeProvider
-from qubx.core.series import Bar, Quote, Trade
+from qubx.core.series import Bar, OrderBook, Quote, Trade
 
 
 class SimulatedAccountProcessor(BasicAccountProcessor):
@@ -101,7 +103,7 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         return super().process_order(order, update_locked_value)
 
     def emulate_quote_from_data(
-        self, instrument: Instrument, timestamp: dt_64, data: float | Trade | Bar
+        self, instrument: Instrument, timestamp: dt_64, data: float | Timestamped | BatchEvent
     ) -> Quote | None:
         if instrument not in self._half_tick_size:
             _ = self.get_position(instrument)
@@ -109,15 +111,25 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         _ts2 = self._half_tick_size[instrument]
         if isinstance(data, Quote):
             return data
+
         elif isinstance(data, Trade):
             if data.taker:  # type: ignore
                 return Quote(timestamp, data.price - _ts2 * 2, data.price, 0, 0)  # type: ignore
             else:
                 return Quote(timestamp, data.price, data.price + _ts2 * 2, 0, 0)  # type: ignore
+
         elif isinstance(data, Bar):
             return Quote(timestamp, data.close - _ts2, data.close + _ts2, 0, 0)  # type: ignore
+
+        elif isinstance(data, OrderBook):
+            return data.to_quote()
+
+        elif isinstance(data, BatchEvent):
+            return self.emulate_quote_from_data(instrument, timestamp, data.data[-1])
+
         elif isinstance(data, float):
             return Quote(timestamp, data - _ts2, data + _ts2, 0, 0)
+
         else:
             return None
 

qubx/backtester/broker.py

@@ -18,9 +18,11 @@ class SimulatedBroker(IBroker):
         self,
         channel: CtrlChannel,
         account: SimulatedAccountProcessor,
+        exchange_id: str = "simulated",
     ) -> None:
         self.channel = channel
         self._account = account
+        self._exchange_id = exchange_id
 
     @property
     def is_simulated_trading(self) -> bool:
@@ -80,3 +82,6 @@ class SimulatedBroker(IBroker):
         self.channel.send((instrument, "order", report.order, False))
         if report.exec is not None:
             self.channel.send((instrument, "deals", [report.exec], False))
+
+    def exchange(self) -> str:
+        return self._exchange_id.upper()

qubx/backtester/data.py

@@ -267,3 +267,6 @@ class SimulatedDataProvider(IDataProvider):
         cc.send((instrument, data_type, data, is_hist))
 
         return cc.control.is_set()
+
+    def exchange(self) -> str:
+        return self._exchange_id.upper()

qubx/backtester/ome.py

@@ -1,14 +1,16 @@
-from typing import List, Dict
 from dataclasses import dataclass
 from operator import neg
+from typing import Dict, List
 
 import numpy as np
 from sortedcontainers import SortedDict
 
 from qubx import logger
 from qubx.core.basics import (
+    OPTION_FILL_AT_SIGNAL_PRICE,
     Deal,
     Instrument,
+    ITimeProvider,
     Order,
     OrderSide,
     OrderType,
@@ -16,14 +18,12 @@ from qubx.core.basics import (
     Signal,
     TransactionCostsCalculator,
     dt_64,
-    ITimeProvider,
-    OPTION_FILL_AT_SIGNAL_PRICE,
 )
-from qubx.core.series import Quote, Trade
 from qubx.core.exceptions import (
     ExchangeError,
     InvalidOrder,
 )
+from qubx.core.series import Quote, Trade
 
 
 @dataclass
@@ -127,11 +127,8 @@ class OrdersManagementEngine:
         time_in_force: str = "gtc",
         **options,
     ) -> OmeReport:
-
         if self.bbo is None:
-            raise ExchangeError(
-                f"Simulator is not ready for order management - no any quote for {self.instrument.symbol}"
-            )
+            raise ExchangeError(f"Simulator is not ready for order management - no quote for {self.instrument.symbol}")
 
         # - validate order parameters
         self._validate_order(order_side, order_type, amount, price, time_in_force)

qubx/backtester/optimization.py

@@ -1,9 +1,9 @@
-from typing import Any, Dict, List, Sequence, Tuple, Type
-import numpy as np
 import re
-
-from types import FunctionType
 from itertools import product
+from types import FunctionType
+from typing import Any, Dict, List, Sequence, Tuple, Type
+
+import numpy as np
 
 
 def _wrap_single_list(param_grid: List | Dict) -> Dict[str, Any] | List:
@@ -167,7 +167,7 @@ def variate(clz: Type[Any] | List[Type[Any]], *args, conditions=None, **kwargs)
     """
 
     def _cmprss(xs: str):
-        return "".join([x[0] for x in re.split("((?<!-)(?=[A-Z]))|_|(\d)", xs) if x])
+        return "".join([x[0] for x in re.split(r"((?<!-)(?=[A-Z]))|_|(\d)", xs) if x])
 
     if isinstance(clz, type):
         sfx = _cmprss(clz.__name__)

qubx/backtester/simulated_data.py

@@ -5,8 +5,7 @@ from typing import Any, Iterable, Iterator, TypeAlias
 import pandas as pd
 
 from qubx import logger
-from qubx.core.basics import BatchEvent, DataType, Instrument, TimestampedDict, dt_64
-from qubx.core.series import Bar, OrderBook, Quote, Trade
+from qubx.core.basics import BatchEvent, DataType, Instrument, Timestamped, dt_64
 from qubx.data.readers import (
     AsDict,
     AsQuotes,
@@ -18,8 +17,7 @@ from qubx.data.readers import (
     RestoreTradesFromOHLC,
 )
 
-InData: TypeAlias = Quote | Trade | Bar | OrderBook | TimestampedDict
-SlicerOutData: TypeAlias = tuple[str, int, InData] | tuple
+SlicerOutData: TypeAlias = tuple[str, int, Timestamped] | tuple
 
 
 class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
@@ -29,8 +27,8 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
     It supports adding / removing new data streams to the slicer on the fly (during the itration).
     """
 
-    _iterators: dict[str, Iterator[list[InData]]]
-    _buffers: dict[str, list[InData]]
+    _iterators: dict[str, Iterator[list[Timestamped]]]
+    _buffers: dict[str, list[Timestamped]]
     _keys: deque[str]
     _iterating: bool
 
@@ -40,7 +38,7 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
         self._keys = deque()
         self._iterating = False
 
-    def put(self, data: dict[str, Iterator[list[InData]]]):
+    def put(self, data: dict[str, Iterator[list[Timestamped]]]):
         _rebuild = False
         for k, vi in data.items():
             if k not in self._keys:
@@ -85,10 +83,10 @@ class IteratedDataStreamsSlicer(Iterator[SlicerOutData]):
         _init_seq = dict(sorted(_init_seq.items(), key=lambda item: item[1]))
         self._keys = deque(_init_seq.keys())
 
-    def _load_next_chunk_to_buffer(self, index: str) -> list[InData]:
+    def _load_next_chunk_to_buffer(self, index: str) -> list[Timestamped]:
         return list(reversed(next(self._iterators[index])))
 
-    def _pop_top(self, k: str) -> InData:
+    def _pop_top(self, k: str) -> Timestamped:
         v = (data := self._buffers[k]).pop()
         if not data:
             try:
@@ -226,8 +224,6 @@ class DataFetcher:
         _requests = self._specs if not to_load else set(self._make_request_id(i) for i in to_load)
         _r_iters = {}
 
-        # logger.debug(f"{self._fetcher_id} loading {_requests}")
-
         for _r in _requests:  # - TODO: replace this loop with multi-instrument request after DataReader refactoring
             if _r in self._specs:
                 _start = pd.Timestamp(start)
@@ -247,7 +243,10 @@ class DataFetcher:
                 if self._timeframe:
                     _args["timeframe"] = self._timeframe
 
-                _r_iters[self._fetcher_id + "." + _r] = self._reader.read(**_args)  # type: ignore
+                try:
+                    _r_iters[self._fetcher_id + "." + _r] = self._reader.read(**_args)  # type: ignore
+                except Exception as e:
+                    logger.error(f">>> (DataFetcher::load) - failed to load <g>'{self._fetcher_id}'</g> data: {e}")
             else:
                 raise IndexError(
                     f"Instrument {_r} is not subscribed for this data {self._requested_data_type} in {self._fetcher_id} !"
@@ -438,7 +437,7 @@ class IterableSimulationData(Iterator):
         self._slicing_iterator = iter(self._slicer_ctrl)
         return self
 
-    def __next__(self) -> tuple[Instrument, str, InData, bool]:  # type: ignore
+    def __next__(self) -> tuple[Instrument, str, Timestamped, bool]:  # type: ignore
         try:
             while data := next(self._slicing_iterator):  # type: ignore
                 k, t, v = data

qubx/backtester/simulator.py

@@ -5,15 +5,16 @@ import pandas as pd
 from joblib import delayed
 
 from qubx import QubxLogConfig, logger, lookup
-from qubx.core.basics import DataType, TradingSessionResult
+from qubx.core.basics import DataType
 from qubx.core.context import StrategyContext
 from qubx.core.exceptions import SimulationError
 from qubx.core.helpers import extract_parameters_from_object, full_qualified_class_name
 from qubx.core.interfaces import IStrategy
 from qubx.core.loggers import InMemoryLogsWriter, StrategyLogging
+from qubx.core.metrics import TradingSessionResult
 from qubx.data.helpers import InMemoryCachedReader, TimeGuardedWrapper
 from qubx.data.readers import DataReader
-from qubx.utils.misc import ProgressParallel
+from qubx.utils.misc import ProgressParallel, get_current_user
 
 from .account import SimulatedAccountProcessor
 from .broker import SimulatedBroker
@@ -226,7 +227,7 @@ def _run_setup(
         accurate_stop_orders_execution=accurate_stop_orders_execution,
     )
     scheduler = SimulatedScheduler(channel, lambda: time_provider.time().item())
-    broker = SimulatedBroker(channel, account)
+    broker = SimulatedBroker(channel, account, setup.exchange)
     data_provider = SimulatedDataProvider(
         exchange_id=setup.exchange,
         channel=channel,
@@ -346,4 +347,5 @@ def _run_setup(
         strategy_class=_s_class,
         parameters=_s_params,
         is_simulation=True,
+        author=get_current_user(),
     )

qubx/connectors/ccxt/broker.py

@@ -22,7 +22,7 @@ from .utils import ccxt_convert_order_info, instrument_to_ccxt_symbol
 
 
 class CcxtBroker(IBroker):
-    exchange: cxp.Exchange
+    _exchange: cxp.Exchange
 
     _positions: dict[Instrument, Position]
     _loop: AsyncThreadLoop
@@ -34,7 +34,7 @@ class CcxtBroker(IBroker):
         time_provider: ITimeProvider,
         account: IAccountProcessor,
     ):
-        self.exchange = exchange
+        self._exchange = exchange
         self.ccxt_exchange_id = str(exchange.name)
         self.channel = channel
         self.time_provider = time_provider
@@ -73,7 +73,7 @@ class CcxtBroker(IBroker):
         r: dict[str, Any] | None = None
         try:
             r = self._loop.submit(
-                self.exchange.create_order(
+                self._exchange.create_order(
                     symbol=ccxt_symbol,
                     type=order_type,  # type: ignore
                     side=order_side,  # type: ignore
@@ -109,7 +109,7 @@ class CcxtBroker(IBroker):
             try:
                 logger.info(f"Canceling order {order_id} ...")
                 r = self._loop.submit(
-                    self.exchange.cancel_order(order_id, symbol=instrument_to_ccxt_symbol(order.instrument))
+                    self._exchange.cancel_order(order_id, symbol=instrument_to_ccxt_symbol(order.instrument))
                 ).result()
             except Exception as err:
                 logger.error(f"Canceling [{order}] exception : {err}")
@@ -122,3 +122,9 @@ class CcxtBroker(IBroker):
 
     def update_order(self, order_id: str, price: float | None = None, amount: float | None = None) -> Order:
         raise NotImplementedError("Not implemented yet")
+
+    def exchange(self) -> str:
+        """
+        Return the name of the exchange this broker is connected to.
+        """
+        return self.ccxt_exchange_id.upper()

qubx/connectors/ccxt/data.py

@@ -423,6 +423,14 @@ class CcxtDataProvider(IDataProvider):
                                 False,  # not historical bar
                             )
                         )
+                    if not (
+                        self.has_subscription(instrument, DataType.ORDERBOOK)
+                        or self.has_subscription(instrument, DataType.QUOTE)
+                    ):
+                        _price = ohlcvs[-1][4]
+                        _s2 = instrument.tick_size / 2.0
+                        _bid, _ask = _price - _s2, _price + _s2
+                        self._last_quotes[instrument] = Quote(oh[0] * 1_000_000, _bid, _ask, 0.0, 0.0)
 
         # ohlc subscription reuses the same connection always, unsubscriptions don't work properly
         # but it's likely not very needed
@@ -599,3 +607,6 @@ class CcxtDataProvider(IDataProvider):
             name=name,
             unsubscriber=un_watch_funding_rates,
         )
+
+    def exchange(self) -> str:
+        return self._exchange_id.upper()

qubx/core/basics.py

@@ -3,26 +3,59 @@ from datetime import datetime
 from enum import StrEnum
 from queue import Empty, Queue
 from threading import Event, Lock
-from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union
+from typing import Any, Literal, Optional, TypeAlias, Union
 
 import numpy as np
 import pandas as pd
 
 from qubx.core.exceptions import QueueTimeout
-from qubx.core.series import Quote, Trade, time_as_nsec
+from qubx.core.series import Bar, OrderBook, Quote, Trade, time_as_nsec
 from qubx.core.utils import prec_ceil, prec_floor, time_delta_to_str
-from qubx.utils.misc import Stopwatch
+from qubx.utils.misc import Stopwatch, version
 from qubx.utils.ntp import start_ntp_thread, time_now
 
 dt_64 = np.datetime64
 td_64 = np.timedelta64
-ns_to_dt_64 = lambda ns: np.datetime64(ns, "ns")
 
 OPTION_FILL_AT_SIGNAL_PRICE = "fill_at_signal_price"
 
 SW = Stopwatch()
 
 
+@dataclass
+class Liquidation:
+    time: dt_64
+    quantity: float
+    price: float
+    side: int
+
+
+@dataclass
+class FundingRate:
+    time: dt_64
+    rate: float
+    interval: str
+    next_funding_time: dt_64
+    mark_price: float | None = None
+    index_price: float | None = None
+
+
+@dataclass
+class TimestampedDict:
+    """
+    Generic class for representing arbitrary data (as dict) with timestamp
+
+    TODO: probably we need to have generic interface for classes like Quote, Bar, .... etc
+    """
+
+    time: dt_64
+    data: dict[str, Any]
+
+
+# Alias for timestamped data types used in Qubx
+Timestamped: TypeAlias = Quote | Trade | Bar | OrderBook | TimestampedDict | FundingRate | Liquidation
+
+
 @dataclass
 class Signal:
     """
@@ -240,7 +273,7 @@ class Instrument:
 @dataclass
 class BatchEvent:
     time: dt_64 | pd.Timestamp
-    data: list[Any]
+    data: list[Timestamped]
 
 
 class TransactionCostsCalculator:
@@ -798,116 +831,6 @@ class DataType(StrEnum):
         return "(" in value
 
 
-class TradingSessionResult:
-    # fmt: off
-    id: int
-    name: str
-    start: str | pd.Timestamp
-    stop: str | pd.Timestamp
-    exchange: str                     # exchange name (TODO: need to think how to do with it for multiple exchanges)
-    instruments: list[Instrument]     # instruments used at the start of the session (TODO: need to collect all traded instruments)
-    capital: float
-    leverage: float
-    base_currency: str
-    commissions: str                   # used commissions ("vip0_usdt" etc)
-    portfolio_log: pd.DataFrame        # portfolio log records
-    executions_log: pd.DataFrame       # executed trades
-    signals_log: pd.DataFrame          # signals generated by the strategy
-    strategy_class: str                # strategy full qualified class name
-    parameters: dict[str, Any]         # strategy parameters if provided
-    is_simulation: bool
-    # fmt: on
-
-    def __init__(
-        self,
-        id: int,
-        name: str,
-        start: str | pd.Timestamp,
-        stop: str | pd.Timestamp,
-        exchange: str,
-        instruments: list[Instrument],
-        capital: float,
-        leverage: float,
-        base_currency: str,
-        commissions: str,
-        portfolio_log: pd.DataFrame,
-        executions_log: pd.DataFrame,
-        signals_log: pd.DataFrame,
-        strategy_class: str,
-        parameters: dict[str, Any] | None = None,
-        is_simulation=True,
-    ):
-        self.id = id
-        self.name = name
-        self.start = start
-        self.stop = stop
-        self.exchange = exchange
-        self.instruments = instruments
-        self.capital = capital
-        self.leverage = leverage
-        self.base_currency = base_currency
-        self.commissions = commissions
-        self.portfolio_log = portfolio_log
-        self.executions_log = executions_log
-        self.signals_log = signals_log
-        self.strategy_class = strategy_class
-        self.parameters = parameters if parameters else {}
-        self.is_simulation = is_simulation
-
-    @property
-    def symbols(self) -> list[str]:
-        """
-        Extracts all traded symbols from the portfolio log
-        """
-        if not self.portfolio_log.empty:
-            return list(set(self.portfolio_log.columns.str.split("_").str.get(0).values))
-        return []
-
-    def config(self, short=True) -> str:
-        """
-        Return configuration as string: "test.strategies.Strategy1(parameter1=12345)"
-        TODO: probably we need to return recreated new object
-        """
-        _cfg = ""
-        if self.strategy_class:
-            _params = ", ".join([f"{k}={repr(v)}" for k, v in self.parameters.items()])
-            _class = self.strategy_class.split(".")[-1] if short else self.strategy_class
-            _cfg = f"{_class}({_params})"
-            # _cfg = f"{{ {repr(self.name)}: {_class}({_params}) }}"
-            # if instantiated: return eval(_cfg)
-        return _cfg
-
-
-@dataclass
-class Liquidation:
-    time: dt_64
-    quantity: float
-    price: float
-    side: int
-
-
-@dataclass
-class FundingRate:
-    time: dt_64
-    rate: float
-    interval: str
-    next_funding_time: dt_64
-    mark_price: float | None = None
-    index_price: float | None = None
-
-
-@dataclass
-class TimestampedDict:
-    """
-    Generic class for representing arbitrary data (as dict) with timestamp
-
-    TODO: probably we need to have gebneric interface for classes like Quote, Bar, .... etc
-    """
-
-    time: dt_64
-    data: dict[str, Any]
-
-
 class LiveTimeProvider(ITimeProvider):
     def __init__(self):
         self._start_ntp_thread()

qubx/core/context.py

@@ -102,7 +102,10 @@ class StrategyContext(IStrategyContext):
 
         __position_gathering = position_gathering if position_gathering is not None else SimplePositionGatherer()
 
-        self._subscription_manager = SubscriptionManager(data_provider=self._data_provider)
+        self._subscription_manager = SubscriptionManager(
+            data_provider=self._data_provider,
+            default_base_subscription=DataType.ORDERBOOK if not self._data_provider.is_simulation else DataType.NONE,
+        )
         self.account.set_subscription_manager(self._subscription_manager)
 
         self._market_data_provider = MarketManager(
@@ -331,6 +334,10 @@ class StrategyContext(IStrategyContext):
     def instruments(self):
         return self._universe_manager.instruments
 
+    @property
+    def exchanges(self) -> list[str]:
+        return self._trading_manager.exchanges()
+
     # ISubscriptionManager delegation
     def subscribe(self, subscription_type: str, instruments: List[Instrument] | Instrument | None = None):
         return self._subscription_manager.subscribe(subscription_type, instruments)