Spaces:
Running
Running
Download pmct/metrics.py from sharpflowapp/web: direct link, hf CLI and curl.
- Browser
- Download file 5.72 kB
-
https://huggingface.co/spaces/sharpflowapp/web/resolve/main/pmct/metrics.py
- Command line
-
hf download hf://spaces/sharpflowapp/web/pmct/metrics.py
-
curl -L -o metrics.py https://huggingface.co/spaces/sharpflowapp/web/resolve/main/pmct/metrics.py
5.72 kB
| """Per-wallet performance metrics computed from the normalized ledger. | |
| Everything here is derived from two inputs: | |
| - ledger : normalized activity (see ledger.normalize_activity) | |
| - open_df : marked-to-market open positions (see ledger.attach_open_positions) | |
| Key definitions: | |
| total_pnl = realized cashflow over closed markets + MTM value of open ones | |
| roi = total_pnl / capital_deployed (sum of buy cost basis) | |
| win_rate = share of *resolved* markets that ended net-positive | |
| equity_curve= cumulative realized cashflow over time (+ running deposits view) | |
| max_dd = worst peak-to-trough drawdown of the equity curve | |
| consistency = fraction of active months that were net green | |
| """ | |
| from __future__ import annotations | |
| from dataclasses import dataclass, asdict | |
| import numpy as np | |
| import pandas as pd | |
| from .ledger import REBATE_TYPES | |
| class WalletStats: | |
| wallet: str | |
| total_pnl: float | |
| realized_pnl: float | |
| open_pnl: float | |
| capital_deployed: float | |
| roi: float | |
| win_rate: float | |
| n_trades: int | |
| n_markets: int | |
| n_resolved_markets: int | |
| active_days: int | |
| first_ts: str | |
| last_ts: str | |
| max_drawdown_pct: float | |
| monthly_profit_ratio: float | |
| avg_trade_usdc: float | |
| median_entry_price: float | |
| rebate_pnl: float # income from liquidity rewards + maker/taker rebates | |
| rebate_share: float # rebate_pnl / total_pnl -> high = market maker (uncopyable) | |
| def to_dict(self) -> dict: | |
| return asdict(self) | |
| def _resolved_market_pnl(ledger: pd.DataFrame) -> pd.Series: | |
| """Net cashflow per market. A market is 'resolved' for our purposes when the | |
| trader has fully exited it (net share flow ~0) or redeemed it. We approximate | |
| resolution by net share balance: BUY adds shares, SELL/REDEEM remove them.""" | |
| if ledger.empty: | |
| return pd.Series(dtype=float) | |
| signed_size = np.where(ledger["side"].eq("BUY"), ledger["size"], -ledger["size"]) | |
| tmp = ledger.assign(signed_size=signed_size) | |
| pnl = tmp.groupby("market")["cashflow"].sum() | |
| net_shares = tmp.groupby("market")["signed_size"].sum().abs() | |
| # treat markets with a near-zero residual share balance as resolved/closed | |
| resolved = net_shares < 1e-6 | |
| pnl.attrs["resolved_mask"] = resolved | |
| return pnl | |
| def _empty(wallet: str) -> WalletStats: | |
| return WalletStats( | |
| wallet=wallet, total_pnl=0.0, realized_pnl=0.0, open_pnl=0.0, | |
| capital_deployed=0.0, roi=0.0, win_rate=0.0, n_trades=0, n_markets=0, | |
| n_resolved_markets=0, active_days=0, first_ts="", last_ts="", | |
| max_drawdown_pct=0.0, monthly_profit_ratio=0.0, avg_trade_usdc=0.0, | |
| median_entry_price=0.0, rebate_pnl=0.0, rebate_share=0.0, | |
| ) | |
| def compute(wallet: str, ledger: pd.DataFrame, open_df: pd.DataFrame) -> WalletStats: | |
| if ledger.empty: | |
| return _empty(wallet) | |
| market_pnl = _resolved_market_pnl(ledger) | |
| resolved_mask = market_pnl.attrs.get("resolved_mask", pd.Series(dtype=bool)) | |
| realized_pnl = float(market_pnl.sum()) | |
| open_pnl = float(open_df["cashPnl"].sum()) if not open_df.empty else 0.0 | |
| total_pnl = realized_pnl + open_pnl | |
| buys = ledger.loc[ledger["side"].eq("BUY"), "usdc"] | |
| capital_deployed = float(buys.sum()) | |
| roi = total_pnl / capital_deployed if capital_deployed > 0 else 0.0 | |
| resolved_pnl = market_pnl[resolved_mask] if len(resolved_mask) else market_pnl | |
| n_resolved = int(len(resolved_pnl)) | |
| win_rate = float((resolved_pnl > 0).mean()) if n_resolved else 0.0 | |
| first_ts, last_ts = ledger["ts"].iloc[0], ledger["ts"].iloc[-1] | |
| active_days = int((last_ts - first_ts).days) | |
| # equity curve = cumulative realized cashflow through time | |
| eq = ledger.sort_values("ts")["cashflow"].cumsum() | |
| max_dd = _max_drawdown_pct(eq.values, capital_deployed) | |
| # monthly consistency | |
| monthly = (ledger.set_index("ts")["cashflow"] | |
| .resample("ME").sum()) | |
| monthly_profit_ratio = float((monthly > 0).mean()) if len(monthly) else 0.0 | |
| trade_rows = ledger[ledger["side"].isin(["BUY", "SELL"])] | |
| avg_trade_usdc = float(trade_rows["usdc"].mean()) if not trade_rows.empty else 0.0 | |
| median_entry = float(ledger.loc[ledger["side"].eq("BUY"), "price"].median() or 0.0) | |
| # copyability: how much of the profit is protocol incentives (market-making) | |
| rebate_pnl = float(ledger.loc[ledger["type"].isin(REBATE_TYPES), "usdc"].sum()) | |
| rebate_share = rebate_pnl / total_pnl if total_pnl > 0 else (1.0 if rebate_pnl > 0 else 0.0) | |
| return WalletStats( | |
| wallet=wallet, | |
| total_pnl=round(total_pnl, 2), | |
| realized_pnl=round(realized_pnl, 2), | |
| open_pnl=round(open_pnl, 2), | |
| capital_deployed=round(capital_deployed, 2), | |
| roi=round(roi, 4), | |
| win_rate=round(win_rate, 4), | |
| n_trades=int(len(trade_rows)), | |
| n_markets=int(ledger["market"].nunique()), | |
| n_resolved_markets=n_resolved, | |
| active_days=active_days, | |
| first_ts=str(first_ts), | |
| last_ts=str(last_ts), | |
| max_drawdown_pct=round(max_dd, 4), | |
| monthly_profit_ratio=round(monthly_profit_ratio, 4), | |
| avg_trade_usdc=round(avg_trade_usdc, 2), | |
| median_entry_price=round(median_entry, 4), | |
| rebate_pnl=round(rebate_pnl, 2), | |
| rebate_share=round(min(max(rebate_share, 0.0), 1.0), 4), | |
| ) | |
| def _max_drawdown_pct(equity: np.ndarray, denom: float) -> float: | |
| """Max peak-to-trough drop, normalized by capital deployed so it reads as a | |
| fraction. Returns 0..1 (higher = worse).""" | |
| if len(equity) == 0 or denom <= 0: | |
| return 0.0 | |
| running_max = np.maximum.accumulate(equity) | |
| drawdown = running_max - equity | |
| return float(drawdown.max() / denom) | |