Qubx 3.2.2.dev1__tar.gz → 3.3.0__tar.gz

{qubx-3.2.2.dev1 → qubx-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: Qubx
-Version: 3.2.2.dev1
+Version: 3.3.0
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx
@@ -23,7 +23,6 @@ Requires-Dist: joblib<2,>=1.3.0
 Requires-Dist: jupyter-client<9,>=8.0.0
 Requires-Dist: loguru<1,>=0.7.2
 Requires-Dist: msgspec<1,>=0.18.6
-Requires-Dist: ntplib<1,>=0.4.0
 Requires-Dist: numba<1,>=0.59.1
 Requires-Dist: numpy>=2.0.0
 Requires-Dist: orjson<4,>=3.10.15

{qubx-3.2.2.dev1 → qubx-3.3.0}/pyproject.toml

@@ -53,7 +53,6 @@ dependencies = [
     "croniter>=2.0.5,<3",
     "tabulate>=0.9.0,<1",
     "gitpython>=3.1.44,<4",
-    "ntplib>=0.4.0,<1",
     "jinja2>=3.1.0,<4",
     "rich>=13.9.4,<14",
     "click>=8.1.7,<9",

{qubx-3.2.2.dev1 → qubx-3.3.0}/src/qubx/_version.py

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

{qubx-3.2.2.dev1 → qubx-3.3.0}/src/qubx/backtester/connector.py

@@ -298,13 +298,17 @@ class SimulatedConnector(ChannelEmitter):
     def is_simulated_trading(self) -> bool:
         return True
 
-    def set_max_instrument_leverage(self, instrument: Instrument, leverage: float) -> bool:
-        return True
+    def set_instrument_leverage(self, instrument: Instrument, leverage: float) -> None:
+        # - simulation does not model venue leverage settings; accept and forget
+        return None
 
     def set_margin_mode(self, instrument: Instrument, mode: str) -> bool:
         return True
 
     # Simulation does not model venue margin: the config getters read neutral.
+    def get_instrument_leverage(self, instrument: Instrument) -> float | None:
+        return None
+
     def get_max_instrument_leverage(self, instrument: Instrument) -> float | None:
         return None
 

{qubx-3.2.2.dev1 → qubx-3.3.0}/src/qubx/backtester/runner.py

@@ -11,7 +11,7 @@ from qubx.backtester.sentinels import NoDataContinue
 from qubx.backtester.simulated_data import SimulatedDataIterator
 from qubx.backtester.transfers import SimulationTransferManager
 from qubx.core.account_manager import AccountManagerConfig, SimulatedAccountManager
-from qubx.core.basics import SW, Balance, DataType, Instrument, TransactionCostsCalculator
+from qubx.core.basics import SW, DataType, Instrument, TransactionCostsCalculator
 from qubx.core.context import StrategyContext
 from qubx.core.exceptions import SimulationConfigError, SimulationError
 from qubx.core.helpers import extract_parameters_from_object, full_qualified_class_name
@@ -49,6 +49,7 @@ from .utils import (
     SimulationSetup,
     _get_default_warmup_period,
     find_open_close_time_indent_secs_from_subscription,
+    initial_balances,
 )
 
 
@@ -608,7 +609,7 @@ class SimulationRunner:
 
         am = SimulatedAccountManager(
             connectors=self._connectors,
-            base_currencies={exchange: self.setup.base_currency for exchange in self.setup.exchanges},
+            base_currencies=self.setup.base_currencies,
             time=time_provider,
             cfg=AccountManagerConfig(),
             account_id=self.account_id,
@@ -616,17 +617,7 @@ class SimulationRunner:
         )
 
         # - seed initial capital per exchange into the account state
-        assert isinstance(self.setup.capital, dict)
-        for exchange, capital in self.setup.capital.items():
-            am.seed_balance(
-                exchange,
-                Balance(
-                    exchange=exchange,
-                    currency=self.setup.base_currency,
-                    total=capital,
-                    free=capital,
-                    locked=0.0,
-                ),
-            )
+        for exchange, balance in initial_balances(self.setup).items():
+            am.seed_balance(exchange, balance)
 
         return am

{qubx-3.2.2.dev1 → qubx-3.3.0}/src/qubx/backtester/simulator.py

@@ -38,7 +38,7 @@ def simulate(
     instruments: list[str] | list[Instrument] | dict[ExchangeName_t, list[SymbolOrInstrument_t]] | None = None,
     commissions: str | dict[str, str | None] | None = None,
     exchange: ExchangeName_t | list[ExchangeName_t] | None = None,
-    base_currency: str = "USDT",
+    base_currency: str | dict[str, str] = "USDT",
     n_jobs: int = 1,
     silent: bool = False,
     aux_data: IStorage | None = None,

{qubx-3.2.2.dev1 → qubx-3.3.0}/src/qubx/backtester/transfers.py

@@ -21,6 +21,15 @@ class SimulationTransferManager(ITransferManager):
     def transfer_funds(self, from_exchange: str, to_exchange: str, currency: str, amount: float) -> str:
         if amount <= 0:
             raise ValueError(f"Transfer amount must be positive, got {amount}")
+        to_currency = self._account.get_base_currency(to_exchange)
+        # Venues settle in their own currency: a withdrawal leaves in `currency` and arrives as
+        # `to_currency`. Both legs must be priced — an unpriced asset has no transferable value.
+        from_rate = self._account.get_state(from_exchange).conversion_rate_to_base(currency)
+        to_rate = self._account.get_state(to_exchange).conversion_rate_to_base(to_currency)
+        if from_rate is None or to_rate is None:
+            raise ValueError(f"Cannot transfer {currency} to {to_exchange} {to_currency}: no conversion rate")
+        to_amount = amount * from_rate / to_rate
+
         from_balance = self._account.get_balance(currency, exchange=from_exchange)
         if from_balance.free < amount:
             raise ValueError(
@@ -28,11 +37,8 @@ class SimulationTransferManager(ITransferManager):
                 f"{from_balance.free:.8f} {currency} available, {amount:.8f} requested"
             )
 
-        # Instant transfer: debit the source and credit the destination. adjust_balance
-        # mutates the held Balance in place (holders keep a live reference) and creates
-        # the destination Balance if missing.
         self._account.adjust_balance(from_exchange, currency, -amount)
-        self._account.adjust_balance(to_exchange, currency, amount)
+        self._account.adjust_balance(to_exchange, to_currency, to_amount)
 
         transaction_id = f"sim_{uuid.uuid4().hex[:12]}"
         self._transfers[transaction_id] = Transfer(
@@ -43,8 +49,13 @@ class SimulationTransferManager(ITransferManager):
             amount=amount,
             status=TransferStatus.COMPLETED,  # transfers are instant in simulation
             timestamp=self._time.time(),
+            to_currency=to_currency,
+            to_amount=to_amount,
+        )
+        logger.debug(
+            f"[SimTransfer] {amount:.8f} {currency} {from_exchange} -> "
+            f"{to_amount:.8f} {to_currency} {to_exchange} ({transaction_id})"
         )
-        logger.debug(f"[SimTransfer] {amount:.8f} {currency} {from_exchange} -> {to_exchange} ({transaction_id})")
         return transaction_id
 
     def get_transfer_status(self, transaction_id: str) -> Transfer:

{qubx-3.2.2.dev1 → qubx-3.3.0}/src/qubx/backtester/utils.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping, Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from typing import Any, Callable, TypeAlias
 
@@ -8,6 +8,8 @@ import pandas as pd
 
 from qubx import logger
 from qubx.core.basics import (
+    STABLE_CURRENCIES,
+    Balance,
     CtrlChannel,
     DataType,
     Instrument,
@@ -80,6 +82,20 @@ def _type(obj: Any) -> SetupTypes:
     return t
 
 
+def _settle_currencies(instruments: list[Instrument], exchange: str) -> set[str]:
+    return {i.settle.upper() for i in instruments if i.exchange == exchange and i.settle}
+
+
+def _derive_settle_currency(instruments: list[Instrument], exchange: str) -> str | None:
+    """The one settle currency a venue's instruments agree on, or None when absent, mixed, or
+    not a recognized stable — BINANCE.UM:ETHBTC settles in BTC, and BTC is not 1.0 of capital."""
+    settles = _settle_currencies(instruments, exchange)
+    if len(settles) != 1:
+        return None
+    settle = settles.pop()
+    return settle if settle in STABLE_CURRENCIES else None
+
+
 @dataclass
 class SimulationSetup:
     """
@@ -93,16 +109,37 @@ class SimulationSetup:
     instruments: list[Instrument]
     exchanges: list[str]
     capital: float | dict[str, float]
-    base_currency: str
+    base_currency: str | dict[str, str]
     commissions: str | dict[str, str | None] | None = None
     signal_timeframe: str = "1Min"
     accurate_stop_orders_execution: bool = False
     enable_funding: bool = False
+    base_currencies: dict[str, str] = field(init=False, default_factory=dict)
 
     def __post_init__(self) -> None:
-        # Normalize once at the config boundary: AccountState stores base_currency upper-cased,
-        # so a lowercase value here would seed capital under a key total_capital never reads.
-        self.base_currency = self.base_currency.upper()
+        # Per-exchange base currency: explicit mapping wins, else the venue's shared settle
+        # currency, else the scalar. AccountState upper-cases, so normalize here or the seeded
+        # Balance lands under a key total_capital never reads.
+        explicit = (
+            {ex: ccy.upper() for ex, ccy in self.base_currency.items()}
+            if isinstance(self.base_currency, dict)
+            else {}
+        )
+        default_ccy = (
+            self.base_currency.upper()
+            if isinstance(self.base_currency, str)
+            else (explicit.get(self.exchanges[0], "USDT") if self.exchanges else "USDT")
+        )
+        self.base_currencies = {}
+        for ex in self.exchanges:
+            resolved = explicit.get(ex) or _derive_settle_currency(self.instruments, ex)
+            if resolved is None and (settles := _settle_currencies(self.instruments, ex)):
+                logger.debug(
+                    f"No single stable settle currency for {ex} (saw {sorted(settles)}) "
+                    f"- using {default_ccy} as its base currency"
+                )
+            self.base_currencies[ex] = resolved or default_ccy
+        self.base_currency = self.base_currencies[self.exchanges[0]] if self.exchanges else default_ccy
         # Normalize capital to a per-exchange dict: split evenly when a single float is given
         if isinstance(self.capital, (int, float)):
             n = len(self.exchanges)
@@ -113,6 +150,21 @@ class SimulationSetup:
         return f"{self.name} {self.setup_type} capital {self.capital} {self.base_currency} for [{','.join(map(lambda x: x.symbol, self.instruments))}] @ {self.exchanges}[{self.commissions}]"
 
 
+def initial_balances(setup: SimulationSetup) -> dict[str, Balance]:
+    """Startup balance per exchange, each in that venue's own base currency."""
+    assert isinstance(setup.capital, dict)
+    return {
+        exchange: Balance(
+            exchange=exchange,
+            currency=setup.base_currencies[exchange],
+            total=capital,
+            free=capital,
+            locked=0.0,
+        )
+        for exchange, capital in setup.capital.items()
+    }
+
+
 # fmt: off
 @dataclass
 class SimulationDataConfig:
@@ -287,7 +339,9 @@ def find_instruments_and_exchanges(
                 _instrs.append(instrument)
                 _exchanges.append(resolved_exchange)
 
-    return _instrs, list(set(_exchanges))
+    # sorted, not list(set(...)): string hashing is per-process randomized, and exchanges[0]
+    # decides the persisted scalar base_currency of a multi-venue run.
+    return _instrs, sorted(set(_exchanges))
 
 
 class _StructureSniffer:
@@ -345,7 +399,7 @@ def recognize_simulation_configuration(
     instruments: list[Instrument],
     exchanges: list[str],
     capital: float | dict[str, float],
-    basic_currency: str,
+    basic_currency: str | dict[str, str],
     commissions: str | dict[str, str | None] | None,
     signal_timeframe: str,
     accurate_stop_orders_execution: bool,
@@ -640,7 +694,16 @@ def recognize_simulation_data_config(
     )
 
 
-_TRANSFERS_LOG_COLUMNS = ["transaction_id", "from_exchange", "to_exchange", "currency", "amount", "status"]
+_TRANSFERS_LOG_COLUMNS = [
+    "transaction_id",
+    "from_exchange",
+    "to_exchange",
+    "currency",
+    "amount",
+    "status",
+    "to_currency",
+    "to_amount",
+]
 
 
 def collect_transfers_log(transfer_manager: ITransferManager | None) -> pd.DataFrame | None:
@@ -667,6 +730,8 @@ def collect_transfers_log(transfer_manager: ITransferManager | None) -> pd.DataF
                 "currency": t.currency,
                 "amount": t.amount,
                 "status": str(t.status),
+                "to_currency": t.to_currency or t.currency,
+                "to_amount": t.to_amount if t.to_amount is not None else t.amount,
             }
             for t in transfers
         ]

{qubx-3.2.2.dev1 → qubx-3.3.0}/src/qubx/connectors/ccxt/connection_manager.py

@@ -155,7 +155,8 @@ class ConnectionManager:
                 await asyncio.sleep(1)
                 continue
             except (RateLimitExceeded, DDoSProtection) as e:
-                # Rate limit hit — report to rate limiter if available and backoff
+                # WS 429/418 are IP actions that ban REST too, and a gate close is not a token debit,
+                # so the next header sync does not erase it — hence the REST pool.
                 logger.warning(
                     f"<yellow>{self._exchange_id}</yellow> Rate limited in {stream_name}: {e}"
                 )