feat: add consistency and stability metrics

- Add 8 new fields to BacktestSummaryMetrics (return/win_rate/sharpe consistency + stability, composite scores)
- CV-based consistency: 1 - CV where CV = std/|mean|, scale-invariant
- Normalized-std stability: 1 - std/max_std with domain-specific max values
- Add consistency_score and stability_score weights to all 4 BacktestEvaluationFocus presets

Author: MDUYN

investing_algorithm_framework/domain/backtesting/backtest_evaluation_focuss.py

@@ -153,6 +153,10 @@ def get_weights(self):
                 # Efficiency metrics
                 "exposure_ratio": 0.5,
                 "trades_per_year": 0.3,
+
+                # Cross-window consistency
+                "consistency_score": 1.5,
+                "stability_score": 1.5,
             }
 
         elif self == BacktestEvaluationFocus.PROFIT:
@@ -179,6 +183,10 @@ def get_weights(self):
                 # Monthly/yearly consistency
                 "percentage_winning_months": 0.8,
                 "average_monthly_return": 1.0,
+
+                # Cross-window consistency
+                "consistency_score": 1.0,
+                "stability_score": 1.0,
             }
 
         elif self == BacktestEvaluationFocus.FREQUENCY:
@@ -204,6 +212,10 @@ def get_weights(self):
 
                 # Duration efficiency
                 "average_trade_duration": -0.3,  # Prefer shorter trades
+
+                # Cross-window consistency
+                "consistency_score": 1.0,
+                "stability_score": 1.0,
             }
 
         elif self == BacktestEvaluationFocus.RISK_ADJUSTED:
@@ -234,6 +246,10 @@ def get_weights(self):
                 # Downside protection
                 "average_trade_loss_percentage": -1.0,
                 "percentage_negative_trades": -1.0,
+
+                # Cross-window consistency (critical for risk-adjusted)
+                "consistency_score": 2.5,
+                "stability_score": 2.5,
             }
 
         # Fallback to balanced if unknown focus

investing_algorithm_framework/domain/backtesting/backtest_summary_metrics.py

@@ -107,6 +107,14 @@ class BacktestSummaryMetrics:
     average_loss_duration: float = None
     max_consecutive_wins: int = None
     max_consecutive_losses: int = None
+    return_consistency: float = None
+    win_rate_consistency: float = None
+    sharpe_consistency: float = None
+    consistency_score: float = None
+    return_stability: float = None
+    win_rate_stability: float = None
+    sharpe_stability: float = None
+    stability_score: float = None
 
     def to_dict(self) -> dict:
         """
@@ -164,6 +172,14 @@ def to_dict(self) -> dict:
             "cvar_95": self.cvar_95,
             "max_consecutive_wins": self.max_consecutive_wins,
             "max_consecutive_losses": self.max_consecutive_losses,
+            "return_consistency": self.return_consistency,
+            "win_rate_consistency": self.win_rate_consistency,
+            "sharpe_consistency": self.sharpe_consistency,
+            "consistency_score": self.consistency_score,
+            "return_stability": self.return_stability,
+            "win_rate_stability": self.win_rate_stability,
+            "sharpe_stability": self.sharpe_stability,
+            "stability_score": self.stability_score,
         }
 
     def save(self, file_path: str | Path) -> None:

investing_algorithm_framework/domain/backtesting/combine_backtests.py

@@ -1,4 +1,5 @@
 import logging
+import math
 from typing import List
 
 from .backtest_metrics import BacktestMetrics
@@ -439,6 +440,117 @@ def generate_backtest_summary_metrics(
         consecutive_losses
     ) if consecutive_losses else None
 
+    # === CONSISTENCY METRICS ===
+    # Two complementary approaches to measure cross-window stability.
+    #
+    # 1) CV-based consistency: 1 - CV  (CV = std / |mean|), capped [0, 1].
+    #    Standard statistical measure; scale-invariant.
+    #    Drawback: undefined when mean ≈ 0.
+    #
+    # 2) Normalized-std stability: 1 - std/max_std, capped [0, 1].
+    #    Uses a domain-specific max_std for normalization.
+    #    More intuitive for bounded metrics (win rate 0-100,
+    #    Sharpe typically -2 to +4).
+
+    return_consistency = None
+    win_rate_consistency = None
+    sharpe_consistency = None
+    consistency_score = None
+    return_stability = None
+    win_rate_stability = None
+    sharpe_stability = None
+    stability_score = None
+
+    def _cv_consistency(values):
+        """1 - CV capped to [0, 1], or None if insufficient data."""
+        if len(values) < 2:
+            return None
+        mean = sum(values) / len(values)
+        if abs(mean) < 1e-9:
+            return 0.0  # mean ≈ 0 → unstable
+        var = sum((x - mean) ** 2 for x in values) / (len(values) - 1)
+        cv = math.sqrt(var) / abs(mean)
+        return max(0.0, min(1.0, 1.0 - cv))
+
+    def _norm_stability(values, max_std):
+        """1 - std/max_std capped to [0, 1], or None if insufficient."""
+        if len(values) < 2:
+            return None
+        mean = sum(values) / len(values)
+        var = sum((x - mean) ** 2 for x in values) / (len(values) - 1)
+        std = math.sqrt(var)
+        return max(0.0, min(1.0, 1.0 - std / max_std))
+
+    if len(valid_metrics) >= 2:
+        # --- Per-window returns ---
+        per_window_returns = [
+            b.total_net_gain_percentage for b in valid_metrics
+            if b.total_net_gain_percentage is not None
+        ]
+        return_consistency = _cv_consistency(per_window_returns)
+        # max_std = 100: a std of 100% of initial capital → score 0
+        return_stability = _norm_stability(per_window_returns, 100.0)
+
+        # --- Per-window win rates ---
+        per_window_win_rates = [
+            b.win_rate for b in valid_metrics
+            if b.win_rate is not None
+            and b.number_of_trades_closed is not None
+            and b.number_of_trades_closed > 0
+        ]
+        return_consistency = _cv_consistency(per_window_returns)
+        win_rate_consistency = _cv_consistency(per_window_win_rates)
+        # max_std = 50: theoretical max std for a [0, 100] range
+        win_rate_stability = _norm_stability(per_window_win_rates, 50.0)
+
+        # --- Per-window Sharpe ratios ---
+        per_window_sharpe = [
+            b.sharpe_ratio for b in valid_metrics
+            if b.sharpe_ratio is not None
+            and not math.isnan(b.sharpe_ratio)
+            and not math.isinf(b.sharpe_ratio)
+        ]
+        sharpe_consistency = _cv_consistency(per_window_sharpe)
+        # max_std = 2: Sharpe ratios typically range -2 to +4;
+        # a std of 2 means wildly inconsistent
+        sharpe_stability = _norm_stability(per_window_sharpe, 2.0)
+
+        # --- Composite scores ---
+        # Both use the same weighting scheme:
+        # 35% returns, 25% win rate, 20% Sharpe, 20% profitable
+        # window ratio.
+        def _composite(ret_c, wr_c, sh_c):
+            components = []
+            weights_c = []
+            if ret_c is not None:
+                components.append(ret_c)
+                weights_c.append(0.35)
+            if wr_c is not None:
+                components.append(wr_c)
+                weights_c.append(0.25)
+            if sh_c is not None:
+                components.append(sh_c)
+                weights_c.append(0.20)
+            if number_of_windows and number_of_windows > 0:
+                pw_ratio = (
+                    number_of_profitable_windows / number_of_windows
+                )
+                components.append(pw_ratio)
+                weights_c.append(0.20)
+            if not components:
+                return None
+            total_w = sum(weights_c)
+            return sum(
+                c * w for c, w in zip(components, weights_c)
+            ) / total_w
+
+        consistency_score = _composite(
+            return_consistency, win_rate_consistency, sharpe_consistency
+        )
+        stability_score = _composite(
+            return_stability, win_rate_stability, sharpe_stability
+        )
+
     return BacktestSummaryMetrics(
         total_net_gain=total_net_gain,
         total_net_gain_percentage=total_net_gain_percentage,
@@ -487,4 +599,12 @@ def generate_backtest_summary_metrics(
         average_loss_duration=average_loss_duration,
         max_consecutive_wins=max_consecutive_wins,
         max_consecutive_losses=max_consecutive_losses,
+        return_consistency=return_consistency,
+        win_rate_consistency=win_rate_consistency,
+        sharpe_consistency=sharpe_consistency,
+        consistency_score=consistency_score,
+        return_stability=return_stability,
+        win_rate_stability=win_rate_stability,
+        sharpe_stability=sharpe_stability,
+        stability_score=stability_score,
     )