Qubx 1.1.3.dev13__tar.gz → 1.1.3.dev14__tar.gz

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.1.3.dev13
+Version: 1.1.3.dev14
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.3.dev13'
-__version_tuple__ = version_tuple = (1, 1, 3, 'dev13')
+__version__ = version = '1.1.3.dev14'
+__version_tuple__ = version_tuple = (1, 1, 3, 'dev14')
 
 __commit_id__ = commit_id = None

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/connectors/__init__.py

@@ -19,6 +19,7 @@ from qubx.connectors.registry import (  # noqa: F401
 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.ccxt.rate_limits import create_ccxt_rate_limit_config  # noqa: F401
 from qubx.connectors.tardis.data import TardisDataProvider  # noqa: F401
 
 # Note: Paper trading connectors (SimulatedAccountProcessor, SimulatedBroker) are

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/connectors/ccxt/data.py

@@ -47,6 +47,8 @@ class CcxtDataProvider(IDataProvider):
     ):
         from qubx.connectors.ccxt.factory import get_ccxt_exchange_manager
 
+        rate_limiter = kwargs.pop("rate_limiter", None)
+
         settings = account_manager.get_exchange_settings(exchange_name)
         self._exchange_manager = get_ccxt_exchange_manager(
             exchange=exchange_name,
@@ -58,6 +60,10 @@ class CcxtDataProvider(IDataProvider):
         )
         self.orderbook_limit = orderbook_limit
 
+        # Attach rate limiter to exchange manager (overrides CCXT's built-in throttle)
+        if rate_limiter is not None:
+            self._exchange_manager.attach_rate_limiter(rate_limiter)
+
         self.time_provider = time_provider
         self.channel = channel
         self.max_ws_retries = max_ws_retries

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/connectors/ccxt/exchange_manager.py

@@ -276,11 +276,9 @@ class ExchangeManager:
         if rate_limiter is None:
             return
 
-        exchange.enableRateLimit = False
-
-        # Override the throttle method to use our rate limiter
-        # CCXT calls self.throttle(cost) in fetch2() before every REST request
-        # cost comes from calculateRateLimiterCost() which uses per-endpoint weights
+        # Keep enableRateLimit=True so CCXT calls self.throttle(cost) in fetch2()
+        # We override the throttle method to use our rate limiter instead of CCXT's built-in
+        exchange.enableRateLimit = True
         async def _rate_limit_throttle(cost=None):
             if cost is None:
                 cost = 1.0

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/connectors/ccxt/factory.py

@@ -111,13 +111,13 @@ def get_ccxt_exchange_manager(
         "exchange": exchange,
         "api_key": api_key,
         "secret": secret,
-        "loop": None,
+        "loop": loop,
         "use_testnet": use_testnet,
         **kwargs,
     }
 
     ccxt_exchange = get_ccxt_exchange(
-        exchange=exchange, api_key=api_key, secret=secret, loop=None, use_testnet=use_testnet, **kwargs
+        exchange=exchange, api_key=api_key, secret=secret, loop=loop, use_testnet=use_testnet, **kwargs
     )
 
     manager = ExchangeManager(
@@ -129,11 +129,6 @@ def get_ccxt_exchange_manager(
         check_interval_seconds=check_interval_seconds,
     )
 
-    # Attach rate limiter if provided in kwargs
-    rate_limiter = kwargs.pop("rate_limiter", None)
-    if rate_limiter is not None:
-        manager.attach_rate_limiter(rate_limiter)
-
     _exchange_manager_cache[cache_key] = manager
     return manager
 

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/connectors/ccxt/rate_limits.py

@@ -13,9 +13,11 @@ References:
 - Bybit: https://bybit-exchange.github.io/docs/v5/rate-limit
 """
 
+from qubx.connectors.registry import rate_limit_config
 from qubx.rate_limiting import EndpointCosts, ExchangeRateLimitConfig, PoolConfig
 
 
+@rate_limit_config("ccxt")
 def create_ccxt_rate_limit_config(exchange_name: str, ccxt_exchange=None) -> ExchangeRateLimitConfig:
     """Create rate limit config for a CCXT exchange.
 

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/connectors/registry.py

@@ -26,6 +26,7 @@ class ConnectorRegistry:
     _data_providers: dict[str, Type[IDataProvider]] = {}
     _account_processors: dict[str, Type[IAccountProcessor]] = {}
     _brokers: dict[str, Type[IBroker]] = {}
+    _rate_limit_configs: dict[str, Callable] = {}
 
     @classmethod
     def register_data_provider(cls, name: str) -> Callable[[Type[T]], Type[T]]:
@@ -153,6 +154,32 @@ class ConnectorRegistry:
             )
         return broker_cls(**kwargs)
 
+    @classmethod
+    def register_rate_limit_config(cls, name: str) -> Callable:
+        """Decorator to register a rate limit config factory for a connector.
+
+        The factory receives (exchange_name: str) and returns ExchangeRateLimitConfig or None.
+        """
+
+        def decorator(func: Callable) -> Callable:
+            cls._rate_limit_configs[name.lower()] = func
+            logger.debug(f"Registered rate limit config: {name}")
+            return func
+
+        return decorator
+
+    @classmethod
+    def get_rate_limit_config(cls, name: str, exchange_name: str):
+        """Get rate limit config for a connector/exchange pair.
+
+        Returns:
+            ExchangeRateLimitConfig or None if connector has no rate limiting registered
+        """
+        factory = cls._rate_limit_configs.get(name.lower())
+        if factory is None:
+            return None
+        return factory(exchange_name)
+
     @classmethod
     def is_data_provider_registered(cls, name: str) -> bool:
         """Check if a data provider is registered."""
@@ -222,3 +249,15 @@ def broker(name: str) -> Callable[[Type[T]], Type[T]]:
                 ...
     """
     return ConnectorRegistry.register_broker(name)
+
+
+def rate_limit_config(name: str) -> Callable:
+    """
+    Decorator for registering a rate limit config factory.
+
+    Usage:
+        @rate_limit_config("my_exchange")
+        def create_my_exchange_rate_limits(exchange_name: str) -> ExchangeRateLimitConfig:
+            return ExchangeRateLimitConfig(pools={...}, ...)
+    """
+    return ConnectorRegistry.register_rate_limit_config(name)

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/control/builtin.py

@@ -29,6 +29,14 @@ def _resolve(ctx: IStrategyContext, symbol: str, exchange: str | None = None) ->
         return None
 
 
+def _default_quote(ctx: IStrategyContext) -> str:
+    """Get default quote currency from the first exchange's base currency."""
+    try:
+        return ctx.account.get_base_currency()
+    except Exception:
+        return "USDT"
+
+
 # --- Rounding helpers ---
 
 
@@ -121,7 +129,9 @@ def _set_universe(ctx: IStrategyContext, symbols: list[str], exchange: str | Non
 # --- Instrument discovery actions ---
 
 
-def _get_available_instruments(ctx: IStrategyContext, exchange: str, quote: str = "USDT", market_type: str = "SWAP", **kwargs) -> ActionResult:
+def _get_available_instruments(ctx: IStrategyContext, exchange: str, quote: str | None = None, market_type: str = "SWAP", **kwargs) -> ActionResult:
+    if quote is None:
+        quote = _default_quote(ctx)
     mt = MarketType(market_type) if market_type else None
     as_of = to_timestamp(ctx.time())
     instruments = lookup.find_instruments(exchange, quote=quote, market_type=mt, as_of=as_of)
@@ -173,10 +183,12 @@ def _get_top_instruments(
     sort_by: str = "turnover",
     period: str = "3d",
     timeframe: str = "1d",
-    quote: str = "USDT",
+    quote: str | None = None,
     market_type: str = "SWAP",
     **kwargs,
 ) -> ActionResult:
+    if quote is None:
+        quote = _default_quote(ctx)
     stop = to_timestamp(ctx.time())
     start = stop - to_timedelta(period)
 
@@ -308,10 +320,10 @@ def _get_balances(ctx: IStrategyContext, **kwargs) -> ActionResult:
     return ActionResult(status="ok", data={"balances": balances})
 
 
-def _get_orders(ctx: IStrategyContext, symbol: str | None = None, **kwargs) -> ActionResult:
+def _get_orders(ctx: IStrategyContext, symbol: str | None = None, exchange: str | None = None, **kwargs) -> ActionResult:
     orders_data = []
     if symbol:
-        instr = _resolve(ctx, symbol)
+        instr = _resolve(ctx, symbol, exchange)
         if instr is None:
             return ActionResult(status="error", error=f"Unknown symbol: {symbol}")
         orders = ctx.get_orders(instrument=instr)
@@ -333,8 +345,8 @@ def _get_orders(ctx: IStrategyContext, symbol: str | None = None, **kwargs) -> A
     return ActionResult(status="ok", data={"orders": orders_data})
 
 
-def _get_quote(ctx: IStrategyContext, symbol: str, **kwargs) -> ActionResult:
-    instr = _resolve(ctx, symbol)
+def _get_quote(ctx: IStrategyContext, symbol: str, exchange: str | None = None, **kwargs) -> ActionResult:
+    instr = _resolve(ctx, symbol, exchange)
     if instr is None:
         return ActionResult(status="error", error=f"Unknown symbol: {symbol}")
 
@@ -354,8 +366,8 @@ def _get_quote(ctx: IStrategyContext, symbol: str, **kwargs) -> ActionResult:
     )
 
 
-def _get_ohlc(ctx: IStrategyContext, symbol: str, timeframe: str = "1h", length: int = 20, **kwargs) -> ActionResult:
-    instr = _resolve(ctx, symbol)
+def _get_ohlc(ctx: IStrategyContext, symbol: str, timeframe: str = "1h", length: int = 20, exchange: str | None = None, **kwargs) -> ActionResult:
+    instr = _resolve(ctx, symbol, exchange)
     if instr is None:
         return ActionResult(status="error", error=f"Unknown symbol: {symbol}")
 
@@ -520,8 +532,8 @@ def _get_state_schema(ctx: IStrategyContext, **kwargs) -> ActionResult:
 # --- Trading actions ---
 
 
-def _trade(ctx: IStrategyContext, symbol: str, amount: float, price: float | None = None, time_in_force: str = "gtc", **kwargs) -> ActionResult:
-    instr = _resolve(ctx, symbol)
+def _trade(ctx: IStrategyContext, symbol: str, amount: float, price: float | None = None, time_in_force: str = "gtc", exchange: str | None = None, **kwargs) -> ActionResult:
+    instr = _resolve(ctx, symbol, exchange)
     if instr is None:
         return ActionResult(status="error", error=f"Unknown symbol: {symbol}")
 
@@ -535,8 +547,8 @@ def _trade(ctx: IStrategyContext, symbol: str, amount: float, price: float | Non
         return ActionResult(status="error", error=str(e))
 
 
-def _set_target_position(ctx: IStrategyContext, symbol: str, target: float, price: float | None = None, **kwargs) -> ActionResult:
-    instr = _resolve(ctx, symbol)
+def _set_target_position(ctx: IStrategyContext, symbol: str, target: float, price: float | None = None, exchange: str | None = None, **kwargs) -> ActionResult:
+    instr = _resolve(ctx, symbol, exchange)
     if instr is None:
         return ActionResult(status="error", error=f"Unknown symbol: {symbol}")
 
@@ -550,8 +562,8 @@ def _set_target_position(ctx: IStrategyContext, symbol: str, target: float, pric
         return ActionResult(status="error", error=str(e))
 
 
-def _set_target_leverage(ctx: IStrategyContext, symbol: str, leverage: float, price: float | None = None, **kwargs) -> ActionResult:
-    instr = _resolve(ctx, symbol)
+def _set_target_leverage(ctx: IStrategyContext, symbol: str, leverage: float, price: float | None = None, exchange: str | None = None, **kwargs) -> ActionResult:
+    instr = _resolve(ctx, symbol, exchange)
     if instr is None:
         return ActionResult(status="error", error=f"Unknown symbol: {symbol}")
 
@@ -562,8 +574,8 @@ def _set_target_leverage(ctx: IStrategyContext, symbol: str, leverage: float, pr
         return ActionResult(status="error", error=str(e))
 
 
-def _close_position(ctx: IStrategyContext, symbol: str, **kwargs) -> ActionResult:
-    instr = _resolve(ctx, symbol)
+def _close_position(ctx: IStrategyContext, symbol: str, exchange: str | None = None, **kwargs) -> ActionResult:
+    instr = _resolve(ctx, symbol, exchange)
     if instr is None:
         return ActionResult(status="error", error=f"Unknown symbol: {symbol}")
 
@@ -586,10 +598,10 @@ def _close_positions(ctx: IStrategyContext, **kwargs) -> ActionResult:
         return ActionResult(status="error", error=str(e))
 
 
-def _cancel_orders(ctx: IStrategyContext, symbol: str | None = None, **kwargs) -> ActionResult:
+def _cancel_orders(ctx: IStrategyContext, symbol: str | None = None, exchange: str | None = None, **kwargs) -> ActionResult:
     try:
         if symbol:
-            instr = _resolve(ctx, symbol)
+            instr = _resolve(ctx, symbol, exchange)
             if instr is None:
                 return ActionResult(status="error", error=f"Unknown symbol: {symbol}")
             ctx.cancel_orders(instr)
@@ -601,8 +613,8 @@ def _cancel_orders(ctx: IStrategyContext, symbol: str | None = None, **kwargs) -
         return ActionResult(status="error", error=str(e))
 
 
-def _emit_signal(ctx: IStrategyContext, symbol: str, signal_value: float, price: float | None = None, group: str = "", **kwargs) -> ActionResult:
-    instr = _resolve(ctx, symbol)
+def _emit_signal(ctx: IStrategyContext, symbol: str, signal_value: float, price: float | None = None, group: str = "", exchange: str | None = None, **kwargs) -> ActionResult:
+    instr = _resolve(ctx, symbol, exchange)
     if instr is None:
         return ActionResult(status="error", error=f"Unknown symbol: {symbol}")
 
@@ -623,6 +635,7 @@ def _emit_signal(ctx: IStrategyContext, symbol: str, signal_value: float, price:
 # --- Action registry ---
 
 _MARKET_TYPE_DOC = "Market type: SPOT, SWAP (perpetual futures), FUTURE (dated futures), OPTION, MARGIN"
+_EXCHANGE_PARAM = ActionParam(name="exchange", type="string", description="Exchange for symbol resolution (required when bot trades on multiple exchanges)", required=False, default=None)
 
 BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
     # Universe
@@ -679,7 +692,7 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
             read_only=True,
             params=[
                 ActionParam(name="exchange", type="string", description="Exchange name (e.g., BINANCE.UM, KRAKEN, BYBIT)"),
-                ActionParam(name="quote", type="string", description="Quote currency filter", required=False, default="USDT"),
+                ActionParam(name="quote", type="string", description="Quote currency filter (defaults to bot's base currency)", required=False, default=None),
                 ActionParam(name="market_type", type="string", description=_MARKET_TYPE_DOC, required=False, default="SWAP"),
             ],
         ),
@@ -710,7 +723,7 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
                 ActionParam(name="sort_by", type="string", description="Ranking metric: turnover, market_cap, or funding", required=False, default="turnover"),
                 ActionParam(name="period", type="string", description="Lookback period (e.g., 3d, 7d, 1h)", required=False, default="3d"),
                 ActionParam(name="timeframe", type="string", description="Candle timeframe for turnover (e.g., 1d, 1h)", required=False, default="1d"),
-                ActionParam(name="quote", type="string", description="Quote currency filter", required=False, default="USDT"),
+                ActionParam(name="quote", type="string", description="Quote currency filter (defaults to bot's base currency)", required=False, default=None),
                 ActionParam(name="market_type", type="string", description=_MARKET_TYPE_DOC, required=False, default="SWAP"),
             ],
         ),
@@ -731,7 +744,10 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
             description="Get open orders",
             category="diagnostics",
             read_only=True,
-            params=[ActionParam(name="symbol", type="string", description="Filter by symbol", required=False, default=None)],
+            params=[
+                ActionParam(name="symbol", type="string", description="Filter by symbol", required=False, default=None),
+                _EXCHANGE_PARAM,
+            ],
         ),
         _get_orders,
     ),
@@ -741,7 +757,7 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
             description="Get latest quote for an instrument",
             category="diagnostics",
             read_only=True,
-            params=[ActionParam(name="symbol", type="string", description="Trading instrument symbol")],
+            params=[ActionParam(name="symbol", type="string", description="Trading instrument symbol"), _EXCHANGE_PARAM],
         ),
         _get_quote,
     ),
@@ -755,6 +771,7 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
                 ActionParam(name="symbol", type="string", description="Trading instrument symbol"),
                 ActionParam(name="timeframe", type="string", description="Bar timeframe", required=False, default="1h"),
                 ActionParam(name="length", type="integer", description="Number of bars", required=False, default=20),
+                _EXCHANGE_PARAM,
             ],
         ),
         _get_ohlc,
@@ -801,6 +818,7 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
                 ActionParam(name="amount", type="number", description="Order amount (positive=buy, negative=sell)"),
                 ActionParam(name="price", type="number", description="Limit price", required=False, default=None),
                 ActionParam(name="time_in_force", type="string", description="Time in force", required=False, default="gtc"),
+                _EXCHANGE_PARAM,
             ],
         ),
         _trade,
@@ -815,6 +833,7 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
                 ActionParam(name="symbol", type="string", description="Trading instrument symbol"),
                 ActionParam(name="target", type="number", description="Target position size"),
                 ActionParam(name="price", type="number", description="Limit price", required=False, default=None),
+                _EXCHANGE_PARAM,
             ],
         ),
         _set_target_position,
@@ -829,6 +848,7 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
                 ActionParam(name="symbol", type="string", description="Trading instrument symbol"),
                 ActionParam(name="leverage", type="number", description="Target leverage"),
                 ActionParam(name="price", type="number", description="Limit price", required=False, default=None),
+                _EXCHANGE_PARAM,
             ],
         ),
         _set_target_leverage,
@@ -839,7 +859,7 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
             description="Close position for an instrument",
             category="trading",
             dangerous=True,
-            params=[ActionParam(name="symbol", type="string", description="Trading instrument symbol")],
+            params=[ActionParam(name="symbol", type="string", description="Trading instrument symbol"), _EXCHANGE_PARAM],
         ),
         _close_position,
     ),
@@ -852,7 +872,10 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
             name="cancel_orders",
             description="Cancel open orders",
             category="trading",
-            params=[ActionParam(name="symbol", type="string", description="Filter by symbol", required=False, default=None)],
+            params=[
+                ActionParam(name="symbol", type="string", description="Filter by symbol", required=False, default=None),
+                _EXCHANGE_PARAM,
+            ],
         ),
         _cancel_orders,
     ),
@@ -867,6 +890,7 @@ BUILTIN_ACTIONS: dict[str, tuple[ActionDef, Callable]] = {
                 ActionParam(name="signal_value", type="number", description="Signal value (target position)"),
                 ActionParam(name="price", type="number", description="Limit price", required=False, default=None),
                 ActionParam(name="group", type="string", description="Signal group", required=False, default=""),
+                _EXCHANGE_PARAM,
             ],
         ),
         _emit_signal,

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/core/context.py

@@ -159,7 +159,6 @@ class StrategyContext(IStrategyContext):
         data_throttler: "InstrumentThrottler | None" = None,
         state_persistence: IStatePersistence | None = None,
         state_snapshot_interval: str | None = None,
-        rate_limit_backend: Any | None = None,
         rate_limiting_config: Any | None = None,
         event_loop: "asyncio.AbstractEventLoop | None" = None,
     ) -> None:
@@ -193,7 +192,6 @@ class StrategyContext(IStrategyContext):
         self.health = self._health_monitor
         self._state_persistence = state_persistence or DummyStatePersistence()
         self._state_snapshot_interval = state_snapshot_interval
-        self._rate_limit_backend = rate_limit_backend
         self._rate_limiting_config = rate_limiting_config
         self.event_loop = event_loop
 
@@ -314,12 +312,6 @@ class StrategyContext(IStrategyContext):
         # Configure periodic state snapshot persistence
         self._processing_manager.configure_state_snapshot(self._state_snapshot_interval)
 
-        # Collect rate limiters from data providers
-        for dp in self._data_providers:
-            rl = dp.rate_limiter
-            if rl is not None:
-                self.rate_limiters[rl.exchange] = rl
-
         # Configure periodic rate limit metric emission
         _rl_metrics_interval = self._rate_limiting_config.metrics_interval if self._rate_limiting_config else None
         self._processing_manager.configure_rate_limit_metrics(_rl_metrics_interval)
@@ -600,11 +592,6 @@ class StrategyContext(IStrategyContext):
             self._rate_limiters: dict = {}
         return self._rate_limiters
 
-    @property
-    def rate_limit_backend(self):
-        """Rate limit storage backend (InMemoryBackend or RedisBackend)."""
-        return self._rate_limit_backend
-
     # IAccountViewer delegation
 
     # capital information

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/core/interfaces.py

@@ -831,11 +831,6 @@ class IDataProvider:
         """
         raise NotImplementedError("exchange() is not implemented")
 
-    @property
-    def rate_limiter(self):
-        """Return the ExchangeRateLimiter for this provider, if any."""
-        return None
-
     def is_connected(self) -> bool:
         """
         Check if the data provider is currently connected to the exchange.

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/core/mixins/processing.py

@@ -327,7 +327,7 @@ class ProcessingManager(IProcessingManager):
             except concurrent.futures.TimeoutError:
                 logger.warning(f"Rate limit metrics collection timed out for {exchange_name}")
             except Exception as e:
-                logger.error(f"Failed to collect rate limit metrics for {exchange_name}: {e}")
+                logger.opt(colors=False).error(f"Failed to collect rate limit metrics for {exchange_name}: {e}")
 
     @staticmethod
     def _do_emit_metrics(ctx, metrics: list[dict]) -> None:

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/data/storages/ccxt.py

@@ -314,9 +314,11 @@ class CcxtStorage(IStorage):
         _uri_hint: str = "",  # - ignored; absorbed from URI "ccxt::EXCHANGE" via StorageRegistry
         max_bars: int = 10_000,
         max_history: str = "3650d",
+        rate_limiters: dict | None = None,
     ) -> None:
         self._max_bars = max_bars
         self._max_history = to_timedelta(max_history)
+        self._rate_limiters = rate_limiters or {}
         # - shared async loop (created from first exchange connection)
         self._loop = None
         self._capabilities = None
@@ -448,6 +450,16 @@ class CcxtStorage(IStorage):
             _start = _max_time
         return _start, _stop
 
+    def _get_rate_limiter(self, ccxt_ex: Exchange):
+        """Find the rate limiter for a CCXT exchange instance."""
+        if not self._rate_limiters:
+            return None
+        # Match by exchange key in our cache (e.g., "BINANCE.UM", "OKX.F")
+        for exch_key, ex in self._exchanges.items():
+            if ex is ccxt_ex:
+                return self._rate_limiters.get(exch_key)
+        return None
+
     async def _async_paginated_fetch(
         self,
         ccxt_ex: Exchange,
@@ -472,7 +484,12 @@ class CcxtStorage(IStorage):
         all_items: list = []
         current_since = since
 
+        # Get rate limiter for this exchange (if available)
+        _rl = self._get_rate_limiter(ccxt_ex)
+
         for _ in range(max_pages):
+            if _rl:
+                await _rl.acquire("ccxt_rest")
             batch = await method(since=current_since, limit=limit, **method_kwargs)
             if not batch:
                 break
@@ -525,10 +542,16 @@ class CcxtStorage(IStorage):
         until: int,
     ) -> dict[str, list]:
         """
-        Concurrent OHLCV fetch for multiple instruments via asyncio.gather.
+        Concurrent OHLCV fetch for multiple instruments with bounded concurrency.
         Returns ``{qubx_sym: raw_candles}``.
         """
-        coros = [self._async_fetch_ohlcv(ccxt_ex, ccxt_sym, exc_tf, since, until) for ccxt_sym, _ in instruments_info]
+        sem = asyncio.Semaphore(5)  # max 5 concurrent fetches
+
+        async def _fetch_with_sem(ccxt_sym: str, exc_tf: str, since: int, until: int) -> list:
+            async with sem:
+                return await self._async_fetch_ohlcv(ccxt_ex, ccxt_sym, exc_tf, since, until)
+
+        coros = [_fetch_with_sem(ccxt_sym, exc_tf, since, until) for ccxt_sym, _ in instruments_info]
         results = await asyncio.gather(*coros, return_exceptions=True)
         out: dict[str, list] = {}
         for i, result in enumerate(results):
@@ -600,11 +623,17 @@ class CcxtStorage(IStorage):
         default_hours: float,
     ) -> dict[str, list[tuple[int, float, float]]]:
         """
-        Concurrent per-instrument funding fetch via asyncio.gather.
+        Concurrent per-instrument funding fetch with bounded concurrency.
         Returns ``{qubx_sym: [(ts_ms, rate, hours), ...]}``.
         """
+        sem = asyncio.Semaphore(5)
+
+        async def _fetch_with_sem(ccxt_ex, instr, ccxt_sym, since, until, default_hours):
+            async with sem:
+                return await self._async_fetch_funding_one(ccxt_ex, instr, ccxt_sym, since, until, default_hours)
+
         coros = [
-            self._async_fetch_funding_one(ccxt_ex, instr, ccxt_sym, since, until, default_hours)
+            _fetch_with_sem(ccxt_ex, instr, ccxt_sym, since, until, default_hours)
             for ccxt_sym, instr in instruments_info
         ]
         results = await asyncio.gather(*coros, return_exceptions=True)

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/rate_limiting/engine.py

@@ -47,6 +47,7 @@ class ExchangeRateLimiter:
         config: ExchangeRateLimitConfig,
         backend: IRateLimitBackend | None = None,
         scope_ids: dict[str, str] | None = None,
+        event_loop: "asyncio.AbstractEventLoop | None" = None,
     ):
         """
         Args:
@@ -54,11 +55,13 @@ class ExchangeRateLimiter:
             config: Rate limit configuration with pools and endpoint mappings
             backend: Storage backend (default: InMemoryBackend)
             scope_ids: Maps scope type to identifier, e.g. {"ip": "1.2.3.4", "account": "abc123"}
+            event_loop: Event loop this rate limiter operates on (for metrics collection)
         """
         self._exchange = exchange
         self._config = config
         self._backend = backend or InMemoryBackend()
         self._scope_ids = scope_ids or {}
+        self._event_loop = event_loop
 
         # Per-pool gates (asyncio.Event: set = open, clear = closed)
         self._gates: dict[str, asyncio.Event] = {}
@@ -84,6 +87,15 @@ class ExchangeRateLimiter:
     def exchange(self) -> str:
         return self._exchange
 
+    @property
+    def event_loop(self):
+        """Event loop this rate limiter operates on (set by connector)."""
+        return getattr(self, "_event_loop", None)
+
+    @event_loop.setter
+    def event_loop(self, loop):
+        self._event_loop = loop
+
     @property
     def config(self) -> ExchangeRateLimitConfig:
         return self._config
@@ -356,7 +368,6 @@ class ExchangeRateLimiter:
         """Collect current metrics for all pools.
 
         Returns a list of metric dicts suitable for emitting via ctx.emitter.emit().
-        Each dict has: name, value, tags.
 
         Call this periodically (e.g., once per minute) and emit via:
             for m in await rate_limiter.collect_metrics():

{qubx-1.1.3.dev13 → qubx-1.1.3.dev14}/src/qubx/rate_limiting/ip_resolver.py

@@ -93,6 +93,6 @@ class EgressIPResolver:
                         try:
                             cb(old_ip, new_ip)
                         except Exception as e:
-                            logger.error(f"IP change callback error: {e}")
+                            logger.opt(colors=False).error(f"IP change callback error: {e}")
         except asyncio.CancelledError:
             pass