Qubx 1.2.3.dev1__tar.gz → 1.2.3.dev3__tar.gz

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/PKG-INFO

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

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/src/qubx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.2.3.dev1'
-__version_tuple__ = version_tuple = (1, 2, 3, 'dev1')
+__version__ = version = '1.2.3.dev3'
+__version_tuple__ = version_tuple = (1, 2, 3, 'dev3')
 
 __commit_id__ = commit_id = None

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/src/qubx/connectors/ccxt/exchange_manager.py

@@ -271,14 +271,32 @@ class ExchangeManager:
         logger.info(f"Rate limiter attached to {self._exchange_name}")
 
     def _apply_rate_limiter_to_exchange(self, exchange: cxp.Exchange) -> None:
-        """Disable CCXT's built-in rate limiter and install our throttle override."""
+        """Install our throttle and response-header-sync hooks on *exchange*.
+
+        Two hooks are installed per exchange:
+
+        1. **Throttle (pre-request)** — replaces CCXT's built-in throttle so every
+           REST call blocks on our token bucket first. ``acquire`` forwards the
+           CCXT-provided cost to the limiter as ``weight_override``.
+
+        2. **Response hook (post-request)** — wraps CCXT's ``on_rest_response`` to
+           invoke the exchange-specific header parser (OKX ``x-ratelimit-*``,
+           Binance ``X-MBX-USED-WEIGHT-1M``, etc.). The parser calls
+           ``rate_limiter.sync_from_exchange`` so our modeled budget tracks the
+           exchange's reported usage. Unlike ``CcxtStorage``'s best-effort sync,
+           this path runs atomically inside CCXT's fetch pipeline — no
+           concurrent-fetch race on ``last_response_headers``.
+
+        Both hooks are reapplied automatically after exchange recreation via
+        ``register_recreation_callback`` in :meth:`attach_rate_limiter`.
+        """
         rate_limiter = getattr(self, "_rate_limiter", None)
         if rate_limiter is None:
             return
 
-        # 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
+        # 1) Throttle override — pre-request acquisition.
         exchange.enableRateLimit = True
+
         async def _rate_limit_throttle(cost=None):
             if cost is None:
                 cost = 1.0
@@ -286,6 +304,23 @@ class ExchangeManager:
 
         exchange.throttle = _rate_limit_throttle
 
+        # 2) Response hook — post-response state sync.
+        from qubx.connectors.ccxt.rate_limits import get_header_parser
+
+        parser = get_header_parser(getattr(exchange, "id", ""))
+        if parser is not None:
+            _orig_on_rest = exchange.on_rest_response
+
+            def _header_sync_hook(code, reason, url, method, headers, body, req_headers, req_body):
+                try:
+                    if headers:
+                        parser(headers, rate_limiter)
+                except Exception as e:
+                    logger.debug(f"[{self._exchange_name}] header sync failed (non-fatal): {e}")
+                return _orig_on_rest(code, reason, url, method, headers, body, req_headers, req_body)
+
+            exchange.on_rest_response = _header_sync_hook
+
     @property
     def rate_limiter(self):
         """Access the attached rate limiter (if any)."""

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/src/qubx/connectors/ccxt/rate_limits.py

@@ -277,3 +277,21 @@ def get_header_parser(exchange_name: str):
     """Get the response header parser for an exchange."""
     name = exchange_name.lower().split(".")[0]
     return HEADER_PARSERS.get(name)
+
+
+# NOTE: As of #264 these parsers are invoked from two fetch paths:
+#
+#   * ``qubx.data.storages.ccxt._sync_rate_limiter_from_response_headers`` after
+#     each successful OHLCV page fetch. Best-effort — ``last_response_headers`` is
+#     an exchange-wide attribute so under concurrent fetches the read may be from a
+#     neighboring request. Since all concurrent requests drain the same IP-scoped
+#     budget, an approximate reading is still strictly better than no sync.
+#
+#   * ``qubx.connectors.ccxt.exchange_manager.ExchangeManager._apply_rate_limiter_to_exchange``
+#     via CCXT's ``on_rest_response`` hook. This one is atomic per-request (the
+#     hook runs inside CCXT's fetch pipeline with the actual response headers), so
+#     the live path gets exact sync rather than best-effort.
+#
+# Both code paths call the parser, which in turn calls
+# ``rate_limiter.sync_from_exchange(...)`` to pin the modeled budget to the
+# server-reported remaining.

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/src/qubx/data/storages/ccxt.py

@@ -35,9 +35,11 @@ Supported data types
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Callable, Iterator
+import random
+from collections.abc import Awaitable, Callable, Iterator
 from typing import Any, cast
 
+import ccxt
 import numpy as np
 import pandas as pd
 import pyarrow as pa
@@ -272,6 +274,149 @@ class CcxtReader(IReader):
         pass
 
 
+_T = Any  # explicit alias keeps the retry helper signature readable
+
+# retry defaults — conservative. tuned for warmup OHLCV bursts where transient
+# RateLimitExceeded / NetworkError are the dominant failure modes (see #264).
+_RETRY_MAX_ATTEMPTS = 5
+_RETRY_BASE_DELAY_S = 1.0
+_RETRY_MAX_DELAY_S = 30.0
+_RETRY_JITTER_S = 1.0
+
+
+def _sync_rate_limiter_from_response_headers(ccxt_ex: Any, rate_limiter: Any) -> None:
+    """
+    Best-effort sync of the rate limiter's modeled state from the exchange's
+    last HTTP response headers.
+
+    Without this, the client-side token bucket flies blind to:
+        * cross-process / cross-bot contention on the same IP or account,
+        * drift between our ``PoolConfig`` and the exchange's real limits,
+        * pre-existing budget debt at process start.
+
+    This is a *best-effort* correction because ``ccxt_ex.last_response_headers``
+    is exchange-wide, not per-request — under concurrent fetches the attribute
+    may have been overwritten between the awaited response and this read.
+    That is acceptable in practice: every concurrent request drains the same
+    IP-scoped budget, so whatever remaining value we read is approximately
+    correct, and the limiter converges on subsequent syncs.
+
+    Any exception (missing attr, malformed header, parser bug) is swallowed
+    at DEBUG — header sync must never break a fetch.
+    """
+    if rate_limiter is None:
+        return
+    try:
+        from qubx.connectors.ccxt.rate_limits import get_header_parser
+
+        parser = get_header_parser(getattr(ccxt_ex, "id", ""))
+        if parser is None:
+            return
+        headers = getattr(ccxt_ex, "last_response_headers", None)
+        if not headers:
+            return
+        parser(headers, rate_limiter)
+    except Exception as e:
+        logger.debug(f"[CCXT] header sync failed (non-fatal): {e}")
+
+
+class CcxtFetchExhausted(RuntimeError):
+    """
+    Raised when one or more symbols exhaust all retry attempts during a
+    multi-symbol fetch. The caller cannot silently proceed with partial data,
+    because downstream indicators may compute nonsense on zero bars and
+    propagate into corrupt live state (see #264).
+
+    The ``failures`` attribute maps ``qubx_sym -> last_exception`` so callers
+    can log or dispatch based on specific failures.
+    """
+
+    def __init__(self, failures: dict[str, BaseException], total_requested: int) -> None:
+        self.failures = failures
+        self.total_requested = total_requested
+        failed_symbols = sorted(failures.keys())
+        preview = ", ".join(
+            f"{s}={type(failures[s]).__name__}" for s in failed_symbols[:5]
+        )
+        more = f" (+{len(failed_symbols) - 5} more)" if len(failed_symbols) > 5 else ""
+        super().__init__(
+            f"OHLCV fetch exhausted retries for {len(failures)}/{total_requested} "
+            f"symbols: {preview}{more}"
+        )
+
+
+async def _retryable_fetch(
+    call: Callable[[], Awaitable[_T]],
+    *,
+    rate_limiter: Any = None,
+    rate_limiter_endpoint: str = "ccxt_rest",
+    max_attempts: int = _RETRY_MAX_ATTEMPTS,
+    base_delay: float = _RETRY_BASE_DELAY_S,
+    max_delay: float = _RETRY_MAX_DELAY_S,
+    jitter: float = _RETRY_JITTER_S,
+    context: str = "",
+    sleep: Callable[[float], Awaitable[None]] = asyncio.sleep,
+) -> _T:
+    """
+    Invoke ``call()`` with exponential backoff + jitter on transient CCXT errors.
+
+    Retryable errors:
+        * ``ccxt.RateLimitExceeded`` — exchange-level 429 / OKX 50011.
+        * ``ccxt.NetworkError`` (parent; also covers ``ExchangeNotAvailable``
+          and ``OnMaintenance``).
+        * ``asyncio.TimeoutError``.
+
+    Everything else (``ccxt.ExchangeError`` and subclasses like ``BadSymbol``,
+    ``AuthenticationError``, plus any non-CCXT exception) is re-raised
+    immediately — permanent errors should not consume retry budget.
+
+    The rate-limiter interaction is handled here in two stages per attempt:
+        1. ``acquire(endpoint)`` before each call to block while the gate is closed.
+        2. ``report_limit_hit(endpoint=...)`` on ``RateLimitExceeded`` so the
+           gate closes for ``cooldown`` seconds, pausing all concurrent callers.
+
+    Args:
+        call: Zero-arg callable returning the coroutine to invoke.
+        rate_limiter: Optional ``ExchangeRateLimiter``; if provided, calls are
+            gated and rate-limit hits are reported back to it.
+        rate_limiter_endpoint: Endpoint name used for ``acquire`` /
+            ``report_limit_hit`` lookups.
+        max_attempts: Total attempts including the initial one.
+        base_delay: First retry delay in seconds; doubles each attempt.
+        max_delay: Cap on the exponential delay.
+        jitter: Uniform jitter (0..jitter) added to each delay.
+        context: Short human label included in log lines (e.g. ``"OKX BTCUSDT"``).
+        sleep: Async sleep function (injectable for tests).
+
+    Raises:
+        The last retryable exception once ``max_attempts`` is exhausted.
+    """
+    last_exc: BaseException | None = None
+    for attempt in range(1, max_attempts + 1):
+        if rate_limiter is not None:
+            await rate_limiter.acquire(rate_limiter_endpoint)
+        try:
+            return await call()
+        except (ccxt.NetworkError, asyncio.TimeoutError) as e:
+            last_exc = e
+            if isinstance(e, ccxt.RateLimitExceeded) and rate_limiter is not None:
+                rate_limiter.report_limit_hit(
+                    endpoint=rate_limiter_endpoint,
+                    reason=(f"{context}: " if context else "") + str(e)[:120],
+                )
+            if attempt >= max_attempts:
+                break
+            delay = min(base_delay * (2 ** (attempt - 1)), max_delay) + random.uniform(0, jitter)
+            logger.warning(
+                f"[CCXT] transient error on {context or 'fetch'} "
+                f"(attempt {attempt}/{max_attempts}): {type(e).__name__}: {e}; "
+                f"retrying in {delay:.2f}s"
+            )
+            await sleep(delay)
+    assert last_exc is not None  # unreachable: the loop always raises or returns
+    raise last_exc
+
+
 @storage("ccxt")
 class CcxtStorage(IStorage):
     """
@@ -315,10 +460,20 @@ class CcxtStorage(IStorage):
         max_bars: int = 10_000,
         max_history: str = "3650d",
         rate_limiters: dict | None = None,
+        retry_max_attempts: int = _RETRY_MAX_ATTEMPTS,
+        retry_base_delay: float = _RETRY_BASE_DELAY_S,
+        retry_max_delay: float = _RETRY_MAX_DELAY_S,
+        retry_jitter: float = _RETRY_JITTER_S,
+        strict_fetch: bool = True,
     ) -> None:
         self._max_bars = max_bars
         self._max_history = to_timedelta(max_history)
         self._rate_limiters = rate_limiters or {}
+        self._retry_max_attempts = retry_max_attempts
+        self._retry_base_delay = retry_base_delay
+        self._retry_max_delay = retry_max_delay
+        self._retry_jitter = retry_jitter
+        self._strict_fetch = strict_fetch
         # - shared async loop (created from first exchange connection)
         self._loop = None
         self._capabilities = None
@@ -484,13 +639,31 @@ class CcxtStorage(IStorage):
         all_items: list = []
         current_since = since
 
-        # Get rate limiter for this exchange (if available)
+        # Get rate limiter for this exchange (if available). Retry + backoff + rate-limit
+        # acquisition are all encapsulated inside ``_retryable_fetch`` so this loop stays
+        # focused on pagination.
         _rl = self._get_rate_limiter(ccxt_ex)
+        _ex_id = getattr(ccxt_ex, "id", "ccxt")
 
         for _ in range(max_pages):
-            if _rl:
-                await _rl.acquire("ccxt_rest")
-            batch = await method(since=current_since, limit=limit, **method_kwargs)
+            _since = current_since  # capture for the closure below
+
+            async def _do_page() -> list:
+                batch = await method(since=_since, limit=limit, **method_kwargs)
+                # Best-effort: keep our modeled budget in sync with what the exchange
+                # actually reports — see ``_sync_rate_limiter_from_response_headers``.
+                _sync_rate_limiter_from_response_headers(ccxt_ex, _rl)
+                return batch
+
+            batch = await _retryable_fetch(
+                _do_page,
+                rate_limiter=_rl,
+                max_attempts=self._retry_max_attempts,
+                base_delay=self._retry_base_delay,
+                max_delay=self._retry_max_delay,
+                jitter=self._retry_jitter,
+                context=f"{_ex_id} {method_kwargs.get('symbol', '?')}",
+            )
             if not batch:
                 break
             for item in batch:
@@ -543,7 +716,24 @@ class CcxtStorage(IStorage):
     ) -> dict[str, list]:
         """
         Concurrent OHLCV fetch for multiple instruments with bounded concurrency.
-        Returns ``{qubx_sym: raw_candles}``.
+
+        Per-symbol results go through ``_async_paginated_fetch`` which already
+        retries transient errors with backoff. If retries are exhausted, behavior
+        depends on ``self._strict_fetch``:
+
+        * ``strict_fetch=True`` (default) — logs ERROR per symbol and raises
+          :class:`CcxtFetchExhausted` listing all failures. This prevents
+          downstream indicators from computing on zero bars (see #264).
+        * ``strict_fetch=False`` — logs WARNING per symbol and returns ``[]``
+          for that symbol. Kept for backwards compatibility and use cases
+          where partial data is acceptable.
+
+        Returns:
+            ``{qubx_sym: raw_candles}`` on full or partial success.
+
+        Raises:
+            CcxtFetchExhausted: when any symbol exhausts retries and
+                ``strict_fetch`` is True.
         """
         sem = asyncio.Semaphore(5)  # max 5 concurrent fetches
 
@@ -553,14 +743,26 @@ class CcxtStorage(IStorage):
 
         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):
-            _, qubx_sym = instruments_info[i]
-            if isinstance(result, Exception):
-                logger.warning(f"[CCXT] Failed to fetch OHLCV for {qubx_sym}: {result}")
+        failures: dict[str, BaseException] = {}
+        for (_, qubx_sym), result in zip(instruments_info, results):
+            if isinstance(result, BaseException):
+                failures[qubx_sym] = result
                 out[qubx_sym] = []
             else:
                 out[qubx_sym] = cast(list, result)
+
+        if failures:
+            _ex_id = getattr(ccxt_ex, "id", "ccxt")
+            for qubx_sym, exc in failures.items():
+                logger.error(
+                    f"[CCXT] {_ex_id}: OHLCV fetch for {qubx_sym} exhausted retries — "
+                    f"{type(exc).__name__}: {exc}"
+                )
+            if self._strict_fetch:
+                raise CcxtFetchExhausted(failures, total_requested=len(instruments_info))
+
         return out
 
     def _ccxt_sym_to_qubx(self, ccxt_symbol: str) -> str:

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/src/qubx/data/transformers.py

@@ -310,7 +310,7 @@ class TypedRecords(IDataTransformer):
                 return FundingPayment(
                     time=int(row["time"]),
                     funding_rate=float(row["funding_rate"]),
-                    funding_interval_hours=int(row["funding_interval_hours"]),
+                    funding_interval_hours=round(float(row["funding_interval_hours"])),
                 )
 
             case DataType.OPEN_INTEREST:

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/src/qubx/pandaz/ta.py

@@ -251,7 +251,7 @@ def running_view(arr, window, axis=-1):
     """
     shape = list(arr.shape)
     shape[axis] -= window - 1
-    return np.lib.index_tricks.as_strided(arr, shape + [window], arr.strides + (arr.strides[axis],))
+    return np.lib.stride_tricks.as_strided(arr, shape + [window], arr.strides + (arr.strides[axis],))
 
 
 def detrend(y, order):

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/src/qubx/trackers/riskctrl.py

@@ -794,9 +794,11 @@ class AtrRiskTracker(GenericRiskControllerDecorator):
     def calculate_risks(self, ctx: IStrategyContext, quote: Quote | None, signal: Signal) -> Signal | None:
         volatility = self._get_volatility(ctx, signal.instrument)
 
-        if len(volatility) < 2 or ((last_volatility := volatility[1]) is None or not np.isfinite(last_volatility)):
+        last_volatility = volatility[1] if len(volatility) >= 2 else None
+        if last_volatility is None or not np.isfinite(last_volatility) or last_volatility <= 0:
             logger.debug(
-                f"[<y>{self._full_name}</y>(<g>{signal.instrument}</g>)] :: not enough ATR data, skipping risk calculation"
+                f"[<y>{self._full_name}</y>(<g>{signal.instrument}</g>)] :: "
+                f"ATR unusable (value={last_volatility!r}), skipping risk calculation"
             )
             return None
 

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/src/qubx/trackers/sizers.py

@@ -113,6 +113,14 @@ class FixedRiskSizer(IPositionSizer):
                     if (_entry := self.get_signal_entry_price(ctx, signal)) is None:
                         continue
 
+                    _stop_distance = abs(signal.stop / _entry - 1)
+                    if _stop_distance <= 0 or not np.isfinite(_stop_distance):
+                        logger.warning(
+                            f" >>> {self.__class__.__name__}: degenerate stop/entry for "
+                            f"{signal.instrument.symbol} (entry={_entry}, stop={signal.stop}) - skipping"
+                        )
+                        continue
+
                     # - hey, we can't trade using negative balance ;)
                     _cap = max(ctx.get_total_capital() if self.reinvest_profit else ctx.get_capital(), 0)
                     _scale = abs(signal.signal) if self.scale_by_signal else 1
@@ -122,7 +130,7 @@ class FixedRiskSizer(IPositionSizer):
                     _notional_per_contract = _entry * signal.instrument.quantity_multiplier
                     target_position_size = (
                         _direction
-                        *min((_cap * self.max_cap_in_risk) / abs(signal.stop / _entry - 1), self.max_allowed_position_quoted) / _notional_per_contract
+                        *min((_cap * self.max_cap_in_risk) / _stop_distance, self.max_allowed_position_quoted) / _notional_per_contract
                         / (len(ctx.instruments) if self.divide_by_symbols else 1)
                         * _scale
                     )
@@ -237,6 +245,14 @@ class FixedRiskSizerWithConstantCapital(IPositionSizer):
                     if (_entry := self.get_signal_entry_price(ctx, signal)) is None:
                         continue
 
+                    _stop_distance = abs(signal.stop / _entry - 1)
+                    if _stop_distance <= 0 or not np.isfinite(_stop_distance):
+                        logger.warning(
+                            f" >>> {self.__class__.__name__}: degenerate stop/entry for {signal.instrument.symbol} "
+                            f"(entry={_entry}, stop={signal.stop}) - skipping"
+                        )
+                        continue
+
                     # - just use same fixed capital
                     _cap = self.capital / (len(ctx.instruments) if self.divide_by_symbols else 1)
 
@@ -245,7 +261,7 @@ class FixedRiskSizerWithConstantCapital(IPositionSizer):
                     _notional_per_contract = _entry * signal.instrument.quantity_multiplier
                     target_position_size = (
                         _direction * min(
-                            (_cap * self.max_cap_in_risk) / abs(signal.stop / _entry - 1),
+                            (_cap * self.max_cap_in_risk) / _stop_distance,
                             self.max_allowed_position_quoted
                         ) / _notional_per_contract
                     )

{qubx-1.2.3.dev1 → qubx-1.2.3.dev3}/src/qubx/utils/runner/runner.py

@@ -80,6 +80,27 @@ from .accounts import AccountConfigurationManager
 INVERSE_EXCHANGE_MAPPINGS = {mapping: exchange for exchange, mapping in EXCHANGE_MAPPINGS.items()}
 
 
+def _inject_warmup_rate_limiters(warmup: WarmupConfig | None, rate_limiters: dict | None) -> None:
+    """
+    Inject rate limiters into warmup storage configs.
+
+    Mirrors the aux_configs injection done in ``create_strategy_context`` — without this,
+    warmup data fetches (e.g. via ``CcxtStorage``) bypass the per-exchange rate limiter
+    and can be rate-limited by the exchange with no retry, producing empty bars and
+    corrupting downstream indicators (see xLydianSoftware/Qubx#264).
+
+    Args:
+        warmup: Warmup config. If None or no rate_limiters, this is a no-op.
+        rate_limiters: Dict of rate limiters keyed by exchange name (from ``RateLimitManager``).
+    """
+    if warmup is None or not rate_limiters:
+        return
+    warmup.data.args["rate_limiters"] = rate_limiters
+    for typed_cfg in warmup.custom_data or []:
+        for sc in typed_cfg.storages:
+            sc.args["rate_limiters"] = rate_limiters
+
+
 def _cleanup_event_loop(loop: asyncio.AbstractEventLoop | None) -> None:
     """
     Cleanup the shared event loop.
@@ -1028,6 +1049,11 @@ def _run_warmup(
 
     logger.info(f"<yellow>Warmup start time: {warmup_start_time}</yellow>")
 
+    # - inject rate limiters into warmup storage configs (for CcxtStorage, LighterStorage, etc.)
+    #   mirrors the aux_configs injection done in create_strategy_context.
+    #   without this, warmup OHLCV fetches bypass the configured per-exchange rate limiter.
+    _inject_warmup_rate_limiters(warmup, getattr(ctx, "_rate_limiters", None))
+
     # - resolve warmup data sources (mirrors SimulationConfig layout)
     # - warmup.data is required (StorageConfig, not None) so construct_storage always returns IStorage
     _warmup_data_storage = construct_storage(warmup.data)