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

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/backtester/management.py

@@ -1,6 +1,7 @@
 import re
 import zipfile
 from collections import defaultdict
+from os.path import expanduser
 from pathlib import Path
 
 import numpy as np
@@ -39,7 +40,7 @@ class BacktestsResultsManager:
     """
 
     def __init__(self, path: str):
-        self.path = path
+        self.path = expanduser(path)
         self.reload()
 
     def reload(self) -> "BacktestsResultsManager":

qubx/cli/commands.py

@@ -69,11 +69,32 @@ 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(
+    "--textual-dev", is_flag=True, default=False, help="Enable Textual dev mode (use with 'textual console').", show_default=True
+)
+@click.option(
+    "--textual-web", is_flag=True, default=False, help="Serve Textual app in web browser.", show_default=True
+)
+@click.option(
+    "--textual-port", type=int, default=None, help="Port for Textual (web server: 8000, devtools: 8081).", show_default=False
+)
+@click.option(
+    "--textual-host", type=str, default="0.0.0.0", help="Host for Textual web server.", show_default=True
+)
+@click.option(
+    "--kernel-only", is_flag=True, default=False, help="Start kernel without UI (returns connection file).", show_default=True
+)
+@click.option(
+    "--connect", type=Path, default=None, help="Connect to existing kernel via connection file.", show_default=False
+)
 @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, textual_dev: bool, textual_web: bool, textual_port: int | None, textual_host: str, kernel_only: bool, connect: Path | None, restore: bool, no_color: bool):
     """
     Starts the strategy with the given configuration file. If paper mode is enabled, account is not required.
 
@@ -84,12 +105,54 @@ 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()
+
+    # Handle --kernel-only mode
+    if kernel_only:
+        import asyncio
+
+        from qubx.utils.runner.kernel_service import KernelService
+
+        add_project_to_system_path()
+        add_project_to_system_path(str(config_file.parent.parent))
+        add_project_to_system_path(str(config_file.parent))
+
+        click.echo("Starting persistent kernel...")
+        connection_file = asyncio.run(KernelService.start(config_file, account_file, paper, restore))
+        click.echo(click.style("✓ Kernel started successfully!", fg="green", bold=True))
+        click.echo(click.style(f"Connection file: {connection_file}", fg="cyan"))
+        click.echo()
+        click.echo("To connect a UI to this kernel:")
+        click.echo(f"  qubx run --textual --connect {connection_file}")
+        click.echo()
+        click.echo("To stop this kernel:")
+        click.echo(f"  qubx kernel stop {connection_file}")
+        click.echo()
+        click.echo("Press Ctrl+C to stop the kernel and exit...")
+
+        # Keep the process alive until interrupted
+        try:
+            import signal
+            signal.pause()
+        except KeyboardInterrupt:
+            click.echo("\nShutting down kernel...")
+            asyncio.run(KernelService.stop(connection_file))
+            click.echo("Kernel stopped.")
+        return
 
     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, textual_dev, textual_web, textual_port, textual_host, connect)
     else:
         logo()
         run_strategy_yaml(config_file, account_file, paper=paper, restore=restore, blocking=True, no_color=no_color)
@@ -449,5 +512,69 @@ def init(
         raise click.Abort()
 
 
+@main.group()
+def kernel():
+    """
+    Manage persistent Jupyter kernels for strategy execution.
+
+    Kernels can be started independently of the UI, allowing multiple
+    UI instances to connect to the same running strategy.
+    """
+    pass
+
+
+@kernel.command("list")
+def kernel_list():
+    """
+    List all active kernel sessions.
+
+    Shows connection files and associated strategy configurations
+    for all currently running kernels.
+    """
+    from qubx.utils.runner.kernel_service import KernelService
+
+    active = KernelService.list_active()
+
+    if not active:
+        click.echo("No active kernels found.")
+        return
+
+    import datetime
+
+    click.echo(click.style("Active Kernels:", fg="cyan", bold=True))
+    click.echo()
+    for i, kernel_info in enumerate(active, 1):
+        # Format timestamp
+        ts = datetime.datetime.fromtimestamp(kernel_info["timestamp"])
+        time_str = ts.strftime("%Y-%m-%d %H:%M:%S")
+
+        click.echo(f"{i}. {click.style('Strategy:', fg='yellow')} {kernel_info['strategy_name']}")
+        click.echo(f"   {click.style('Started:', fg='yellow')} {time_str}")
+        click.echo(f"   {click.style('Connection:', fg='yellow')} {kernel_info['connection_file']}")
+        click.echo()
+
+
+@kernel.command("stop")
+@click.argument("connection-file", type=Path, required=True)
+def kernel_stop(connection_file: Path):
+    """
+    Stop a running kernel by its connection file.
+
+    This will gracefully shutdown the kernel and clean up
+    the connection file.
+    """
+    import asyncio
+
+    from qubx.utils.runner.kernel_service import KernelService
+
+    if not connection_file.exists():
+        click.echo(click.style(f"✗ Connection file not found: {connection_file}", fg="red"))
+        raise click.Abort()
+
+    click.echo(f"Stopping kernel: {connection_file}")
+    asyncio.run(KernelService.stop(str(connection_file)))
+    click.echo(click.style("✓ Kernel stopped successfully", fg="green"))
+
+
 if __name__ == "__main__":
     main()

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/connectors/ccxt/broker.py

@@ -42,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)
@@ -54,6 +55,7 @@ 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:
@@ -476,8 +478,6 @@ class CcxtBroker(IBroker):
             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")
@@ -496,7 +496,7 @@ class CcxtBroker(IBroker):
 
         logger.debug(
             f"[<g>{instrument.symbol}</g>] :: Updating order {order_id}: "
-            f"{amount} @ {price} (was: {existing_order.quantity} @ {existing_order.price})"
+            f"{amount} @ {price} (was: {existing_order.quantity} @ {existing_order.price} ({existing_order.time_in_force}))"
         )
 
         try:
@@ -511,8 +511,6 @@ class CcxtBroker(IBroker):
 
     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()
 
@@ -521,15 +519,13 @@ class CcxtBroker(IBroker):
 
         if updated_order is not None:
             self.account.process_order(updated_order)
-            logger.debug(f"Direct update successful for order {order_id}")
+            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."""
-        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")
@@ -544,7 +540,9 @@ class CcxtBroker(IBroker):
             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}")
+        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(
@@ -555,9 +553,18 @@ class CcxtBroker(IBroker):
             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={}
-            )
+            # 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)

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/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/connectors/ccxt/exchanges/hyperliquid/__init__.py

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

qubx/connectors/ccxt/exchanges/hyperliquid/account.py

@@ -0,0 +1,75 @@
+import asyncio
+
+from qubx import logger
+from qubx.connectors.ccxt.account import CcxtAccountProcessor
+from qubx.connectors.ccxt.utils import (
+    ccxt_convert_order_info,
+    ccxt_extract_deals_from_exec,
+    ccxt_find_instrument,
+)
+from qubx.core.basics import CtrlChannel, Instrument
+from qubx.utils.time import now_utc, timestamp_to_ms
+
+
+class HyperliquidAccountProcessor(CcxtAccountProcessor):
+    """
+    Hyperliquid-specific account processor.
+
+    Hyperliquid uses separate WebSocket channels:
+    - orderUpdates: for order status (watch_orders)
+    - userFills: for trade/fill updates (watch_my_trades)
+
+    Unlike Binance, Hyperliquid's watch_orders does NOT include trades,
+    so we must subscribe to both channels separately.
+    """
+
+    async def _subscribe_instruments(self, instruments: list[Instrument]):
+        """Override to filter out instruments from other exchanges (e.g., spot vs futures)."""
+        # Filter instruments to only those belonging to this exchange
+        exchange_name = self.exchange_manager.exchange.name
+        matching_instruments = [instr for instr in instruments if instr.exchange == exchange_name]
+
+        if len(matching_instruments) < len(instruments):
+            skipped = [instr for instr in instruments if instr.exchange != exchange_name]
+            logger.debug(f"Skipping subscription for {len(skipped)} instruments from other exchanges: {skipped}")
+
+        # Call parent with filtered instruments
+        if matching_instruments:
+            await super()._subscribe_instruments(matching_instruments)
+
+    async def _subscribe_executions(self, name: str, channel: CtrlChannel):
+        logger.info("<yellow>[Hyperliquid]</yellow> Subscribing to executions")
+        _symbol_to_instrument = {}
+
+        async def _watch_orders():
+            orders = await self.exchange_manager.exchange.watch_orders()
+            for order in orders:
+                instrument = ccxt_find_instrument(
+                    order["symbol"], self.exchange_manager.exchange, _symbol_to_instrument
+                )
+                order = ccxt_convert_order_info(instrument, order)
+                channel.send((instrument, "order", order, False))
+
+        async def _watch_my_trades():
+            trades = await self.exchange_manager.exchange.watch_my_trades(since=timestamp_to_ms(now_utc()))
+            for trade in trades:  # type: ignore
+                instrument = ccxt_find_instrument(
+                    trade["symbol"], self.exchange_manager.exchange, _symbol_to_instrument
+                )
+                deals = ccxt_extract_deals_from_exec({"trades": [trade]})
+                channel.send((instrument, "deals", deals, False))
+
+        await asyncio.gather(
+            self._listen_to_stream(
+                subscriber=_watch_orders,
+                exchange=self.exchange_manager.exchange,
+                channel=channel,
+                name=f"{name}_orders",
+            ),
+            self._listen_to_stream(
+                subscriber=_watch_my_trades,
+                exchange=self.exchange_manager.exchange,
+                channel=channel,
+                name=f"{name}_trades",
+            ),
+        )