Qubx 0.2.78__cp311-cp311-manylinux_2_35_x86_64.whl → 0.2.80__cp311-cp311-manylinux_2_35_x86_64.whl

qubx/__init__.py

@@ -6,6 +6,8 @@ from loguru import logger
 import os, sys, stackprinter
 from qubx.core.lookups import FeesLookup, GlobalLookup, InstrumentsLookup
 
+# - TODO: import some main methods from packages
+
 
 def formatter(record):
     end = record["extra"].get("end", "\n")
@@ -63,7 +65,7 @@ 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 import get_ipython
+    from IPython.core.getipython import get_ipython
 
     @magics_class
     class QubxMagics(Magics):
@@ -195,4 +197,4 @@ if runtime_env() in ["notebook", "shell"]:
                     p.terminate()
 
     # - registering magic here
-    get_ipython().register_magics(QubxMagics)
+    get_ipython().register_magics(QubxMagics)  # type: ignore

qubx/_nb_magic.py

@@ -65,6 +65,7 @@ if runtime_env() in ["notebook", "shell"]:
         AsTimestampedRecords,
         RestoreTicksFromOHLC,
     )
+    from qubx.data.helpers import loader
 
     # - - - - Simulator stuff - - - -
     from qubx.backtester.simulator import simulate

qubx/backtester/simulator.py

@@ -37,6 +37,7 @@ from qubx.core.strategy import (
 from qubx.core.context import StrategyContextImpl
 from qubx.backtester.ome import OrdersManagementEngine, OmeReport
 
+from qubx.data.helpers import InMemoryCachedReader, TimeGuardedWrapper
 from qubx.data.readers import (
     AsTrades,
     DataReader,
@@ -428,7 +429,9 @@ class SimulatedExchange(IBrokerServiceProvider):
         units = kwargs.get("timestamp_units", "ns")
 
         for instr in instruments:
-            logger.debug(f"SimulatedExchangeService :: subscribe :: {instr.symbol} :: {subscription_type}")
+            logger.debug(
+                f"SimulatedExchangeService :: subscribe :: {instr.symbol}({subscription_type}, {nback}, {timeframe})"
+            )
             self._symbol_to_instrument[instr.symbol] = instr
 
             _params: Dict[str, Any] = dict(
@@ -731,6 +734,7 @@ def simulate(
     silent: bool = False,
     enable_event_batching: bool = True,
     accurate_stop_orders_execution: bool = False,
+    aux_data: DataReader | None = None,
     debug: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None = "WARNING",
 ) -> list[TradingSessionResult]:
     """
@@ -773,6 +777,8 @@ def simulate(
         If True, enables event batching for optimization.
     accurate_stop_orders_execution (bool):
         If True, enables more accurate stop order execution simulation.
+    aux_data (DataReader | None):
+        Auxiliary data provider (default is None).
     debug (Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] | None):
         Logging level for debugging.
 
@@ -842,6 +848,7 @@ def simulate(
         silent=silent,
         enable_event_batching=enable_event_batching,
         accurate_stop_orders_execution=accurate_stop_orders_execution,
+        aux_data=aux_data,
     )
 
 
@@ -906,6 +913,7 @@ def _run_setups(
     silent: bool = False,
     enable_event_batching: bool = True,
     accurate_stop_orders_execution: bool = False,
+    aux_data: DataReader | None = None,
 ) -> List[TradingSessionResult]:
     # loggers don't work well with joblib and multiprocessing in general because they contain
     # open file handlers that cannot be pickled. I found a solution which requires the usage of enqueue=True
@@ -928,6 +936,7 @@ def _run_setups(
             silent=silent,
             enable_event_batching=enable_event_batching,
             accurate_stop_orders_execution=accurate_stop_orders_execution,
+            aux_data_provider=aux_data,
         )
         for id, s in enumerate(setups)
     )
@@ -946,6 +955,7 @@ def _run_setup(
     silent: bool = False,
     enable_event_batching: bool = True,
     accurate_stop_orders_execution: bool = False,
+    aux_data_provider: InMemoryCachedReader | None = None,
 ) -> TradingSessionResult:
     _trigger = trigger
     _stop = stop
@@ -996,6 +1006,13 @@ def _run_setup(
         case _:
             raise ValueError(f"Unsupported setup type: {setup.setup_type} !")
 
+    # - check aux data provider
+    _aux_data = None
+    if aux_data_provider is not None:
+        if not isinstance(aux_data_provider, InMemoryCachedReader):
+            logger.error("Aux data provider should be an instance of InMemoryCachedReader! Skipping it.")
+        _aux_data = TimeGuardedWrapper(aux_data_provider, broker)
+
     ctx = StrategyContextImpl(
         strategy=strat,  # type: ignore
         config=None,  # TODO: need to think how we could pass altered parameters here (from variating etc)
@@ -1007,6 +1024,7 @@ def _run_setup(
         trigger_spec=_trigger,
         fit_spec=fit,
         logs_writer=logs_writer,
+        aux_data_provider=_aux_data,
     )
     ctx.start()
 

qubx/core/context.py

@@ -36,6 +36,7 @@ from qubx.core.strategy import (
     SubscriptionType,
 )
 from qubx.core.series import Trade, Quote, Bar, OHLCV
+from qubx.data.readers import DataReader
 from qubx.gathering.simplest import SimplePositionGatherer
 from qubx.trackers.sizers import FixedSizer
 from qubx.utils.misc import Stopwatch
@@ -74,6 +75,9 @@ class StrategyContextImpl(StrategyContext):
     _cache: CachedMarketDataHolder  # market data cache
     _scheduler: BasicScheduler
 
+    # - aux data provider
+    _aux_data_provider: DataReader | None  # auxiliary data provider
+
     # - configuration
     _market_data_subcription_type: str = "unknown"
     _market_data_subcription_params: dict = dict()
@@ -126,6 +130,9 @@ class StrategyContextImpl(StrategyContext):
         # - - - - - - - - - - - - - - - - - - - - -
         # - signals executor configuration - - - -
         position_gathering: IPositionGathering | None = None,
+        # - - - - - - - - - - - - - - - - - - - - -
+        # - aux data provider - - - - - - - - - - -
+        aux_data_provider: DataReader | None = None,
     ) -> None:
         # - initialization
         self.broker_provider = broker_connector
@@ -146,6 +153,7 @@ class StrategyContextImpl(StrategyContext):
         self.__init_fit_was_called = False
         self.__pool = None
         self.__fails_counter = 0
+        self._aux_data_provider = aux_data_provider
 
         # - for fast access to instrument by it's symbol
         self._symb_to_instr = {i.symbol: i for i in instruments}
@@ -751,36 +759,12 @@ class StrategyContextImpl(StrategyContext):
         if order_id:
             self.trading_service.cancel_order(order_id)
 
-    def quote(self, symbol: str) -> Quote | None:
-        return self.broker_provider.get_quote(symbol)
-
     def get_capital(self) -> float:
         return self.trading_service.get_capital()
 
     def get_reserved(self, instrument: Instrument) -> float:
         return self.trading_service.get_account().get_reserved(instrument)
 
-    @_SW.watch("StrategyContext")
-    def get_historical_ohlcs(self, instrument: Instrument | str, timeframe: str, length: int) -> OHLCV | None:
-        """
-        Helper for historical ohlc data
-        """
-        instr = self._symb_to_instr.get(instrument) if isinstance(instrument, str) else instrument
-
-        if instr is None:
-            logger.warning(f"Can't find instrument for {instrument} symbol !")
-            return None
-
-        # - first check if we can use cached series
-        rc = self.ohlc(instr, timeframe)
-        if len(rc) >= length:
-            return rc
-
-        # - send request for historical data
-        bars = self.broker_provider.get_historical_ohlcs(instr.symbol, timeframe, length)
-        r = self._cache.update_by_bars(instr.symbol, timeframe, bars)
-        return r
-
     @_SW.watch("StrategyContext")
     def set_universe(self, instruments: list[Instrument]) -> None:
         for instr in instruments:
@@ -901,3 +885,40 @@ class StrategyContextImpl(StrategyContext):
             if self.__pool is None:
                 self.__pool = ThreadPool(2)
             self.__pool.apply_async(func, args)
+
+    # - IMarketDataProvider methods implementation -
+
+    @_SW.watch("StrategyContext")
+    def get_historical_ohlcs(self, instrument: Instrument | str, timeframe: str, length: int) -> OHLCV | None:
+        """
+        Helper for historical ohlc data
+        """
+        instr = self._symb_to_instr.get(instrument) if isinstance(instrument, str) else instrument
+
+        if instr is None:
+            logger.warning(f"Can't find instrument for {instrument} symbol !")
+            return None
+
+        # - first check if we can use cached series
+        rc = self.ohlc(instr, timeframe)
+        if len(rc) >= length:
+            return rc
+
+        # - send request for historical data
+        bars = self.broker_provider.get_historical_ohlcs(instr.symbol, timeframe, length)
+        r = self._cache.update_by_bars(instr.symbol, timeframe, bars)
+        return r
+
+    def get_aux_data(self, data_id: str, **parameters) -> pd.DataFrame | None:
+        if self._aux_data_provider:
+            return self._aux_data_provider.get_aux_data(data_id, **parameters)
+        return None
+
+    def get_instruments(self) -> List[Instrument]:
+        return self.instruments
+
+    def quote(self, symbol: str) -> Quote | None:
+        return self.broker_provider.get_quote(symbol)
+
+    def get_instrument(self, symbol: str) -> Instrument | None:
+        return self._symb_to_instr.get(symbol)

qubx/core/metrics.py

@@ -340,7 +340,7 @@ def aggregate_returns(returns: pd.Series, convert_to: str) -> pd.DataFrame | pd.
     str_check = convert_to.lower()
     resample_mod = None
     if str_check in ["a", "annual", "y", "yearly"]:
-        resample_mod = "A"
+        resample_mod = "YE"
     elif str_check in ["m", "monthly", "mon"]:
         resample_mod = "ME"
     elif str_check in ["w", "weekly"]:

qubx/core/series.pyi

@@ -97,5 +97,6 @@ class IndicatorOHLC(Indicator):
 def time_as_nsec(time: Any) -> np.datetime64: ...
 
 class RollingSum:
+    is_init_stage: bool
     def __init__(self, period: int) -> None: ...
     def update(self, value: float, new_item_started: bool) -> float: ...

qubx/core/strategy.py

@@ -3,11 +3,6 @@
 """
 
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-from types import FunctionType
-from collections import defaultdict
-from dataclasses import dataclass
-from threading import Thread
-from multiprocessing.pool import ThreadPool
 import traceback
 
 import pandas as pd
@@ -30,28 +25,58 @@ from qubx.core.basics import (
 )
 from qubx.core.series import Trade, Quote, Bar, OHLCV
 from qubx.utils.misc import Stopwatch
-from qubx.utils.time import convert_seconds_to_str
 
 
 _SW = Stopwatch()
 
 
 class ITradingServiceProvider(ITimeProvider, IComminucationManager):
+    """
+    Trading service provider interface that manages account operations, order placement, and position tracking.
+    """
+
     acc: AccountProcessor
 
     def set_account(self, account: AccountProcessor):
+        """
+        Set the account processor for the trading service provider.
+
+        :param account: The AccountProcessor object to be set.
+        """
         self.acc = account
 
     def get_account(self) -> AccountProcessor:
+        """
+        Retrieve the current account processor.
+
+        :return: The current AccountProcessor object.
+        """
         return self.acc
 
     def get_name(self) -> str:
+        """
+        Get the name of the trading service provider.
+
+        :return: The name of the trading service provider as a string.
+        :raises NotImplementedError: If the method is not implemented by the subclass.
+        """
         raise NotImplementedError("get_name is not implemented")
 
     def get_account_id(self) -> str:
+        """
+        Get the account ID associated with the trading service provider.
+
+        :return: The account ID as a string.
+        :raises NotImplementedError: If the method is not implemented by the subclass.
+        """
         raise NotImplementedError("get_account_id is not implemented")
 
     def get_capital(self) -> float:
+        """
+        Get the available capital in the account.
+
+        :return: The free capital as a float.
+        """
         return self.acc.get_free_capital()
 
     def send_order(
@@ -65,25 +90,81 @@ class ITradingServiceProvider(ITimeProvider, IComminucationManager):
         time_in_force: str = "gtc",
         **optional,
     ) -> Order:
+        """
+        Send an order to the trading service.
+
+        :param instrument: The instrument to trade.
+        :param order_side: The side of the order (e.g., "buy" or "sell").
+        :param order_type: The type of the order (e.g., "market" or "limit").
+        :param amount: The amount of the instrument to trade.
+        :param price: The price for limit orders (optional).
+        :param client_id: A client-specified ID for the order (optional).
+        :param time_in_force: The time in force for the order (default is "gtc" - good till cancelled).
+        :param optional: Additional optional parameters for the order.
+        :return: An Order object representing the sent order.
+        :raises NotImplementedError: If the method is not implemented by the subclass.
+        """
         raise NotImplementedError("send_order is not implemented")
 
     def cancel_order(self, order_id: str) -> Order | None:
+        """
+        Cancel an existing order.
+
+        :param order_id: The ID of the order to cancel.
+        :return: The cancelled Order object if successful, None otherwise.
+        :raises NotImplementedError: If the method is not implemented by the subclass.
+        """
         raise NotImplementedError("cancel_order is not implemented")
 
     def get_orders(self, symbol: str | None = None) -> List[Order]:
+        """
+        Get a list of current orders, optionally filtered by symbol.
+
+        :param symbol: The symbol to filter orders by (optional).
+        :return: A list of Order objects.
+        :raises NotImplementedError: If the method is not implemented by the subclass.
+        """
         raise NotImplementedError("get_orders is not implemented")
 
     def get_position(self, instrument: Instrument | str) -> Position:
+        """
+        Get the current position for a given instrument.
+
+        :param instrument: The instrument or symbol to get the position for.
+        :return: A Position object representing the current position.
+        :raises NotImplementedError: If the method is not implemented by the subclass.
+        """
         raise NotImplementedError("get_position is not implemented")
 
     def get_base_currency(self) -> str:
+        """
+        Get the base currency for the account.
+
+        :return: The base currency as a string.
+        :raises NotImplementedError: If the method is not implemented by the subclass.
+        """
         raise NotImplementedError("get_basic_currency is not implemented")
 
     def process_execution_report(self, symbol: str, report: Dict[str, Any]) -> Tuple[Order, List[Deal]]:
+        """
+        Process an execution report for a given symbol.
+
+        :param symbol: The symbol the execution report is for.
+        :param report: A dictionary containing the execution report details.
+        :return: A tuple containing the updated Order and a list of Deal objects.
+        :raises NotImplementedError: If the method is not implemented by the subclass.
+        """
         raise NotImplementedError("process_execution_report is not implemented")
 
     @staticmethod
     def _extract_price(update: float | Quote | Trade | Bar) -> float:
+        """
+        Extract the price from various types of market data updates.
+
+        :param update: The market data update, which can be a float, Quote, Trade, or Bar.
+        :return: The extracted price as a float.
+        :raises ValueError: If the update type is unknown.
+        """
         if isinstance(update, float):
             return update
         elif isinstance(update, Quote):
@@ -96,6 +177,13 @@ class ITradingServiceProvider(ITimeProvider, IComminucationManager):
             raise ValueError(f"Unknown update type: {type(update)}")
 
     def update_position_price(self, symbol: str, timestamp: dt_64, update: float | Quote | Trade | Bar):
+        """
+        Update the price of a position for a given symbol.
+
+        :param symbol: The symbol of the position to update.
+        :param timestamp: The timestamp of the update.
+        :param update: The price update, which can be a float, Quote, Trade, or Bar.
+        """
         self.acc.update_position_price(timestamp, symbol, ITradingServiceProvider._extract_price(update))
 
 
@@ -146,7 +234,25 @@ class SubscriptionType:
     OHLC = "ohlc"
 
 
-class StrategyContext(ITimeProvider):
+class IMarketDataProvider(ITimeProvider):
+    """
+    Interface for market data providing class
+    """
+
+    def ohlc(self, instrument: Instrument | str, timeframe: str) -> OHLCV: ...
+
+    def quote(self, symbol: str) -> Quote | None: ...
+
+    def get_historical_ohlcs(self, instrument: Instrument | str, timeframe: str, length: int) -> OHLCV | None: ...
+
+    def get_aux_data(self, data_id: str, **parametes) -> pd.DataFrame | None: ...
+
+    def get_instruments(self) -> List[Instrument]: ...
+
+    def get_instrument(self, symbol: str) -> Instrument | None: ...
+
+
+class StrategyContext(IMarketDataProvider):
     """
     Strategy context interface
     """
@@ -158,14 +264,10 @@ class StrategyContext(ITimeProvider):
 
     def process_data(self, symbol: str, d_type: str, data: Any) -> bool: ...
 
-    def ohlc(self, instrument: str | Instrument, timeframe: str) -> OHLCV: ...
-
     def start(self, blocking: bool = False): ...
 
     def stop(self): ...
 
-    def time(self) -> dt_64: ...
-
     def trade(
         self,
         instr_or_symbol: Instrument | str,
@@ -179,14 +281,10 @@ class StrategyContext(ITimeProvider):
 
     def cancel_order(self, order_id: str): ...
 
-    def quote(self, symbol: str) -> Quote | None: ...
-
     def get_capital(self) -> float: ...
 
     def get_reserved(self, instrument: Instrument) -> float: ...
 
-    def get_historical_ohlcs(self, instrument: Instrument | str, timeframe: str, length: int) -> OHLCV | None: ...
-
     def set_universe(self, instruments: list[Instrument]): ...
 
     def subscribe(self, subscription_type: str, instr_or_symbol: Instrument | str, **kwargs) -> bool: ...

qubx/data/__init__.py

@@ -9,3 +9,5 @@ from .readers import (
     AsTimestampedRecords,
     RestoreTicksFromOHLC,
 )
+
+from .helpers import loader