Qubx 0.6.6__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.8__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/account.py

@@ -154,7 +154,6 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
             return
         for r in ome.process_market_data(data):
             if r.exec is not None:
-                # TODO: why do we pop here if it is popped later after send
                 if r.order.id in self.order_to_instrument:
                     self.order_to_instrument.pop(r.order.id)
                 # - process methods will be called from stg context

qubx/backtester/runner.py

@@ -8,7 +8,8 @@ from qubx.core.basics import SW, DataType
 from qubx.core.context import StrategyContext
 from qubx.core.exceptions import SimulationConfigError, SimulationError
 from qubx.core.helpers import extract_parameters_from_object, full_qualified_class_name
-from qubx.core.interfaces import IMetricEmitter, IStrategy, IStrategyContext
+from qubx.core.initializer import BasicStrategyInitializer
+from qubx.core.interfaces import IMetricEmitter, IStrategy, IStrategyContext, StrategyState
 from qubx.core.loggers import InMemoryLogsWriter, StrategyLogging
 from qubx.core.lookups import lookup
 from qubx.pandaz.utils import _frame_to_str
@@ -58,6 +59,8 @@ class SimulationRunner:
         account_id: str = "SimulatedAccount",
         portfolio_log_freq: str = "5Min",
         emitter: IMetricEmitter | None = None,
+        strategy_state: StrategyState | None = None,
+        initializer: BasicStrategyInitializer | None = None,
     ):
         """
         Initialize the BacktestContextRunner with a strategy context.
@@ -78,6 +81,8 @@ class SimulationRunner:
         self.account_id = account_id
         self.portfolio_log_freq = portfolio_log_freq
         self.emitter = emitter
+        self.strategy_state = strategy_state if strategy_state is not None else StrategyState()
+        self.initializer = initializer
         self.ctx = self._create_backtest_context()
 
         # - get strategy parameters BEFORE simulation start
@@ -239,6 +244,8 @@ class SimulationRunner:
             logging=StrategyLogging(logs_writer, portfolio_log_freq=self.portfolio_log_freq),
             aux_data_provider=_aux_data,
             emitter=self.emitter,
+            strategy_state=self.strategy_state,
+            initializer=self.initializer,
         )
 
         # - setup base subscription from spec

qubx/connectors/ccxt/broker.py

@@ -11,6 +11,7 @@ from qubx.core.basics import (
     Order,
     Position,
 )
+from qubx.core.exceptions import InvalidOrderParameters
 from qubx.core.interfaces import (
     IAccountProcessor,
     IBroker,
@@ -54,13 +55,20 @@ class CcxtBroker(IBroker):
         price: float | None = None,
         client_id: str | None = None,
         time_in_force: str = "gtc",
+        **options,
     ) -> Order:
         params = {}
+        _is_trigger_order = order_type.startswith("stop_")
 
-        if order_type == "limit":
+        if order_type == "limit" or _is_trigger_order:
             params["timeInForce"] = time_in_force.upper()
             if price is None:
-                raise ValueError("Price must be specified for limit order")
+                raise InvalidOrderParameters(f"Price must be specified for '{order_type}' order")
+
+        # - handle trigger (stop) orders
+        if _is_trigger_order:
+            params["triggerPrice"] = price
+            order_type = order_type.split("_")[1]
 
         if client_id:
             params["newClientOrderId"] = client_id

qubx/core/context.py

@@ -100,6 +100,7 @@ class StrategyContext(IStrategyContext):
         lifecycle_notifier: IStrategyLifecycleNotifier | None = None,
         initializer: BasicStrategyInitializer | None = None,
         strategy_name: str | None = None,
+        strategy_state: StrategyState | None = None,
     ) -> None:
         self.account = account
         self.strategy = self.__instantiate_strategy(strategy, config)
@@ -122,7 +123,7 @@ class StrategyContext(IStrategyContext):
         self._cache = CachedMarketDataHolder()
         self._exporter = exporter
         self._lifecycle_notifier = lifecycle_notifier
-        self._strategy_state = StrategyState()
+        self._strategy_state = strategy_state if strategy_state is not None else StrategyState()
         self._strategy_name = strategy_name if strategy_name is not None else strategy.__class__.__name__
 
         __position_tracker = self.strategy.tracker(self)
@@ -182,7 +183,9 @@ class StrategyContext(IStrategyContext):
         self.__post_init__()
 
     def __post_init__(self) -> None:
-        self.strategy.on_init(self.initializer)
+        if not self._strategy_state.is_on_init_called:
+            self.strategy.on_init(self.initializer)
+            self._strategy_state.is_on_init_called = True
 
         if base_sub := self.initializer.get_base_subscription():
             self.set_base_subscription(base_sub)
@@ -196,6 +199,14 @@ class StrategyContext(IStrategyContext):
         if event_schedule := self.initializer.get_event_schedule():
             self.set_event_schedule(event_schedule)
 
+        if pending_global_subscriptions := self.initializer.get_pending_global_subscriptions():
+            for sub_type in pending_global_subscriptions:
+                self.subscribe(sub_type)
+
+        if pending_instrument_subscriptions := self.initializer.get_pending_instrument_subscriptions():
+            for sub_type, instruments in pending_instrument_subscriptions.items():
+                self.subscribe(sub_type, list(instruments))
+
         # - update cache default timeframe
         sub_type = self.get_base_subscription()
         _, params = DataType.from_str(sub_type)
@@ -208,7 +219,7 @@ class StrategyContext(IStrategyContext):
 
         # Update initial instruments if strategy set them after warmup
         if self.get_warmup_positions():
-            self._initial_instruments = list(self.get_warmup_positions().keys())
+            self._initial_instruments = list(set(self.get_warmup_positions().keys()) | set(self._initial_instruments))
 
         # Notify strategy start
         if self._lifecycle_notifier:
@@ -263,7 +274,8 @@ class StrategyContext(IStrategyContext):
 
         # - invoke strategy's stop code
         try:
-            self.strategy.on_stop(self)
+            if not self._strategy_state.is_warmup_in_progress:
+                self.strategy.on_stop(self)
         except Exception as strat_error:
             logger.error(
                 f"[<y>StrategyContext</y>] :: Strategy {self._strategy_name} raised an exception in on_stop: {strat_error}"

qubx/core/exceptions.py

@@ -14,6 +14,10 @@ class InvalidOrder(ExchangeError):
     pass
 
 
+class InvalidOrderParameters(ExchangeError):
+    pass
+
+
 class OrderNotFound(InvalidOrder):
     pass
 

qubx/core/helpers.py

@@ -109,13 +109,19 @@ class CachedMarketDataHolder:
         return list(self._instr_to_sub_to_buffer[instrument][event_type])
 
     def update(
-        self, instrument: Instrument, event_type: str, data: Any, update_ohlc: bool = False, is_historical: bool = False
+        self,
+        instrument: Instrument,
+        event_type: str,
+        data: Any,
+        update_ohlc: bool = False,
+        is_historical: bool = False,
+        is_base_data: bool = True,
     ) -> None:
         # - store data in buffer if it's not OHLC
         if event_type != DataType.OHLC:
             self._instr_to_sub_to_buffer[instrument][event_type].append(data)
 
-        if not is_historical:
+        if not is_historical and is_base_data:
             self._ready_instruments.add(instrument)
 
         if not update_ohlc:

qubx/core/initializer.py

@@ -8,7 +8,7 @@ schedules, warmup periods, and position mismatch resolution.
 from dataclasses import dataclass, field
 from typing import Any, Dict, Optional
 
-from qubx.core.basics import td_64
+from qubx.core.basics import Instrument, td_64
 from qubx.core.interfaces import IStrategyInitializer, StartTimeFinderProtocol, StateResolverProtocol
 from qubx.core.utils import recognize_timeframe
 
@@ -35,6 +35,9 @@ class BasicStrategyInitializer(IStrategyInitializer):
     # Additional configuration that might be needed
     config: Dict[str, Any] = field(default_factory=dict)
 
+    _pending_global_subscriptions: set[str] = field(default_factory=set)
+    _pending_instrument_subscriptions: dict[str, set[Instrument]] = field(default_factory=dict)
+
     def set_base_subscription(self, subscription_type: str) -> None:
         self.base_subscription = subscription_type
 
@@ -87,3 +90,19 @@ class BasicStrategyInitializer(IStrategyInitializer):
     @property
     def is_simulation(self) -> bool | None:
         return self.simulation
+
+    def subscribe(self, subscription_type: str, instruments: list[Instrument] | Instrument | None = None) -> None:
+        if instruments is None:
+            self._pending_global_subscriptions.add(subscription_type)
+            return
+
+        if isinstance(instruments, Instrument):
+            instruments = [instruments]
+
+        self._pending_instrument_subscriptions[subscription_type].update(instruments)
+
+    def get_pending_global_subscriptions(self) -> set[str]:
+        return self._pending_global_subscriptions
+
+    def get_pending_instrument_subscriptions(self) -> dict[str, set[Instrument]]:
+        return self._pending_instrument_subscriptions

qubx/core/interfaces.py

@@ -978,14 +978,18 @@ class IWarmupStateSaver:
 
 @dataclass
 class StrategyState:
+    is_on_init_called: bool = False
     is_on_start_called: bool = False
     is_on_warmup_finished_called: bool = False
     is_on_fit_called: bool = False
+    is_warmup_in_progress: bool = False
 
     def reset_from_state(self, state: "StrategyState"):
+        self.is_on_init_called = state.is_on_init_called
         self.is_on_start_called = state.is_on_start_called
         self.is_on_warmup_finished_called = state.is_on_warmup_finished_called
         self.is_on_fit_called = state.is_on_fit_called
+        self.is_warmup_in_progress = state.is_warmup_in_progress
 
 
 class IStrategyContext(
@@ -1380,6 +1384,27 @@ class IStrategyInitializer:
         """
         ...
 
+    def subscribe(self, subscription_type: str, instruments: list[Instrument] | Instrument | None = None) -> None:
+        """Subscribe to market data for an instrument.
+
+        Args:
+            subscription_type: Type of subscription. If None, the base subscription type is used.
+            instruments: A list of instrument of instrument to subscribe to
+        """
+        ...
+
+    def get_pending_global_subscriptions(self) -> set[str]:
+        """
+        Get the pending global subscriptions.
+        """
+        ...
+
+    def get_pending_instrument_subscriptions(self) -> dict[str, set[Instrument]]:
+        """
+        Get the pending instrument subscriptions.
+        """
+        ...
+
 
 class IStrategy(metaclass=Mixable):
     """Base class for trading strategies."""

qubx/core/lookups.py

@@ -380,7 +380,7 @@ class FeesLookup:
 
         # - check if spec is of type maker=...,taker=...
         # Check if spec is in the format maker=X,taker=Y
-        maker_taker_pattern = re.compile(r"maker=(-?[0-9.]+),taker=(-?[0-9.]+)")
+        maker_taker_pattern = re.compile(r"maker=(-?[0-9.]+)[,\ ]taker=(-?[0-9.]+)")
         match = maker_taker_pattern.match(spec)
         if match:
             maker_rate, taker_rate = float(match.group(1)), float(match.group(2))

qubx/core/mixins/processing.py

@@ -346,7 +346,14 @@ class ProcessingManager(IProcessingManager):
 
         # update cached ohlc is this is base subscription
         _update_ohlc = is_base_data
-        self._cache.update(instrument, event_type, _update, update_ohlc=_update_ohlc, is_historical=is_historical)
+        self._cache.update(
+            instrument,
+            event_type,
+            _update,
+            update_ohlc=_update_ohlc,
+            is_historical=is_historical,
+            is_base_data=is_base_data,
+        )
 
         # update trackers, gatherers on base data
         if not is_historical: