Qubx 0.6.89__tar.gz → 0.6.91__tar.gz

{qubx-0.6.89 → qubx-0.6.91}/PKG-INFO

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

{qubx-0.6.89 → qubx-0.6.91}/pyproject.toml

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

{qubx-0.6.89 → qubx-0.6.91}/src/qubx/backtester/account.py

@@ -42,7 +42,7 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
                 _pos = self.get_position(instrument)
                 _pos.reset_by_position(position)
 
-    def get_orders(self, instrument: Instrument | None = None) -> dict[str, Order]:
+    def get_orders(self, instrument: Instrument | None = None, exchange: str | None = None) -> dict[str, Order]:
         return self._exchange.get_open_orders(instrument)
 
     def get_position(self, instrument: Instrument) -> Position:

{qubx-0.6.89 → qubx-0.6.91}/src/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-0.6.89 → qubx-0.6.91}/src/qubx/cli/commands.py

@@ -69,11 +69,14 @@ def main(debug: bool, debug_port: int, log_level: str):
 @click.option(
     "--jupyter", "-j", is_flag=True, default=False, help="Run strategy in jupyter console.", show_default=True
 )
+@click.option(
+    "--textual", "-t", is_flag=True, default=False, help="Run strategy in textual TUI.", show_default=True
+)
 @click.option(
     "--restore", "-r", is_flag=True, default=False, help="Restore strategy state from previous run.", show_default=True
 )
 @click.option("--no-color", is_flag=True, default=False, help="Disable colored logging output.", show_default=True)
-def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool, restore: bool, no_color: bool):
+def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool, textual: bool, restore: bool, no_color: bool):
     """
     Starts the strategy with the given configuration file. If paper mode is enabled, account is not required.
 
@@ -84,12 +87,21 @@ def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool
     """
     from qubx.utils.misc import add_project_to_system_path, logo
     from qubx.utils.runner.runner import run_strategy_yaml, run_strategy_yaml_in_jupyter
+    from qubx.utils.runner.textual import run_strategy_yaml_in_textual
+
+    # Ensure jupyter and textual are mutually exclusive
+    if jupyter and textual:
+        click.echo("Error: --jupyter and --textual cannot be used together.", err=True)
+        raise click.Abort()
 
     add_project_to_system_path()
     add_project_to_system_path(str(config_file.parent.parent))
     add_project_to_system_path(str(config_file.parent))
+
     if jupyter:
         run_strategy_yaml_in_jupyter(config_file, account_file, paper, restore)
+    elif textual:
+        run_strategy_yaml_in_textual(config_file, account_file, paper, restore)
     else:
         logo()
         run_strategy_yaml(config_file, account_file, paper=paper, restore=restore, blocking=True, no_color=no_color)

{qubx-0.6.89 → qubx-0.6.91}/src/qubx/connectors/ccxt/account.py

@@ -337,7 +337,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         current_pos.change_position_by(timestamp, quantity_diff, _current_price)
 
     def _get_start_time_in_ms(self, days_before: int) -> int:
-        return (self.time_provider.time() - days_before * pd.Timedelta("1d")).asm8.item() // 1000000
+        return (self.time_provider.time() - days_before * pd.Timedelta("1d")).asm8.item() // 1000000  # type: ignore
 
     def _is_our_order(self, order: Order) -> bool:
         if order.client_id is None:
@@ -365,7 +365,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         _fetch_instruments: list[Instrument] = []
         for instr in instruments:
             _dt, _ = self._instrument_to_last_price.get(instr, (None, None))
-            if _dt is None or pd.Timedelta(_current_time - _dt) > pd.Timedelta(self.balance_interval):
+            if _dt is None or pd.Timedelta(_current_time - _dt) > pd.Timedelta(self.balance_interval):  # type: ignore
                 _fetch_instruments.append(instr)
 
         _symbol_to_instrument = {instr.symbol: instr for instr in instruments}
@@ -506,6 +506,7 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         deals: list[Deal] = [ccxt_convert_deal_info(o) for o in deals_data]
         return sorted(deals, key=lambda x: x.time) if deals else []
 
+    # TODO: this should take the exchange manager instead of cxp.Exchange
     async def _listen_to_stream(
         self,
         subscriber: Callable[[], Awaitable[None]],

{qubx-0.6.89 → qubx-0.6.91}/src/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,
@@ -43,6 +42,7 @@ class CcxtBroker(IBroker):
         max_cancel_retries: int = 10,
         enable_create_order_ws: bool = False,
         enable_cancel_order_ws: bool = False,
+        enable_edit_order_ws: bool = False,
     ):
         self._exchange_manager = exchange_manager
         self.ccxt_exchange_id = str(self._exchange_manager.exchange.name)
@@ -55,13 +55,13 @@ class CcxtBroker(IBroker):
         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
+        self.enable_edit_order_ws = enable_edit_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
@@ -178,7 +178,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 +221,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 +314,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 +394,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 +409,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 +462,117 @@ 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
+        """
+        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} ({existing_order.time_in_force}))"
+        )
+
+        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."""
+        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"[<g>{existing_order.instrument.symbol}</g>] :: Successfully updated 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."""
+        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"[<g>{existing_order.instrument.symbol}</g>] :: Successfully updated 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"
+
+            # CCXT requires positive amount (side determines direction)
+            abs_amount = abs(amount)
+
+            # Use WebSocket if enabled, otherwise use REST API
+            if self.enable_edit_order_ws:
+                result = await self._exchange_manager.exchange.edit_order_ws(
+                    id=order_id, symbol=ccxt_symbol, type="limit", side=ccxt_side, amount=abs_amount, price=price, params={}
+                )
+            else:
+                result = await self._exchange_manager.exchange.edit_order(
+                    id=order_id, symbol=ccxt_symbol, type="limit", side=ccxt_side, amount=abs_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-0.6.89 → qubx-0.6.91}/src/qubx/connectors/ccxt/connection_manager.py

@@ -13,6 +13,7 @@ from collections import defaultdict
 from typing import Awaitable, Callable
 
 from ccxt import ExchangeClosedByUser, ExchangeError, ExchangeNotAvailable, NetworkError
+from ccxt.async_support.base.ws.client import Client as _WsClient
 from ccxt.pro import Exchange
 from qubx import logger
 from qubx.core.basics import CtrlChannel
@@ -23,6 +24,19 @@ from .exchange_manager import ExchangeManager
 from .subscription_manager import SubscriptionManager
 
 
+def _safe_buffer(self):
+    conn = getattr(self.connection, "_conn", None)
+    if not conn or not getattr(conn, "protocol", None):
+        return b""
+    payload = getattr(conn.protocol, "_payload", None)
+    buf = getattr(payload, "_buffer", None)
+    return buf if buf is not None else b""
+
+
+# SAFETY PATCH: make ccxt WS buffer access resilient to closed connections
+_WsClient.buffer = property(_safe_buffer)  # type: ignore
+
+
 class ConnectionManager:
     """
     Manages WebSocket connections and stream lifecycle for CCXT data provider.

{qubx-0.6.89 → qubx-0.6.91}/src/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-0.6.89 → qubx-0.6.91}/src/qubx/connectors/ccxt/exchanges/__init__.py

@@ -12,6 +12,7 @@ from .binance.broker import BinanceCcxtBroker
 from .binance.exchange import BINANCE_UM_MM, BinancePortfolioMargin, BinanceQV, BinanceQVUSDM
 from .bitfinex.bitfinex import BitfinexF
 from .bitfinex.bitfinex_account import BitfinexAccountProcessor
+from .hyperliquid.account import HyperliquidAccountProcessor
 from .hyperliquid.broker import HyperliquidCcxtBroker
 from .hyperliquid.hyperliquid import Hyperliquid, HyperliquidF
 from .kraken.kraken import CustomKrakenFutures
@@ -45,12 +46,14 @@ CUSTOM_BROKERS = {
     "binance.cm": partial(BinanceCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
     "binance.pm": partial(BinanceCcxtBroker, enable_create_order_ws=False, enable_cancel_order_ws=False),
     "bitfinex.f": partial(CcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=True),
-    "hyperliquid": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
-    "hyperliquid.f": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False),
+    "hyperliquid": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False, enable_edit_order_ws=True),
+    "hyperliquid.f": partial(HyperliquidCcxtBroker, enable_create_order_ws=True, enable_cancel_order_ws=False, enable_edit_order_ws=True),
 }
 
 CUSTOM_ACCOUNTS = {
     "bitfinex.f": BitfinexAccountProcessor,
+    "hyperliquid": HyperliquidAccountProcessor,
+    "hyperliquid.f": HyperliquidAccountProcessor,
 }
 
 READER_CAPABILITIES = {

qubx-0.6.91/src/qubx/connectors/ccxt/exchanges/hyperliquid/__init__.py

@@ -0,0 +1,7 @@
+# Hyperliquid exchange overrides
+
+from .account import HyperliquidAccountProcessor
+from .broker import HyperliquidCcxtBroker
+from .hyperliquid import Hyperliquid, HyperliquidF
+
+__all__ = ["HyperliquidAccountProcessor", "HyperliquidCcxtBroker", "Hyperliquid", "HyperliquidF"]