Qubx 0.6.58__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/connectors/ccxt/data.py

@@ -44,10 +44,12 @@ class CcxtDataProvider(IDataProvider):
 
     # - subscriptions
     _subscriptions: Dict[str, Set[Instrument]]
+    _pending_subscriptions: Dict[str, Set[Instrument]]  # Track subscriptions being established
     _sub_to_coro: Dict[str, concurrent.futures.Future]
     _sub_to_name: Dict[str, str]
     _sub_to_unsubscribe: Dict[str, Callable[[], Awaitable[None]]]
     _is_sub_name_enabled: Dict[str, bool]
+    _sub_connection_ready: Dict[str, bool]  # Track if connection is actually ready
 
     _sub_instr_to_time: Dict[Tuple[str, Instrument], dt_64]
     _last_quotes: Dict[Instrument, Optional[Quote]]
@@ -80,10 +82,12 @@ class CcxtDataProvider(IDataProvider):
 
         self._last_quotes = defaultdict(lambda: None)
         self._subscriptions = defaultdict(set)
+        self._pending_subscriptions = defaultdict(set)
         self._sub_to_coro = {}
         self._sub_to_name = {}
         self._sub_to_unsubscribe = {}
         self._is_sub_name_enabled = defaultdict(lambda: False)
+        self._sub_connection_ready = defaultdict(lambda: False)
         self._symbol_to_instrument = {}
         self._subscribers = {
             n.split("_subscribe_")[1]: f
@@ -135,11 +139,33 @@ class CcxtDataProvider(IDataProvider):
     def get_subscribed_instruments(self, subscription_type: str | None = None) -> list[Instrument]:
         if not subscription_type:
             return list(self.subscribed_instruments)
-        return list(self._subscriptions[subscription_type]) if subscription_type in self._subscriptions else []
+
+        # Return active subscriptions, fallback to pending if no active ones
+        _sub_type, _ = DataType.from_str(subscription_type)
+        if _sub_type in self._subscriptions:
+            return list(self._subscriptions[_sub_type])
+        elif _sub_type in self._pending_subscriptions:
+            return list(self._pending_subscriptions[_sub_type])
+        else:
+            return []
 
     def has_subscription(self, instrument: Instrument, subscription_type: str) -> bool:
         sub_type, _ = DataType.from_str(subscription_type)
-        return sub_type in self._subscriptions and instrument in self._subscriptions[sub_type]
+        # Only return True if subscription is actually active (not just pending)
+        return (
+            sub_type in self._subscriptions
+            and instrument in self._subscriptions[sub_type]
+            and self._sub_connection_ready.get(sub_type, False)
+        )
+
+    def has_pending_subscription(self, instrument: Instrument, subscription_type: str) -> bool:
+        """Check if a subscription is pending (connection being established)."""
+        sub_type, _ = DataType.from_str(subscription_type)
+        return (
+            sub_type in self._pending_subscriptions
+            and instrument in self._pending_subscriptions[sub_type]
+            and not self._sub_connection_ready.get(subscription_type, False)
+        )
 
     def warmup(self, warmups: Dict[Tuple[str, Instrument], str]) -> None:
         _coros = []
@@ -207,9 +233,9 @@ class CcxtDataProvider(IDataProvider):
 
     @property
     def subscribed_instruments(self) -> Set[Instrument]:
-        if not self._subscriptions:
-            return set()
-        return set.union(*self._subscriptions.values())
+        active = set.union(*self._subscriptions.values()) if self._subscriptions else set()
+        pending = set.union(*self._pending_subscriptions.values()) if self._pending_subscriptions else set()
+        return active.union(pending)
 
     @property
     def is_read_only(self) -> bool:
@@ -226,19 +252,29 @@ class CcxtDataProvider(IDataProvider):
         if _subscriber is None:
             raise ValueError(f"{self._exchange_id}: Subscription type {sub_type} is not supported")
 
+        # Save old subscription state before starting cleanup
+        old_sub_info = None
         if sub_type in self._sub_to_coro:
+            old_sub_info = {"name": self._sub_to_name[sub_type], "coro": self._sub_to_coro[sub_type]}
             logger.debug(
-                f"<yellow>{self._exchange_id}</yellow> Canceling existing {sub_type} subscription for {self._subscriptions[_sub_type]}"
+                f"<yellow>{self._exchange_id}</yellow> Canceling existing {sub_type} subscription for {self._subscriptions.get(_sub_type, set())}"
             )
-            # - wait for the subscriber to stop
-            self._loop.submit(self._stop_subscriber(sub_type, self._sub_to_name[sub_type])).result()
+
+            # Clear state immediately to prevent interference with new subscription
             del self._sub_to_coro[sub_type]
             del self._sub_to_name[sub_type]
-            del self._subscriptions[_sub_type]
+            # Clean up both active and pending subscriptions
+            self._subscriptions.pop(_sub_type, None)
+            self._pending_subscriptions.pop(_sub_type, None)
+            self._sub_connection_ready.pop(sub_type, None)
 
         if instruments is not None and len(instruments) == 0:
             return
 
+        # Mark subscription as pending (not active yet)
+        self._pending_subscriptions[_sub_type] = instruments
+        self._sub_connection_ready[sub_type] = False
+
         kwargs = {"instruments": instruments, **_params}
         _subscriber = self._subscribers[_sub_type]
         _subscriber_params = set(_subscriber.__code__.co_varnames[: _subscriber.__code__.co_argcount])
@@ -247,7 +283,12 @@ class CcxtDataProvider(IDataProvider):
         self._sub_to_name[sub_type] = (name := self._get_subscription_name(_sub_type, **kwargs))
         self._sub_to_coro[sub_type] = self._loop.submit(_subscriber(self, name, _sub_type, self.channel, **kwargs))
 
-        self._subscriptions[_sub_type] = instruments
+        # Now stop the old subscriber after new one is started (to avoid interference)
+        if old_sub_info is not None:
+            # Stop old subscriber in background to avoid blocking
+            self._loop.submit(self._stop_old_subscriber(old_sub_info["name"], old_sub_info["coro"]))
+
+        # Don't set _subscriptions here - it will be set when connection is established
 
     def _time_msec_nbars_back(self, timeframe: str, nbarsback: int = 1) -> int:
         return (self.time_provider.time() - nbarsback * pd.Timedelta(timeframe)).asm8.item() // 1000000
@@ -278,6 +319,14 @@ class CcxtDataProvider(IDataProvider):
             _name += f" ({kwargs_str})"
         return _name
 
+    def _mark_subscription_active(self, sub_type: str) -> None:
+        """Mark a subscription as active once the WebSocket connection is established."""
+        _sub_type, _ = DataType.from_str(sub_type)
+        if _sub_type in self._pending_subscriptions:
+            self._subscriptions[_sub_type] = self._pending_subscriptions[_sub_type]
+            self._sub_connection_ready[sub_type] = True
+            logger.debug(f"<yellow>{self._exchange_id}</yellow> Subscription {sub_type} is now active")
+
     async def _stop_subscriber(self, sub_type: str, sub_name: str) -> None:
         try:
             self._is_sub_name_enabled[sub_name] = False  # stop the subscriber
@@ -303,11 +352,57 @@ class CcxtDataProvider(IDataProvider):
                 del self._sub_to_unsubscribe[sub_name]
 
             del self._is_sub_name_enabled[sub_name]
+
+            # Clean up connection state for this subscription
+            for sub_type, stream_name in list(self._sub_to_name.items()):
+                if stream_name == sub_name:
+                    self._sub_connection_ready.pop(sub_type, None)
+                    break
+
             logger.debug(f"<yellow>{self._exchange_id}</yellow> Unsubscribed from {sub_name}")
         except Exception as e:
             logger.error(f"<yellow>{self._exchange_id}</yellow> Error stopping {sub_name}")
             logger.exception(e)
 
+    async def _stop_old_subscriber(self, old_name: str, old_coro: concurrent.futures.Future) -> None:
+        """Stop an old subscriber safely without interfering with new subscriptions."""
+        try:
+            # Disable the old stream by name
+            self._is_sub_name_enabled[old_name] = False
+
+            # Wait for the old coroutine to finish
+            total_sleep_time = 0.0
+            while old_coro.running():
+                await asyncio.sleep(1.0)
+                total_sleep_time += 1.0
+                if total_sleep_time >= 20.0:
+                    break
+
+            if old_coro.running():
+                logger.warning(
+                    f"<yellow>{self._exchange_id}</yellow> Old subscriber {old_name} is still running. Cancelling it."
+                )
+                old_coro.cancel()
+            else:
+                logger.debug(f"<yellow>{self._exchange_id}</yellow> Old subscriber {old_name} has been stopped")
+
+            # Clean up old unsubscriber if it exists
+            if old_name in self._sub_to_unsubscribe:
+                logger.debug(f"<yellow>{self._exchange_id}</yellow> Calling old unsubscriber for {old_name}")
+                await self._sub_to_unsubscribe[old_name]()
+                # Use pop to safely remove, in case it was already removed
+                self._sub_to_unsubscribe.pop(old_name, None)
+
+            # Clean up old stream state
+            if old_name in self._is_sub_name_enabled:
+                del self._is_sub_name_enabled[old_name]
+
+            logger.debug(f"<yellow>{self._exchange_id}</yellow> Old subscription {old_name} cleaned up")
+
+        except Exception as e:
+            logger.error(f"<yellow>{self._exchange_id}</yellow> Error stopping old subscriber {old_name}")
+            logger.exception(e)
+
     async def _listen_to_stream(
         self,
         subscriber: Callable[[], Awaitable[None]],
@@ -322,10 +417,22 @@ class CcxtDataProvider(IDataProvider):
 
         self._is_sub_name_enabled[name] = True
         n_retry = 0
+        connection_established = False
+
         while channel.control.is_set() and self._is_sub_name_enabled[name]:
             try:
                 await subscriber()
                 n_retry = 0
+
+                # Mark subscription as active on first successful data reception
+                if not connection_established:
+                    # Find the subscription type for this stream name
+                    for sub_type, stream_name in self._sub_to_name.items():
+                        if stream_name == name:
+                            self._mark_subscription_active(sub_type)
+                            connection_established = True
+                            break
+
                 if not self._is_sub_name_enabled[name]:
                     break
             except CcxtSymbolNotRecognized:
@@ -616,7 +723,8 @@ class CcxtDataProvider(IDataProvider):
             for exch_symbol, ccxt_ticker in ccxt_tickers.items():  # type: ignore
                 instrument = ccxt_find_instrument(exch_symbol, self._exchange, _symbol_to_instrument)
                 quote = ccxt_convert_ticker(ccxt_ticker)
-                if self._last_quotes[instrument] is None or quote.time > self._last_quotes[instrument].time:
+                last_quote = self._last_quotes[instrument]
+                if last_quote is None or quote.time > last_quote.time:
                     self._health_monitor.record_data_arrival(sub_type, dt_64(quote.time, "ns"))
                     self._last_quotes[instrument] = quote
                     channel.send((instrument, sub_type, quote, False))

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 {}