TradingBot/metrics.py at main · RogueTex/TradingBot · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import pandas as pd
import numpy as np


def _annualization_factor(index: pd.DatetimeIndex) -> float:
    if len(index) < 2:
        return 252.0
    # seconds between first two points
    dt = (index[1] - index[0]).total_seconds()
    if dt <= 0:
        return 252.0
    # approximate bars per day assuming 6.5 trading hours
    bars_per_day = int((6.5 * 3600) / dt)
    return 252.0 * max(bars_per_day, 1)


def compute_performance_metrics(results: dict) -> dict:
    eq = results['equity'].copy()
    if eq.empty or 'equity' not in eq:
        return {
            'final_equity': 0.0,
            'sharpe_ratio': 0.0,
            'volatility': 0.0,
            'max_drawdown': 0.0,
            'calmar_ratio': 0.0,
            'num_trades': 0,
            'win_rate': 0.0,
            'avg_trade_pnl': 0.0
        }

    eq['returns'] = eq['equity'].pct_change().fillna(0.0)
    eq['returns'] = eq['returns'].replace([np.inf, -np.inf], 0.0)  # Handle inf values

    af = _annualization_factor(eq.index)
    mean_ret = eq['returns'].mean()
    std_ret = eq['returns'].std()

    # Handle NaN/inf in calculations
    if pd.isna(std_ret) or std_ret <= 0:
        ann_sharpe = 0.0
    else:
        ann_sharpe = (mean_ret / std_ret) * np.sqrt(af)

    if pd.isna(ann_sharpe) or not np.isfinite(ann_sharpe):
        ann_sharpe = 0.0

    cummax = eq['equity'].cummax()
    drawdown = (eq['equity'] - cummax) / (cummax.replace(0, 1))  # Avoid division by zero
    max_dd = float(drawdown.min()) if len(drawdown) and np.isfinite(drawdown.min()) else 0.0

    fills = results.get('fills', pd.DataFrame())
    num_trades = int(len(fills))

    if 'pnl' in fills and len(fills) > 0:
        win_rate = float((fills['pnl'] > 0).mean())
        avg_trade_pnl = float(fills['pnl'].mean())
    else:
        win_rate = 0.0
        avg_trade_pnl = 0.0

    # Calmar ratio (handle division by zero)
    calmar = 0.0
    if abs(max_dd) > 1e-10:  # Only calculate if meaningful drawdown
        calmar = (mean_ret * af) / abs(max_dd)
        if not np.isfinite(calmar):
            calmar = 0.0

    metrics = {
        'final_equity': float(eq['equity'].iloc[-1]),
        'sharpe_ratio': float(ann_sharpe),
        'volatility': float(std_ret * np.sqrt(af)) if std_ret > 0 else 0.0,
        'max_drawdown': max_dd,
        'calmar_ratio': float(calmar),
        'num_trades': num_trades,
        'win_rate': win_rate,
        'avg_trade_pnl': avg_trade_pnl,
    }
    return metrics