Qubx 0.4.0__cp311-cp311-manylinux_2_35_x86_64.whl → 0.4.2__cp311-cp311-manylinux_2_35_x86_64.whl

qubx/backtester/queue.py

@@ -17,7 +17,7 @@ _SW = Stopwatch()
 
 
 class DataLoader:
-    _TYPE_MAPPERS = {"agg_trade": "trade", "ohlc": "bar", "ohlcv": "bar"}
+    _TYPE_MAPPERS = {"agg_trade": "trade", "bar": "ohlc", "ohlcv": "ohlc"}
 
     def __init__(
         self,
@@ -25,7 +25,7 @@ class DataLoader:
         reader: DataReader,
         instrument: Instrument,
         timeframe: str | None,
-        preload_bars: int = 0,
+        warmup_period: str | None = None,
         data_type: str = "ohlc",
         output_type: str | None = None,  # transfomer can somtimes map to a different output type
         chunksize: int = 5_000,
@@ -34,7 +34,7 @@ class DataLoader:
         self._spec = f"{instrument.exchange}:{instrument.symbol}"
         self._reader = reader
         self._transformer = transformer
-        self._init_bars_required = preload_bars
+        self._warmup_period = warmup_period
         self._timeframe = timeframe
         self._data_type = data_type
         self._output_type = output_type
@@ -43,8 +43,8 @@ class DataLoader:
 
     def load(self, start: str | pd.Timestamp, end: str | pd.Timestamp) -> Iterator:
         if self._first_load:
-            if self._init_bars_required > 0 and self._timeframe:
-                start = pd.Timestamp(start) - self._init_bars_required * pd.Timedelta(self._timeframe)
+            if self._warmup_period:
+                start = pd.Timestamp(start) - pd.Timedelta(self._warmup_period)
             self._first_load = False
 
         args = dict(

qubx/backtester/simulator.py

@@ -11,7 +11,7 @@ from qubx import lookup, logger, QubxLogConfig
 from qubx.core.account import AccountProcessor
 from qubx.core.helpers import BasicScheduler
 from qubx.core.loggers import InMemoryLogsWriter, StrategyLogging
-from qubx.core.series import Quote
+from qubx.core.series import Quote, time_as_nsec
 from qubx.core.basics import (
     ITimeProvider,
     Instrument,
@@ -23,6 +23,7 @@ from qubx.core.basics import (
     TradingSessionResult,
     TransactionCostsCalculator,
     dt_64,
+    SubscriptionType,
 )
 from qubx.core.series import TimeSeries, Trade, Quote, Bar, OHLCV
 from qubx.core.interfaces import (
@@ -32,7 +33,6 @@ from qubx.core.interfaces import (
     PositionsTracker,
     IStrategyContext,
     TriggerEvent,
-    SubscriptionType,
 )
 
 from qubx.core.context import StrategyContext
@@ -50,6 +50,7 @@ from qubx.data.readers import (
 )
 from qubx.pandaz.utils import scols
 from qubx.utils.misc import ProgressParallel
+from qubx.utils.time import infer_series_frequency
 from joblib import delayed
 from .queue import DataLoader, SimulatedDataQueue, EventBatcher
 
@@ -287,22 +288,21 @@ class SimulatedTrading(ITradingServiceProvider):
         return [o for ome in self._ome.values() for o in ome.get_open_orders()]
 
     def get_position(self, instrument: Instrument) -> Position:
-        symbol = instrument.symbol
-
-        if symbol not in self.acc._positions:
-            # - initiolize OME for this instrument
-            self._ome[instrument] = OrdersManagementEngine(
-                instrument=instrument,
-                time_provider=self,
-                tcc=self._fees_calculator,  # type: ignore
-                fill_stop_order_at_price=self._fill_stop_order_at_price,
-            )
-
-            # - initiolize empty position
-            position = Position(instrument)  # type: ignore
-            self._half_tick_size[instrument] = instrument.min_tick / 2  # type: ignore
-            self.acc.attach_positions(position)
+        if instrument in self.acc.positions:
+            return self.acc.positions[instrument]
+
+        # - initiolize OME for this instrument
+        self._ome[instrument] = OrdersManagementEngine(
+            instrument=instrument,
+            time_provider=self,
+            tcc=self._fees_calculator,  # type: ignore
+            fill_stop_order_at_price=self._fill_stop_order_at_price,
+        )
 
+        # - initiolize empty position
+        position = Position(instrument)  # type: ignore
+        self._half_tick_size[instrument] = instrument.min_tick / 2  # type: ignore
+        self.acc.attach_positions(position)
         return self.acc._positions[instrument]
 
     def time(self) -> dt_64:
@@ -391,7 +391,7 @@ class SimulatedExchange(IBrokerServiceProvider):
     _scheduler: BasicScheduler
     _current_time: dt_64
     _hist_data_type: str
-    _loaders: dict[str, dict[str, DataLoader]]
+    _loaders: dict[Instrument, dict[str, DataLoader]]
     _pregenerated_signals: Dict[Instrument, pd.Series]
 
     def __init__(
@@ -432,22 +432,22 @@ class SimulatedExchange(IBrokerServiceProvider):
         self,
         instruments: list[Instrument],
         subscription_type: str,
+        warmup_period: str | None = None,
         timeframe: str | None = None,
-        nback: int = 0,
         **kwargs,
     ) -> bool:
         units = kwargs.get("timestamp_units", "ns")
 
         for instr in instruments:
             logger.debug(
-                f"SimulatedExchangeService :: subscribe :: {instr.symbol}({subscription_type}, {nback}, {timeframe})"
+                f"SimulatedExchangeService :: subscribe :: {instr.symbol}({subscription_type}, {warmup_period}, {timeframe})"
             )
             self._symbol_to_instrument[instr.symbol] = instr
 
             _params: Dict[str, Any] = dict(
                 reader=self._reader,
                 instrument=instr,
-                preload_bars=nback,
+                warmup_period=warmup_period,
                 timeframe=timeframe,
             )
 
@@ -470,23 +470,34 @@ class SimulatedExchange(IBrokerServiceProvider):
 
             # - add loader for this instrument
             ldr = DataLoader(**_params)
-            self._loaders[instr.symbol][subscription_type] = ldr
+            self._loaders[instr][subscription_type] = ldr
             self._data_queue += ldr
 
         return True
 
-    def unsubscribe(self, subscription_type: str, instruments: List[Instrument]) -> bool:
+    def unsubscribe(self, instruments: List[Instrument], subscription_type: str | None) -> bool:
         for instr in instruments:
             if instr.symbol in self._loaders:
-                logger.debug(f"SimulatedExchangeService :: unsubscribe :: {instr.symbol} :: {subscription_type}")
-                self._data_queue -= self._loaders[instr.symbol].pop(subscription_type)
-                if not self._loaders[instr.symbol]:
-                    self._loaders.pop(instr.symbol)
+                if subscription_type:
+                    logger.debug(f"SimulatedExchangeService :: unsubscribe :: {instr.symbol} :: {subscription_type}")
+                    self._data_queue -= self._loaders[instr].pop(subscription_type)
+                    if not self._loaders[instr]:
+                        self._loaders.pop(instr)
+                else:
+                    logger.debug(f"SimulatedExchangeService :: unsubscribe :: {instr.symbol}")
+                    for ldr in self._loaders[instr].values():
+                        self._data_queue -= ldr
+                    self._loaders.pop(instr)
         return True
 
     def has_subscription(self, subscription_type: str, instrument: Instrument) -> bool:
         return instrument in self._loaders and subscription_type in self._loaders[instrument]
 
+    def get_subscriptions(self, instrument: Instrument) -> Dict[str, Dict[str, Any]]:
+        # TODO: implement
+        # return {k: v.params for k, v in self._loaders[instrument].items()}
+        return {}
+
     def _try_add_process_signals(self, start: str | pd.Timestamp, end: str | pd.Timestamp) -> None:
         if self._pregenerated_signals:
             for s, v in self._pregenerated_signals.items():
@@ -593,17 +604,34 @@ class SimulatedExchange(IBrokerServiceProvider):
 
     def get_historical_ohlcs(self, instrument: Instrument, timeframe: str, nbarsback: int) -> list[Bar]:
         start = pd.Timestamp(self.time())
-        end = start - nbarsback * pd.Timedelta(timeframe)
+        end = start - nbarsback * (_timeframe := pd.Timedelta(timeframe))
         _spec = f"{instrument.exchange}:{instrument.symbol}"
-        records = self._reader.read(
-            data_id=_spec, start=start, stop=end, transform=AsTimestampedRecords()  # type: ignore
+        return self._convert_records_to_bars(
+            self._reader.read(data_id=_spec, start=start, stop=end, transform=AsTimestampedRecords()), 
+            time_as_nsec(self.time()), 
+            _timeframe.asm8.item()
         )
-        if not records:
-            return []
-        return [
-            Bar(np.datetime64(r["timestamp_ns"], "ns").item(), r["open"], r["high"], r["low"], r["close"], r["volume"])
-            for r in records
-        ]
+
+    def _convert_records_to_bars(self, records: List[Dict[str, Any]], cut_time_ns: int, timeframe_ns: int) -> List[Bar]:
+        """
+        Convert records to bars and we need to cut last bar up to the cut_time_ns
+        """
+        bars = []
+
+        _data_tf = infer_series_frequency([r['timestamp_ns'] for r in records[:100]])
+        timeframe_ns = _data_tf.item()
+
+        if records is not None:
+            for r in records:
+                _bts_0 = np.datetime64(r["timestamp_ns"], "ns").item()
+                o, h, l, c, v = r["open"], r["high"], r["low"], r["close"], r["volume"]
+
+                if _bts_0 <= cut_time_ns and cut_time_ns < _bts_0 + timeframe_ns:
+                    break
+
+                bars.append(Bar(_bts_0, o, h, l, c, v))
+
+        return bars
 
     def set_generated_signals(self, signals: pd.Series | pd.DataFrame):
         logger.debug(f"Using pre-generated signals:\n {str(signals.count()).strip('ndtype: int64')}")
@@ -896,11 +924,6 @@ class SignalsProxy(IStrategy):
     def on_init(self, ctx: IStrategyContext):
         ctx.set_base_subscription(SubscriptionType.OHLC, timeframe=self.timeframe)
 
-    def on_fit(
-        self, ctx: IStrategyContext, fit_time: str | pd.Timestamp, previous_fit_time: str | pd.Timestamp | None = None
-    ):
-        return None
-
     def on_event(self, ctx: IStrategyContext, event: TriggerEvent) -> Optional[List[Signal]]:
         if event.data and event.type == "event":
             signal = event.data.get("order")