Qubx 0.6.59__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.60__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/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:
@@ -1145,8 +1175,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 +1265,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 +1553,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 +1562,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
         """
         ...
 

qubx/core/loggers.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Tuple
+from typing import Any
 
 import numpy as np
 
@@ -8,6 +8,7 @@ from qubx.core.basics import (
     Deal,
     Instrument,
     Position,
+    Signal,
     TargetPosition,
 )
 from qubx.core.series import time_as_nsec
@@ -32,7 +33,7 @@ class LogsWriter:
         self.strategy_id = strategy_id
         self.run_id = run_id
 
-    def write_data(self, log_type: str, data: List[Dict[str, Any]]):
+    def write_data(self, log_type: str, data: list[dict[str, Any]]):
         pass
 
     def flush_data(self):
@@ -78,7 +79,7 @@ class PositionsDumper(_BaseIntervalDumper):
     so we could check current situation.
     """
 
-    positions: Dict[Instrument, Position]
+    positions: dict[Instrument, Position]
     _writer: LogsWriter
 
     def __init__(
@@ -155,15 +156,15 @@ class ExecutionsLogger(_BaseIntervalDumper):
     """
 
     _writer: LogsWriter
-    _deals: List[Tuple[Instrument, Deal]]
+    _deals: list[tuple[Instrument, Deal]]
 
     def __init__(self, writer: LogsWriter, max_records=10) -> None:
         super().__init__(None)  # no intervals
         self._writer = writer
         self._max_records = max_records
-        self._deals: List[Tuple[Instrument, Deal]] = []
+        self._deals = []
 
-    def record_deals(self, instrument: Instrument, deals: List[Deal]):
+    def record_deals(self, instrument: Instrument, deals: list[Deal]):
         for d in deals:
             self._deals.append((instrument, d))
             l_time = d.time
@@ -201,54 +202,77 @@ class ExecutionsLogger(_BaseIntervalDumper):
         self._writer.flush_data()
 
 
-class SignalsLogger(_BaseIntervalDumper):
+class SignalsAndTargetsLogger(_BaseIntervalDumper):
     """
-    Signals logger - save signals generated by strategy
+    Signals and targets logger - save signals generated by strategy
     """
 
     _writer: LogsWriter
-    _targets: List[TargetPosition]
+    _targets: list[TargetPosition]
+    _signals: list[Signal]
 
     def __init__(self, writer: LogsWriter, max_records=100) -> None:
         super().__init__(None)
         self._writer = writer
         self._max_records = max_records
         self._targets = []
+        self._signals = []
 
-    def record_signals(self, signals: List[TargetPosition]):
+    def record_targets(self, signals: list[TargetPosition]):
         self._targets.extend(signals)
 
         if len(self._targets) >= self._max_records:
             self.dump(None, None)
 
+    def record_signals(self, signals: list[Signal]):
+        self._signals.extend(signals)
+
+        if len(self._signals) >= self._max_records:
+            self.dump(None, None)
+
     def dump(self, interval_start_time: np.datetime64 | None, actual_timestamp: np.datetime64 | None):
-        data = []
-        for s in self._targets:
-            data.append(
-                {
-                    "timestamp": s.time,
-                    "symbol": s.instrument.symbol,
-                    "exchange": s.instrument.exchange,
-                    "market_type": s.instrument.market_type,
-                    "signal": s.signal.signal,
-                    "target_position": s.target_position_size,
-                    "reference_price": s.signal.reference_price,
-                    "price": s.price,
-                    "take": s.take,
-                    "stop": s.stop,
-                    "group": s.signal.group,
-                    "comment": s.signal.comment,
-                    "service": s.is_service,
-                }
-            )
+        t_data = [
+            {
+                "timestamp": t.time,
+                "symbol": t.instrument.symbol,
+                "exchange": t.instrument.exchange,
+                "market_type": t.instrument.market_type,
+                "target_position": t.target_position_size,
+                "entry_price": t.entry_price,
+                "take_price": t.take_price,
+                "stop_price": t.stop_price,
+            }
+            for t in self._targets
+        ]
+
+        s_data = [
+            {
+                "timestamp": s.time,
+                "symbol": s.instrument.symbol,
+                "exchange": s.instrument.exchange,
+                "market_type": s.instrument.market_type,
+                "signal": s.signal,
+                "reference_price": s.reference_price,
+                "price": s.price,
+                "take": s.take,
+                "stop": s.stop,
+                "group": s.group,
+                "comment": s.comment,
+                "service": s.is_service,
+            }
+            for s in self._signals
+        ]
+        self._writer.write_data("targets", t_data)
         self._targets.clear()
-        self._writer.write_data("signals", data)
+
+        self._writer.write_data("signals", s_data)
+        self._signals.clear()
 
     def store(self, timestamp: np.datetime64):
         pass
 
     def close(self):
-        if self._targets:
+        if self._targets or self._signals:
             self.dump(None, None)
         self._writer.flush_data()
 
@@ -298,7 +322,7 @@ class StrategyLogging:
     portfolio_logger: PortfolioLogger | None = None
     executions_logger: ExecutionsLogger | None = None
     balance_logger: BalanceLogger | None = None
-    signals_logger: SignalsLogger | None = None
+    signals_logger: SignalsAndTargetsLogger | None = None
     heartbeat_freq: np.timedelta64 | None = None
 
     _last_heartbeat_ts: np.datetime64 | None = None
@@ -328,7 +352,7 @@ class StrategyLogging:
 
             # - store signals
             if num_signals_records_to_write >= 1:
-                self.signals_logger = SignalsLogger(logs_writer, num_signals_records_to_write)
+                self.signals_logger = SignalsAndTargetsLogger(logs_writer, num_signals_records_to_write)
 
             # - balance logger
             self.balance_logger = BalanceLogger(logs_writer, positions_log_freq)
@@ -388,13 +412,17 @@ class StrategyLogging:
         # - log heartbeat
         self._log_heartbeat(timestamp)
 
-    def save_deals(self, instrument: Instrument, deals: List[Deal]):
+    def save_deals(self, instrument: Instrument, deals: list[Deal]):
         if self.executions_logger:
             self.executions_logger.record_deals(instrument, deals)
 
-    def save_signals_targets(self, targets: List[TargetPosition]):
+    def save_targets(self, targets: list[TargetPosition]):
         if self.signals_logger and targets:
-            self.signals_logger.record_signals(targets)
+            self.signals_logger.record_targets(targets)
+
+    def save_signals(self, signals: list[Signal]):
+        if self.signals_logger and signals:
+            self.signals_logger.record_signals(signals)
 
     def _log_heartbeat(self, timestamp: np.datetime64):
         if not self.heartbeat_freq: