Qubx 0.6.89__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.90__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/backtester/broker.py

@@ -6,7 +6,7 @@ from qubx.core.basics import (
     Instrument,
     Order,
 )
-from qubx.core.exceptions import OrderNotFound
+from qubx.core.exceptions import BadRequest, OrderNotFound
 from qubx.core.interfaces import IBroker
 
 from .account import SimulatedAccountProcessor
@@ -64,20 +64,66 @@ class SimulatedBroker(IBroker):
     ) -> None:
         self.send_order(instrument, order_side, order_type, amount, price, client_id, time_in_force, **optional)
 
-    def cancel_order(self, order_id: str) -> Order | None:
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an order synchronously and return success status."""
         try:
             self._send_execution_report(order_update := self._exchange.cancel_order(order_id))
-            return order_update.order if order_update is not None else None
+            return order_update is not None
         except OrderNotFound:
             # Order was already cancelled or doesn't exist
             logger.debug(f"Order {order_id} not found")
-            return None
+            return False
+
+    def cancel_order_async(self, order_id: str) -> None:
+        """Cancel an order asynchronously (fire-and-forget)."""
+        # For simulation, async is same as sync since it's fast
+        self.cancel_order(order_id)
 
     def cancel_orders(self, instrument: Instrument) -> None:
         raise NotImplementedError("Not implemented yet")
 
-    def update_order(self, order_id: str, price: float | None = None, amount: float | None = None) -> Order:
-        raise NotImplementedError("Not implemented yet")
+    def update_order(self, order_id: str, price: float, amount: float) -> Order:
+        """Update an existing limit order using cancel+recreate strategy.
+
+        Args:
+            order_id: The ID of the order to update
+            price: New price for the order
+            amount: New amount for the order
+
+        Returns:
+            Order: The updated (newly created) order object
+
+        Raises:
+            OrderNotFound: If the order is not found
+            BadRequest: If the order is not a limit order
+        """
+        # Get the existing order from account
+        active_orders = self._account.get_orders()
+        existing_order = active_orders.get(order_id)
+        if not existing_order:
+            raise OrderNotFound(f"Order {order_id} not found")
+
+        # Validate that it's a limit order
+        if existing_order.type.lower() != "limit":
+            raise BadRequest(
+                f"Order {order_id} is not a limit order (type: {existing_order.type}). Only limit orders can be updated."
+            )
+
+        # Cancel the existing order first
+        self.cancel_order(order_id)
+
+        # Create a new order with updated parameters, preserving original properties
+        updated_order = self.send_order(
+            instrument=existing_order.instrument,
+            order_side=existing_order.side,
+            order_type="limit",
+            amount=abs(amount),
+            price=price,
+            client_id=existing_order.client_id,  # Preserve original client_id for tracking
+            time_in_force=existing_order.time_in_force or "gtc",
+        )
+
+        return updated_order
 
     def _send_execution_report(self, report: SimulatedExecutionReport | None):
         if report is None:

qubx/connectors/ccxt/broker.py

@@ -5,7 +5,6 @@ from typing import Any
 import pandas as pd
 
 import ccxt
-
 from ccxt.base.errors import ExchangeError
 from qubx import logger
 from qubx.core.basics import (
@@ -15,7 +14,7 @@ from qubx.core.basics import (
     OrderSide,
 )
 from qubx.core.errors import ErrorLevel, OrderCancellationError, OrderCreationError, create_error_event
-from qubx.core.exceptions import BadRequest, InvalidOrderParameters
+from qubx.core.exceptions import BadRequest, InvalidOrderParameters, OrderNotFound
 from qubx.core.interfaces import (
     IAccountProcessor,
     IBroker,
@@ -61,7 +60,6 @@ class CcxtBroker(IBroker):
         """Get current AsyncThreadLoop for the exchange."""
         return AsyncThreadLoop(self._exchange_manager.exchange.asyncio_loop)
 
-
     @property
     def is_simulated_trading(self) -> bool:
         return False
@@ -178,7 +176,7 @@ class CcxtBroker(IBroker):
         client_id: str | None = None,
         time_in_force: str = "gtc",
         **options,
-    ) -> Order | None:
+    ) -> Order:
         """
         Submit an order and wait for the result. Exceptions will be raised on errors.
 
@@ -221,22 +219,38 @@ class CcxtBroker(IBroker):
             self._post_order_error_to_databus(
                 err, instrument, order_side, order_type, amount, price, client_id, time_in_force, **options
             )
-            return None
+            raise err
 
-    def cancel_order(self, order_id: str) -> Order | None:
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an order synchronously and return success status."""
         orders = self.account.get_orders()
         if order_id not in orders:
             logger.warning(f"Order {order_id} not found in active orders")
-            return None
+            return False
 
         order = orders[order_id]
-        logger.info(f"Canceling order {order_id} ...")
+        logger.info(f"Canceling order {order_id} synchronously...")
 
-        # Submit the cancellation task to the async loop without waiting for the result
-        self._loop.submit(self._cancel_order_with_retry(order_id, order.instrument))
+        try:
+            # Submit the task and wait for result
+            future = self._loop.submit(self._cancel_order_with_retry(order_id, order.instrument))
+            return future.result()  # This will block until completion or timeout
+        except Exception as e:
+            logger.error(f"Error during synchronous order cancellation: {e}")
+            return False  # Return False on any error for simplicity
+
+    def cancel_order_async(self, order_id: str) -> None:
+        """Cancel an order asynchronously (non blocking)."""
+        orders = self.account.get_orders()
+        if order_id not in orders:
+            logger.warning(f"Order {order_id} not found in active orders")
+            return
 
-        # Always return None as requested
-        return None
+        order = orders[order_id]
+        logger.info(f"Canceling order {order_id} asynchronously...")
+
+        # Submit the task without waiting for result
+        self._loop.submit(self._cancel_order_with_retry(order_id, order.instrument))
 
     async def _create_order(
         self,
@@ -298,8 +312,22 @@ class CcxtBroker(IBroker):
             logger.warning(f"[<y>{instrument.symbol}</y>] :: Quote is not available for order creation.")
             raise BadRequest(f"Quote is not available for order creation for {instrument.symbol}")
 
-        # TODO: think about automatically setting reduce only when needed
-        if not (reduce_only := options.get("reduceOnly", False)):
+        # Auto-detect if order reduces existing position
+        reduce_only = options.get("reduceOnly", False)
+        if not reduce_only:
+            positions = self.account.get_positions()
+            if instrument in positions:
+                position_qty = positions[instrument].quantity
+                # Check if order closes position AND doesn't exceed position size (which would flip to opposite side)
+                if (position_qty > 0 and order_side == "SELL" and abs(amount) <= abs(position_qty)) or (
+                    position_qty < 0 and order_side == "BUY" and abs(amount) <= abs(position_qty)
+                ):
+                    reduce_only = True
+                    logger.debug(
+                        f"[{instrument.symbol}] Auto-setting reduceOnly=True ({order_side}, position: {position_qty})"
+                    )
+
+        if not reduce_only:
             min_notional = instrument.min_notional
             if min_notional > 0 and abs(amount) * quote.mid_price() < min_notional:
                 raise InvalidOrderParameters(
@@ -364,9 +392,13 @@ class CcxtBroker(IBroker):
         while True:
             try:
                 if self.enable_cancel_order_ws:
-                    await self._exchange_manager.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_manager.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()
@@ -375,8 +407,12 @@ class CcxtBroker(IBroker):
                     # These errors might be temporary if the order is still being processed, so retry
                     logger.debug(f"[{order_id}] Order not found for cancellation, might retry: {err}")
                     # Continue with the retry logic instead of returning immediately
+                # Order cannot be cancelled (e.g., already filled)
+                elif "filled" in err_msg or "partially filled" in err_msg:
+                    logger.debug(f"[{order_id}] Order cannot be cancelled - already executed: {err}")
+                    return False  # FAILURE: Order cannot be cancelled
+                # Other operation rejected errors - don't retry
                 else:
-                    # For other operation rejected errors, don't retry
                     logger.debug(f"[{order_id}] Could not cancel order: {err}")
                     return False
             except (ccxt.NetworkError, ccxt.ExchangeError, ccxt.ExchangeNotAvailable) as e:
@@ -424,8 +460,112 @@ class CcxtBroker(IBroker):
         for order_id in instrument_orders:
             self.cancel_order(order_id)
 
-    def update_order(self, order_id: str, price: float | None = None, amount: float | None = None) -> Order:
-        raise NotImplementedError("Not implemented yet")
+    def update_order(self, order_id: str, price: float, amount: float) -> Order:
+        """Update an existing limit order with new price and amount.
+
+        Args:
+            order_id: The ID of the order to update
+            price: New price for the order (already adjusted by TradingManager)
+            amount: New amount for the order (already adjusted by TradingManager)
+
+        Returns:
+            Order: The updated Order object if successful
+
+        Raises:
+            OrderNotFound: If the order is not found
+            BadRequest: If the order is not a limit order
+            ExchangeError: If the exchange operation fails
+        """
+        logger.debug(f"Updating order {order_id} with price={price}, amount={amount}")
+
+        active_orders = self.account.get_orders()
+        if order_id not in active_orders:
+            raise OrderNotFound(f"Order {order_id} not found in active orders")
+
+        existing_order = active_orders[order_id]
+
+        # Validate that the order can still be updated (not fully filled/closed)
+        updatable_statuses = ["OPEN", "NEW", "PENDING"]
+        if existing_order.status not in updatable_statuses:
+            raise BadRequest(
+                f"Order {order_id} with status '{existing_order.status}' cannot be updated. "
+                f"Only orders with status {updatable_statuses} can be updated."
+            )
+
+        instrument = existing_order.instrument
+
+        logger.debug(
+            f"[<g>{instrument.symbol}</g>] :: Updating order {order_id}: "
+            f"{amount} @ {price} (was: {existing_order.quantity} @ {existing_order.price})"
+        )
+
+        try:
+            # Check if exchange supports order editing
+            if self._exchange_manager.exchange.has.get("editOrder", False):
+                return self._update_order_direct(order_id, existing_order, price, amount)
+            else:
+                return self._update_order_fallback(order_id, existing_order, price, amount)
+        except Exception as err:
+            logger.error(f"Failed to update order {order_id}: {err}")
+            raise
+
+    def _update_order_direct(self, order_id: str, existing_order: Order, price: float, amount: float) -> Order:
+        """Update order using exchange's native edit functionality."""
+        logger.debug(f"Using direct order update for {order_id}")
+
+        future_result = self._loop.submit(self._edit_order_async(order_id, existing_order, price, amount))
+        updated_order, error = future_result.result()
+
+        if error is not None:
+            raise error
+
+        if updated_order is not None:
+            self.account.process_order(updated_order)
+            logger.debug(f"Direct update successful for order {order_id}")
+            return updated_order
+        else:
+            raise Exception("Order update returned None without error")
+
+    def _update_order_fallback(self, order_id: str, existing_order: Order, price: float, amount: float) -> Order:
+        """Update order using cancel+recreate strategy for exchanges without editOrder support."""
+        logger.debug(f"Using fallback (cancel+recreate) strategy for order {order_id}")
+
+        success = self.cancel_order(order_id)
+        if not success:
+            raise Exception(f"Failed to cancel order {order_id} during update")
+
+        updated_order = self.send_order(
+            instrument=existing_order.instrument,
+            order_side=existing_order.side,
+            order_type=existing_order.type,
+            amount=amount,
+            price=price,
+            client_id=existing_order.client_id,  # Preserve original client_id for tracking
+            time_in_force=existing_order.time_in_force or "gtc",
+        )
+
+        logger.debug(f"Fallback update successful for order {order_id} -> new order {updated_order.id}")
+        return updated_order
+
+    async def _edit_order_async(
+        self, order_id: str, existing_order: Order, price: float, amount: float
+    ) -> tuple[Order | None, Exception | None]:
+        """Async helper for direct order editing."""
+        try:
+            ccxt_symbol = instrument_to_ccxt_symbol(existing_order.instrument)
+            ccxt_side = "buy" if existing_order.side == "BUY" else "sell"
+
+            result = await self._exchange_manager.exchange.edit_order(
+                id=order_id, symbol=ccxt_symbol, type="limit", side=ccxt_side, amount=amount, price=price, params={}
+            )
+
+            # Convert the result back to our Order format
+            updated_order = ccxt_convert_order_info(existing_order.instrument, result)
+            return updated_order, None
+
+        except Exception as err:
+            logger.error(f"Async edit order failed for {order_id}: {err}")
+            return None, err
 
     def exchange(self) -> str:
         """

qubx/connectors/ccxt/exchange_manager.py

@@ -18,8 +18,6 @@ from qubx.core.interfaces import IDataArrivalListener
 
 # Constants for better maintainability
 DEFAULT_CHECK_INTERVAL_SECONDS = 60.0
-DEFAULT_MAX_RECREATIONS = 5
-DEFAULT_RESET_INTERVAL_HOURS = 6.0
 SECONDS_PER_HOUR = 3600
 
 # Custom stall detection thresholds (in seconds)
@@ -30,7 +28,7 @@ STALL_THRESHOLDS = {
     "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
+    "quote": 2 * 60,  # 2 minutes = 120s
 }
 DEFAULT_STALL_THRESHOLD_SECONDS = 2 * SECONDS_PER_HOUR  # 2 hours = 7,200s
 
@@ -45,7 +43,7 @@ class ExchangeManager(IDataArrivalListener):
     Key Features:
     - Explicit .exchange property for CCXT access
     - Self-contained stall detection and recreation triggering
-    - Circuit breaker protection with recreation limits
+    - Automatic recreation without limits when data stalls
     - Atomic exchange transitions during recreation
     - Background monitoring thread for stall detection
     """
@@ -57,8 +55,6 @@ class ExchangeManager(IDataArrivalListener):
         exchange_name: str,
         factory_params: dict[str, Any],
         initial_exchange: Optional[cxp.Exchange] = None,
-        max_recreations: int = DEFAULT_MAX_RECREATIONS,
-        reset_interval_hours: float = DEFAULT_RESET_INTERVAL_HOURS,
         check_interval_seconds: float = DEFAULT_CHECK_INTERVAL_SECONDS,
     ):
         """Initialize ExchangeManager with underlying CCXT exchange.
@@ -67,19 +63,14 @@ class ExchangeManager(IDataArrivalListener):
             exchange_name: Exchange name for factory (e.g., "binance.um")
             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
             check_interval_seconds: How often to check for stalls (default: 60.0)
         """
         self._exchange_name = exchange_name
         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()
+        self._recreation_count = 0  # Track for logging purposes only
 
         # Stall detection state
         self._check_interval = check_interval_seconds
@@ -142,28 +133,19 @@ class ExchangeManager(IDataArrivalListener):
 
     def force_recreation(self) -> bool:
         """
-        Force recreation due to data stalls (called by BaseHealthMonitor).
+        Force recreation due to data stalls.
 
         Returns:
-            True if recreation successful, False if failed/limit exceeded
+            True if recreation successful, False if failed
         """
         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"
-                )
-                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})")
 
         # Create new exchange
         try:
@@ -190,18 +172,6 @@ class ExchangeManager(IDataArrivalListener):
 
         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.
 
@@ -254,7 +224,6 @@ class ExchangeManager(IDataArrivalListener):
         while self._monitoring_enabled:
             try:
                 self._check_and_handle_stalls()
-                self.reset_recreation_count_if_needed()
                 time.sleep(self._check_interval)
             except Exception as e:
                 logger.error(f"Error in ExchangeManager stall detection: {e}")

qubx/connectors/ccxt/factory.py

@@ -85,8 +85,6 @@ def get_ccxt_exchange_manager(
     secret: str | None = None,
     loop: asyncio.AbstractEventLoop | None = None,
     use_testnet: bool = False,
-    max_recreations: int = 3,
-    reset_interval_hours: float = 24.0,
     check_interval_seconds: float = 30.0,
     **kwargs,
 ) -> ExchangeManager:
@@ -102,8 +100,6 @@ def get_ccxt_exchange_manager(
         secret (str, optional): The API secret. Default is None.
         loop (asyncio.AbstractEventLoop, optional): Event loop. Default is None.
         use_testnet (bool): Use testnet/sandbox mode. Default is False.
-        max_recreations (int): Maximum recreation attempts before circuit breaker. Default is 3.
-        reset_interval_hours (float): Hours between recreation count resets. Default is 24.0.
         check_interval_seconds (float): How often to check for stalls. Default is 30.0.
         **kwargs: Additional parameters for exchange configuration.
         
@@ -117,9 +113,7 @@ def get_ccxt_exchange_manager(
         'secret': secret,
         'loop': loop,
         'use_testnet': use_testnet,
-        **{k: v for k, v in kwargs.items() if k not in {
-            'max_recreations', 'reset_interval_hours', 'check_interval_seconds'
-        }}
+        **{k: v for k, v in kwargs.items() if k != 'check_interval_seconds'}
     }
     
     # Create raw CCXT exchange using public factory method
@@ -137,8 +131,6 @@ def get_ccxt_exchange_manager(
         exchange_name=exchange,
         factory_params=factory_params,
         initial_exchange=ccxt_exchange,
-        max_recreations=max_recreations,
-        reset_interval_hours=reset_interval_hours,
         check_interval_seconds=check_interval_seconds,
     )
 

qubx/core/context.py

@@ -468,12 +468,22 @@ class StrategyContext(IStrategyContext):
     def close_positions(self, market_type: MarketType | None = None, without_signals: bool = False) -> None:
         return self._trading_manager.close_positions(market_type, without_signals)
 
-    def cancel_order(self, order_id: str, exchange: str | None = None) -> None:
+    def cancel_order(self, order_id: str, exchange: str | None = None) -> bool:
+        """Cancel a specific order synchronously."""
         return self._trading_manager.cancel_order(order_id, exchange)
 
-    def cancel_orders(self, instrument: Instrument):
+    def cancel_order_async(self, order_id: str, exchange: str | None = None) -> None:
+        """Cancel a specific order asynchronously (non blocking)."""
+        return self._trading_manager.cancel_order_async(order_id, exchange)
+
+    def cancel_orders(self, instrument: Instrument) -> None:
+        """Cancel all orders for an instrument."""
         return self._trading_manager.cancel_orders(instrument)
 
+    def update_order(self, order_id: str, price: float, amount: float, exchange: str | None = None) -> Order:
+        """Update an existing limit order with new price and amount."""
+        return self._trading_manager.update_order(order_id, price, amount, exchange)
+
     # IUniverseManager delegation
     def set_universe(
         self, instruments: list[Instrument], skip_callback: bool = False, if_has_position_then: RemovalPolicy = "close"

qubx/core/helpers.py

@@ -237,12 +237,20 @@ class CachedMarketDataHolder:
             bought_volume_quote = volume_quote if trade.side == 1 else 0.0
             for ser in series.values():
                 if len(ser) > 0:
-                    current_bar_start = floor_t64(np.datetime64(ser[0].time, 'ns'), np.timedelta64(ser.timeframe, 'ns'))
-                    trade_bar_start = floor_t64(np.datetime64(trade.time, 'ns'), np.timedelta64(ser.timeframe, 'ns'))
+                    current_bar_start = floor_t64(np.datetime64(ser[0].time, "ns"), np.timedelta64(ser.timeframe, "ns"))
+                    trade_bar_start = floor_t64(np.datetime64(trade.time, "ns"), np.timedelta64(ser.timeframe, "ns"))
                     if trade_bar_start < current_bar_start:
                         # Trade belongs to a previous bar - skip it
                         continue
-                ser.update(trade.time, trade.price, total_vol, bought_vol, volume_quote, bought_volume_quote, 1)
+                ser.update(
+                    trade.time,
+                    trade.price,
+                    volume=total_vol,
+                    bvolume=bought_vol,
+                    volume_quote=volume_quote,
+                    bought_volume_quote=bought_volume_quote,
+                    trade_count=1,
+                )
 
     def finalize_ohlc_for_instruments(self, time: dt_64, instruments: list[Instrument]):
         """

qubx/core/interfaces.py

@@ -348,14 +348,25 @@ class IBroker:
         """
         raise NotImplementedError("send_order_async is not implemented")
 
-    def cancel_order(self, order_id: str) -> None:
-        """Cancel an existing order (non blocking).
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an existing order synchronously.
 
         Args:
             order_id: The ID of the order to cancel.
+
+        Returns:
+            bool: True if cancellation was successful, False otherwise.
         """
         raise NotImplementedError("cancel_order is not implemented")
 
+    def cancel_order_async(self, order_id: str) -> None:
+        """Cancel an existing order asynchronously (non blocking).
+
+        Args:
+            order_id: The ID of the order to cancel.
+        """
+        raise NotImplementedError("cancel_order_async is not implemented")
+
     def cancel_orders(self, instrument: Instrument) -> None:
         """Cancel all orders for an instrument.
 
@@ -364,8 +375,8 @@ class IBroker:
         """
         raise NotImplementedError("cancel_orders is not implemented")
 
-    def update_order(self, order_id: str, price: float | None = None, amount: float | None = None) -> Order:
-        """Update an existing order.
+    def update_order(self, order_id: str, price: float, amount: float) -> Order:
+        """Update an existing order with new price and amount.
 
         Args:
             order_id: The ID of the order to update.
@@ -378,7 +389,8 @@ class IBroker:
         Raises:
             NotImplementedError: If the method is not implemented
             OrderNotFound: If the order is not found
-            BadRequest: If the request is invalid
+            BadRequest: If the request is invalid (e.g., not a limit order)
+            InvalidOrderParameters: If the order cannot be updated
         """
         raise NotImplementedError("update_order is not implemented")
 
@@ -698,11 +710,24 @@ class ITradingManager:
         """Close all positions."""
         ...
 
-    def cancel_order(self, order_id: str, exchange: str | None = None) -> None:
-        """Cancel a specific order.
+    def cancel_order(self, order_id: str, exchange: str | None = None) -> bool:
+        """Cancel a specific order synchronously.
 
         Args:
             order_id: ID of the order to cancel
+            exchange: Exchange to cancel on (optional)
+
+        Returns:
+            bool: True if cancellation was successful, False otherwise.
+        """
+        ...
+
+    def cancel_order_async(self, order_id: str, exchange: str | None = None) -> None:
+        """Cancel a specific order asynchronously (non blocking).
+
+        Args:
+            order_id: ID of the order to cancel
+            exchange: Exchange to cancel on (optional)
         """
         ...
 
@@ -714,6 +739,25 @@ class ITradingManager:
         """
         ...
 
+    def update_order(self, order_id: str, price: float, amount: float, exchange: str | None = None) -> Order:
+        """Update an existing limit order with new price and amount.
+
+        Args:
+            order_id: ID of the order to update
+            price: New price for the order
+            amount: New amount for the order
+            exchange: Exchange to update on (optional, defaults to first exchange)
+
+        Returns:
+            Order: The updated order object
+
+        Raises:
+            OrderNotFound: If the order is not found
+            BadRequest: If the order is not a limit order or other validation errors
+            InvalidOrderParameters: If the update parameters are invalid
+        """
+        ...
+
     def exchanges(self) -> list[str]: ...
 
 

qubx/core/mixins/trading.py

@@ -159,7 +159,7 @@ class TradingManager(ITradingManager):
     def close_position(self, instrument: Instrument, without_signals: bool = False) -> None:
         position = self._account.get_position(instrument)
 
-        if not position.is_open():
+        if position.quantity == 0:
             logger.debug(f"[<g>{instrument.symbol}</g>] :: Position already closed or zero size")
             return
 
@@ -196,13 +196,36 @@ class TradingManager(ITradingManager):
         for instrument in positions_to_close:
             self.close_position(instrument, without_signals)
 
-    def cancel_order(self, order_id: str, exchange: str | None = None) -> None:
+    def cancel_order(self, order_id: str, exchange: str | None = None) -> bool:
+        """Cancel a specific order synchronously."""
+        if not order_id:
+            return False
+        if exchange is None:
+            exchange = self._brokers[0].exchange()
+        try:
+            success = self._get_broker(exchange).cancel_order(order_id)
+            if success:
+                self._account.remove_order(order_id, exchange)
+            return success
+        except OrderNotFound:
+            # Order was already cancelled or doesn't exist
+            # Still try to remove it from account to keep state consistent
+            self._account.remove_order(order_id, exchange)
+            return False  # Return False since order wasn't found
+        except Exception as e:
+            logger.error(f"Error canceling order {order_id}: {e}")
+            return False  # Return False for any other errors
+
+    def cancel_order_async(self, order_id: str, exchange: str | None = None) -> None:
+        """Cancel a specific order asynchronously (non blocking)."""
         if not order_id:
             return
         if exchange is None:
             exchange = self._brokers[0].exchange()
         try:
-            self._get_broker(exchange).cancel_order(order_id)
+            self._get_broker(exchange).cancel_order_async(order_id)
+            # Note: For async, we remove the order optimistically
+            # The actual removal will be confirmed via order status updates
             self._account.remove_order(order_id, exchange)
         except OrderNotFound:
             # Order was already cancelled or doesn't exist
@@ -213,6 +236,49 @@ class TradingManager(ITradingManager):
         for o in self._account.get_orders(instrument).values():
             self.cancel_order(o.id, instrument.exchange)
 
+    def update_order(self, order_id: str, price: float, amount: float, exchange: str | None = None) -> Order:
+        """Update an existing limit order with new price and amount."""
+        if not order_id:
+            raise ValueError("Order ID is required")
+        if exchange is None:
+            exchange = self._brokers[0].exchange()
+
+        # Get the existing order to determine instrument for adjustments
+        active_orders = self._account.get_orders()
+        existing_order = active_orders.get(order_id)
+        if not existing_order:
+            # Let broker handle the OrderNotFound - just pass through
+            logger.debug(f"Updating order {order_id}: {amount} @ {price} on {exchange}")
+        else:
+            # Apply TradingManager-level adjustments before sending to broker
+            instrument = existing_order.instrument
+            adjusted_amount = self._adjust_size(instrument, amount)
+            adjusted_price = self._adjust_price(instrument, price, amount)
+            if adjusted_price is None:
+                raise ValueError(f"Price adjustment failed for {instrument.symbol}")
+
+            logger.debug(
+                f"[<g>{instrument.symbol}</g>] :: Updating order {order_id}: "
+                f"{adjusted_amount} @ {adjusted_price} (was: {existing_order.quantity} @ {existing_order.price})"
+            )
+
+            # Update the values to use adjusted ones
+            amount = adjusted_amount
+            price = adjusted_price
+
+        try:
+            updated_order = self._get_broker(exchange).update_order(order_id, price, amount)
+
+            if updated_order is not None:
+                # Update account tracking with new order info
+                self._account.process_order(updated_order)
+                logger.info(f"[<g>{updated_order.instrument.symbol}</g>] :: Successfully updated order {order_id}")
+
+            return updated_order
+        except Exception as e:
+            logger.error(f"Error updating order {order_id}: {e}")
+            raise e
+
     def _generate_order_client_id(self, symbol: str) -> str:
         return self._client_id_store.generate_id(self._context, symbol)
 

qubx/exporters/formatters/target_position.py

@@ -71,10 +71,6 @@ class TargetPositionFormatter(DefaultFormatter):
         exchange = self.exchange_mapping.get(target.instrument.exchange, target.instrument.exchange)
 
         return {
-            "action": "TARGET_POSITION",
-            "alertName": self.alert_name,
-            "exchange": exchange,
-            "symbol": target.instrument.exchange_symbol.upper(),
-            "side": side,
-            "leverage": leverage,
+            "type": "TARGET_POSITION",
+            "data": f'{{"action":"TARGET_POSITION","alertName":"{self.alert_name}","exchange":"{exchange}","symbol":"{target.instrument.exchange_symbol.upper()}","side":"{side}","leverage":{leverage}}}',
         }

qubx/loggers/csv.py

@@ -31,10 +31,10 @@ class CsvFileLogsWriter(LogsWriter):
         self._hdr_sig = not os.path.exists(_sig_path)
         self._hdr_tgt = not os.path.exists(_tgt_path)
 
-        self._pfl_file_ = open(_pfl_path, "+a", newline="")
-        self._execs_file_ = open(_exe_path, "+a", newline="")
-        self._sig_file_ = open(_sig_path, "+a", newline="")
-        self._tgt_file_ = open(_tgt_path, "+a", newline="")
+        self._pfl_file_ = open(_pfl_path, "a", newline="")
+        self._execs_file_ = open(_exe_path, "a", newline="")
+        self._sig_file_ = open(_sig_path, "a", newline="")
+        self._tgt_file_ = open(_tgt_path, "a", newline="")
 
         self._pfl_writer = csv.writer(self._pfl_file_)
         self._exe_writer = csv.writer(self._execs_file_)

qubx/utils/marketdata/ccxt.py

@@ -71,11 +71,42 @@ def ccxt_symbol_to_instrument(ccxt_exchange_name: str, market: dict[str, Any]) -
 
     mkt_type = MarketType[market["type"].upper()]
 
-    # - extract expiry date if present
-    expiry_date = pd.Timestamp(market["expiryDatetime"]) if "expiryDatetime" in market else None
-    if not expiry_date and "expiry" in market:
-        expiry_date = pd.Timestamp(int(market["expiry"]), unit="ms") if "expiry" in market else None
-
+     # - extract expiry date if present
+    expiry_date = None
+    if "expiryDatetime" in market and market["expiryDatetime"]:
+        expiry_date = pd.Timestamp(market["expiryDatetime"])
+    elif "expiry" in market and market["expiry"]:
+        expiry_date = pd.Timestamp(int(market["expiry"]), unit="ms")
+    elif "deliveryDate" in inner_info and inner_info["deliveryDate"]:
+        expiry_date = pd.Timestamp(int(inner_info["deliveryDate"]), unit="ms")
+    
+    # - extract onboard date from multiple possible sources
+    onboard_date = None
+    try:
+        # Try inner_info.onboardDate first (Binance futures)
+        if "onboardDate" in inner_info and inner_info["onboardDate"]:
+            onboard_date = pd.Timestamp(int(inner_info["onboardDate"]), unit="ms")
+        # Try top-level created field (available for many exchanges)
+        elif "created" in market and market["created"]:
+            onboard_date = pd.Timestamp(int(market["created"]), unit="ms")
+    except (ValueError, TypeError, OverflowError) as e:
+        onboard_date = None
+
+    # - extract delist date if present
+    delist_date = None
+    try:
+        if "delistDate" in inner_info and inner_info["delistDate"]:
+            delist_date = pd.Timestamp(int(inner_info["delistDate"]), unit="ms")
+        # Some exchanges may have status-based delisting info
+        elif "deliveryDate" in inner_info and inner_info["deliveryDate"]:
+            delist_date = pd.Timestamp(int(inner_info["deliveryDate"]), unit="ms")
+        elif "status" in inner_info and inner_info["status"] in ["DELISTED", "INACTIVE"]:
+            # For delisted instruments, we could set delist_date to now, but it's better to leave None
+            # and let the 'active' field handle current status
+            pass
+    except (ValueError, TypeError, OverflowError) as e:
+        delist_date = None
+    
     # - add expiry date to futures symbol if present
     if mkt_type == MarketType.FUTURE and expiry_date:
         symbol += f".{expiry_date.strftime('%Y%m%d')}"
@@ -97,8 +128,9 @@ def ccxt_symbol_to_instrument(ccxt_exchange_name: str, market: dict[str, Any]) -
         maint_margin=maint_margin,
         liquidation_fee=liquidation_fee,
         contract_size=float(market.get("contractSize", 1.0) or 1.0),
-        onboard_date=pd.Timestamp(int(inner_info["onboardDate"]), unit="ms") if "onboardDate" in inner_info else None,
+        onboard_date=onboard_date,
         delivery_date=expiry_date,
+        delist_date=delist_date,
         inverse=market.get("inverse", False),
     )
 

{qubx-0.6.89.dist-info → qubx-0.6.90.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 0.6.89
+Version: 0.6.90
 Summary: Qubx - Quantitative Trading Framework
 License-File: LICENSE
 Author: Dmitry Marienko

{qubx-0.6.89.dist-info → qubx-0.6.90.dist-info}/RECORD

@@ -2,7 +2,7 @@ qubx/__init__.py,sha256=hOsIaNAqETrL6SLd979Xcr5_WOAGo9q30eQkqSiv7gw,8113
 qubx/_nb_magic.py,sha256=G3LkaX_-gN5Js6xl7rjaahSs_u3dVPDRCZW0IIxPCb0,3051
 qubx/backtester/__init__.py,sha256=OhXhLmj2x6sp6k16wm5IPATvv-E2qRZVIcvttxqPgcg,176
 qubx/backtester/account.py,sha256=0yvE06icSeK2ymovvaKkuftY8Ou3Z7Y2JrDa6VtkINw,3048
-qubx/backtester/broker.py,sha256=lJ6PpqE2L0vKcgw2ZP7xahne4eZguJFYWXHiWP6jmXM,2949
+qubx/backtester/broker.py,sha256=3J9MQqdnh2JzpKLrJ_aYqzPZEVixvYuuzg1BzfyITOc,4668
 qubx/backtester/data.py,sha256=eDS-fe44m6dKy3hp2P7Gll2HRZRpsf_EG-K52Z3zsx8,8057
 qubx/backtester/management.py,sha256=cgeO7cIyd5J9r1XYGWC9XV2oVHtgAMpQZ6rhxFYl0J4,21147
 qubx/backtester/ome.py,sha256=LnnSANMD2XBo18JtLRh96Ey9BH_StrfshQnCu2_aOc4,18646
@@ -23,11 +23,11 @@ qubx/connectors/ccxt/__init__.py,sha256=HEQ7lM9HS8sED_zfsAHrhFT7F9E7NFGAecwZwNr-
 qubx/connectors/ccxt/account.py,sha256=VyPQGlELm1lFXD4sf4zD8xaC9ZQpneB8gAVm-di4hhE,25396
 qubx/connectors/ccxt/adapters/__init__.py,sha256=4qwWer4C9fTIZKUYmcgbMFEwFuYp34UKbb-AoQNvXjc,178
 qubx/connectors/ccxt/adapters/polling_adapter.py,sha256=UrOAoIfgtoRw7gj6Bmk5lPs_UI8iOxr88DAfp5o5CF8,8962
-qubx/connectors/ccxt/broker.py,sha256=I6I_BynhwHadKa62nBGmDoj5LhFiEzbUq-1ZDwE25aM,16512
+qubx/connectors/ccxt/broker.py,sha256=BqLKzFIYlf2Tw5LE2CWkv3UTEKMeqEpoBnEJmhMNGPE,23025
 qubx/connectors/ccxt/connection_manager.py,sha256=Jv4c7eymGm_RVHbgViy3DMv5hr_SONm0wir1enKS7V0,11621
 qubx/connectors/ccxt/data.py,sha256=cUKLWDT_d0w4ZUU-HabI5FmJzDDf0ZU9gZFzb5PU5Ek,15799
 qubx/connectors/ccxt/exceptions.py,sha256=OfZc7iMdEG8uLorcZta2NuEuJrSIqi0FG7IICmwF54M,262
-qubx/connectors/ccxt/exchange_manager.py,sha256=QVNY7qq2VeUbYTXODBKVy3sBdoaZ6psB3hJ-WmR7iPU,14242
+qubx/connectors/ccxt/exchange_manager.py,sha256=2dlK4zNlL58r_gM1JTxzn8OVTEgkJbXXz-tvvFXfc5g,12737
 qubx/connectors/ccxt/exchanges/__init__.py,sha256=vhBxEWljNE_uan5Kxlr8WLnZhHFKdvjUt8tv2KRKFAA,3167
 qubx/connectors/ccxt/exchanges/base.py,sha256=0MGKBJhvmy89-JNp_8Dc61vEJwakWV7rL8IZUwUOsVo,2249
 qubx/connectors/ccxt/exchanges/binance/broker.py,sha256=BB2V82zaOm1EjP3GrsOqQQMeGpml6-w23iv7goKrjyU,2111
@@ -38,7 +38,7 @@ qubx/connectors/ccxt/exchanges/hyperliquid/__init__.py,sha256=j6OB7j_yKRgitQAeJX
 qubx/connectors/ccxt/exchanges/hyperliquid/broker.py,sha256=yoht8KsiMS3F6rkyfwQ3prBn-OgnY6tCDwYJQbsq1t0,3130
 qubx/connectors/ccxt/exchanges/hyperliquid/hyperliquid.py,sha256=nHeMCBfIBdcWYl8s9vqyr9fxVmnzEz0uEwxQskLN6UM,20353
 qubx/connectors/ccxt/exchanges/kraken/kraken.py,sha256=ntxf41aPY0JqxT5jn-979fgQih2TvMbr_p9fvCJB9QE,414
-qubx/connectors/ccxt/factory.py,sha256=hX5WODwwo49J3YjGulpDyq1SKq9VvWH3otzFw6avS5I,6259
+qubx/connectors/ccxt/factory.py,sha256=dyTUhgKkpq8jHofRO-H9f34EHtK4d0qtKhp2ZDBxgAc,5835
 qubx/connectors/ccxt/handlers/__init__.py,sha256=Cuo2RsHiijhBd8YIkLey9JhHkBGWRtPoeu_BEg_jlDE,879
 qubx/connectors/ccxt/handlers/base.py,sha256=1QS9uhFsisWvGwDmoAc83kLcSd1Lf3hSlnrWwKoHuAk,3334
 qubx/connectors/ccxt/handlers/factory.py,sha256=SlMAOmaUy1dQ-q5ZzrjODj_XMcLr1BORGGZ7klLNndk,4250
@@ -60,13 +60,13 @@ qubx/connectors/tardis/utils.py,sha256=epThu9DwqbDb7BgScH6fHa_FVpKUaItOqp3JwtKGc
 qubx/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qubx/core/account.py,sha256=GGolhM9Qzr2qstipYZ1lxuiac1aOEfQl6fnuQ1Drf5s,23920
 qubx/core/basics.py,sha256=TZPg99rkSx6x_iJX9qkl53irQx9Bc9G6WqLtzktMiZw,41437
-qubx/core/context.py,sha256=Yq039nsKmf-IeyvcRdnMs_phVmehoCUqFvQuVnm-d4s,26074
+qubx/core/context.py,sha256=QFPVy9egHw4T35DV1ruVsxkdUelDUll9BDZ3WGNQukQ,26686
 qubx/core/deque.py,sha256=3PsmJ5LF76JpsK4Wp5LLogyE15rKn6EDCkNOOWT6EOk,6203
 qubx/core/errors.py,sha256=LENtlgmVzxxUFNCsuy4PwyHYhkZkxuZQ2BPif8jaGmw,1411
 qubx/core/exceptions.py,sha256=11wQC3nnNLsl80zBqbE6xiKCqm31kctqo6W_gdnZkg8,581
-qubx/core/helpers.py,sha256=xFcgXtNGvaz8SvLeHToePMx0tx85eX3H4ymxjz66ekg,22129
+qubx/core/helpers.py,sha256=fiHOi_j9oLUkat_kOBMI-gyH6G31LSyDtvRfxH_mAas,22348
 qubx/core/initializer.py,sha256=VVti9UJDJCg0125Mm09S6Tt1foHK4XOBL0mXgDmvXes,7724
-qubx/core/interfaces.py,sha256=cf1-_cNGIucXI8be3BLXwBXBBGVB_88x33eh1hLsZJc,67906
+qubx/core/interfaces.py,sha256=ic_5qrqXq_Cms4BIimObY1GQ5hcayhvjuV5Qs2Lfa4g,69548
 qubx/core/loggers.py,sha256=eYijsR02S5u1Hv21vjIk_dOUwOMv0fiBDYwEmFhAoWk,14344
 qubx/core/lookups.py,sha256=Bed30kPZvbTGjZ8exojhIMOIVfB46j6741yF3fXGTiM,18313
 qubx/core/metrics.py,sha256=j8fXGs946reDLugywxTuWPB8WhZbsoZpwVVDUFePcJE,81480
@@ -74,15 +74,15 @@ qubx/core/mixins/__init__.py,sha256=AMCLvfNuIb1kkQl3bhCj9jIOEl2eKcVPJeyLgrkB-rk,
 qubx/core/mixins/market.py,sha256=w9OEDfy0r9xnb4KdKA-PuFsCQugNo4pMLQivGFeyqGw,6356
 qubx/core/mixins/processing.py,sha256=UqKwOzkDXvmcjvffrsR8vugq_XacwW9rcGM0TcBd9RM,44485
 qubx/core/mixins/subscription.py,sha256=2nUikNNPsMExS9yO38kNt7jk1vKE-RPm0b3h1bU6gjE,11397
-qubx/core/mixins/trading.py,sha256=7KwxHiPWkXGnkHS4VLaxOZ7BHULkvvqPS8ooAG1NTxM,9477
+qubx/core/mixins/trading.py,sha256=hYyDSLmy9mGCCzmfvs8UBFi7yk_RMuitcTK1SVci5O4,12629
 qubx/core/mixins/universe.py,sha256=UBa3OIr2XvlK04O7YUG9c66CY8AZ5rQDSZov1rnUSjQ,10512
 qubx/core/mixins/utils.py,sha256=P71cLuqKjId8989MwOL_BtvvCnnwOFMkZyB1SY-0Ork,147
-qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=MeZdu0YZwIw978g-3xDUEQO69wjl3dX5L6z_Sf-sPRQ,1027944
+qubx/core/series.cpython-312-x86_64-linux-gnu.so,sha256=PeNuRhkuhHf7-Qs1x5uEVgutaRgX4IvX-skQh1zPwKQ,1027944
 qubx/core/series.pxd,sha256=4WpEexOBwZdKvqI81yR7wCnQh2rKgVZp9Y0ejr8B3E4,4841
 qubx/core/series.pyi,sha256=30F48-oMp-XuySh5pyuoZcV20R4yODRpYBgLv7yxhjY,5534
 qubx/core/series.pyx,sha256=9d3XjPAyI6qYLXuKXqZ3HrxBir1CRVste8GpGvgqYL4,52876
 qubx/core/stale_data_detector.py,sha256=NHnnG9NkcivC93n8QMwJUzFVQv2ziUaN-fg76ppng_c,17118
-qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=EHgyf8V9FxVEOp-a4W_QjL_Dh5p8fPY1ReH9EVP5RHM,86568
+qubx/core/utils.cpython-312-x86_64-linux-gnu.so,sha256=Br9aqkN4oGmiRbU_nTg5Mibcr-VJ2eYeL5xhMUiG7YM,86568
 qubx/core/utils.pyi,sha256=a-wS13V2p_dM1CnGq40JVulmiAhixTwVwt0ah5By0Hc,348
 qubx/core/utils.pyx,sha256=UR9achMR-LARsztd2eelFsDsFH3n0gXACIKoGNPI9X4,1766
 qubx/data/__init__.py,sha256=BlyZ99esHLDmFA6ktNkuIce9RZO99TA1IMKWe94aI8M,599
@@ -106,7 +106,7 @@ qubx/exporters/formatters/__init__.py,sha256=nyPFrsRJczffszAV2gXE_23qwRPOkNJo72P
 qubx/exporters/formatters/base.py,sha256=rhfStE_ORLTj4dV5l10gpwmQEvGtMxeRJp8SE77IDzQ,5597
 qubx/exporters/formatters/incremental.py,sha256=V8kbxKDqjQm82wR8wDjHs2bR5WsHqSDFn_O5mI3yBxg,5260
 qubx/exporters/formatters/slack.py,sha256=MPjbEFh7PQufPdkg_Fwiu2tVw5zYJa977tCemoI790Y,7017
-qubx/exporters/formatters/target_position.py,sha256=uuO9-TJhWzOvUUDHYD4VNQ3XGzgXiomxKsty-um_mWg,3137
+qubx/exporters/formatters/target_position.py,sha256=beUTB4R188_hbz3wrxIMMAjXHhyvEii1mBaPbxB5ESc,3138
 qubx/exporters/redis_streams.py,sha256=wu9ianwMiKfFerSaCFMNz6XMRjOMev02UN00D2pxxLg,10048
 qubx/exporters/slack.py,sha256=wnVZRwWOKq9lMQyW0MWh_6gkW1id1TUanfOKy-_clwI,7723
 qubx/features/__init__.py,sha256=ZFCX7K5bDAH7yTsG-mf8zibW8UW8GCneEagL1_p8kDQ,385
@@ -119,7 +119,7 @@ qubx/gathering/simplest.py,sha256=7SHTwK5MojtgjDR5pNObGZCD1EFK15ewG58oGonCC_8,44
 qubx/health/__init__.py,sha256=ThJTgf-CPD5tMU_emqANpnE6oXfUmzyyugfbDfzeVB0,111
 qubx/health/base.py,sha256=RIm2nc_FPBBJ9Ji3w_mlIwISjmGR8K94iqRjgVvkGSY,27941
 qubx/loggers/__init__.py,sha256=nA7nLQKkR9hIJCYQyZxikm--xsB6DaTE5itKypEPBKA,443
-qubx/loggers/csv.py,sha256=FCzGSPz1OvqshoRD-pHwfpndwsZbL1S4i7ou57bNAuE,4390
+qubx/loggers/csv.py,sha256=Njwk3UkK_blmHZOmRB0-OvNcvOFk50-wUm9cgPwGrzs,4386
 qubx/loggers/factory.py,sha256=pDwLuFPPpoCCTiVoDrzvcAsyPFm6sS0e4Zi3j5UEhqk,1791
 qubx/loggers/inmemory.py,sha256=L1U7YrypTUhE6F9jXKljudBkScjUsUq6CQ7sihFwjeU,4198
 qubx/loggers/mongo.py,sha256=qFtUZN9SaPlM8A_C09TMrzMC2zjtiGB3GmazSi6QVQk,2769
@@ -157,7 +157,7 @@ qubx/restorers/signal.py,sha256=5nK5ji8AucyWrFBK9uW619YCI_vPRGFnuDu8JnG3B_Y,1451
 qubx/restorers/state.py,sha256=I1VIN0ZcOjigc3WMHIYTNJeAAbN9YB21MDcMl04ZWmY,8018
 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=QwjXANt1P_Q1-SXrkZzNMapRf4prNK91B9iCKILpW8g,804392
+qubx/ta/indicators.cpython-312-x86_64-linux-gnu.so,sha256=TWM-iBq0WMrs4zfUbKZL20MV__xPsOShYqAs5PK8l3M,804392
 qubx/ta/indicators.pxd,sha256=r9mYcpDFxn3RW5lVJ497Fiq2-eqD4k7VX0-Q0xcftkk,4913
 qubx/ta/indicators.pyi,sha256=T87VwJrBJK8EuqtoW1Dhjri05scH_Y6BXN9kex6G7mQ,2881
 qubx/ta/indicators.pyx,sha256=jJMZ7D2kUspwiZITBnFuNPNvzqUm26EtEfSzBWSrLvQ,39286
@@ -191,7 +191,7 @@ qubx/utils/charting/mpl_helpers.py,sha256=oG9aaz1jFkRHk2g-jiaLlto6mLjhFtq3KTyDUE
 qubx/utils/charting/orderbook.py,sha256=NmeXxru3CUiKLtl1DzCBbQgSdL4qmTDIxV0u81p2tTw,11083
 qubx/utils/collections.py,sha256=go2sH_q2TlXqI3Vxq8GHLfNGlYL4JwS3X1lwJWbpFLE,7425
 qubx/utils/marketdata/binance.py,sha256=hWX3noZj704JIMBqlwsXA5IzUP7EgiLiC2r12dJAKQA,11565
-qubx/utils/marketdata/ccxt.py,sha256=onUPYuHIjGjl3oVtiMSRqcB-Ec77Rj-PwZQ0tH-U9BA,5333
+qubx/utils/marketdata/ccxt.py,sha256=K1u9R2dyIdDjKZlg7WnXLL89XuZqH5oMmIL8yUICU98,6850
 qubx/utils/marketdata/dukas.py,sha256=rFtvEE9SZDmJGS1Ka8bEjleQu_ORy4criIDHsjXE7A4,3237
 qubx/utils/misc.py,sha256=gb8z3zzVdRUIKncAmI0uMQnT4zSRo41qKh1w0WiOMAU,17360
 qubx/utils/ntp.py,sha256=yNurgbdiqKhq_dVrJ5PRnho9SzT3ijQG-Bi2sDnFSLs,1904
@@ -212,8 +212,8 @@ qubx/utils/runner/factory.py,sha256=hmtUDYNFQwVQffHEfxgrlmKwOGLcFQ6uJIH_ZLscpIY,
 qubx/utils/runner/runner.py,sha256=q3b80zD4za6dFSOA6mUCuSQXe0DKS6LwGBMxO1aL3aw,34324
 qubx/utils/time.py,sha256=xOWl_F6dOLFCmbB4xccLIx5yVt5HOH-I8ZcuowXjtBQ,11797
 qubx/utils/version.py,sha256=e52fIHyxzCiIuH7svCF6pkHuDlqL64rklqz-2XjWons,5309
-qubx-0.6.89.dist-info/METADATA,sha256=zt2b-yd4YaWFLhtQj6wibB5azRt7nNMyrNkRnlCCxVg,5909
-qubx-0.6.89.dist-info/WHEEL,sha256=RA6gLSyyVpI0R7d3ofBrM1iY5kDUsPwh15AF0XpvgQo,110
-qubx-0.6.89.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
-qubx-0.6.89.dist-info/licenses/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
-qubx-0.6.89.dist-info/RECORD,,
+qubx-0.6.90.dist-info/METADATA,sha256=roluwar3N_k6jDaqe6-tOBmFSoHoPaJkmDKeLalYr-c,5909
+qubx-0.6.90.dist-info/WHEEL,sha256=RA6gLSyyVpI0R7d3ofBrM1iY5kDUsPwh15AF0XpvgQo,110
+qubx-0.6.90.dist-info/entry_points.txt,sha256=VqilDTe8mVuV9SbR-yVlZJBTjbkHIL2JBgXfQw076HY,47
+qubx-0.6.90.dist-info/licenses/LICENSE,sha256=qwMHOSJ2TD0nx6VUJvFhu1ynJdBfNozRMt6tnSul-Ts,35140
+qubx-0.6.90.dist-info/RECORD,,