Qubx 1.1.2.dev4__tar.gz → 1.1.2.dev6__tar.gz

{qubx-1.1.2.dev4 → qubx-1.1.2.dev6}/PKG-INFO

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

{qubx-1.1.2.dev4 → qubx-1.1.2.dev6}/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.2.dev4'
-__version_tuple__ = version_tuple = (1, 1, 2, 'dev4')
+__version__ = version = '1.1.2.dev6'
+__version_tuple__ = version_tuple = (1, 1, 2, 'dev6')
 
 __commit_id__ = commit_id = None

{qubx-1.1.2.dev4 → qubx-1.1.2.dev6}/src/qubx/core/metrics.py

@@ -913,11 +913,34 @@ class TradingSessionResult:
             return pd.Series(dtype=float)
         return calculate_leverage(self.portfolio_log, self.get_total_capital(), self.start)
 
+    @property
+    def gross_leverage(self) -> pd.Series:
+        """Get gross leverage over time (sum of absolute exposures / capital)"""
+        if self.portfolio_log.empty:
+            return pd.Series(dtype=float)
+        return calculate_gross_leverage(self.portfolio_log, self.get_total_capital(), self.start)
+
     def get_funding_per_symbol(self, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.DataFrame:
         if self.portfolio_log.empty:
             return pd.DataFrame(dtype=float)
         return calculate_funding_per_symbol(self.portfolio_log, start, stop)
 
+    def get_commissions_per_asset(
+        self, start: OptTimestamp = None, stop: OptTimestamp = None, filter_zero: bool = True
+    ) -> pd.DataFrame:
+        if self.portfolio_log.empty:
+            return pd.DataFrame(dtype=float)
+        return calculate_commissions_per_asset(self.portfolio_log, start, stop, filter_zero)
+
+    def get_commissions_total(self, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.Series:
+        return self.get_commissions_per_asset(start, stop).sum(axis=1).rename("commissions_total")
+
+    def get_commissions_breakdown(self, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.Series:
+        df = self.get_commissions_per_asset(start, stop)
+        if df.empty:
+            return pd.Series(dtype=float)
+        return df.iloc[-1].sort_values(ascending=False).rename("commissions_breakdown")
+
     def get_funding_per_asset(
         self, start: OptTimestamp = None, stop: OptTimestamp = None, filter_zero: bool = True
     ) -> pd.DataFrame:
@@ -928,8 +951,8 @@ class TradingSessionResult:
     def get_funding_total(self, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.Series:
         return self.get_funding_per_asset(start, stop).sum(axis=1).rename("funding_total")
 
-    def get_funding_pnl(self, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.Series:
-        return self.get_funding_per_asset(start, stop).iloc[-1].sort_values(ascending=False).rename("funding_pnl")
+    def get_funding_breakdown(self, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.Series:
+        return self.get_funding_per_asset(start, stop).iloc[-1].sort_values(ascending=False).rename("funding_breakdown")
 
     def get_asset_pnl(
         self,
@@ -951,7 +974,7 @@ class TradingSessionResult:
                 funding_delta = funding.diff().fillna(funding.iloc[0])
                 pnl -= funding_delta.cumsum()
         if commission_factor:
-            comm = portfolio.filter(regex=f".*{asset}.*_Commissions").loc[start:stop].sum(axis=1).cumsum()
+            comm = portfolio.filter(regex=f".*:{asset}USD.*_Commissions").loc[start:stop].sum(axis=1).cumsum()
             pnl -= comm * commission_factor
         return pnl / init_capital * 100 if pct_from_initial_capital else pnl
 
@@ -959,10 +982,11 @@ class TradingSessionResult:
         self,
         start: OptTimestamp = None,
         stop: OptTimestamp = None,
+        commission_factor: float = 1.0,
         pct_from_initial_capital: bool = False,
         drop_zero: bool = True,
         include_funding: bool = False,
-    ) -> pd.Series:
+    ) -> pd.DataFrame:
         start = start or self.start
         stop = stop or self.stop
         assets = set()
@@ -976,13 +1000,60 @@ class TradingSessionResult:
                 assets.add(instrument.asset)
         asset_to_pnl = {}
         for asset in assets:
-            pnl = self.get_asset_pnl(asset, start, stop, pct_from_initial_capital=pct_from_initial_capital, include_funding=include_funding)
+            pnl = self.get_asset_pnl(
+                asset,
+                start,
+                stop,
+                commission_factor=commission_factor,
+                pct_from_initial_capital=pct_from_initial_capital,
+                include_funding=include_funding,
+            )
             if pnl is not None and not pnl.empty:
-                last_pnl = pnl.iloc[-1]
-                if drop_zero and last_pnl == 0:
+                if drop_zero and pnl.iloc[-1] == 0:
                     continue
-                asset_to_pnl[asset] = last_pnl
-        return pd.Series(asset_to_pnl).sort_values(ascending=False)
+                asset_to_pnl[asset] = pnl
+        if not asset_to_pnl:
+            return pd.DataFrame(dtype=float)
+        return pd.DataFrame(asset_to_pnl)
+
+    def get_pnl_total(
+        self,
+        start: OptTimestamp = None,
+        stop: OptTimestamp = None,
+        commission_factor: float = 1.0,
+        pct_from_initial_capital: bool = False,
+        include_funding: bool = False,
+    ) -> pd.Series:
+        return (
+            self.get_pnl_per_asset(
+                start,
+                stop,
+                commission_factor=commission_factor,
+                pct_from_initial_capital=pct_from_initial_capital,
+                include_funding=include_funding,
+            )
+            .sum(axis=1)
+            .rename("pnl_total")
+        )
+
+    def get_pnl_breakdown(
+        self,
+        start: OptTimestamp = None,
+        stop: OptTimestamp = None,
+        pct_from_initial_capital: bool = False,
+        drop_zero: bool = True,
+        include_funding: bool = False,
+    ) -> pd.Series:
+        df = self.get_pnl_per_asset(
+            start,
+            stop,
+            pct_from_initial_capital=pct_from_initial_capital,
+            drop_zero=drop_zero,
+            include_funding=include_funding,
+        )
+        if df.empty:
+            return pd.Series(dtype=float)
+        return df.iloc[-1].sort_values(ascending=False).rename("pnl_breakdown")
 
     def get_position_asset(self, asset: str, start: OptTimestamp = None, stop: OptTimestamp = None) -> pd.DataFrame:
         pos = self.portfolio_log.filter(regex=f".*{asset}.*_Pos")
@@ -2062,6 +2133,14 @@ def calculate_leverage(
     return (value.squeeze() / capital).mul(100).rename("Leverage")  # type: ignore
 
 
+def calculate_gross_leverage(portfolio: pd.DataFrame, init_capital: float, start: str | pd.Timestamp) -> pd.Series:
+    total_pnl = calculate_total_pnl(portfolio, split_cumulative=False).loc[start:]
+    capital = init_capital + total_pnl["Total_PnL"].cumsum() - total_pnl["Total_Commissions"].cumsum()
+    value_columns = [col for col in portfolio.columns if "_Value" in col]
+    abs_value = portfolio[value_columns].loc[start:].abs().sum(axis=1)
+    return (abs_value / capital).mul(100).rename("Gross Leverage")
+
+
 def calculate_leverage_per_symbol(
     session: TradingSessionResult,
     start: str | pd.Timestamp | None = None,
@@ -2173,6 +2252,39 @@ def _slice_df(df: pd.DataFrame, start: OptTimestamp = None, stop: OptTimestamp =
     return df
 
 
+def calculate_commissions_per_symbol(
+    portfolio_log: pd.DataFrame, start: OptTimestamp = None, stop: OptTimestamp = None
+) -> pd.DataFrame:
+    """Calculate cumulative commissions for each symbol in the trading session."""
+    return _slice_df(portfolio_log.filter(like="_Commissions"), start, stop).cumsum()
+
+
+def calculate_commissions_per_asset(
+    portfolio_log: pd.DataFrame,
+    start: OptTimestamp = None,
+    stop: OptTimestamp = None,
+    filter_zero: bool = True,
+) -> pd.DataFrame:
+    """
+    Calculate cumulative commissions for each asset in the trading session.
+    """
+    df = calculate_commissions_per_symbol(portfolio_log, start, stop)
+    df = df.rename(columns=lambda x: x.replace("_Commissions", ""))
+
+    # Map each column (EXCHANGE:SYMBOL) to its asset name
+    col_to_asset: dict[str, str] = {}
+    for col in df.columns:
+        exchange, symbol = col.split(":")
+        instr = lookup.find_symbol(exchange, symbol)
+        col_to_asset[col] = instr.asset if instr else col
+
+    # Group by asset and sum
+    df = df.rename(columns=col_to_asset).T.groupby(level=0).sum().T
+    if filter_zero:
+        df = df.loc[:, df.ne(0).any(axis=0)]
+    return df
+
+
 def calculate_funding_per_symbol(
     portfolio_log: pd.DataFrame, start: OptTimestamp = None, stop: OptTimestamp = None
 ) -> pd.DataFrame:

{qubx-1.1.2.dev4 → qubx-1.1.2.dev6}/src/qubx/data/storages/multi.py

@@ -143,7 +143,9 @@ class MultiReader(IReader):
                         dtype_ref = result.dtype
                     batches.append(result.data)
             except Exception as e:
-                logger.warning(f"{reader.__class__.__name__}.read() failed for '{data_id}': {e}")
+                # - expected when one storage doesn't carry this dtype (e.g. QuestDB has no
+                #   vendor microstructure tables); the next reader will be tried
+                logger.debug(f"{reader.__class__.__name__} has no '{data_id}' ({dtype}): {e}")
 
         return batches, time_idx, schema, dtype_ref
 
@@ -180,9 +182,14 @@ class MultiReader(IReader):
                             time_idx = raw.index
                             dtype_ref = raw.dtype
             except Exception as e:
-                logger.warning(f"{reader.__class__.__name__}.read() failed for multi data_ids: {e}")
+                # - expected when one storage doesn't carry this dtype; the next reader will be tried
+                logger.debug(f"{reader.__class__.__name__} has no ({dtype}) for multi data_ids: {e}")
 
         if not batches_per_id:
+            # - all readers exhausted with no data — only now it's worth a warning
+            logger.warning(
+                f"No data for ({dtype}) in any of {len(self._readers)} reader(s): {[r.__class__.__name__ for r in self._readers]}"
+            )
             return RawMultiData([])
 
         merged_raws = [
@@ -239,7 +246,9 @@ class MultiReader(IReader):
                     if ts_name is None:
                         ts_name = f.name
                         ts_unit = f.type.unit
-                    elif f.name == ts_name and _precision_rank.get(f.type.unit, 0) > _precision_rank.get(ts_unit or "s", 0):
+                    elif f.name == ts_name and _precision_rank.get(f.type.unit, 0) > _precision_rank.get(
+                        ts_unit or "s", 0
+                    ):
                         ts_unit = f.type.unit
         # - fallback: if no timestamp column found, default to "ms"
         ts_unit = ts_unit or "ms"
@@ -407,11 +416,14 @@ class MultiStorage(IStorage):
 
     def __init__(
         self,
-        storages: list[IStorage],
+        storages: list[str | IStorage],
         tolerance: str | None = None,
         keep: str = "last",
     ):
-        self._storages = storages
+        from qubx.data.registry import StorageRegistry
+
+        # - resolve string URIs (e.g. "qdb::quantlab") to IStorage instances
+        self._storages = [StorageRegistry.get(s) if isinstance(s, str) else s for s in storages]
         self._tolerance = tolerance
         self._keep = keep
         self._reader_cache: dict[tuple[str, str], IReader] = {}