Qubx 0.6.91__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.94__cp312-cp312-manylinux_2_39_x86_64.whl

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

@@ -1,4 +1,4 @@
-from typing import Literal
+from typing import Literal, cast
 
 import pandas as pd
 from joblib import delayed
@@ -15,6 +15,7 @@ from qubx.utils.runner.configs import PrefetchConfig
 from qubx.utils.time import handle_start_stop, to_utc_naive
 
 from .runner import SimulationRunner
+from .transfers import SimulationTransferManager
 from .utils import (
     DataDecls_t,
     ExchangeName_t,
@@ -300,6 +301,18 @@ def _run_setup(
         if enable_inmemory_emitter and emitter is not None:
             emitter_data = emitter.get_dataframe()
 
+        # - get transfers log
+        transfers_log = None
+        if hasattr(runner.ctx, "_transfer_manager") and isinstance(
+            getattr(runner.ctx, "_transfer_manager"), SimulationTransferManager
+        ):
+            try:
+                transfer_manager = cast(SimulationTransferManager, getattr(runner.ctx, "_transfer_manager"))
+                transfers_log = transfer_manager.get_transfers_dataframe()
+            except Exception as e:
+                logger.error(f"Failed to get transfers log: {e}")
+                transfers_log = None
+
         return TradingSessionResult(
             setup_id,
             setup.name,
@@ -319,6 +332,7 @@ def _run_setup(
             is_simulation=True,
             author=get_current_user(),
             emitter_data=emitter_data,
+            transfers_log=transfers_log,
         )
     except Exception as e:
         logger.error(f"Simulation setup {setup_id} failed with error: {e}")

qubx/backtester/transfers.py

@@ -0,0 +1,146 @@
+import uuid
+from typing import Any
+
+import pandas as pd
+
+from qubx import logger
+from qubx.core.account import CompositeAccountProcessor
+from qubx.core.basics import ITimeProvider
+from qubx.core.interfaces import ITransferManager
+
+
+class SimulationTransferManager(ITransferManager):
+    """
+    Transfer manager for simulation mode.
+
+    Handles fund transfers between exchanges by directly manipulating account balances.
+    All transfers are instant and tracked in a DataFrame for export to results.
+    """
+
+    _account: CompositeAccountProcessor
+    _time: ITimeProvider
+    _transfers: list[dict[str, Any]]
+
+    def __init__(self, account_processor: CompositeAccountProcessor, time_provider: ITimeProvider):
+        """
+        Initialize simulation transfer manager.
+
+        Args:
+            account_processor: Account processor (typically CompositeAccountProcessor)
+            time_provider: Time provider for timestamping transfers
+        """
+        self._account = account_processor
+        self._time = time_provider
+        self._transfers = []
+
+    def transfer_funds(self, from_exchange: str, to_exchange: str, currency: str, amount: float) -> str:
+        """
+        Transfer funds between exchanges (instant in simulation).
+
+        Args:
+            from_exchange: Source exchange identifier
+            to_exchange: Destination exchange identifier
+            currency: Currency to transfer
+            amount: Amount to transfer
+
+        Returns:
+            str: Transaction ID (UUID)
+
+        Raises:
+            ValueError: If exchanges not found or insufficient funds
+        """
+        # Generate transaction ID
+        transaction_id = f"sim_{uuid.uuid4().hex[:12]}"
+
+        # Get timestamp
+        timestamp = self._time.time()
+
+        # Get individual processors
+        try:
+            from_processor = self._account.get_account_processor(from_exchange)
+            to_processor = self._account.get_account_processor(to_exchange)
+        except (KeyError, AttributeError) as e:
+            raise ValueError(f"Exchange not found: {e}")
+
+        # Validate sufficient funds
+        from_balances = from_processor.get_balances()
+        if currency not in from_balances:
+            raise ValueError(f"Currency '{currency}' not found in {from_exchange}")
+
+        available = from_balances[currency].free
+        if available < amount:
+            raise ValueError(
+                f"Insufficient funds in {from_exchange}: "
+                f"{available:.8f} {currency} available, {amount:.8f} {currency} requested"
+            )
+
+        # Execute transfer (instant balance manipulation)
+        from_balances[currency].total -= amount
+        from_balances[currency].free -= amount
+
+        to_balances = to_processor.get_balances()
+        to_balances[currency].total += amount
+        to_balances[currency].free += amount
+
+        # Record transfer
+        transfer_record = {
+            "transaction_id": transaction_id,
+            "timestamp": timestamp,
+            "from_exchange": from_exchange,
+            "to_exchange": to_exchange,
+            "currency": currency,
+            "amount": amount,
+            "status": "completed",  # Always completed in simulation
+        }
+        self._transfers.append(transfer_record)
+
+        logger.debug(f"[SimTransfer] {amount:.8f} {currency} {from_exchange} → {to_exchange} (ID: {transaction_id})")
+
+        return transaction_id
+
+    def get_transfer_status(self, transaction_id: str) -> dict[str, Any]:
+        """
+        Get the status of a transfer.
+
+        Args:
+            transaction_id: Transaction ID
+
+        Returns:
+            dict[str, Any]: Transfer status information
+        """
+        # Find transfer
+        for transfer in self._transfers:
+            if transfer["transaction_id"] == transaction_id:
+                return transfer.copy()
+
+        # Not found
+        return {
+            "transaction_id": transaction_id,
+            "status": "not_found",
+            "error": f"Transaction {transaction_id} not found",
+        }
+
+    def get_transfers(self) -> dict[str, dict[str, Any]]:
+        """
+        Get all transfers as a dictionary.
+
+        Returns:
+            dict[str, dict[str, Any]]: Dictionary mapping transaction IDs to transfer info
+        """
+        return {t["transaction_id"]: t for t in self._transfers}
+
+    def get_transfers_dataframe(self) -> pd.DataFrame:
+        """
+        Get all transfers as a pandas DataFrame.
+
+        Returns:
+            pd.DataFrame: DataFrame with columns [transaction_id, timestamp, from_exchange,
+                         to_exchange, currency, amount, status]
+        """
+        if not self._transfers:
+            # Return empty DataFrame with correct schema
+            return pd.DataFrame(
+                columns=["transaction_id", "from_exchange", "to_exchange", "currency", "amount", "status"]  # type: ignore
+            )
+
+        return pd.DataFrame(self._transfers).set_index("timestamp")

qubx/cli/commands.py

@@ -72,11 +72,29 @@ def main(debug: bool, debug_port: int, log_level: str):
 @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, textual: 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.
 
@@ -94,6 +112,39 @@ def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool
         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))
@@ -101,7 +152,7 @@ def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool
     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)
+        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)
@@ -461,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/factory.py

@@ -8,8 +8,8 @@ from qubx.core.basics import CtrlChannel
 from qubx.core.interfaces import IAccountProcessor, IBroker, IDataProvider, ITimeProvider
 
 from .account import CcxtAccountProcessor
-from .exchanges import CUSTOM_ACCOUNTS, CUSTOM_BROKERS, EXCHANGE_ALIASES
 from .exchange_manager import ExchangeManager
+from .exchanges import CUSTOM_ACCOUNTS, CUSTOM_BROKERS, EXCHANGE_ALIASES
 
 
 def get_ccxt_exchange(
@@ -22,10 +22,10 @@ def get_ccxt_exchange(
 ) -> cxp.Exchange:
     """
     Get a raw CCXT exchange object.
-    
+
     Creates and configures a CCXT exchange instance without any stability wrapper.
     Use get_ccxt_exchange_manager() if you need automatic stability management.
-    
+
     Parameters:
         exchange (str): The exchange name.
         api_key (str, optional): The API key. Default is None.
@@ -33,7 +33,7 @@ def get_ccxt_exchange(
         loop (asyncio.AbstractEventLoop, optional): Event loop. Default is None.
         use_testnet (bool): Use testnet/sandbox mode. Default is False.
         **kwargs: Additional parameters for exchange configuration.
-        
+
     Returns:
         Raw CCXT Exchange instance
     """
@@ -90,10 +90,10 @@ def get_ccxt_exchange_manager(
 ) -> ExchangeManager:
     """
     Get a CCXT exchange with automatic stability management.
-    
+
     Returns ExchangeManager wrapper that handles exchange recreation
     during data stall scenarios via self-monitoring.
-    
+
     Parameters:
         exchange (str): The exchange name.
         api_key (str, optional): The API key. Default is None.
@@ -102,28 +102,23 @@ def get_ccxt_exchange_manager(
         use_testnet (bool): Use testnet/sandbox mode. Default is False.
         check_interval_seconds (float): How often to check for stalls. Default is 30.0.
         **kwargs: Additional parameters for exchange configuration.
-        
+
     Returns:
         ExchangeManager wrapping the CCXT Exchange
     """
     # Prepare factory parameters for ExchangeManager recreation
     factory_params = {
-        'exchange': exchange,
-        'api_key': api_key,  
-        'secret': secret,
-        'loop': loop,
-        'use_testnet': use_testnet,
-        **{k: v for k, v in kwargs.items() if k != 'check_interval_seconds'}
+        "exchange": exchange,
+        "api_key": api_key,
+        "secret": secret,
+        "loop": loop,
+        "use_testnet": use_testnet,
+        **{k: v for k, v in kwargs.items() if k != "check_interval_seconds"},
     }
-    
+
     # Create raw CCXT exchange using public factory method
     ccxt_exchange = get_ccxt_exchange(
-        exchange=exchange,
-        api_key=api_key,
-        secret=secret,
-        loop=loop,
-        use_testnet=use_testnet,
-        **kwargs
+        exchange=exchange, api_key=api_key, secret=secret, loop=loop, use_testnet=use_testnet, **kwargs
     )
 
     # Wrap in ExchangeManager for stability management

qubx/connectors/xlighter/__init__.py

@@ -0,0 +1,83 @@
+"""XLighter exchange connector for Qubx"""
+
+from .account import LighterAccountProcessor
+from .broker import LighterBroker
+from .client import LighterClient
+from .constants import (
+    DEDICATED_CHANNELS,
+    MULTIPLEX_CHANNELS,
+    WS_CHANNEL_ACCOUNT_ALL,
+    WS_CHANNEL_EXECUTED_TX,
+    WS_CHANNEL_MARKET_STATS,
+    WS_CHANNEL_ORDER_BOOK,
+    WS_CHANNEL_TRADE,
+    WS_CHANNEL_USER_STATS,
+    LighterMarginMode,
+    LighterOrderSide,
+    LighterOrderType,
+    LighterTimeInForce,
+)
+from .data import LighterDataProvider
+from .factory import (
+    get_xlighter_account,
+    get_xlighter_broker,
+    get_xlighter_client,
+    get_xlighter_data_provider,
+)
+from .instruments import LighterInstrumentLoader, load_lighter_instruments
+from .parsers import PositionState
+from .reader import XLighterDataReader
+from .utils import (
+    convert_lighter_order,
+    convert_lighter_orderbook,
+    convert_lighter_quote,
+    convert_lighter_trade,
+    lighter_order_side_to_qubx,
+    lighter_symbol_to_qubx,
+    qubx_order_side_to_lighter,
+    qubx_symbol_to_lighter,
+)
+from .websocket import LighterWebSocketManager
+
+__all__ = [
+    # Core Components
+    "LighterClient",
+    "LighterDataProvider",
+    "LighterBroker",
+    "LighterAccountProcessor",
+    "LighterWebSocketManager",
+    # Factory Functions
+    "get_xlighter_client",
+    "get_xlighter_data_provider",
+    "get_xlighter_account",
+    "get_xlighter_broker",
+    # Data Reader
+    "XLighterDataReader",
+    # Instruments
+    "LighterInstrumentLoader",
+    "load_lighter_instruments",
+    # Parsers
+    "PositionState",
+    # Constants
+    "LighterOrderType",
+    "LighterTimeInForce",
+    "LighterOrderSide",
+    "LighterMarginMode",
+    "WS_CHANNEL_ORDER_BOOK",
+    "WS_CHANNEL_TRADE",
+    "WS_CHANNEL_MARKET_STATS",
+    "WS_CHANNEL_ACCOUNT_ALL",
+    "WS_CHANNEL_USER_STATS",
+    "WS_CHANNEL_EXECUTED_TX",
+    "MULTIPLEX_CHANNELS",
+    "DEDICATED_CHANNELS",
+    # Utils
+    "lighter_symbol_to_qubx",
+    "qubx_symbol_to_lighter",
+    "lighter_order_side_to_qubx",
+    "qubx_order_side_to_lighter",
+    "convert_lighter_orderbook",
+    "convert_lighter_trade",
+    "convert_lighter_quote",
+    "convert_lighter_order",
+]