Qubx 0.6.72__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.74__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/data.py

@@ -27,7 +27,7 @@ def _get_first_existing(data: dict, keys: list, default: T = None) -> T:
     data_get = data.get  # Cache method lookup
     sentinel = object()
     for key in keys:
-        if (value := data_get(key, sentinel)) is not sentinel:
+        if (value := data_get(key, sentinel)) is not sentinel and value is not None:
             return value
     return default
 
@@ -169,14 +169,24 @@ class SimulatedDataProvider(IDataProvider):
             if _b_ts_0 <= cut_time_ns and cut_time_ns < _b_ts_1:
                 break
 
+            # Handle None values in OHLC data
+            open_price = r.data["open"]
+            high_price = r.data["high"]
+            low_price = r.data["low"]
+            close_price = r.data["close"]
+            
+            # Skip this record if any OHLC value is None
+            if open_price is None or high_price is None or low_price is None or close_price is None:
+                continue
+            
             bars.append(
                 Bar(
                     _b_ts_0,
-                    r.data["open"],
-                    r.data["high"],
-                    r.data["low"],
-                    r.data["close"],
-                    volume=r.data.get("volume", 0),
+                    open_price,
+                    high_price,
+                    low_price,
+                    close_price,
+                    volume=r.data.get("volume", 0) or 0,  # Handle None volume
                     bought_volume=_get_first_existing(r.data, ["taker_buy_volume", "bought_volume"], 0),
                     volume_quote=_get_first_existing(r.data, ["quote_volume", "volume_quote"], 0),
                     bought_volume_quote=_get_first_existing(

qubx/backtester/runner.py

@@ -328,6 +328,7 @@ class SimulationRunner:
 
         if not _run(instrument, data_type, event, is_hist):
             return False
+        
         return True
 
     def _handle_no_data_scenario(self, stop_time):

qubx/connectors/ccxt/adapters/polling_adapter.py

@@ -98,9 +98,6 @@ class PollingToWebSocketAdapter:
             current_symbols = list(self._symbols)
             symbols_changed = self._symbols_changed
 
-        if not current_symbols:
-            raise ValueError(f"No symbols configured for adapter {self.adapter_id}")
-
         # If symbols changed, poll immediately
         if symbols_changed:
             logger.debug(f"Symbols changed, polling immediately for adapter {self.adapter_id}")
@@ -161,7 +158,7 @@ class PollingToWebSocketAdapter:
         self._poll_count += 1
         self._last_poll_time = time.time()
 
-        logger.debug(f"Polling {len(symbols)} symbols for adapter {self.adapter_id}")
+        logger.debug(f"Polling {len(symbols) if symbols else 'all'} symbols for adapter {self.adapter_id}")
 
         try:
             # Filter out adapter-specific parameters

qubx/connectors/ccxt/broker.py

@@ -5,7 +5,7 @@ from typing import Any
 import pandas as pd
 
 import ccxt
-import ccxt.pro as cxp
+
 from ccxt.base.errors import ExchangeError
 from qubx import logger
 from qubx.core.basics import (
@@ -24,16 +24,16 @@ from qubx.core.interfaces import (
 )
 from qubx.utils.misc import AsyncThreadLoop
 
+from .exchange_manager import ExchangeManager
 from .utils import ccxt_convert_order_info, instrument_to_ccxt_symbol
 
 
 class CcxtBroker(IBroker):
-    _exchange: cxp.Exchange
-    _loop: AsyncThreadLoop
+    _exchange_manager: ExchangeManager
 
     def __init__(
         self,
-        exchange: cxp.Exchange,
+        exchange_manager: ExchangeManager,
         channel: CtrlChannel,
         time_provider: ITimeProvider,
         account: IAccountProcessor,
@@ -44,19 +44,24 @@ class CcxtBroker(IBroker):
         enable_create_order_ws: bool = False,
         enable_cancel_order_ws: bool = False,
     ):
-        self._exchange = exchange
-        self.ccxt_exchange_id = str(exchange.name)
+        self._exchange_manager = exchange_manager
+        self.ccxt_exchange_id = str(self._exchange_manager.exchange.name)
         self.channel = channel
         self.time_provider = time_provider
         self.account = account
         self.data_provider = data_provider
-        self._loop = AsyncThreadLoop(exchange.asyncio_loop)
         self.cancel_timeout = cancel_timeout
         self.cancel_retry_interval = cancel_retry_interval
         self.max_cancel_retries = max_cancel_retries
         self.enable_create_order_ws = enable_create_order_ws
         self.enable_cancel_order_ws = enable_cancel_order_ws
 
+    @property
+    def _loop(self) -> AsyncThreadLoop:
+        """Get current AsyncThreadLoop for the exchange."""
+        return AsyncThreadLoop(self._exchange_manager.exchange.asyncio_loop)
+
+
     @property
     def is_simulated_trading(self) -> bool:
         return False
@@ -255,9 +260,9 @@ class CcxtBroker(IBroker):
                 instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
             )
             if self.enable_create_order_ws:
-                r = await self._exchange.create_order_ws(**payload)
+                r = await self._exchange_manager.exchange.create_order_ws(**payload)
             else:
-                r = await self._exchange.create_order(**payload)
+                r = await self._exchange_manager.exchange.create_order(**payload)
 
             if r is None:
                 msg = "(::_create_order) No response from exchange"
@@ -294,12 +299,14 @@ class CcxtBroker(IBroker):
             raise BadRequest(f"Quote is not available for order creation for {instrument.symbol}")
 
         # TODO: think about automatically setting reduce only when needed
-        if not options.get("reduceOnly", False):
+        if not (reduce_only := options.get("reduceOnly", False)):
             min_notional = instrument.min_notional
             if min_notional > 0 and abs(amount) * quote.mid_price() < min_notional:
                 raise InvalidOrderParameters(
                     f"[{instrument.symbol}] Order amount {amount} is too small. Minimum notional is {min_notional}"
                 )
+        else:
+            params["reduceOnly"] = reduce_only
 
         # - handle trigger (stop) orders
         if _is_trigger_order:
@@ -357,9 +364,9 @@ class CcxtBroker(IBroker):
         while True:
             try:
                 if self.enable_cancel_order_ws:
-                    await self._exchange.cancel_order_ws(order_id, symbol=instrument_to_ccxt_symbol(instrument))
+                    await self._exchange_manager.exchange.cancel_order_ws(order_id, symbol=instrument_to_ccxt_symbol(instrument))
                 else:
-                    await self._exchange.cancel_order(order_id, symbol=instrument_to_ccxt_symbol(instrument))
+                    await self._exchange_manager.exchange.cancel_order(order_id, symbol=instrument_to_ccxt_symbol(instrument))
                 return True
             except ccxt.OperationRejected as err:
                 err_msg = str(err).lower()

qubx/connectors/ccxt/connection_manager.py

@@ -7,62 +7,75 @@ separating connection concerns from subscription state and data handling.
 
 import asyncio
 import concurrent.futures
+import time
 from asyncio.exceptions import CancelledError
 from collections import defaultdict
-from typing import Awaitable, Callable, Dict
+from typing import Awaitable, Callable
 
 from ccxt import ExchangeClosedByUser, ExchangeError, ExchangeNotAvailable, NetworkError
 from ccxt.pro import Exchange
 from qubx import logger
 from qubx.core.basics import CtrlChannel
+from qubx.utils.misc import AsyncThreadLoop
 
 from .exceptions import CcxtSymbolNotRecognized
+from .exchange_manager import ExchangeManager
 from .subscription_manager import SubscriptionManager
 
 
 class ConnectionManager:
     """
     Manages WebSocket connections and stream lifecycle for CCXT data provider.
-    
+
     Responsibilities:
     - Handle WebSocket connection establishment and management
     - Implement retry logic and error handling
     - Manage stream lifecycle (start, stop, cleanup)
     - Coordinate with SubscriptionManager for state updates
     """
-    
+
     def __init__(
-        self, 
-        exchange_id: str, 
+        self,
+        exchange_id: str,
+        exchange_manager: ExchangeManager,
         max_ws_retries: int = 10,
-        subscription_manager: SubscriptionManager | None = None
+        subscription_manager: SubscriptionManager | None = None,
+        cleanup_timeout: float = 3.0,
     ):
         self._exchange_id = exchange_id
+        self._exchange_manager = exchange_manager
         self.max_ws_retries = max_ws_retries
         self._subscription_manager = subscription_manager
-        
+        self._cleanup_timeout = cleanup_timeout
+
         # Stream state management
-        self._is_stream_enabled: Dict[str, bool] = defaultdict(lambda: False)
-        self._stream_to_unsubscriber: Dict[str, Callable[[], Awaitable[None]]] = {}
-        
+        self._is_stream_enabled: dict[str, bool] = defaultdict(lambda: False)
+        self._stream_to_unsubscriber: dict[str, Callable[[], Awaitable[None]]] = {}
+
         # Connection tracking
-        self._stream_to_coro: Dict[str, concurrent.futures.Future] = {}
-    
+        self._stream_to_coro: dict[str, concurrent.futures.Future] = {}
+
+    @property
+    def _loop(self) -> AsyncThreadLoop:
+        """Get current AsyncThreadLoop from exchange manager."""
+        return AsyncThreadLoop(self._exchange_manager.exchange.asyncio_loop)
+
     def set_subscription_manager(self, subscription_manager: SubscriptionManager) -> None:
         """Set the subscription manager for state coordination."""
         self._subscription_manager = subscription_manager
-    
+
     async def listen_to_stream(
         self,
         subscriber: Callable[[], Awaitable[None]],
         exchange: Exchange,
         channel: CtrlChannel,
+        subscription_type: str,
         stream_name: str,
         unsubscriber: Callable[[], Awaitable[None]] | None = None,
     ) -> None:
         """
         Listen to a WebSocket stream with error handling and retry logic.
-        
+
         Args:
             subscriber: Async function that handles the stream data
             exchange: CCXT exchange instance
@@ -71,32 +84,30 @@ class ConnectionManager:
             unsubscriber: Optional cleanup function for graceful unsubscription
         """
         logger.info(f"<yellow>{self._exchange_id}</yellow> Listening to {stream_name}")
-        
+
         # Register unsubscriber for cleanup
         if unsubscriber is not None:
             self._stream_to_unsubscriber[stream_name] = unsubscriber
-        
+
         # Enable the stream
         self._is_stream_enabled[stream_name] = True
         n_retry = 0
         connection_established = False
-        
+
         while channel.control.is_set() and self._is_stream_enabled[stream_name]:
             try:
                 await subscriber()
                 n_retry = 0  # Reset retry counter on success
-                
+
                 # Mark subscription as active on first successful data reception
                 if not connection_established and self._subscription_manager:
-                    subscription_type = self._subscription_manager.find_subscription_type_by_name(stream_name)
-                    if subscription_type:
-                        self._subscription_manager.mark_subscription_active(subscription_type)
-                        connection_established = True
-                
+                    self._subscription_manager.mark_subscription_active(subscription_type)
+                    connection_established = True
+
                 # Check if stream was disabled during subscriber execution
                 if not self._is_stream_enabled[stream_name]:
                     break
-                    
+
             except CcxtSymbolNotRecognized:
                 # Skip unrecognized symbols but continue listening
                 continue
@@ -109,7 +120,9 @@ class ConnectionManager:
                 break
             except (NetworkError, ExchangeError, ExchangeNotAvailable) as e:
                 # Network/exchange errors - retry after short delay
-                logger.error(f"<yellow>{self._exchange_id}</yellow> {e.__class__.__name__} :: Error in {stream_name} : {e}")
+                logger.error(
+                    f"<yellow>{self._exchange_id}</yellow> {e.__class__.__name__} :: Error in {stream_name} : {e}"
+                )
                 await asyncio.sleep(1)
                 continue
             except Exception as e:
@@ -117,10 +130,10 @@ class ConnectionManager:
                 if not channel.control.is_set() or not self._is_stream_enabled[stream_name]:
                     # Channel closed or stream disabled, exit gracefully
                     break
-                
+
                 logger.error(f"<yellow>{self._exchange_id}</yellow> Exception in {stream_name}: {e}")
                 logger.exception(e)
-                
+
                 n_retry += 1
                 if n_retry >= self.max_ws_retries:
                     logger.error(
@@ -129,182 +142,164 @@ class ConnectionManager:
                     # Clean up exchange reference to force reconnection
                     del exchange
                     break
-                
+
                 # Exponential backoff with cap at 60 seconds
                 await asyncio.sleep(min(2**n_retry, 60))
-        
+
         # Stream ended, cleanup
         logger.debug(f"<yellow>{self._exchange_id}</yellow> Stream {stream_name} ended")
-    
-    async def stop_stream(
-        self, 
-        stream_name: str, 
-        future: concurrent.futures.Future | None = None,
-        is_resubscription: bool = False
-    ) -> None:
+
+    def stop_stream(self, stream_name: str, wait: bool = True) -> None:
         """
-        Stop a stream gracefully with proper cleanup.
-        
+        Stop a stream (signal it to stop).
+
         Args:
             stream_name: Name of the stream to stop
-            future: Optional future representing the stream task
-            is_resubscription: True if this is stopping an old stream during resubscription
+            wait: If True, wait for stream and unsubscriber to complete (default).
+                  If False, cancel asynchronously without waiting.
         """
-        try:
-            context = "old stream" if is_resubscription else "stream"
-            logger.debug(f"<yellow>{self._exchange_id}</yellow> Stopping {context} {stream_name}")
-            
-            # Disable the stream to signal it should stop
-            self._is_stream_enabled[stream_name] = False
-            
-            # Wait for the stream to stop naturally
-            if future:
-                total_sleep_time = 0.0
-                while future.running() and total_sleep_time < 20.0:
-                    await asyncio.sleep(1.0)
-                    total_sleep_time += 1.0
-                
-                if future.running():
-                    logger.warning(
-                        f"<yellow>{self._exchange_id}</yellow> {context.title()} {stream_name} is still running. Cancelling it."
-                    )
-                    future.cancel()
-                else:
-                    logger.debug(f"<yellow>{self._exchange_id}</yellow> {context.title()} {stream_name} has been stopped")
-            
-            # Run unsubscriber if available
-            if stream_name in self._stream_to_unsubscriber:
-                logger.debug(f"<yellow>{self._exchange_id}</yellow> Unsubscribing from {stream_name}")
-                await self._stream_to_unsubscriber[stream_name]()
-                del self._stream_to_unsubscriber[stream_name]
-            
-            # Clean up stream state
-            if is_resubscription:
-                # For resubscription, only clean up if the stream is actually disabled
-                # (avoid interfering with new streams using the same name)
-                if stream_name in self._is_stream_enabled and not self._is_stream_enabled[stream_name]:
-                    del self._is_stream_enabled[stream_name]
-            else:
-                # For regular stops, always clean up completely
-                self._is_stream_enabled.pop(stream_name, None)
-                self._stream_to_coro.pop(stream_name, None)
-            
-            logger.debug(f"<yellow>{self._exchange_id}</yellow> {context.title()} {stream_name} stopped")
-            
-        except Exception as e:
-            logger.error(f"<yellow>{self._exchange_id}</yellow> Error stopping {stream_name}")
-            logger.exception(e)
-    
-    def register_stream_future(
-        self, 
-        stream_name: str, 
-        future: concurrent.futures.Future
-    ) -> None:
+        assert self._subscription_manager is not None
+
+        logger.debug(f"Stopping stream: {stream_name}, wait={wait}")
+
+        self._is_stream_enabled[stream_name] = False
+
+        stream_future = self.get_stream_future(stream_name)
+        if stream_future:
+            stream_future.cancel()
+            if wait:
+                self._wait(stream_future, stream_name)
+        else:
+            logger.warning(f"[CONNECTION] No stream future found for {stream_name}")
+
+        unsubscriber = self.get_stream_unsubscriber(stream_name)
+        if unsubscriber:
+            logger.debug(f"Calling unsubscriber for {stream_name}")
+            unsub_task = self._loop.submit(unsubscriber())
+            if wait:
+                self._wait(unsub_task, f"unsubscriber for {stream_name}")
+                # Wait for 1 second just in case
+                self._loop.submit(asyncio.sleep(1)).result()
+        else:
+            logger.debug(f"No unsubscriber found for {stream_name}")
+
+        self._is_stream_enabled.pop(stream_name, None)
+        self._stream_to_coro.pop(stream_name, None)
+        self._stream_to_unsubscriber.pop(stream_name, None)
+
+    def register_stream_future(self, stream_name: str, future: concurrent.futures.Future) -> None:
         """
         Register a future for a stream for tracking and cleanup.
-        
+
         Args:
             stream_name: Name of the stream
             future: Future representing the stream task
         """
+        # Add done callback to handle any exceptions and prevent "Future exception was never retrieved"
+        future.add_done_callback(lambda f: self._handle_stream_completion(f, stream_name))
         self._stream_to_coro[stream_name] = future
-    
+
     def is_stream_enabled(self, stream_name: str) -> bool:
         """
         Check if a stream is enabled.
-        
+
         Args:
             stream_name: Name of the stream to check
-            
+
         Returns:
             True if stream is enabled, False otherwise
         """
         return self._is_stream_enabled.get(stream_name, False)
-    
+
     def get_stream_future(self, stream_name: str) -> concurrent.futures.Future | None:
         """
         Get the future for a stream.
-        
+
         Args:
             stream_name: Name of the stream
-            
+
         Returns:
             Future if exists, None otherwise
         """
         return self._stream_to_coro.get(stream_name)
-    
-    def disable_stream(self, stream_name: str) -> None:
-        """
-        Disable a stream (signal it to stop).
-        
-        Args:
-            stream_name: Name of the stream to disable
-        """
-        self._is_stream_enabled[stream_name] = False
-    
+
     def enable_stream(self, stream_name: str) -> None:
         """
         Enable a stream.
-        
+
         Args:
             stream_name: Name of the stream to enable
         """
         self._is_stream_enabled[stream_name] = True
-    
-    def set_stream_unsubscriber(
-        self, 
-        stream_name: str, 
-        unsubscriber: Callable[[], Awaitable[None]]
-    ) -> None:
+
+    def set_stream_unsubscriber(self, stream_name: str, unsubscriber: Callable[[], Awaitable[None]]) -> None:
         """
         Set unsubscriber function for a stream.
-        
+
         Args:
             stream_name: Name of the stream
             unsubscriber: Async function to call for unsubscription
         """
         self._stream_to_unsubscriber[stream_name] = unsubscriber
-    
+
     def get_stream_unsubscriber(self, stream_name: str) -> Callable[[], Awaitable[None]] | None:
         """
         Get unsubscriber function for a stream.
-        
+
         Args:
             stream_name: Name of the stream
-            
+
         Returns:
             Unsubscriber function if exists, None otherwise
         """
         return self._stream_to_unsubscriber.get(stream_name)
-    
-    def set_stream_coro(
-        self, 
-        stream_name: str, 
-        coro: concurrent.futures.Future
-    ) -> None:
+
+    def set_stream_coro(self, stream_name: str, coro: concurrent.futures.Future) -> None:
         """
         Set coroutine/future for a stream.
-        
+
         Args:
             stream_name: Name of the stream
             coro: Future representing the stream task
         """
         self._stream_to_coro[stream_name] = coro
-    
+
     def get_stream_coro(self, stream_name: str) -> concurrent.futures.Future | None:
         """
         Get coroutine/future for a stream.
-        
+
         Args:
             stream_name: Name of the stream
-            
+
         Returns:
             Future if exists, None otherwise
         """
         return self._stream_to_coro.get(stream_name)
 
-    def cleanup_all_streams(self) -> None:
-        """Clean up all stream state (for shutdown)."""
-        self._is_stream_enabled.clear()
-        self._stream_to_unsubscriber.clear()
-        self._stream_to_coro.clear()
+    def _handle_stream_completion(self, future: concurrent.futures.Future, stream_name: str) -> None:
+        """
+        Handle stream future completion and any exceptions to prevent 'Future exception was never retrieved'.
+
+        Args:
+            future: The completed future
+            stream_name: Name of the stream for logging
+        """
+        try:
+            future.result()  # Retrieve result to handle any exceptions
+        except Exception:
+            pass  # Silent handling to prevent "Future exception was never retrieved"
+
+    def _wait(self, future: concurrent.futures.Future, context: str) -> None:
+        """Wait for future completion with timeout and exception handling."""
+        start_wait = time.time()
+        while future.running() and (time.time() - start_wait) < self._cleanup_timeout:
+            time.sleep(0.1)
+
+        if future.running():
+            logger.warning(f"[{self._exchange_id}] {context} still running after {self._cleanup_timeout}s timeout")
+        else:
+            # Always retrieve result to handle exceptions properly and prevent "Future exception was never retrieved"
+            try:
+                future.result()  # This will raise any exception that occurred
+            except Exception:
+                pass  # Silent handling during cleanup - UnsubscribeError is expected