Qubx 1.2.2.dev2__tar.gz → 1.2.3.dev1__tar.gz

{qubx-1.2.2.dev2 → qubx-1.2.3.dev1}/PKG-INFO

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

{qubx-1.2.2.dev2 → qubx-1.2.3.dev1}/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.2.dev2'
-__version_tuple__ = version_tuple = (1, 2, 2, 'dev2')
+__version__ = version = '1.2.3.dev1'
+__version_tuple__ = version_tuple = (1, 2, 3, 'dev1')
 
 __commit_id__ = commit_id = None

{qubx-1.2.2.dev2 → qubx-1.2.3.dev1}/src/qubx/connectors/ccxt/exchanges/okx/account.py

@@ -18,8 +18,35 @@ class OkxAccountProcessor(CcxtAccountProcessor):
     so we must subscribe to both channels separately:
     - orders channel: for order status updates (watch_orders)
     - trades channel: for trade/fill updates (watch_my_trades)
+
+    Balance streaming: uses watch_balance WS to get real-time totalEq updates
+    instead of relying solely on 30s polling.
     """
 
+    def start(self):
+        super().start()
+        if self._is_running and not self.exchange_manager.exchange.isSandboxModeEnabled:
+            self._polling_tasks["balance_ws"] = self._loop.submit(self._watch_balance_stream())
+
+    async def _watch_balance_stream(self):
+        """Stream balance updates via WS to get real-time totalEq."""
+
+        async def _watch():
+            balances_raw = await self.exchange_manager.exchange.watch_balance()
+            equity = self._extract_portfolio_value(balances_raw)
+            if equity is not None:
+                self._exchange_total_capital = equity
+            margin_ratio = self._extract_margin_ratio(balances_raw)
+            if margin_ratio is not None:
+                self._exchange_margin_ratio = margin_ratio
+
+        await self._listen_to_stream(
+            subscriber=_watch,
+            exchange=self.exchange_manager.exchange,
+            channel=self.channel,
+            name="okx_balance_ws",
+        )
+
     async def _subscribe_executions(self, name: str, channel: CtrlChannel):
         logger.info("<yellow>[OKX]</yellow> Subscribing to executions (orders + trades)")
         _symbol_to_instrument = {}
@@ -57,11 +84,31 @@ class OkxAccountProcessor(CcxtAccountProcessor):
             ),
         )
 
+    def _get_account_data(self, balances_raw: dict) -> dict:
+        """Get the OKX account data dict from info.data[0]."""
+        return balances_raw.get("info", {}).get("data", [{}])[0]
+
+    def _extract_margin_ratio(self, balances_raw: dict) -> float | None:
+        """Extract OKX margin ratio from the base currency detail entry.
+
+        The account-level mgnRatio is empty; the real value is per-currency in details.
+        We use the base currency's mgnRatio as the account margin ratio.
+        """
+        details = self._get_account_data(balances_raw).get("details", [])
+        for detail in details:
+            if detail.get("ccy", "").upper() == self.base_currency.upper():
+                val = detail.get("mgnRatio")
+                if val is not None and val != "":
+                    try:
+                        return float(val)
+                    except (ValueError, TypeError):
+                        pass
+        return None
+
     def _extract_portfolio_value(self, balances_raw: dict) -> float | None:
-        """Extract OKX total equity from raw balance response."""
-        data = balances_raw.get("info", {}).get("data", [{}])[0]
-        total_eq = data.get("totalEq")
-        if total_eq is not None:
+        """Extract OKX total equity from info.data[0].totalEq."""
+        total_eq = self._get_account_data(balances_raw).get("totalEq")
+        if total_eq is not None and total_eq != "":
             try:
                 return float(total_eq)
             except (ValueError, TypeError):
@@ -81,6 +128,10 @@ class OkxAccountProcessor(CcxtAccountProcessor):
         if equity is not None:
             self._exchange_total_capital = equity
 
+        margin_ratio = self._extract_margin_ratio(balances_raw)
+        if margin_ratio is not None:
+            self._exchange_margin_ratio = margin_ratio
+
         # Extract cashBal from raw OKX response instead of CCXT-parsed eq
         balances: list[AssetBalance] = []
         raw_details = balances_raw.get("info", {}).get("data", [{}])[0].get("details", [])

{qubx-1.2.2.dev2 → qubx-1.2.3.dev1}/src/qubx/core/account.py

@@ -66,6 +66,7 @@ class BasicAccountProcessor(IAccountProcessor):
         self._pending_order_requests = {}
         self._balances = {}
         self._exchange_total_capital: float | None = None
+        self._exchange_margin_ratio: float | None = None
         # Initialize with base currency balance
         self._balances[self.base_currency] = AssetBalance(
             exchange=self.exchange, currency=self.base_currency, free=initial_capital, locked=0.0, total=initial_capital
@@ -183,7 +184,9 @@ class BasicAccountProcessor(IAccountProcessor):
         return self.get_total_capital(exchange) - self.get_total_required_margin(exchange)
 
     def get_margin_ratio(self, exchange: str | None = None) -> float:
-        # total capital / total required margin
+        if self._exchange_margin_ratio is not None:
+            return self._exchange_margin_ratio
+        # fallback: total capital / total required margin
         required_margin = self.get_total_required_margin(exchange)
         if required_margin == 0:
             return 100.0

{qubx-1.2.2.dev2 → qubx-1.2.3.dev1}/src/qubx/core/loggers.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import Any
 
 import numpy as np
+import pandas as pd
 
 from qubx import logger
 from qubx.core.basics import (
@@ -100,28 +101,35 @@ class PositionsDumper(_BaseIntervalDumper):
             self.positions[p.instrument] = p
         return self
 
+    @staticmethod
+    def _position_row(instrument: Instrument, position: Position, timestamp: np.datetime64) -> dict[str, Any]:
+        return {
+            "timestamp": str(timestamp),
+            "symbol": instrument.symbol,
+            "exchange": instrument.exchange,
+            "market_type": instrument.market_type,
+            "pnl_quoted": position.pnl,
+            "funding_pnl_quoted": position.cumulative_funding,
+            "realized_pnl_quoted": position.r_pnl,
+            "quantity": position.quantity,
+            "notional": position.notional_value,
+            "avg_position_price": position.position_avg_price if position.quantity != 0.0 else 0.0,
+            "current_price": position.last_update_price,
+            "market_value_quoted": position.market_value_funds,
+            "commissions_quoted": position.commissions,
+        }
+
     def dump(self, interval_start_time: np.datetime64, actual_timestamp: np.datetime64):
-        data = []
-        for i, p in self.positions.items():
-            data.append(
-                {
-                    "timestamp": str(actual_timestamp),
-                    "symbol": i.symbol,
-                    "exchange": i.exchange,
-                    "market_type": i.market_type,
-                    "pnl_quoted": p.pnl,
-                    "funding_pnl_quoted": p.cumulative_funding,
-                    "realized_pnl_quoted": p.r_pnl,
-                    "quantity": p.quantity,
-                    "notional": p.notional_value,
-                    "avg_position_price": p.position_avg_price if p.quantity != 0.0 else 0.0,
-                    "current_price": p.last_update_price,
-                    "market_value_quoted": p.market_value_funds,
-                    "commissions_quoted": p.commissions,
-                }
-            )
+        data = [self._position_row(i, p, actual_timestamp) for i, p in self.positions.items()]
         self._writer.write_data("positions", data)
 
+    def dump_instrument(self, instrument: Instrument, timestamp: np.datetime64) -> None:
+        """Write a single position snapshot row for ``instrument`` (used for on-fill event logging)."""
+        position = self.positions.get(instrument)
+        if position is None:
+            return
+        self._writer.write_data("positions", [self._position_row(instrument, position, timestamp)])
+
 
 class PortfolioLogger(PositionsDumper):
     """
@@ -343,11 +351,12 @@ class StrategyLogging:
     def __init__(
         self,
         logs_writer: LogsWriter | None = None,
-        positions_log_freq: str = "1Min",
-        portfolio_log_freq: str = "5Min",
+        positions_log_freq: str | None = "1Min",
+        portfolio_log_freq: str | None = "5Min",
         num_exec_records_to_write=1,  # in live let's write every execution
         num_signals_records_to_write=1,
         heartbeat_freq: str | None = None,
+        positions_log_on_change: bool = False,
     ) -> None:
         # - instantiate loggers
         if logs_writer:
@@ -367,13 +376,16 @@ class StrategyLogging:
             if num_signals_records_to_write >= 1:
                 self.signals_logger = SignalsAndTargetsLogger(logs_writer, num_signals_records_to_write)
 
-            # - balance logger
-            self.balance_logger = BalanceLogger(logs_writer, positions_log_freq)
+            # - balance logger (tracks positions_log_freq when set, otherwise portfolio_log_freq)
+            balance_freq = positions_log_freq or portfolio_log_freq
+            if balance_freq:
+                self.balance_logger = BalanceLogger(logs_writer, balance_freq)
         else:
             logger.warning("Log writer is not defined - strategy activity will not be saved !")
 
         self.logs_writer = logs_writer
         self.heartbeat_freq = convert_tf_str_td64(heartbeat_freq) if heartbeat_freq else None
+        self.positions_log_on_change = positions_log_on_change
 
     def initialize(
         self,
@@ -431,6 +443,10 @@ class StrategyLogging:
     def save_deals(self, instrument: Instrument, deals: list[Deal]):
         if self.executions_logger:
             self.executions_logger.record_deals(instrument, deals)
+        if self.positions_log_on_change and self.positions_dumper and deals:
+            latest_deal_time = max(d.time for d in deals)
+            ts = latest_deal_time.as_unit("ns").asm8 if isinstance(latest_deal_time, pd.Timestamp) else latest_deal_time
+            self.positions_dumper.dump_instrument(instrument, ts)
 
     def save_targets(self, targets: list[TargetPosition]):
         if self.signals_logger and targets:

{qubx-1.2.2.dev2 → qubx-1.2.3.dev1}/src/qubx/core/utils.pyx

@@ -8,6 +8,12 @@ NS = 1_000_000_000
 
 cpdef recognize_time(time):
     if isinstance(time, str):
+        # Strip timezone suffix (e.g. 'Z', '+00:00') — np.datetime64 expects tz-naive ISO strings.
+        # All incoming timestamps are assumed UTC.
+        if time.endswith('Z') or time.endswith('z'):
+            time = time[:-1]
+        elif '+' in time[10:]:
+            time = time[:time.rindex('+')]
         return np.datetime64(time, 'ns')
     elif isinstance(time, np.datetime64):
         return time

{qubx-1.2.2.dev2 → qubx-1.2.3.dev1}/src/qubx/utils/runner/configs.py

@@ -106,8 +106,9 @@ class WarmupConfig(StrictBaseModel):
 
 class LoggingConfig(StrictBaseModel):
     logger: str
-    position_interval: str
-    portfolio_interval: str
+    position_interval: str | None = None
+    portfolio_interval: str | None = None
+    position_log_on_change: bool = False
     args: dict = Field(default_factory=dict)
     heartbeat_interval: str | None = None
 

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

@@ -693,6 +693,7 @@ def _setup_strategy_logging(
         positions_log_freq=log_config.position_interval,
         portfolio_log_freq=log_config.portfolio_interval,
         heartbeat_freq=log_config.heartbeat_interval,
+        positions_log_on_change=log_config.position_log_on_change,
     )
     return stg_logging