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

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/mixins/market.py

@@ -86,7 +86,7 @@ class MarketManager(IMarketManager):
             _time = pd.Timestamp(self._time_provider.time())
             _timedelta = pd.Timedelta(timeframe)
             _last_bar_time = ohlc.index[-1]
-            if _last_bar_time + _timedelta >= _time:
+            if _last_bar_time + _timedelta > _time:
                 ohlc = ohlc.iloc[:-1]
 
         if length:

qubx/core/mixins/processing.py

@@ -191,9 +191,9 @@ class ProcessingManager(IProcessingManager):
 
         # - if strategy still fitting - skip on_event call
         if self._fit_is_running:
-            logger.debug(
-                f"Skipping {self._strategy_name}::on_event({instrument}, {d_type}, [...], {is_historical}) fitting in progress (orders and deals processed)!"
-            )
+            # logger.debug(
+            #     f"Skipping {self._strategy_name}::on_event({instrument}, {d_type}, [...], {is_historical}) fitting in progress (orders and deals processed)!"
+            # )
             return False
 
         signals: list[Signal] | Signal = []

{qubx-0.6.57.dist-info → qubx-0.6.59.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: Qubx
-Version: 0.6.57
+Version: 0.6.59
 Summary: Qubx - Quantitative Trading Framework
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com

{qubx-0.6.57.dist-info → qubx-0.6.59.dist-info}/RECORD

@@ -21,7 +21,7 @@ qubx/cli/tui.py,sha256=N15UiNEdnWOWYh8E9DNlQCDWdoyP6rMGMhEItogPW88,16491
 qubx/connectors/ccxt/__init__.py,sha256=HEQ7lM9HS8sED_zfsAHrhFT7F9E7NFGAecwZwNr-TDE,65
 qubx/connectors/ccxt/account.py,sha256=HILqsSPfor58NrlP0qYwO5lkNZzUBG-SR5Hy1OSa7_M,24308
 qubx/connectors/ccxt/broker.py,sha256=Hg2tC3qKPYAURGro9ONzzR7QaiI41oytyKqQlpcM5Zw,16175
-qubx/connectors/ccxt/data.py,sha256=COVUh37ZdCUjiDB0a38Cj9SNSV8P95mqG2B3Gc_fQ2U,30172
+qubx/connectors/ccxt/data.py,sha256=gH1ug0vFvbEyUnHvgwlujsJdWbg9RXopIX3_fQhzApk,35456
 qubx/connectors/ccxt/exceptions.py,sha256=OfZc7iMdEG8uLorcZta2NuEuJrSIqi0FG7IICmwF54M,262
 qubx/connectors/ccxt/exchanges/__init__.py,sha256=dEBkyeiGEQgfyuGVhhx4ZTRIlU9e_H1m6K2ROXRpIi8,1884
 qubx/connectors/ccxt/exchanges/binance/broker.py,sha256=BB2V82zaOm1EjP3GrsOqQQMeGpml6-w23iv7goKrjyU,2111
@@ -48,16 +48,16 @@ qubx/core/loggers.py,sha256=85Xgt1-Hh-2gAlJez3TxTHr32KSWYNqNhmbeWZwhw0o,13340
 qubx/core/lookups.py,sha256=2UmODxDeDQqi-xHOvjm2_GckC4piKI3x4ZEf5vny8YI,18275
 qubx/core/metrics.py,sha256=74xIecCvlxVXl0gy0JvgjJ2X5gg-RMmVZw9hQikkHE0,60269
 qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,329
-qubx/core/mixins/market.py,sha256=MH7A2jZFEClrfeioio1lPgYBbxVZCL1Af-b-DSFvSM4,4567
-qubx/core/mixins/processing.py,sha256=pgzDCrB9A6SvsWaZ1Op-M22yvcWy6Y8L1IIef6rwpGM,30655
+qubx/core/mixins/market.py,sha256=f0PJTK5Y9nQkV2XWxytixFG1Oc6ihYVwlxIMraTnmms,4566
+qubx/core/mixins/processing.py,sha256=OBsr-2c-W_Iy68tL80wFqTPN3HnW1stDjpm77vFaSB0,30661
 qubx/core/mixins/subscription.py,sha256=V_g9wCPQ8S5SHkU-qOZ84cV5nReAUrV7DoSNAGG0LPY,10372
 qubx/core/mixins/trading.py,sha256=idfRPaqrvkfMxzu9mXr9i_xfqLee-ZAOrERxkxv6Ruo,7256
 qubx/core/mixins/universe.py,sha256=tsMpBriLHwK9lAVYvIrO94EIx8_ETSXUlzxN_sDOsL8,9838
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=CtCikl3YWB60CW205Dm9MwlVtjgcB5zuj5sXZ0PEpyo,978280
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=V-Kj9bhekUUV4wX6Ao1JzXG5tzHeaqruPLjG7Lo1i_A,978280
 qubx/core/series.pxd,sha256=jBdMwgO8J4Zrue0e_xQ5RlqTXqihpzQNu6V3ckZvvpY,3978
 qubx/core/series.pyi,sha256=RaHm_oHHiWiNUMJqVfx5FXAXniGLsHxUFOUpacn7GC0,4604
 qubx/core/series.pyx,sha256=ZQPp1-Kp2lX22n04gaBWak9mW139e-uc8bhsbZMohgs,46507
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=Sg9UQCj4hovrE6dWSuTEbss5s82m19b9ScA6ECE7tQ4,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=KpHSsIjpXpVCQ8BO8gqFT64DRPezuaYxvOJ8T4kGeVY,86568
 qubx/core/utils.pyi,sha256=a-wS13V2p_dM1CnGq40JVulmiAhixTwVwt0ah5By0Hc,348
 qubx/core/utils.pyx,sha256=k5QHfEFvqhqWfCob89ANiJDKNG8gGbOh-O4CVoneZ8M,1696
 qubx/data/__init__.py,sha256=ELZykvpPGWc5rX7QoNyNQwMLgdKMG8MACOByA4pM5hA,549
@@ -129,7 +129,7 @@ qubx/restorers/signal.py,sha256=0QFoy7OzDkK6AAmJEbbmSsHwmAhjMJYYggVFuLraKjk,1089
 qubx/restorers/state.py,sha256=dLaVnUwRCNRkUqbYyi0RfZs3Q3AdglkI_qTtQ8GDD5Y,7289
 qubx/restorers/utils.py,sha256=We2gfqwQKWziUYhuUnjb-xo-5tSlbuHWpPQn0CEMTn0,1155
 qubx/ta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=RxL_qH6tyCoHddeu7BwOmhkmV2aWPWGafq-My49AoX0,654440
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=OV84KH_YT8D_SIQjCZWERFdmBMB4o38Q8tqdDBjSpb8,654440
 qubx/ta/indicators.pxd,sha256=Goo0_N0Xnju8XGo3Xs-3pyg2qr_0Nh5C-_26DK8U_IE,4224
 qubx/ta/indicators.pyi,sha256=19W0uERft49In5bf9jkJHkzJYEyE9gzudN7_DJ5Vdv8,1963
 qubx/ta/indicators.pyx,sha256=Xgpew46ZxSXsdfSEWYn3A0Q35MLsopB9n7iyCsXTufs,25969
@@ -166,8 +166,8 @@ qubx/utils/runner/factory.py,sha256=eM4-Etcq-FewD2AjH_srFGzP413pm8er95KIZixXRpM,
 qubx/utils/runner/runner.py,sha256=PnSQ_soWXzjcIYxG5HHUtbZnWSaoeSXr7VxbQWtOsII,31444
 qubx/utils/time.py,sha256=J0ZFGjzFL5T6GA8RPAel8hKG0sg2LZXeQ5YfDCfcMHA,10055
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.57.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.57.dist-info/METADATA,sha256=udbK6RAZPp6B3-XXug773pK6FZg3PFnYuUFuoYzrbOE,4612
-qubx-0.6.57.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
-qubx-0.6.57.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.57.dist-info/RECORD,,
+qubx-0.6.59.dist-info/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.59.dist-info/METADATA,sha256=kXg2STWUJpn3dNfxzEngSiV7OMDN1unJIbcrjKzTTEE,4612
+qubx-0.6.59.dist-info/WHEEL,sha256=UckHTmFUCaLKpi4yFY8Dewu0c6XkY-KvEAGzGOnaWo8,110
+qubx-0.6.59.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.59.dist-info/RECORD,,