Qubx 0.6.78__tar.gz → 0.6.85__tar.gz

{qubx-0.6.78 → qubx-0.6.85}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: Qubx
-Version: 0.6.78
+Version: 0.6.85
 Summary: Qubx - Quantitative Trading Framework
+License-File: LICENSE
 Author: Dmitry Marienko
 Author-email: dmitry.marienko@xlydian.com
 Requires-Python: >=3.10,<4.0
@@ -10,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: aiohttp (>=3.10.11,<3.11.0)
 Requires-Dist: ccxt (>=4.2.68,<5.0.0)
 Requires-Dist: croniter (>=2.0.5,<3.0.0)

{qubx-0.6.78 → qubx-0.6.85}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "Qubx"
-version = "0.6.78"
+version = "0.6.85"
 description = "Qubx - Quantitative Trading Framework"
 authors = [ "Dmitry Marienko <dmitry.marienko@xlydian.com>", "Yuriy Arabskyy <yuriy.arabskyy@xlydian.com>",]
 readme = "README.md"

{qubx-0.6.78 → qubx-0.6.85}/src/qubx/backtester/management.py

@@ -6,6 +6,7 @@ from pathlib import Path
 import numpy as np
 import pandas as pd
 import yaml
+from tqdm.auto import tqdm
 
 from qubx.core.metrics import TradingSessionResult
 from qubx.utils.misc import blue, cyan, green, magenta, red, yellow
@@ -420,8 +421,10 @@ class BacktestsResultsManager:
         Returns:
             plotly.graph_objects.Figure: The plot of the variation.
         """
-        import plotly.express as px
         from itertools import cycle
+
+        import plotly.express as px
+
         from qubx.utils.misc import string_shortener
 
         _vars = self.variations.get(variation_idx)
@@ -507,3 +510,11 @@ class BacktestsResultsManager:
             )
         )
         return figure
+
+    def export_backtests_to_markdown(self, path: str, tags: tuple[str] | None = None):
+        """
+        Export backtests to markdown format
+        """
+        for n, v in tqdm(self.results.items()):
+            r = TradingSessionResult.from_file(v.get("path"))
+            r.to_markdown(path, list(tags) if tags else None)

{qubx-0.6.78 → qubx-0.6.85}/src/qubx/backtester/runner.py

@@ -15,6 +15,7 @@ from qubx.core.helpers import extract_parameters_from_object, full_qualified_cla
 from qubx.core.initializer import BasicStrategyInitializer
 from qubx.core.interfaces import (
     CtrlChannel,
+    IDataProvider,
     IMetricEmitter,
     IStrategy,
     IStrategyContext,
@@ -224,7 +225,7 @@ class SimulationRunner:
         cc = self.channel
         t = np.datetime64(data.time, "ns")
         _account = self.account.get_account_processor(instrument.exchange)
-        _data_provider = self._exchange_to_data_provider[instrument.exchange]
+        _data_provider = self._get_data_provider(instrument.exchange)
         assert isinstance(_account, SimulatedAccountProcessor)
         assert isinstance(_data_provider, SimulatedDataProvider)
 
@@ -249,7 +250,7 @@ class SimulationRunner:
         cc = self.channel
         t = np.datetime64(data.time, "ns")
         _account = self.account.get_account_processor(instrument.exchange)
-        _data_provider = self._exchange_to_data_provider[instrument.exchange]
+        _data_provider = self._get_data_provider(instrument.exchange)
         assert isinstance(_account, SimulatedAccountProcessor)
         assert isinstance(_data_provider, SimulatedDataProvider)
 
@@ -267,6 +268,11 @@ class SimulationRunner:
 
         return cc.control.is_set()
 
+    def _get_data_provider(self, exchange: str) -> IDataProvider:
+        if exchange in self._exchange_to_data_provider:
+            return self._exchange_to_data_provider[exchange]
+        raise ValueError(f"Data provider for exchange {exchange} not found")
+
     def _run(self, start: pd.Timestamp, stop: pd.Timestamp, silent: bool = False) -> None:
         logger.info(f"{self.__class__.__name__} ::: Simulation started at {start} :::")
 
@@ -328,7 +334,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-0.6.78 → qubx-0.6.85}/src/qubx/connectors/ccxt/account.py

@@ -82,6 +82,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         open_order_backoff: str = "1Min",
         max_position_restore_days: int = 5,
         max_retries: int = 10,
+        connection_timeout: int = 30,
         read_only: bool = False,
     ):
         super().__init__(
@@ -109,6 +110,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         self._latest_instruments = set()
         self._subscription_manager = None
         self._read_only = read_only
+        self._connection_timeout = connection_timeout
 
     def set_subscription_manager(self, manager: ISubscriptionManager) -> None:
         self._subscription_manager = manager
@@ -128,6 +130,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
         if not self.exchange_manager.exchange.isSandboxModeEnabled:
             # - start polling tasks
+            self._loop.submit(self.exchange_manager.exchange.load_markets()).result()
             self._polling_tasks["balance"] = self._loop.submit(
                 self._poller("balance", self._update_balance, self.balance_interval)
             )
@@ -172,6 +175,14 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         super().update_position_price(time, instrument, update)
 
     def get_total_capital(self, exchange: str | None = None) -> float:
+        # If polling is not running yet, we need to fetch balance data directly
+        if not self._is_running and self.exchange_manager.exchange:
+            try:
+                future = self._loop.submit(self._update_balance())
+                future.result(timeout=self._connection_timeout)
+            except Exception as e:
+                logger.warning(f"Failed to fetch balance data before polling started: {e}")
+
         # sum of balances + market value of all positions on non spot/margin
         _currency_to_value = {c: self._get_currency_value(b.total, c) for c, b in self._balances.items()}
         _positions_value = sum([p.market_value_funds for p in self._positions.values() if p.instrument.is_futures()])
@@ -294,7 +305,9 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     async def _update_positions(self) -> None:
         # fetch and update positions from exchange
         ccxt_positions = await self.exchange_manager.exchange.fetch_positions()
-        positions = ccxt_convert_positions(ccxt_positions, self.exchange_manager.exchange.name, self.exchange_manager.exchange.markets)  # type: ignore
+        positions = ccxt_convert_positions(
+            ccxt_positions, self.exchange_manager.exchange.name, self.exchange_manager.exchange.markets
+        )  # type: ignore
         # update required instruments that we need to subscribe to
         self._required_instruments.update([p.instrument for p in positions])
         # update positions
@@ -458,7 +471,9 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
             async def _cancel_order(order: Order) -> None:
                 try:
-                    await self.exchange_manager.exchange.cancel_order(order.id, symbol=instrument_to_ccxt_symbol(order.instrument))
+                    await self.exchange_manager.exchange.cancel_order(
+                        order.id, symbol=instrument_to_ccxt_symbol(order.instrument)
+                    )
                     logger.debug(
                         f"  :: [SYNC] Canceled {order.id} {order.instrument.symbol} {order.side} {order.quantity} @ {order.price} ({order.status})"
                     )
@@ -476,7 +491,9 @@ class CcxtAccountProcessor(BasicAccountProcessor):
     ) -> dict[str, Order]:
         _start_ms = self._get_start_time_in_ms(days_before) if limit is None else None
         _ccxt_symbol = instrument_to_ccxt_symbol(instrument)
-        _fetcher = self.exchange_manager.exchange.fetch_open_orders if is_open else self.exchange_manager.exchange.fetch_orders
+        _fetcher = (
+            self.exchange_manager.exchange.fetch_open_orders if is_open else self.exchange_manager.exchange.fetch_orders
+        )
         _raw_orders = await _fetcher(_ccxt_symbol, since=_start_ms, limit=limit)
         _orders = [ccxt_convert_order_info(instrument, o) for o in _raw_orders]
         _id_to_order = {o.id: o for o in _orders}
@@ -533,7 +550,9 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         async def _watch_executions():
             exec = await self.exchange_manager.exchange.watch_orders()
             for report in exec:
-                instrument = ccxt_find_instrument(report["symbol"], self.exchange_manager.exchange, _symbol_to_instrument)
+                instrument = ccxt_find_instrument(
+                    report["symbol"], self.exchange_manager.exchange, _symbol_to_instrument
+                )
                 order = ccxt_convert_order_info(instrument, report)
                 deals = ccxt_extract_deals_from_exec(report)
                 channel.send((instrument, "order", order, False))

{qubx-0.6.78 → qubx-0.6.85}/src/qubx/connectors/ccxt/exchange_manager.py

@@ -24,12 +24,13 @@ SECONDS_PER_HOUR = 3600
 
 # Custom stall detection thresholds (in seconds)
 STALL_THRESHOLDS = {
-    'funding_payment': 12 * SECONDS_PER_HOUR,    # 12 hours = 43,200s
-    'open_interest': 30 * 60,                    # 30 minutes = 1,800s
-    'orderbook': 5 * 60,                         # 5 minutes = 300s
-    'trade': 60 * 60,                            # 60 minutes = 3,600s
-    'liquidation': 7 * 24 * SECONDS_PER_HOUR,    # 7 days = 604,800s
-    'ohlc': 15 * 60,                             # 15 minutes = 900s
+    "funding_payment": 12 * SECONDS_PER_HOUR,  # 12 hours = 43,200s
+    "open_interest": 30 * 60,  # 30 minutes = 1,800s
+    "orderbook": 5 * 60,  # 5 minutes = 300s
+    "trade": 60 * 60,  # 60 minutes = 3,600s
+    "liquidation": 7 * 24 * SECONDS_PER_HOUR,  # 7 days = 604,800s
+    "ohlc": 5 * 60,  # 5 minutes = 300s
+    "quote": 5 * 60,  # 5 minutes = 300s
 }
 DEFAULT_STALL_THRESHOLD_SECONDS = 2 * SECONDS_PER_HOUR  # 2 hours = 7,200s
 
@@ -37,10 +38,10 @@ DEFAULT_STALL_THRESHOLD_SECONDS = 2 * SECONDS_PER_HOUR  # 2 hours = 7,200s
 class ExchangeManager(IDataArrivalListener):
     """
     Wrapper for CCXT Exchange that handles recreation internally with self-monitoring.
-    
+
     Exposes the underlying exchange via .exchange property for explicit access.
     Self-monitors for data stalls and triggers recreation automatically.
-    
+
     Key Features:
     - Explicit .exchange property for CCXT access
     - Self-contained stall detection and recreation triggering
@@ -48,7 +49,7 @@ class ExchangeManager(IDataArrivalListener):
     - Atomic exchange transitions during recreation
     - Background monitoring thread for stall detection
     """
-    
+
     _exchange: cxp.Exchange  # Type hint that this is always a valid exchange
 
     def __init__(
@@ -61,10 +62,10 @@ class ExchangeManager(IDataArrivalListener):
         check_interval_seconds: float = DEFAULT_CHECK_INTERVAL_SECONDS,
     ):
         """Initialize ExchangeManager with underlying CCXT exchange.
-        
+
         Args:
             exchange_name: Exchange name for factory (e.g., "binance.um")
-            factory_params: Parameters for get_ccxt_exchange() 
+            factory_params: Parameters for get_ccxt_exchange()
             initial_exchange: Pre-created exchange instance (from factory)
             max_recreations: Maximum recreation attempts before giving up
             reset_interval_hours: Hours between recreation count resets
@@ -74,24 +75,24 @@ class ExchangeManager(IDataArrivalListener):
         self._factory_params = factory_params.copy()
         self._max_recreations = max_recreations
         self._reset_interval_hours = reset_interval_hours
-        
+
         # Recreation state
         self._recreation_count = 0
         self._recreation_lock = threading.RLock()
         self._last_successful_reset = time.time()
-        
+
         # Stall detection state
         self._check_interval = check_interval_seconds
         self._last_data_times: dict[str, float] = {}
         self._data_lock = threading.RLock()
-        
+
         # Monitoring control
         self._monitoring_enabled = False
         self._monitor_thread = None
-        
+
         # Recreation callback management
         self._recreation_callbacks: list[Callable[[], None]] = []
-        
+
         # Use provided exchange or create new one
         if initial_exchange:
             self._exchange = initial_exchange
@@ -105,23 +106,23 @@ class ExchangeManager(IDataArrivalListener):
         try:
             # Import here to avoid circular import (factory → broker → exchange_manager)
             from .factory import get_ccxt_exchange
-            
+
             # Create raw exchange using factory logic
             ccxt_exchange = get_ccxt_exchange(**self._factory_params)
-            
+
             # Setup exception handler for the new exchange
             self._setup_ccxt_exception_handler(ccxt_exchange)
-            
+
             logger.debug(f"Created new {self._exchange_name} exchange instance")
             return ccxt_exchange
-            
+
         except Exception as e:
             logger.error(f"Failed to create {self._exchange_name} exchange: {e}")
             raise RuntimeError(f"Failed to create {self._exchange_name} exchange: {e}") from e
-    
+
     def register_recreation_callback(self, callback: Callable[[], None]) -> None:
         """Register callback to be called after successful exchange recreation.
-        
+
         Args:
             callback: Function to call after successful recreation (no parameters)
         """
@@ -131,7 +132,7 @@ class ExchangeManager(IDataArrivalListener):
     def _call_recreation_callbacks(self) -> None:
         """Call all registered recreation callbacks after successful exchange recreation."""
         logger.debug(f"Calling {len(self._recreation_callbacks)} recreation callbacks for {self._exchange_name}")
-        
+
         for callback in self._recreation_callbacks:
             try:
                 callback()
@@ -142,66 +143,68 @@ class ExchangeManager(IDataArrivalListener):
     def force_recreation(self) -> bool:
         """
         Force recreation due to data stalls (called by BaseHealthMonitor).
-        
+
         Returns:
             True if recreation successful, False if failed/limit exceeded
         """
         with self._recreation_lock:
             # Check recreation limit
             if self._recreation_count >= self._max_recreations:
-                logger.error(f"Cannot recreate {self._exchange_name}: recreation limit ({self._max_recreations}) exceeded")
+                logger.error(
+                    f"Cannot recreate {self._exchange_name}: recreation limit ({self._max_recreations}) exceeded"
+                )
                 return False
-            
+
             logger.info(f"Stall-triggered recreation for {self._exchange_name}")
             return self._recreate_exchange()
-    
+
     def _recreate_exchange(self) -> bool:
         """Recreate the underlying exchange (must be called with _recreation_lock held)."""
         self._recreation_count += 1
-        logger.warning(f"Recreating {self._exchange_name} exchange (attempt {self._recreation_count}/{self._max_recreations})")
-        
+        logger.warning(
+            f"Recreating {self._exchange_name} exchange (attempt {self._recreation_count}/{self._max_recreations})"
+        )
+
         # Create new exchange
         try:
             new_exchange = self._create_exchange()
         except Exception as e:
             logger.error(f"Failed to recreate {self._exchange_name} exchange: {e}")
             return False
-            
+
         # Atomically replace the exchange
         old_exchange = self._exchange
         self._exchange = new_exchange
-        
+
         # Clean up old exchange
         try:
-            if hasattr(old_exchange, 'close') and hasattr(old_exchange, 'asyncio_loop'):
-                old_exchange.asyncio_loop.call_soon_threadsafe(
-                    lambda: asyncio.create_task(old_exchange.close())
-                )
+            if hasattr(old_exchange, "close") and hasattr(old_exchange, "asyncio_loop"):
+                old_exchange.asyncio_loop.call_soon_threadsafe(lambda: asyncio.create_task(old_exchange.close()))
         except Exception as e:
             logger.warning(f"Error closing old {self._exchange_name} exchange: {e}")
-        
+
         logger.info(f"Successfully recreated {self._exchange_name} exchange")
-        
+
         # Call recreation callbacks after successful recreation
         self._call_recreation_callbacks()
-        
+
         return True
-        
+
     def reset_recreation_count_if_needed(self) -> None:
         """Reset recreation count periodically (called by monitoring loop)."""
         reset_interval_seconds = self._reset_interval_hours * SECONDS_PER_HOUR
-        
+
         current_time = time.time()
         time_since_reset = current_time - self._last_successful_reset
-        
+
         if time_since_reset >= reset_interval_seconds and self._recreation_count > 0:
             logger.info(f"Resetting recreation count for {self._exchange_name} (was {self._recreation_count})")
             self._recreation_count = 0
             self._last_successful_reset = current_time
-    
+
     def on_data_arrival(self, event_type: str, event_time: dt_64) -> None:
         """Record data arrival for stall detection.
-        
+
         Args:
             event_type: Type of data event (e.g., "ohlcv", "trade", "orderbook")
             event_time: Timestamp of the data event (unused for stall detection)
@@ -209,10 +212,10 @@ class ExchangeManager(IDataArrivalListener):
         current_timestamp = time.time()
         with self._data_lock:
             self._last_data_times[event_type] = current_timestamp
-    
+
     def _extract_ohlc_timeframe(self, event_type: str) -> Optional[str]:
         """Extract timeframe from OHLC event type like 'ohlc(1m)' -> '1m'."""
-        if event_type.startswith('ohlc(') and event_type.endswith(')'):
+        if event_type.startswith("ohlc(") and event_type.endswith(")"):
             return event_type[5:-1]  # Simple slice: ohlc(1m) -> 1m
         return None
 
@@ -222,30 +225,30 @@ class ExchangeManager(IDataArrivalListener):
 
     def _get_stall_threshold(self, event_type: str) -> float:
         """Get stall threshold for specific event type.
-        
+
         Extracts base data type from parameterized types like 'ohlc(1m)' -> 'ohlc'.
         """
         # Extract base data type (everything before first '(' if present)
-        base_event_type = event_type.split('(')[0]
+        base_event_type = event_type.split("(")[0]
         return float(STALL_THRESHOLDS.get(base_event_type, DEFAULT_STALL_THRESHOLD_SECONDS))
-            
+
     def start_monitoring(self) -> None:
         """Start background stall detection monitoring."""
         if self._monitoring_enabled:
             return
-            
+
         self._monitoring_enabled = True
         self._monitor_thread = threading.Thread(target=self._stall_monitor_loop, daemon=True)
         self._monitor_thread.start()
         logger.debug(f"ExchangeManager: Started stall monitoring for {self._exchange_name}")
-        
+
     def stop_monitoring(self) -> None:
         """Stop background stall detection monitoring."""
         self._monitoring_enabled = False
         if self._monitor_thread:
             self._monitor_thread = None
         logger.debug(f"ExchangeManager: Stopped stall monitoring for {self._exchange_name}")
-        
+
     def _stall_monitor_loop(self) -> None:
         """Background thread that checks for data stalls and triggers self-recreation."""
         while self._monitoring_enabled:
@@ -256,26 +259,26 @@ class ExchangeManager(IDataArrivalListener):
             except Exception as e:
                 logger.error(f"Error in ExchangeManager stall detection: {e}")
                 time.sleep(self._check_interval)
-                
+
     def _check_and_handle_stalls(self) -> None:
         """Check for stalls using custom thresholds per data type."""
         current_time = time.time()
         stalled_types = []
-        
+
         with self._data_lock:
             for event_type, last_data_time in self._last_data_times.items():
                 time_since_data = current_time - last_data_time
                 threshold = self._get_stall_threshold(event_type)
-                
+
                 if time_since_data > threshold:
                     stalled_types.append((event_type, time_since_data))
-                    
+
         if not stalled_types:
             return  # No stalls detected
-            
+
         stall_info = ", ".join([f"{event_type}({int(time_since)}s)" for event_type, time_since in stalled_types])
         logger.error(f"Data stalls detected in {self._exchange_name}: {stall_info}")
-        
+
         try:
             logger.info(f"Self-triggering recreation for {self._exchange_name} due to stalls...")
             if self.force_recreation():
@@ -288,14 +291,14 @@ class ExchangeManager(IDataArrivalListener):
                 logger.error(f"Stall-triggered recreation failed for {self._exchange_name}")
         except Exception as e:
             logger.error(f"Error during stall-triggered recreation: {e}")
-    
+
     def _setup_ccxt_exception_handler(self, exchange: cxp.Exchange) -> None:
         """
         Set up global exception handler for the CCXT async loop to handle unretrieved futures.
 
         This prevents 'Future exception was never retrieved' warnings from CCXT's internal
         per-symbol futures that complete with UnsubscribeError during resubscription.
-        
+
         Applied to every newly created exchange (initial and recreated).
         """
         asyncio_loop = exchange.asyncio_loop
@@ -324,15 +327,15 @@ class ExchangeManager(IDataArrivalListener):
         # Set the custom exception handler on the CCXT loop
         asyncio_loop.set_exception_handler(handle_ccxt_exception)
 
-    # === Exchange Property Access === 
+    # === Exchange Property Access ===
     # Explicit property to access underlying CCXT exchange
-    
+
     @property
     def exchange(self) -> cxp.Exchange:
         """Access to the underlying CCXT exchange instance.
-        
+
         Use this property to call CCXT methods: exchange_manager.exchange.fetch_ticker(symbol)
-        
+
         Returns:
             The current CCXT exchange instance (may change after recreation)
         """

{qubx-0.6.78 → qubx-0.6.85}/src/qubx/connectors/ccxt/exchanges/hyperliquid/broker.py

@@ -9,7 +9,7 @@ from qubx.core.exceptions import BadRequest
 class HyperliquidCcxtBroker(CcxtBroker):
     """
     HyperLiquid-specific broker that handles market order slippage requirements.
-    
+
     HyperLiquid requires a price even for market orders to calculate max slippage.
     This broker automatically calculates slippage-protected prices for market orders.
     """
@@ -17,7 +17,7 @@ class HyperliquidCcxtBroker(CcxtBroker):
     def __init__(
         self,
         *args,
-        market_order_slippage: float = 0.05,  # 5% default slippage
+        market_order_slippage: float = 0.01,  # 5% default slippage
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
@@ -38,21 +38,29 @@ class HyperliquidCcxtBroker(CcxtBroker):
         if order_type.lower() == "market" and price is None:
             quote = self.data_provider.get_quote(instrument)
             if quote is None:
-                logger.warning(f"[<y>{instrument.symbol}</y>] :: Quote is not available for market order slippage calculation.")
-                raise BadRequest(f"Quote is not available for market order slippage calculation for {instrument.symbol}")
+                logger.warning(
+                    f"[<y>{instrument.symbol}</y>] :: Quote is not available for market order slippage calculation."
+                )
+                raise BadRequest(
+                    f"Quote is not available for market order slippage calculation for {instrument.symbol}"
+                )
 
             # Get slippage from options or use default
             slippage = options.get("slippage", self.market_order_slippage)
-            
+
             # Calculate slippage-protected price
             if order_side.upper() == "BUY":
                 # For buy orders, add slippage to ask price to ensure execution
                 price = quote.ask * (1 + slippage)
-                logger.debug(f"[<y>{instrument.symbol}</y>] :: Market BUY order: using slippage-protected price {price:.6f} (ask: {quote.ask:.6f}, slippage: {slippage:.1%})")
+                logger.debug(
+                    f"[<y>{instrument.symbol}</y>] :: Market BUY order: using slippage-protected price {price:.6f} (ask: {quote.ask:.6f}, slippage: {slippage:.1%})"
+                )
             else:  # SELL
                 # For sell orders, subtract slippage from bid price to ensure execution
                 price = quote.bid * (1 - slippage)
-                logger.debug(f"[<y>{instrument.symbol}</y>] :: Market SELL order: using slippage-protected price {price:.6f} (bid: {quote.bid:.6f}, slippage: {slippage:.1%})")
+                logger.debug(
+                    f"[<y>{instrument.symbol}</y>] :: Market SELL order: using slippage-protected price {price:.6f} (bid: {quote.bid:.6f}, slippage: {slippage:.1%})"
+                )
 
         # Call parent implementation with calculated price
         payload = super()._prepare_order_payload(
@@ -64,6 +72,6 @@ class HyperliquidCcxtBroker(CcxtBroker):
         if "slippage" in options:
             # HyperLiquid accepts slippage as a percentage (e.g., 0.05 for 5%)
             params["px"] = price  # Explicit price for slippage calculation
-            
+
         payload["params"] = params
-        return payload
+        return payload

{qubx-0.6.78 → qubx-0.6.85}/src/qubx/connectors/ccxt/handlers/orderbook.py

@@ -65,7 +65,7 @@ class OrderBookDataHandler(BaseDataTypeHandler):
 
         # Notify all listeners
         self._data_provider.notify_data_arrival(sub_type, dt_64(ob.time, "ns"))
-        
+
         channel.send((instrument, sub_type, ob, False))
         return True
 
@@ -150,7 +150,7 @@ class OrderBookDataHandler(BaseDataTypeHandler):
     ) -> SubscriptionConfiguration:
         """
         Prepare subscription configuration for individual instruments.
-        
+
         Creates separate subscriber functions for each instrument to enable independent
         WebSocket streams without waiting for all instruments. This follows the same
         pattern as the OHLC handler for proper individual stream management.
@@ -169,10 +169,10 @@ class OrderBookDataHandler(BaseDataTypeHandler):
                     try:
                         # Watch orderbook for single instrument
                         ccxt_ob = await self._exchange_manager.exchange.watch_order_book(symbol)
-                        
+
                         # Use private processing method to avoid duplication
                         self._process_orderbook(ccxt_ob, inst, sub_type, channel, depth, tick_size_pct)
-                        
+
                     except Exception as e:
                         logger.error(
                             f"<yellow>{exchange_id}</yellow> Error in individual orderbook subscription for {inst.symbol}: {e}"
@@ -186,13 +186,15 @@ class OrderBookDataHandler(BaseDataTypeHandler):
             # Create individual unsubscriber if exchange supports it
             un_watch_method = getattr(self._exchange_manager.exchange, "un_watch_order_book", None)
             if un_watch_method is not None and callable(un_watch_method):
-                
+
                 def create_individual_unsubscriber(symbol=ccxt_symbol, exchange_id=self._exchange_id):
                     async def individual_unsubscriber():
                         try:
                             await self._exchange_manager.exchange.un_watch_order_book(symbol)
                         except Exception as e:
-                            logger.error(f"<yellow>{exchange_id}</yellow> Error unsubscribing orderbook for {symbol}: {e}")
+                            logger.error(
+                                f"<yellow>{exchange_id}</yellow> Error unsubscribing orderbook for {symbol}: {e}"
+                            )
 
                     return individual_unsubscriber