Fix metrics generation

Author: MDUYN

investing_algorithm_framework/__init__.py

@@ -48,7 +48,7 @@
     get_current_average_trade_gain, get_current_average_trade_duration, \
     get_current_average_trade_loss, get_negative_trades, \
     get_positive_trades, get_number_of_trades, get_current_win_rate, \
-    get_current_win_loss_ratio
+    get_current_win_loss_ratio, create_backtest_metrics_for_backtest
 
 
 __all__ = [
@@ -192,5 +192,6 @@
     "BacktestRun",
     "load_backtests_from_directory",
     "save_backtests_to_directory",
-    "DataError"
+    "DataError",
+    "create_backtest_metrics_for_backtest"
 ]

investing_algorithm_framework/domain/backtesting/combine_backtests.py

@@ -1,7 +1,11 @@
+import logging
 from typing import List
 
-from .backtest_summary_metrics import BacktestSummaryMetrics
+from .backtest import Backtest
 from .backtest_metrics import BacktestMetrics
+from .backtest_summary_metrics import BacktestSummaryMetrics
+
+logger = logging.getLogger("investing_algorithm_framework")
 
 
 def safe_weighted_mean(values, weights):
@@ -41,22 +45,26 @@ def combine_backtests(backtests):
     backtest_runs = []
 
     for backtest in backtests:
-        backtest_metric = None
-        backtest_run = backtest.backtest_runs[0] \
-            if len(backtest.backtest_runs) > 0 else None
-
-        if backtest_run is not None:
-            backtest_metric = backtest_run.backtest_metrics
-
-        if backtest_metric is not None:
-            backtest_metrics.append(backtest_metric)
-            backtest_runs.append(backtest_run)
+        backtest_runs += backtest.get_all_backtest_runs()
+        backtest_metrics += backtest.get_all_backtest_metrics()
 
     summary = generate_backtest_summary_metrics(backtest_metrics)
 
     metadata = None
     risk_free_rate = None
 
+    # Check if there are duplicate backtest runs
+    unique_date_ranges = set()
+    for backtest in backtests:
+        for run in backtest.get_all_backtest_runs():
+            date_range = (run.start_date, run.end_date)
+            if date_range in unique_date_ranges:
+                logger.warning(
+                    "Duplicate backtest run detected for date range: "
+                    f"{date_range} when combining backtests."
+                )
+            unique_date_ranges.add(date_range)
+
     # Get first non-empty metadata
     for backtest in backtests:
         if backtest.metadata:
@@ -69,8 +77,6 @@ def combine_backtests(backtests):
             risk_free_rate = backtest.risk_free_rate
             break
 
-    from .backtest import Backtest
-
     backtest = Backtest(
         backtest_summary=summary,
         metadata=metadata,

investing_algorithm_framework/services/__init__.py

@@ -37,7 +37,7 @@
     get_positive_trades, get_negative_trades, get_number_of_trades, \
     get_current_win_rate, get_current_average_trade_return, \
     get_current_average_trade_loss, get_current_average_trade_duration, \
-    get_current_average_trade_gain
+    get_current_average_trade_gain, create_backtest_metrics_for_backtest
 
 __all__ = [
     "OrderService",
@@ -128,4 +128,5 @@
     "get_current_average_trade_duration",
     "get_current_average_trade_gain",
     "get_current_average_trade_return",
+    "create_backtest_metrics_for_backtest"
 ]

investing_algorithm_framework/services/metrics/__init__.py

@@ -27,7 +27,8 @@
 from .win_rate import get_win_rate, get_win_loss_ratio, get_current_win_rate, \
     get_current_win_loss_ratio
 from .calmar_ratio import get_calmar_ratio
-from .generate import create_backtest_metrics
+from .generate import create_backtest_metrics, \
+    create_backtest_metrics_for_backtest
 from .risk_free_rate import get_risk_free_rate_us
 from .trades import get_negative_trades, get_positive_trades, \
     get_number_of_trades, get_number_of_closed_trades, \
@@ -109,4 +110,5 @@
     "get_current_average_trade_return",
     "get_number_of_open_trades",
     "get_average_trade_duration",
+    "create_backtest_metrics_for_backtest"
 ]

investing_algorithm_framework/services/metrics/generate.py

@@ -2,7 +2,7 @@
 from logging import getLogger
 
 from investing_algorithm_framework.domain import BacktestMetrics, \
-    BacktestRun, OperationalException
+    BacktestRun, OperationalException, Backtest, BacktestDateRange
 from .cagr import get_cagr
 from .calmar_ratio import get_calmar_ratio
 from .drawdown import get_drawdown_series, get_max_drawdown, \
@@ -35,6 +35,47 @@
 
 logger = getLogger("investing_algorithm_framework")
 
+def create_backtest_metrics_for_backtest(
+    backtest: Backtest,
+    risk_free_rate: float, metrics: List[str] = None,
+    backtest_date_range: BacktestDateRange = None
+) -> Backtest:
+
+    """
+    Create BacktestMetrics for a Backtest object.
+
+    Args:
+        backtest (Backtest): The Backtest object containing
+            backtest runs.
+        risk_free_rate (float): The risk-free rate used in certain
+            metric calculations.
+        metrics (List[str], optional): List of metric names to compute.
+            If None, a default set of metrics will be computed.
+        backtest_date_range (BacktestDateRange, optional): The date range
+            for the backtest. If None, all backtest metrics will be computed
+            for each backtest run.
+
+    Returns:
+        Backtest: The Backtest object with computed metrics for each run.
+    """
+    if backtest_date_range is not None:
+        backtest_runs = [
+            backtest.get_backtest_run(backtest_date_range)
+        ]
+    else:
+        backtest_runs = backtest.get_all_backtest_runs()
+
+    for backtest_run in backtest_runs:
+        # If a date range is provided, check if the backtest run falls
+        # within the range
+        backtest_metrics = create_backtest_metrics(
+            backtest_run, risk_free_rate, metrics
+        )
+        backtest_run.backtest_metrics = backtest_metrics
+
+    backtest.backtest_runs = backtest_runs
+    return backtest
+
 
 def create_backtest_metrics(
     backtest_run: BacktestRun, risk_free_rate: float, metrics: List[str] = None

investing_algorithm_framework/services/metrics/volatility.py

@@ -5,13 +5,18 @@
 annualizes it, giving an estimate of how much the portfolio's value
 fluctuates on a yearly basis.
 
-| **Annual Volatility** | **Risk Level** | **Typical for...**                                                     | **Comments**                                                                    |
-| --------------------- | -------------- | ---------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
-| **< 5%**              | Very Low Risk  | Cash equivalents, short-term bonds                                     | Low return expectations; often used for capital preservation                    |
-| **5% – 10%**          | Low Risk       | Diversified bond portfolios, conservative allocation strategies        | Suitable for risk-averse investors                                              |
-| **10% – 15%**         | Moderate Risk  | Balanced portfolios, large-cap equity indexes (e.g., S\&P 500 ≈ \~15%) | Standard for traditional diversified portfolios                                 |
-| **15% – 25%**         | High Risk      | Growth stocks, hedge funds, active equity strategies                   | Higher return potential, but more drawdowns                                     |
-| **> 25%**             | Very High Risk | Crypto, leveraged ETFs, speculative strategies                         | High potential returns, but prone to large losses; often not suitable long-term |
+| **Annual Volatility** | **Risk Level (Standalone)** | **Context Matters: Sharpe Ratio Impact** | **Comments** |
+| --------------------- | --------------------------- | ---------------------------------------- | ----------- |
+| **< 5%** | Very Low Risk | Sharpe > 2.0 = Excellent<br>Sharpe < 0.5 = Poor | Low volatility is great unless returns are negative |
+| **5% – 10%** | Low Risk | Sharpe > 1.0 = Good<br>Sharpe < 0.3 = Mediocre | Typical for conservative portfolios |
+| **10% – 15%** | Moderate Risk | Sharpe > 0.8 = Good<br>Sharpe < 0.2 = Risky | S&P 500 benchmark; quality matters |
+| **15% – 25%** | High Risk | Sharpe > 0.6 = Acceptable<br>Sharpe < 0.0 = Avoid | **Example: 30% CAGR + 23% vol = Sharpe ~1.3 = Excellent** |
+| **> 25%** | Very High Risk | Sharpe > 0.4 = Maybe acceptable<br>Sharpe < 0.0 = Dangerous | Only viable with strong positive returns |
+
+
+Key takeaway: Don't interpret volatility in isolation. Always calculate
+and compare the Sharpe Ratio to assess true strategy quality.
+Your 30% CAGR with 23% volatility is exceptional because the return far outweighs the risk taken.
 
 """
 
@@ -23,47 +28,70 @@
 from investing_algorithm_framework.domain import PortfolioSnapshot
 
 
-def get_annual_volatility(snapshots: List[PortfolioSnapshot]) -> float:
+def get_annual_volatility(
+    snapshots: List[PortfolioSnapshot],
+    trading_days_per_year=365
+) -> float:
     """
     Calculate the annualized volatility of portfolio net values.
 
+    !Important Note:
+
+    Volatility measures variability, not direction. For example:
+
+    A standard deviation of 0.238 (23.8%) means returns swing
+    wildly around their average, but it doesn't tell you if that average
+    is positive or negative.
+
+    Two scenarios with the same 23.8% volatility:
+        Mean return = +15% per year, Std = 23.8%
+        16% chance of losing >8.8% (15% - 23.8%)
+        16% chance of gaining >38.8% (15% + 23.8%)
+        This is excellent — high growth with swings
+
+        Mean return = -5% per year, Std = 23.8%
+        16% chance of losing >28.8% (-5% - 23.8%)
+        16% chance of gaining >18.8% (-5% + 23.8%)
+        This is terrible — losing money with high risk
+
+    To assess if "always good returns with high std" is perfect, you need
+    to consider risk-adjusted metrics like the Sharpe Ratio:
+    Sharpe Ratio = (Mean Return - Risk-Free Rate) / Volatility
+    Higher is better; tells you return per unit of risk taken
+
     Args:
         snapshots (List[PortfolioSnapshot]): List of portfolio snapshots
             from the backtest report.
+        trading_days_per_year (int): Number of trading days in a year.
 
     Returns:
         Float: Annualized volatility as a float
     """
 
     if len(snapshots) < 2:
-        return 0.0  # Not enough data to calculate volatility
+        return 0.0
 
     # Build DataFrame from snapshots
     records = [
         (snapshot.total_value, snapshot.created_at) for snapshot in snapshots
     ]
     df = pd.DataFrame(records, columns=['total_value', 'created_at'])
     df['created_at'] = pd.to_datetime(df['created_at'])
-    df = df.sort_values('created_at').drop_duplicates('created_at').copy()
+    df = df.set_index('created_at').sort_index().drop_duplicates()
 
-    # Calculate log returns
-    df['log_return'] = np.log(df['total_value'] / df['total_value'].shift(1))
-    df = df.dropna()
+    # Resample to daily frequency, taking the last value of each day
+    df_daily = df.resample('D').last()
+    df_daily = df_daily.dropna()
 
-    if df.empty:
+    if len(df_daily) < 2:
         return 0.0
 
-    daily_volatility = df['log_return'].std()
-
-    start_date = snapshots[0].created_at
-    end_date = snapshots[-1].created_at
-    # Estimate trading days per year based on snapshot frequency
-    total_days = (end_date - start_date).days
-    num_observations = len(df)
+    # Calculate log returns on daily data
+    df_daily['log_return'] = np.log(df_daily['total_value'] / df_daily['total_value'].shift(1))
+    df_daily = df_daily.dropna()
 
-    if total_days > 0:
-        trading_days_per_year = (num_observations / total_days) * 365
-    else:
-        trading_days_per_year = 365  # Default fallback
+    # Calculate daily volatility (standard deviation of daily returns)
+    daily_volatility = df_daily['log_return'].std()
 
+    # Annualize using trading days per year
     return daily_volatility * np.sqrt(trading_days_per_year)