Qubx 0.7.40.dev8__tar.gz → 0.7.40.dev9__tar.gz

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 0.7.40.dev8
+Version: 0.7.40.dev9
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx
@@ -39,7 +39,6 @@ Requires-Dist: python-binance<2,>=1.0.19
 Requires-Dist: python-dotenv<2,>=1.0.0
 Requires-Dist: pyyaml<7,>=6.0.2
 Requires-Dist: qubx-bitfinex-api<4,>=3.0.7
-Requires-Dist: qubx-lighter-api<1,>=0.1.5
 Requires-Dist: questdb<3,>=2.0.3
 Requires-Dist: redis<6,>=5.2.1
 Requires-Dist: rich<14,>=13.9.4

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/pyproject.toml

@@ -54,7 +54,6 @@ dependencies = [
     "textual-serve>=1.0.0,<2",
     "rich>=13.9.4,<14",
     "jinja2>=3.1.0,<4",
-    "qubx-lighter-api>=0.1.5,<1",
     "uvloop>=0.22.1,<1; sys_platform != 'win32'",
     "textual[syntax]>=6.0.0,<7",
 ]

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.7.40.dev8'
-__version_tuple__ = version_tuple = (0, 7, 40, 'dev8')
+__version__ = version = '0.7.40.dev9'
+__version_tuple__ = version_tuple = (0, 7, 40, 'dev9')
 
 __commit_id__ = commit_id = None

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/backtester/account.py

@@ -42,7 +42,6 @@ class SimulatedAccountProcessor(BasicAccountProcessor):
         self._channel = channel
 
         if restored_state is not None:
-            # Convert list of AssetBalance to dict for internal storage
             for balance in restored_state.balances:
                 self._balances[balance.currency] = balance
             for instrument, position in restored_state.positions.items():

qubx-0.7.40.dev9/src/qubx/connectors/__init__.py

@@ -0,0 +1,26 @@
+"""
+Qubx connectors package.
+
+This module provides the connector registry and ensures all built-in connectors are registered.
+
+Note: Paper trading connectors (SimulatedAccountProcessor, SimulatedBroker) are NOT registered
+with the registry - they are created directly by the backtester and paper trading runner.
+"""
+
+# Re-export the registry for convenience
+from qubx.connectors.registry import (  # noqa: F401
+    ConnectorRegistry,
+    account_processor,
+    broker,
+    data_provider,
+)
+
+# Import connector modules to trigger decorator registration
+from qubx.connectors.ccxt.account import CcxtAccountProcessor  # noqa: F401
+from qubx.connectors.ccxt.broker import CcxtBroker  # noqa: F401
+from qubx.connectors.ccxt.data import CcxtDataProvider  # noqa: F401
+from qubx.connectors.tardis.data import TardisDataProvider  # noqa: F401
+
+# Note: Paper trading connectors (SimulatedAccountProcessor, SimulatedBroker) are
+# NOT registered with the registry - they are created directly by the backtester
+# and paper trading runner.

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/connectors/ccxt/account.py

@@ -2,14 +2,15 @@ import asyncio
 import concurrent.futures
 from asyncio.exceptions import CancelledError
 from collections import defaultdict
-from typing import Awaitable, Callable
+from typing import TYPE_CHECKING, Awaitable, Callable
 
+import ccxt.pro as cxp
 import numpy as np
 import pandas as pd
-
-import ccxt.pro as cxp
 from ccxt import ExchangeClosedByUser, ExchangeError, ExchangeNotAvailable, NetworkError
+
 from qubx import logger
+from qubx.connectors.registry import account_processor
 from qubx.core.account import BasicAccountProcessor
 from qubx.core.basics import (
     CtrlChannel,
@@ -42,7 +43,11 @@ from .utils import (
     instrument_to_ccxt_symbol,
 )
 
+if TYPE_CHECKING:
+    from qubx.utils.runner.accounts import AccountConfigurationManager
+
 
+@account_processor("ccxt")
 class CcxtAccountProcessor(BasicAccountProcessor):
     """
     Subscribes to account information from the exchange.
@@ -70,14 +75,16 @@ class CcxtAccountProcessor(BasicAccountProcessor):
 
     def __init__(
         self,
-        account_id: str,
-        exchange_manager: ExchangeManager,
+        exchange_name: str,
         channel: CtrlChannel,
         time_provider: ITimeProvider,
-        base_currency: str,
-        health_monitor: IHealthMonitor,
-        exchange: str,
+        account_manager: "AccountConfigurationManager",
         tcc: TransactionCostsCalculator,
+        health_monitor: IHealthMonitor,
+        data_provider=None,
+        restored_state: RestoredState | None = None,
+        read_only: bool = False,
+        loop: asyncio.AbstractEventLoop | None = None,
         balance_interval: str = "30Sec",
         position_interval: str = "30Sec",
         subscription_interval: str = "10Sec",
@@ -86,14 +93,27 @@ class CcxtAccountProcessor(BasicAccountProcessor):
         max_position_restore_days: int = 5,
         max_retries: int = 10,
         connection_timeout: int = 30,
-        read_only: bool = False,
-        restored_state: RestoredState | None = None,
+        **kwargs,
     ):
+        from qubx.connectors.ccxt.factory import get_ccxt_exchange_manager
+
+        creds = account_manager.get_exchange_credentials(exchange_name)
+
+        exchange_manager = get_ccxt_exchange_manager(
+            exchange=exchange_name,
+            use_testnet=creds.testnet,
+            api_key=creds.api_key,
+            secret=creds.secret,
+            health_monitor=health_monitor,
+            time_provider=time_provider,
+            loop=loop,
+        )
+
         super().__init__(
-            account_id=account_id,
+            account_id=exchange_name,
             time_provider=time_provider,
-            base_currency=base_currency,
-            exchange=exchange,
+            base_currency=creds.base_currency,
+            exchange=exchange_name,
             tcc=tcc,
             health_monitor=health_monitor,
             initial_capital=0,

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/connectors/ccxt/broker.py

@@ -1,12 +1,13 @@
 import asyncio
 import traceback
-from typing import Any
-
-import pandas as pd
+from typing import TYPE_CHECKING, Any
 
 import ccxt
+import pandas as pd
 from ccxt.base.errors import ExchangeError
+
 from qubx import logger
+from qubx.connectors.registry import broker
 from qubx.core.basics import (
     CtrlChannel,
     Instrument,
@@ -27,25 +28,46 @@ from qubx.utils.misc import AsyncThreadLoop
 from .exchange_manager import ExchangeManager
 from .utils import ccxt_convert_order_info, instrument_to_ccxt_symbol
 
+if TYPE_CHECKING:
+    from qubx.utils.runner.accounts import AccountConfigurationManager
+
 
+@broker("ccxt")
 class CcxtBroker(IBroker):
     _exchange_manager: ExchangeManager
 
     def __init__(
         self,
-        exchange_manager: ExchangeManager,
+        exchange_name: str,
         channel: CtrlChannel,
         time_provider: ITimeProvider,
         account: IAccountProcessor,
         data_provider: IDataProvider,
+        account_manager: "AccountConfigurationManager",
+        health_monitor,
+        loop: asyncio.AbstractEventLoop | None = None,
         cancel_timeout: int = 30,
         cancel_retry_interval: int = 2,
         max_cancel_retries: int = 10,
         enable_create_order_ws: bool = False,
         enable_cancel_order_ws: bool = False,
         enable_edit_order_ws: bool = False,
+        enable_mm: bool = False,
+        **kwargs,
     ):
-        self._exchange_manager = exchange_manager
+        from qubx.connectors.ccxt.factory import get_ccxt_exchange_manager
+
+        creds = account_manager.get_exchange_credentials(exchange_name)
+        self._exchange_manager = get_ccxt_exchange_manager(
+            exchange=exchange_name,
+            use_testnet=creds.testnet,
+            api_key=creds.api_key,
+            secret=creds.secret,
+            time_provider=time_provider,
+            enable_mm=enable_mm,
+            health_monitor=health_monitor,
+            loop=loop,
+        )
         self.ccxt_exchange_id = str(self._exchange_manager.exchange.name)
         self.channel = channel
         self.time_provider = time_provider

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/connectors/ccxt/connection_manager.py

@@ -15,6 +15,7 @@ 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
 from qubx.utils.misc import AsyncThreadLoop

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/connectors/ccxt/data.py

@@ -1,12 +1,14 @@
+import asyncio
 import re
 from collections import defaultdict
-from typing import Dict, List, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
 
 import pandas as pd
 
 # CCXT exceptions are now handled in ConnectionManager
 from qubx import logger
 from qubx.connectors.ccxt.utils import ccxt_convert_timeframe_to_exchange_format
+from qubx.connectors.registry import data_provider
 from qubx.core.basics import CtrlChannel, DataType, Instrument, ITimeProvider
 from qubx.core.helpers import BasicScheduler
 from qubx.core.interfaces import IDataProvider, IHealthMonitor
@@ -22,38 +24,49 @@ from .subscription_manager import SubscriptionManager
 from .subscription_orchestrator import SubscriptionOrchestrator
 from .warmup_service import WarmupService
 
+if TYPE_CHECKING:
+    from qubx.utils.runner.accounts import AccountConfigurationManager
 
+
+@data_provider("ccxt")
 class CcxtDataProvider(IDataProvider):
     time_provider: ITimeProvider
     _exchange_manager: ExchangeManager
     _scheduler: BasicScheduler | None = None
-
-    # Core state - still needed
     _last_quotes: dict[Instrument, Optional[Quote]]
     _warmup_timeout: int
 
     def __init__(
         self,
-        exchange_manager: ExchangeManager,
+        exchange_name: str,
         time_provider: ITimeProvider,
         channel: CtrlChannel,
+        health_monitor: IHealthMonitor,
+        account_manager: "AccountConfigurationManager",
+        loop: asyncio.AbstractEventLoop | None = None,
         max_ws_retries: int = 10,
         warmup_timeout: int = 120,
-        health_monitor: IHealthMonitor | None = None,
+        **kwargs,
     ):
-        # Store the exchange manager (always ExchangeManager now)
-        self._exchange_manager = exchange_manager
+        from qubx.connectors.ccxt.factory import get_ccxt_exchange_manager
+
+        settings = account_manager.get_exchange_settings(exchange_name)
+        self._exchange_manager = get_ccxt_exchange_manager(
+            exchange=exchange_name,
+            use_testnet=settings.testnet,
+            health_monitor=health_monitor,
+            time_provider=time_provider,
+            loop=loop,
+            **kwargs,
+        )
 
         self.time_provider = time_provider
         self.channel = channel
         self.max_ws_retries = max_ws_retries
         self._warmup_timeout = warmup_timeout
         self._health_monitor = health_monitor
-
-        # Core components - access exchange directly via exchange_manager.exchange
         self._exchange_id = str(self._exchange_manager.exchange.name)
 
-        # Initialize composed components
         self._subscription_manager = SubscriptionManager()
         self._connection_manager = ConnectionManager(
             exchange_id=self._exchange_id,
@@ -67,15 +80,11 @@ class CcxtDataProvider(IDataProvider):
             connection_manager=self._connection_manager,
             exchange_manager=self._exchange_manager,
         )
-
-        # Data type handler factory for clean separation of data processing logic
         self._data_type_handler_factory = DataTypeHandlerFactory(
             data_provider=self,
             exchange_manager=self._exchange_manager,
             exchange_id=self._exchange_id,
         )
-
-        # Warmup service for handling historical data warmup
         self._warmup_service = WarmupService(
             handler_factory=self._data_type_handler_factory,
             channel=channel,
@@ -83,14 +92,9 @@ class CcxtDataProvider(IDataProvider):
             exchange_manager=self._exchange_manager,
             warmup_timeout=warmup_timeout,
         )
-
-        # Quote caching for synthetic quote generation
         self._last_quotes = defaultdict(lambda: None)
 
-        # Start ExchangeManager monitoring
         self._exchange_manager.start_monitoring()
-
-        # Register recreation callback for automatic resubscription
         self._exchange_manager.register_recreation_callback(self._handle_exchange_recreation)
 
         logger.info(f"<yellow>{self._exchange_id}</yellow> Initialized")

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/connectors/ccxt/exchange_manager.py

@@ -10,6 +10,7 @@ import time
 from typing import Any, Callable, Optional
 
 import ccxt.pro as cxp
+
 from qubx import logger
 from qubx.core.interfaces import IHealthMonitor, ITimeProvider
 

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/connectors/ccxt/exchanges/hyperliquid/hyperliquid.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional
 import ccxt.pro as cxp
 from ccxt.async_support.base.ws.client import Client
 from ccxt.base.errors import ExchangeError, InvalidOrder
+
 from qubx import logger
 
 from ...adapters.polling_adapter import PollingConfig, PollingToWebSocketAdapter

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/connectors/ccxt/factory.py

@@ -3,6 +3,7 @@ from threading import Thread
 from typing import Any
 
 import ccxt.pro as cxp
+
 from qubx.connectors.ccxt.broker import CcxtBroker
 from qubx.core.basics import CtrlChannel
 from qubx.core.interfaces import IAccountProcessor, IBroker, IDataProvider, IHealthMonitor, ITimeProvider
@@ -79,6 +80,9 @@ def get_ccxt_exchange(
     return ccxt_exchange
 
 
+_exchange_manager_cache: dict[tuple, ExchangeManager] = {}
+
+
 def get_ccxt_exchange_manager(
     exchange: str,
     health_monitor: IHealthMonitor,
@@ -94,37 +98,28 @@ def get_ccxt_exchange_manager(
     Get a CCXT exchange with automatic stability management.
 
     Returns ExchangeManager wrapper that handles exchange recreation
-    during data stall scenarios via self-monitoring.
+    during data stall scenarios via self-monitoring. Instances are cached
+    by (exchange, api_key, secret, use_testnet) to enable sharing across
+    data provider, account processor, and broker.
+    """
+    cache_key = (exchange.lower(), api_key, secret, use_testnet, check_interval_seconds)
 
-    Parameters:
-        exchange (str): The exchange name.
-        api_key (str, optional): The API key. Default is None.
-        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.
-        check_interval_seconds (float): How often to check for stalls. Default is 30.0.
-        **kwargs: Additional parameters for exchange configuration.
+    if cache_key in _exchange_manager_cache:
+        return _exchange_manager_cache[cache_key]
 
-    Returns:
-        ExchangeManager wrapping the CCXT Exchange
-    """
-    # Prepare factory parameters for ExchangeManager recreation
     factory_params = {
         "exchange": exchange,
         "api_key": api_key,
         "secret": secret,
-        "loop": loop,
+        "loop": None,
         "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=None, use_testnet=use_testnet
     )
 
-    # Wrap in ExchangeManager for stability management
-    return ExchangeManager(
+    manager = ExchangeManager(
         exchange_name=exchange,
         factory_params=factory_params,
         health_monitor=health_monitor,
@@ -133,6 +128,14 @@ def get_ccxt_exchange_manager(
         check_interval_seconds=check_interval_seconds,
     )
 
+    _exchange_manager_cache[cache_key] = manager
+    return manager
+
+
+def clear_exchange_manager_cache() -> None:
+    """Clear the exchange manager cache. Useful for testing."""
+    _exchange_manager_cache.clear()
+
 
 def get_ccxt_broker(
     exchange_name: str,

{qubx-0.7.40.dev8 → qubx-0.7.40.dev9}/src/qubx/connectors/ccxt/subscription_orchestrator.py

@@ -10,6 +10,7 @@ import uuid
 from typing import Awaitable, Callable
 
 from ccxt.pro import Exchange
+
 from qubx import logger
 from qubx.core.basics import CtrlChannel, DataType, Instrument
 from qubx.utils.misc import AsyncThreadLoop

qubx-0.7.40.dev9/src/qubx/connectors/registry.py

@@ -0,0 +1,224 @@
+"""
+Registry for data providers, account processors, and brokers.
+
+This module provides a registry pattern for connectors, allowing plugins
+to register custom connectors using decorators (like readers and storages).
+"""
+
+from typing import Any, Callable, Type, TypeVar
+
+from qubx import logger
+from qubx.core.interfaces import IAccountProcessor, IBroker, IDataProvider
+
+T = TypeVar("T")
+
+
+class ConnectorRegistry:
+    """
+    Registry for connector classes (data providers, account processors, brokers).
+
+    This registry allows plugins to register their own connector implementations
+    using decorators, making them available for use in strategy configurations.
+
+    Classes are registered and instantiated with standardized constructor arguments.
+    """
+
+    _data_providers: dict[str, Type[IDataProvider]] = {}
+    _account_processors: dict[str, Type[IAccountProcessor]] = {}
+    _brokers: dict[str, Type[IBroker]] = {}
+
+    @classmethod
+    def register_data_provider(cls, name: str) -> Callable[[Type[T]], Type[T]]:
+        """
+        Decorator to register a data provider class.
+
+        Args:
+            name: The name to register the data provider under (e.g., "ccxt", "tardis")
+
+        Returns:
+            A decorator function that registers the class
+        """
+
+        def decorator(provider_cls: Type[T]) -> Type[T]:
+            cls._data_providers[name.lower()] = provider_cls  # type: ignore
+            logger.debug(f"Registered data provider: {name}")
+            return provider_cls
+
+        return decorator
+
+    @classmethod
+    def register_account_processor(cls, name: str) -> Callable[[Type[T]], Type[T]]:
+        """
+        Decorator to register an account processor class.
+
+        Args:
+            name: The name to register the account processor under
+
+        Returns:
+            A decorator function that registers the class
+        """
+
+        def decorator(processor_cls: Type[T]) -> Type[T]:
+            cls._account_processors[name.lower()] = processor_cls  # type: ignore
+            logger.debug(f"Registered account processor: {name}")
+            return processor_cls
+
+        return decorator
+
+    @classmethod
+    def register_broker(cls, name: str) -> Callable[[Type[T]], Type[T]]:
+        """
+        Decorator to register a broker class.
+
+        Args:
+            name: The name to register the broker under
+
+        Returns:
+            A decorator function that registers the class
+        """
+
+        def decorator(broker_cls: Type[T]) -> Type[T]:
+            cls._brokers[name.lower()] = broker_cls  # type: ignore
+            logger.debug(f"Registered broker: {name}")
+            return broker_cls
+
+        return decorator
+
+    @classmethod
+    def get_data_provider(cls, name: str, **kwargs: Any) -> IDataProvider:
+        """
+        Get a data provider instance by name.
+
+        Args:
+            name: The name of the data provider
+            **kwargs: Arguments to pass to the constructor
+
+        Returns:
+            An instance of the data provider
+
+        Raises:
+            ValueError: If the data provider is not found
+        """
+        provider_cls = cls._data_providers.get(name.lower())
+        if provider_cls is None:
+            raise ValueError(
+                f"Data provider '{name}' is not registered. "
+                f"Available: {list(cls._data_providers.keys())}"
+            )
+        return provider_cls(**kwargs)
+
+    @classmethod
+    def get_account_processor(cls, name: str, **kwargs: Any) -> IAccountProcessor:
+        """
+        Get an account processor instance by name.
+
+        Args:
+            name: The name of the account processor
+            **kwargs: Arguments to pass to the constructor
+
+        Returns:
+            An instance of the account processor
+
+        Raises:
+            ValueError: If the account processor is not found
+        """
+        processor_cls = cls._account_processors.get(name.lower())
+        if processor_cls is None:
+            raise ValueError(
+                f"Account processor '{name}' is not registered. "
+                f"Available: {list(cls._account_processors.keys())}"
+            )
+        return processor_cls(**kwargs)
+
+    @classmethod
+    def get_broker(cls, name: str, **kwargs: Any) -> IBroker:
+        """
+        Get a broker instance by name.
+
+        Args:
+            name: The name of the broker
+            **kwargs: Arguments to pass to the constructor
+
+        Returns:
+            An instance of the broker
+
+        Raises:
+            ValueError: If the broker is not found
+        """
+        broker_cls = cls._brokers.get(name.lower())
+        if broker_cls is None:
+            raise ValueError(
+                f"Broker '{name}' is not registered. "
+                f"Available: {list(cls._brokers.keys())}"
+            )
+        return broker_cls(**kwargs)
+
+    @classmethod
+    def is_data_provider_registered(cls, name: str) -> bool:
+        """Check if a data provider is registered."""
+        return name.lower() in cls._data_providers
+
+    @classmethod
+    def is_account_processor_registered(cls, name: str) -> bool:
+        """Check if an account processor is registered."""
+        return name.lower() in cls._account_processors
+
+    @classmethod
+    def is_broker_registered(cls, name: str) -> bool:
+        """Check if a broker is registered."""
+        return name.lower() in cls._brokers
+
+    @classmethod
+    def get_all_data_providers(cls) -> dict[str, Type[IDataProvider]]:
+        """Get all registered data provider classes."""
+        return cls._data_providers.copy()
+
+    @classmethod
+    def get_all_account_processors(cls) -> dict[str, Type[IAccountProcessor]]:
+        """Get all registered account processor classes."""
+        return cls._account_processors.copy()
+
+    @classmethod
+    def get_all_brokers(cls) -> dict[str, Type[IBroker]]:
+        """Get all registered broker classes."""
+        return cls._brokers.copy()
+
+
+# Convenience decorators
+def data_provider(name: str) -> Callable[[Type[T]], Type[T]]:
+    """
+    Decorator for registering a data provider class.
+
+    Usage:
+        @data_provider("my_exchange")
+        class MyExchangeDataProvider(IDataProvider):
+            def __init__(self, exchange_name, time_provider, channel, ...):
+                ...
+    """
+    return ConnectorRegistry.register_data_provider(name)
+
+
+def account_processor(name: str) -> Callable[[Type[T]], Type[T]]:
+    """
+    Decorator for registering an account processor class.
+
+    Usage:
+        @account_processor("my_exchange")
+        class MyExchangeAccountProcessor(IAccountProcessor):
+            def __init__(self, exchange_name, channel, time_provider, ...):
+                ...
+    """
+    return ConnectorRegistry.register_account_processor(name)
+
+
+def broker(name: str) -> Callable[[Type[T]], Type[T]]:
+    """
+    Decorator for registering a broker class.
+
+    Usage:
+        @broker("my_exchange")
+        class MyExchangeBroker(IBroker):
+            def __init__(self, exchange_name, channel, time_provider, account, ...):
+                ...
+    """
+    return ConnectorRegistry.register_broker(name)