Qubx 1.2.2.dev1__tar.gz → 1.2.2.dev3__tar.gz

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

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

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

{qubx-1.2.2.dev1 → qubx-1.2.2.dev3}/src/qubx/cli/release.py

@@ -1432,12 +1432,14 @@ def _bundle_source_overrides(
                 continue
 
             checkout_dir = _find_uv_git_checkout(commit_sha)
+            cloned_locally = False
             if not checkout_dir:
                 # Cache miss — clone the repo at the exact commit
                 git_url = source["git"]
                 git_ref = source.get("tag") or source.get("branch") or commit_sha
                 logger.info(f"  {pkg_name}: cache miss, cloning {git_url} at {git_ref} ...")
                 checkout_dir = os.path.join(os.path.dirname(wheels_dir), f".git-clone-{pkg_norm}")
+                cloned_locally = True
                 try:
                     subprocess.run(
                         ["git", "clone", "--depth", "1", "--branch", git_ref, git_url, checkout_dir],
@@ -1473,6 +1475,9 @@ def _bundle_source_overrides(
                 logger.info(f"  Bundled {pkg_name}=={pkg_ver} from git")
             except subprocess.CalledProcessError as e:
                 logger.opt(colors=False).warning(f"  Failed to build wheel for {pkg_name}: {e.stderr or e}")
+            finally:
+                if cloned_locally and os.path.isdir(checkout_dir):
+                    shutil.rmtree(checkout_dir, ignore_errors=True)
 
     return bundled
 

{qubx-1.2.2.dev1 → qubx-1.2.2.dev3}/src/qubx/connectors/ccxt/account.py

@@ -222,7 +222,10 @@ class CcxtAccountProcessor(BasicAccountProcessor):
             except Exception as e:
                 logger.warning(f"Failed to fetch balance data before polling started: {e}")
 
-        # sum of balances + market value of all positions on non spot/margin
+        if self._exchange_total_capital is not None:
+            return self._exchange_total_capital
+
+        # fallback: sum of balances + market value of all positions on non spot/margin
         _currency_to_value = {c: self._get_currency_value(b.total, c) for c, b in self._balances.items()}
         _positions_value = sum([p.market_value_funds for p in self._positions.values() if p.instrument.is_futures()])
         return sum(_currency_to_value.values()) + _positions_value
@@ -316,9 +319,32 @@ class CcxtAccountProcessor(BasicAccountProcessor):
             await self._subscribe_instruments(list(self._required_instruments))
             self._latest_instruments.update(self._required_instruments)
 
+    def _extract_portfolio_value(self, balances_raw: dict) -> float | None:
+        """Extract exchange-reported portfolio value (equity) from raw balance response.
+
+        Override in exchange-specific processors for non-standard responses.
+        Base implementation handles Binance futures (totalMarginBalance).
+
+        Returns:
+            Total equity as float, or None to fall back to computed value.
+        """
+        info = balances_raw.get("info", {})
+        val = info.get("totalMarginBalance")
+        if val is not None:
+            try:
+                return float(val)
+            except (ValueError, TypeError):
+                pass
+        return None
+
     async def _update_balance(self) -> None:
         """Fetch and update balances from exchange"""
         balances_raw = await self.exchange_manager.exchange.fetch_balance()
+
+        equity = self._extract_portfolio_value(balances_raw)
+        if equity is not None:
+            self._exchange_total_capital = equity
+
         balances = ccxt_convert_balance(balances_raw, self.exchange)
         current_balances = self.get_balances()
 

{qubx-1.2.2.dev1 → qubx-1.2.2.dev3}/src/qubx/connectors/ccxt/exchanges/hyperliquid/account.py

@@ -23,6 +23,19 @@ class HyperliquidAccountProcessor(CcxtAccountProcessor):
     so we must subscribe to both channels separately.
     """
 
+    def _extract_portfolio_value(self, balances_raw: dict) -> float | None:
+        """Extract Hyperliquid account value from raw balance response."""
+        info = balances_raw.get("info", {})
+        for key in ("marginSummary", "crossMarginSummary"):
+            summary = info.get(key, {})
+            val = summary.get("accountValue")
+            if val is not None:
+                try:
+                    return float(val)
+                except (ValueError, TypeError):
+                    pass
+        return None
+
     async def _subscribe_instruments(self, instruments: list[Instrument]):
         """Override to filter out instruments from other exchanges (e.g., spot vs futures)."""
         # Filter instruments to only those belonging to this exchange

{qubx-1.2.2.dev1 → qubx-1.2.2.dev3}/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,15 +84,54 @@ 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 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):
+                pass
+        return None
+
     async def _update_balance(self) -> None:
-        """OKX balance override: use cashBal instead of eq (equity) to avoid double-counting unrealized PnL.
+        """OKX balance override: use cashBal for per-currency balances.
 
         CCXT maps OKX's `eq` (equity = cashBal + unrealizedPnL) to balance `total`.
-        Since get_total_capital() adds position market values (= unrealized PnL) on top,
-        using `eq` would double-count unrealized PnL. We use `cashBal` instead.
+        We use `cashBal` for individual currency balances, and extract `totalEq`
+        as the authoritative portfolio value via _extract_portfolio_value().
         """
         balances_raw = await self.exchange_manager.exchange.fetch_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
+
         # 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.dev1 → qubx-1.2.2.dev3}/src/qubx/core/account.py

@@ -65,6 +65,8 @@ class BasicAccountProcessor(IAccountProcessor):
         self._locked_capital_by_order = dict()
         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
@@ -90,7 +92,9 @@ class BasicAccountProcessor(IAccountProcessor):
         return self.get_available_margin(exchange)
 
     def get_total_capital(self, exchange: str | None = None) -> float:
-        # sum of cash + market value of all positions
+        if self._exchange_total_capital is not None:
+            return self._exchange_total_capital
+        # fallback: sum of cash + market value of all positions
         _cash_amount = self._balances[self.base_currency].total
         _positions_value = sum([p.market_value_funds for p in self._positions.values()])
         return _cash_amount + _positions_value
@@ -180,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.dev1 → qubx-1.2.2.dev3}/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