Qubx 0.6.59__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.61__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/simulator.py

@@ -265,12 +265,13 @@ def _run_setup(
             stop,
             setup.exchanges,
             setup.instruments,
-            setup.capital,
-            setup.base_currency,
-            commissions_for_result,
-            runner.logs_writer.get_portfolio(as_plain_dataframe=True),
-            runner.logs_writer.get_executions(),
-            runner.logs_writer.get_signals(),
+            capital=setup.capital,
+            base_currency=setup.base_currency,
+            commissions=commissions_for_result,
+            portfolio_log=runner.logs_writer.get_portfolio(as_plain_dataframe=True),
+            executions_log=runner.logs_writer.get_executions(),
+            signals_log=runner.logs_writer.get_signals(),
+            targets_log=runner.logs_writer.get_targets(),
             strategy_class=runner.strategy_class,
             parameters=runner.strategy_params,
             is_simulation=True,

qubx/backtester/utils.py

@@ -209,7 +209,7 @@ class SignalsProxy(IStrategy):
             signal = event.data.get("order")
             # - TODO: also need to think about how to pass stop/take here
             if signal is not None and event.instrument:
-                return [event.instrument.signal(signal)]
+                return [event.instrument.signal(ctx, signal)]
         return None
 
 

qubx/core/basics.py

@@ -56,22 +56,73 @@ class TimestampedDict:
     data: dict[str, Any]
 
 
+class ITimeProvider:
+    """
+    Generic interface for providing current time
+    """
+
+    def time(self) -> dt_64:
+        """
+        Returns current time
+        """
+        ...
+
+
 # Alias for timestamped data types used in Qubx
 Timestamped: TypeAlias = Quote | Trade | Bar | OrderBook | TimestampedDict | FundingRate | Liquidation
 
 
+@dataclass
+class TargetPosition:
+    """
+    Class for presenting target position calculated from signal
+    """
+
+    time: dt_64 | str  # time when position was created
+    instrument: "Instrument"
+    target_position_size: float  # actual position size after processing in sizer
+    entry_price: float | None = None
+    stop_price: float | None = None
+    take_price: float | None = None
+    options: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def price(self) -> float | None:
+        return self.entry_price
+
+    @property
+    def stop(self) -> float | None:
+        return self.stop_price
+
+    @property
+    def take(self) -> float | None:
+        return self.take_price
+
+    def __str__(self) -> str:
+        _d = f"{pd.Timestamp(self.time).strftime('%Y-%m-%d %H:%M:%S.%f')}"
+        _p = f" @ {self.entry_price}" if self.entry_price is not None else ""
+        _s = f" stop: {self.stop_price}" if self.stop_price is not None else ""
+        _t = f" take: {self.take_price}" if self.take_price is not None else ""
+        return f"[{_d}] TARGET {self.target_position_size:+f} {self.instrument.base}{_p}{_s}{_t} for {self.instrument}"
+
+
 @dataclass
 class Signal:
     """
     Class for presenting signals generated by strategy
 
     Attributes:
-        reference_price: float - exact price when signal was generated
+        reference_price: float - aux market price when signal was generated
+        is_service: bool - when we need this signal only for informative purposes (post-factum risk management etc)
 
         Options:
-        - allow_override: bool - if True, and there is another signal for the same instrument, then override current.
+            - allow_override: bool - if True, and there is another signal for the same instrument, then override current.
+            - group: str - group name for signal
+            - comment: str - comment for signal
+            - options: dict[str, Any] - additional options for signal
     """
 
+    time: dt_64 | str  # time when signal was generated
     instrument: "Instrument"
     signal: float
     price: float | None = None
@@ -81,20 +132,37 @@ class Signal:
     group: str = ""
     comment: str = ""
     options: dict[str, Any] = field(default_factory=dict)
+    is_service: bool = False  # when we need this signal only for informative purposes (post-factum risk management etc)
+
+    def target_for_amount(self, amount: float, **kwargs) -> TargetPosition:
+        assert not self.is_service, "Service signals can't be converted to target positions !"
+        return self.instrument.target(
+            self.time,
+            self.instrument.round_size_down(amount),
+            entry_price=self.price,
+            stop_price=self.stop,
+            take_price=self.take,
+            options=self.options,
+            **kwargs,
+        )
 
     def __str__(self) -> str:
+        _d = f"{pd.Timestamp(self.time).strftime('%Y-%m-%d %H:%M:%S.%f')}"
         _p = f" @ {self.price}" if self.price is not None else ""
         _s = f" stop: {self.stop}" if self.stop is not None else ""
         _t = f" take: {self.take}" if self.take is not None else ""
         _r = f" {self.reference_price:.2f}" if self.reference_price is not None else ""
         _c = f" ({self.comment})" if self.comment else ""
-        return f"{self.group}{_r} {self.signal:+f} {self.instrument}{_p}{_s}{_t}{_c}"
+        _i = "SERVICE ::" if self.is_service else ""
+
+        return f"[{_d}] {_i}{self.group}{_r} {self.signal:+.2f} {self.instrument}{_p}{_s}{_t}{_c}"
 
     def copy(self) -> "Signal":
         """
         Return a copy of the original signal
         """
         return Signal(
+            self.time,
             self.instrument,
             self.signal,
             self.price,
@@ -104,60 +172,27 @@ class Signal:
             self.group,
             self.comment,
             dict(self.options),
+            self.is_service,
         )
 
 
 @dataclass
-class TargetPosition:
+class InitializingSignal(Signal):
     """
-    Class for presenting target position calculated from signal
+    Special signal type for post-warmup initialization
     """
 
-    time: dt_64  # time when position was set
-    signal: Signal  # original signal
-    target_position_size: float  # actual position size after processing in sizer
-    _is_service: bool = False
-
-    @staticmethod
-    def create(ctx: "ITimeProvider", signal: Signal, target_size: float) -> "TargetPosition":
-        return TargetPosition(ctx.time(), signal, signal.instrument.round_size_down(target_size))
-
-    @staticmethod
-    def zero(ctx: "ITimeProvider", signal: Signal) -> "TargetPosition":
-        return TargetPosition(ctx.time(), signal, 0.0)
-
-    @staticmethod
-    def service(ctx: "ITimeProvider", signal: Signal, size: float | None = None) -> "TargetPosition":
-        """
-        Generate just service position target (for logging purposes)
-        """
-        return TargetPosition(ctx.time(), signal, size if size else signal.signal, _is_service=True)
-
-    @property
-    def instrument(self) -> "Instrument":
-        return self.signal.instrument
-
-    @property
-    def price(self) -> float | None:
-        return self.signal.price
-
-    @property
-    def stop(self) -> float | None:
-        return self.signal.stop
-
-    @property
-    def take(self) -> float | None:
-        return self.signal.take
-
-    @property
-    def is_service(self) -> bool:
-        """
-        Some target may be used just for informative purposes (post-factum risk management etc)
-        """
-        return self._is_service
+    use_limit_order: bool = False  # if True, then use limit order for post-warmup initialization
 
     def __str__(self) -> str:
-        return f"{'::: INFORMATIVE ::: ' if self.is_service else ''}Target {self.target_position_size:+f} for {self.signal}"
+        _d = f"{pd.Timestamp(self.time).strftime('%Y-%m-%d %H:%M:%S.%f')}"
+        _p = f" @ {self.price}" if self.price is not None else ""
+        _s = f" stop: {self.stop}" if self.stop is not None else ""
+        _t = f" take: {self.take}" if self.take is not None else ""
+        _r = f" {self.reference_price:.2f}" if self.reference_price is not None else ""
+        _c = f" ({self.comment})" if self.comment else ""
+
+        return f"[{_d}] POST-WARMUP-INIT ::{self.group}{_r} {self.signal:+.2f} {self.instrument}{_p}{_s}{_t}{_c}"
 
 
 class AssetType(StrEnum):
@@ -261,8 +296,26 @@ class Instrument:
         """
         return prec_ceil(price, self.price_precision)
 
+    def service_signal(
+        self,
+        time: dt_64 | str | ITimeProvider,
+        signal: float,
+        price: float | None = None,
+        stop: float | None = None,
+        take: float | None = None,
+        group: str = "",
+        comment: str = "",
+        options: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> Signal:
+        """
+        Create service signal for the instrument
+        """
+        return self.signal(time, signal, price, stop, take, group, comment, options, is_service=True, **kwargs)
+
     def signal(
         self,
+        time: dt_64 | str | ITimeProvider,
         signal: float,
         price: float | None = None,
         stop: float | None = None,
@@ -270,9 +323,14 @@ class Instrument:
         group: str = "",
         comment: str = "",
         options: dict[str, Any] | None = None,
+        is_service: bool = False,
         **kwargs,
     ) -> Signal:
+        """
+        Create signal for the instrument
+        """
         return Signal(
+            time=time.time() if isinstance(time, ITimeProvider) else time,
             instrument=self,
             signal=signal,
             price=price,
@@ -281,6 +339,30 @@ class Instrument:
             group=group,
             comment=comment,
             options=(options or {}) | kwargs,
+            is_service=is_service,
+        )
+
+    def target(
+        self,
+        time: dt_64 | str | ITimeProvider,
+        amount: float,
+        entry_price: float | None = None,
+        stop_price: float | None = None,
+        take_price: float | None = None,
+        options: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> TargetPosition:
+        """
+        Create target position for the instrument
+        """
+        return TargetPosition(
+            time=time.time() if isinstance(time, ITimeProvider) else time,
+            instrument=self,
+            target_position_size=self.round_size_down(amount),
+            entry_price=entry_price,
+            stop_price=stop_price,
+            take_price=take_price,
+            options=(options or {}) | kwargs,
         )
 
     def __hash__(self) -> int:
@@ -736,18 +818,6 @@ class CtrlChannel:
             raise QueueTimeout(f"Timeout waiting for data on {self.name} channel")
 
 
-class ITimeProvider:
-    """
-    Generic interface for providing current time
-    """
-
-    def time(self) -> dt_64:
-        """
-        Returns current time
-        """
-        ...
-
-
 class DataType(StrEnum):
     """
     Data type constants. Used for specifying the type of data and can be used for subscription to.
@@ -884,6 +954,7 @@ class RestoredState:
 
     time: np.datetime64
     balances: dict[str, AssetBalance]
+    instrument_to_signal_positions: dict[Instrument, list[Signal]]
     instrument_to_target_positions: dict[Instrument, list[TargetPosition]]
     positions: dict[Instrument, Position]
 

qubx/core/context.py

@@ -15,6 +15,8 @@ from qubx.core.basics import (
     Order,
     OrderRequest,
     Position,
+    Signal,
+    TargetPosition,
     Timestamped,
     dt_64,
 )
@@ -87,6 +89,7 @@ class StrategyContext(IStrategyContext):
 
     _warmup_positions: dict[Instrument, Position] | None = None
     _warmup_orders: dict[Instrument, list[Order]] | None = None
+    _warmup_active_targets: dict[Instrument, list[TargetPosition]] | None = None
 
     def __init__(
         self,
@@ -420,6 +423,8 @@ class StrategyContext(IStrategyContext):
 
     # ITradingManager delegation
     def trade(self, instrument: Instrument, amount: float, price: float | None = None, time_in_force="gtc", **options):
+        # TODO: we need to generate target position and apply it in the processing manager
+        # - one of the options is to have multiple entry levels in TargetPosition class
         return self._trading_manager.trade(instrument, amount, price, time_in_force, **options)
 
     def trade_async(
@@ -522,16 +527,28 @@ class StrategyContext(IStrategyContext):
     def is_fitted(self) -> bool:
         return self._processing_manager.is_fitted()
 
+    def get_active_targets(self) -> dict[Instrument, list[TargetPosition]]:
+        return self._processing_manager.get_active_targets()
+
+    def emit_signal(self, signal: Signal) -> None:
+        return self._processing_manager.emit_signal(signal)
+
     # IWarmupStateSaver delegation
     def set_warmup_positions(self, positions: dict[Instrument, Position]) -> None:
         self._warmup_positions = positions
 
+    def set_warmup_active_targets(self, active_targets: dict[Instrument, list[TargetPosition]]) -> None:
+        self._warmup_active_targets = active_targets
+
     def set_warmup_orders(self, orders: dict[Instrument, list[Order]]) -> None:
         self._warmup_orders = orders
 
     def get_warmup_positions(self) -> dict[Instrument, Position]:
         return self._warmup_positions if self._warmup_positions is not None else {}
 
+    def get_warmup_active_targets(self) -> dict[Instrument, list[TargetPosition]]:
+        return self._warmup_active_targets if self._warmup_active_targets is not None else {}
+
     def get_warmup_orders(self) -> dict[Instrument, list[Order]]:
         return self._warmup_orders if self._warmup_orders is not None else {}
 

qubx/core/helpers.py

@@ -276,6 +276,10 @@ def _parse_schedule_spec(schedule: str) -> dict[str, str]:
     return {k: v for k, v in m.groupdict().items() if v} if m else {}
 
 
+def _to_dt_64(time: float) -> np.datetime64:
+    return np.datetime64(int(time * 1000000000), "ns")
+
+
 def process_schedule_spec(spec_str: str | None) -> dict[str, Any]:
     AS_INT = lambda d, k: int(d.get(k, 0))  # noqa: E731
     S = lambda s: [x for x in re.split(r"[, ]", s) if x]  # noqa: E731
@@ -409,11 +413,11 @@ class BasicScheduler:
         prev_time = iter.get_prev()
         next_time = iter.get_next(start_time=start_time)
         if next_time:
-            self._scdlr.enterabs(next_time, 1, self._trigger, (event, prev_time, next_time))
+            self._scdlr.enterabs(next_time, 1, self._trigger, (event, _to_dt_64(prev_time), _to_dt_64(next_time)))
 
             # - update next nearest time
             self._next_times[event] = next_time
-            self._next_nearest_time = np.datetime64(int(min(self._next_times.values()) * 1000000000), "ns")
+            self._next_nearest_time = _to_dt_64(min(self._next_times.values()))
             # logger.debug(f" >>> ({event}) task is scheduled at {self._next_nearest_time}")
 
             return True

qubx/core/interfaces.py

@@ -508,7 +508,9 @@ class IMarketManager(ITimeProvider):
         """
         ...
 
-    def ohlc_pd(self, instrument: Instrument, timeframe: str | None = None, length: int | None = None, consolidated: bool = True) -> pd.DataFrame:
+    def ohlc_pd(
+        self, instrument: Instrument, timeframe: str | None = None, length: int | None = None, consolidated: bool = True
+    ) -> pd.DataFrame:
         """Get OHLCV data for an instrument as pandas DataFrame.
 
         Args:
@@ -1035,6 +1037,26 @@ class IProcessingManager:
         """
         ...
 
+    def get_active_targets(self) -> dict[Instrument, TargetPosition]:
+        """
+        Get active target positions for each instrument in the universe.
+        Target position (TP) is considered active if
+            1. signal (S) is sent, converted to a TP, and position is open
+            2. S is sent, converted to a TP, and limit order is sent for opening
+
+        So when position is closed TP (because of opposite signal or stop loss/take profit) becomes inactive.
+
+        Returns:
+            dict[Instrument, TargetPosition]: Dictionary mapping instruments to their active targets.
+        """
+        ...
+
+    def emit_signal(self, signal: Signal) -> None:
+        """
+        Emit a signal for processing
+        """
+        ...
+
 
 class IWarmupStateSaver:
     """
@@ -1057,6 +1079,14 @@ class IWarmupStateSaver:
         """Get warmup orders."""
         ...
 
+    def set_warmup_active_targets(self, active_targets: dict[Instrument, TargetPosition]) -> None:
+        """Set warmup active targets."""
+        ...
+
+    def get_warmup_active_targets(self) -> dict[Instrument, TargetPosition]:
+        """Get warmup active targets."""
+        ...
+
 
 @dataclass
 class StrategyState:
@@ -1118,6 +1148,11 @@ class IStrategyContext(
         """Check if the strategy context is running in simulation mode."""
         return False
 
+    @property
+    def is_live_or_warmup(self) -> bool:
+        """Check if the strategy context is running in live or warmup mode."""
+        return not self.is_simulation or self.is_warmup_in_progress
+
     @property
     def is_paper_trading(self) -> bool:
         """Check if the strategy context is running in simulated trading mode."""
@@ -1145,8 +1180,6 @@ class IPositionGathering:
         res = {}
         if targets:
             for t in targets:
-                if t.is_service:  # we skip processing service positions
-                    continue
                 try:
                     res[t.instrument] = self.alter_position_size(ctx, t)
                 except Exception as ex:
@@ -1237,6 +1270,16 @@ class PositionsTracker:
         """
         ...
 
+    def restore_position_from_target(self, ctx: IStrategyContext, target: TargetPosition):
+        """
+        Restore active position and tracking from the target.
+
+        Args:
+            - ctx: Strategy context object.
+            - target: Target position to restore from.
+        """
+        ...
+
 
 @dataclass
 class HealthMetrics:
@@ -1515,6 +1558,7 @@ class StateResolverProtocol(Protocol):
         ctx: "IStrategyContext",
         sim_positions: dict[Instrument, Position],
         sim_orders: dict[Instrument, list[Order]],
+        sim_active_targets: dict[Instrument, TargetPosition],
     ) -> None:
         """
         Resolve position mismatches between warmup simulation and live trading.
@@ -1523,6 +1567,7 @@ class StateResolverProtocol(Protocol):
             ctx (IStrategyContext): The strategy context
             sim_positions (dict[Instrument, Position]): Positions from the simulation
             sim_orders (dict[Instrument, list[Order]]): Orders from the simulation
+            sim_active_targets (dict[Instrument, TargetPosition]): Active targets from the simulation
         """
         ...