Qubx 1.1.2.dev4__tar.gz → 1.1.2.dev5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.1.2.dev4
+Version: 1.1.2.dev5
 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.dev5}/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.dev5'
+__version_tuple__ = version_tuple = (1, 1, 2, 'dev5')
 
 __commit_id__ = commit_id = None

{qubx-1.1.2.dev4 → qubx-1.1.2.dev5}/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: