investing-algorithm-framework 6.9.1__py3-none-any.whl → 7.19.15__py3-none-any.whl

investing_algorithm_framework/{app/reporting → services}/metrics/__init__.py

@@ -3,10 +3,9 @@ from .sortino_ratio import get_sortino_ratio
 from .drawdown import get_drawdown_series, get_max_drawdown
 from .equity_curve import get_equity_curve
 from .price_efficiency import get_price_efficiency_ratio
-from .sharp_ratio import get_sharpe_ratio
 from .profit_factor import get_profit_factor, \
     get_cumulative_profit_factor_series, get_rolling_profit_factor_series
-from .sharp_ratio import get_sharpe_ratio, get_rolling_sharpe_ratio
+from .sharpe_ratio import get_sharpe_ratio, get_rolling_sharpe_ratio
 from .price_efficiency import get_price_efficiency_ratio
 from .equity_curve import get_equity_curve
 from .drawdown import get_drawdown_series, get_max_drawdown, \
@@ -16,17 +15,29 @@ from .cagr import get_cagr
 from .standard_deviation import get_standard_deviation_downside_returns, \
     get_standard_deviation_returns
 from .returns import get_yearly_returns, get_monthly_returns, \
-    get_best_year, get_best_month, get_worst_month, get_best_trade, \
-    get_worst_trade, get_total_return, get_average_yearly_return, \
-    get_average_gain, get_average_loss, get_average_monthly_return, \
+    get_best_year, get_best_month, get_worst_month, get_total_return, \
+    get_average_yearly_return, get_average_monthly_return, \
     get_percentage_winning_months, get_average_monthly_return_losing_months, \
-    get_average_monthly_return_winning_months, get_best_trade_date, \
-    get_worst_trade_date, get_percentage_winning_years, \
-    get_worst_year
-from .exposure import get_exposure, get_average_trade_duration, \
-    get_trade_frequency, get_trades_per_day, get_trades_per_year
-from .win_rate import get_win_rate, get_win_loss_ratio
+    get_average_monthly_return_winning_months, get_total_growth, \
+    get_percentage_winning_years, get_worst_year, get_cumulative_return, \
+    get_total_loss, get_cumulative_return_series
+from .exposure import get_average_trade_duration, \
+    get_trade_frequency, get_trades_per_day, get_trades_per_year, \
+    get_cumulative_exposure, get_exposure_ratio
+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, \
+    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, \
+    get_average_trade_size, get_average_trade_return, get_best_trade, \
+    get_worst_trade, get_average_trade_gain, get_median_trade_return, \
+    get_average_trade_loss, get_current_average_trade_loss, \
+    get_current_average_trade_duration, get_current_average_trade_gain, \
+    get_current_average_trade_return, get_number_of_open_trades, \
+    get_average_trade_duration
 
 __all__ = [
     "get_annual_volatility",
@@ -45,8 +56,10 @@ __all__ = [
     "get_standard_deviation_downside_returns",
     "get_max_drawdown_absolute",
     "get_total_return",
-    "get_exposure",
-    "get_average_trade_duration",
+    "get_total_loss",
+    "get_total_growth",
+    "get_cumulative_exposure",
+    "get_exposure_ratio",
     "get_win_rate",
     "get_win_loss_ratio",
     "get_calmar_ratio",
@@ -60,8 +73,6 @@ __all__ = [
     "get_best_trade",
     "get_worst_trade",
     "get_average_yearly_return",
-    "get_average_gain",
-    "get_average_loss",
     "get_average_monthly_return",
     "get_percentage_winning_months",
     "get_average_trade_duration",
@@ -76,8 +87,28 @@ __all__ = [
     "get_trades_per_year",
     "get_average_monthly_return_losing_months",
     "get_average_monthly_return_winning_months",
-    "get_best_trade_date",
-    "get_worst_trade_date",
     "get_percentage_winning_years",
     "get_rolling_sharpe_ratio",
+    "create_backtest_metrics",
+    "get_risk_free_rate_us",
+    "get_median_trade_return",
+    "get_average_trade_gain",
+    "get_average_trade_loss",
+    "get_average_trade_size",
+    "get_average_trade_return",
+    "get_number_of_trades",
+    "get_number_of_closed_trades",
+    "get_negative_trades",
+    "get_positive_trades",
+    "get_cumulative_return",
+    "get_cumulative_return_series",
+    "get_current_win_rate",
+    "get_current_win_loss_ratio",
+    "get_current_average_trade_loss",
+    "get_current_average_trade_duration",
+    "get_current_average_trade_gain",
+    "get_current_average_trade_return",
+    "get_number_of_open_trades",
+    "get_average_trade_duration",
+    "create_backtest_metrics_for_backtest"
 ]

investing_algorithm_framework/{app/reporting → services}/metrics/drawdown.py

@@ -13,11 +13,11 @@ peak-to-trough decline of a portfolio:
 from typing import List, Tuple
 import pandas as pd
 from datetime import datetime
-from investing_algorithm_framework.domain import PortfolioSnapshot
+from investing_algorithm_framework.domain import PortfolioSnapshot, Trade
 from .equity_curve import get_equity_curve
 
 
-def get_drawdown_series(snapshots: List[PortfolioSnapshot]) -> List[Tuple[datetime, float]]:
+def get_drawdown_series(snapshots: List[PortfolioSnapshot]) -> List[Tuple[float, datetime]]:
     """
     Calculate the drawdown series of a backtest report.
 
@@ -39,12 +39,12 @@ def get_drawdown_series(snapshots: List[PortfolioSnapshot]) -> List[Tuple[dateti
     drawdown_series = []
     max_value = None
 
-    for timestamp, value in equity_curve:
+    for value, timestamp in equity_curve:
         if max_value is None:
             max_value = value
         max_value = max(max_value, value)
         drawdown = (value - max_value) / max_value  # This will be <= 0
-        drawdown_series.append((timestamp, drawdown))
+        drawdown_series.append((drawdown, timestamp))
 
     return drawdown_series
 
@@ -69,10 +69,10 @@ def get_max_drawdown(snapshots: List[PortfolioSnapshot]) -> float:
     if not equity_curve:
         return 0.0
 
-    peak = equity_curve[0][1]
+    peak = equity_curve[0][0]
     max_drawdown_pct = 0.0
 
-    for _, equity in equity_curve:
+    for equity, _  in equity_curve:
         if equity > peak:
             peak = equity
 
@@ -134,11 +134,11 @@ def get_max_drawdown_duration(snapshots: List[PortfolioSnapshot]) -> int:
     if not equity_curve:
         return 0
 
-    peak = equity_curve[0][1]
+    peak = equity_curve[0][0]
     max_duration = 0
     current_duration = 0
 
-    for _, equity in equity_curve:
+    for equity, _ in equity_curve:
         if equity < peak:
             current_duration += 1
         else:
@@ -168,10 +168,10 @@ def get_max_drawdown_absolute(snapshots: List[PortfolioSnapshot]) -> float:
     if not equity_curve:
         return 0.0
 
-    peak = equity_curve[0][1]
+    peak = equity_curve[0][0]
     max_drawdown = 0.0
 
-    for _, equity in equity_curve:
+    for equity, _ in equity_curve:
         if equity > peak:
             peak = equity
 

investing_algorithm_framework/{app/reporting → services}/metrics/equity_curve.py

@@ -5,7 +5,7 @@ from investing_algorithm_framework.domain import PortfolioSnapshot
 
 def get_equity_curve(
     snapshots: List[PortfolioSnapshot]
-) -> list[tuple[datetime, float]]:
+) -> list[tuple[float, datetime]]:
     """
     Calculate the total size of the portfolio at each snapshot timestamp.
 
@@ -19,6 +19,6 @@ def get_equity_curve(
     for snapshot in snapshots:
         timestamp = snapshot.created_at
         total_size = snapshot.total_value
-        series.append((timestamp, total_size))
+        series.append((total_size, timestamp))
 
     return series

investing_algorithm_framework/{app/reporting → services}/metrics/exposure.py

@@ -6,12 +6,70 @@ Exposure around 1 means capital is nearly fully invested most of the time, but n
 Low exposure (<1) means capital is mostly idle or only partially invested.
 """
 
+from datetime import datetime, timedelta
 from typing import List
-from datetime import timedelta, datetime
+
 from investing_algorithm_framework.domain import Trade
 
 
-def get_exposure(
+def get_exposure_ratio(
+    trades: List["Trade"], start_date: datetime, end_date: datetime
+) -> float:
+    """
+    Calculates the exposure ratio (time in market) as the fraction of the total
+    backtest duration where at least one position was open.
+
+    Unlike cumulative exposure, overlapping trades are not double-counted.
+    The result is always between 0 and 1.
+
+    Args:
+        trades (List[Trade]): List of trades executed during the backtest.
+        start_date (datetime): The start date of the backtest.
+        end_date (datetime): The end date of the backtest.
+
+    Returns:
+        A float between 0 and 1 representing the exposure ratio.
+    """
+    if not trades:
+        return 0.0
+
+    # Collect trade intervals
+    intervals = []
+    for trade in trades:
+        entry = max(trade.opened_at, start_date)
+        exit = min(trade.closed_at or end_date, end_date)
+        if exit > entry:
+            intervals.append((entry, exit))
+
+    if not intervals:
+        return 0.0
+
+    # Sort intervals by start time
+    intervals.sort(key=lambda x: x[0])
+
+    # Merge overlapping intervals
+    merged = []
+    current_start, current_end = intervals[0]
+    for start, end in intervals[1:]:
+        if start <= current_end:  # overlap
+            current_end = max(current_end, end)
+        else:
+            merged.append((current_start, current_end))
+            current_start, current_end = start, end
+    merged.append((current_start, current_end))
+
+    # Total time with at least one open trade
+    total_exposed_time = sum((end - start for start, end in merged), timedelta(0))
+
+    backtest_duration = end_date - start_date
+    if backtest_duration.total_seconds() == 0:
+        return 0.0
+
+    return total_exposed_time.total_seconds() \
+        / backtest_duration.total_seconds()
+
+
+def get_cumulative_exposure(
     trades: List[Trade], start_date: datetime, end_date: datetime
 ) -> float:
     """

investing_algorithm_framework/services/metrics/generate.py

@@ -0,0 +1,358 @@
+from typing import List
+from logging import getLogger
+
+from investing_algorithm_framework.domain import BacktestMetrics, \
+    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, \
+    get_max_daily_drawdown, get_max_drawdown_absolute, \
+    get_max_drawdown_duration
+from .equity_curve import get_equity_curve
+from .exposure import get_exposure_ratio, get_cumulative_exposure, \
+    get_trades_per_year, get_trades_per_day
+from .profit_factor import get_profit_factor, get_gross_loss, get_gross_profit
+from .returns import get_monthly_returns, get_yearly_returns, \
+    get_worst_year, get_best_year, get_best_month, get_worst_month, \
+    get_percentage_winning_months, get_percentage_winning_years, \
+    get_average_monthly_return, get_average_monthly_return_winning_months, \
+    get_average_monthly_return_losing_months, get_cumulative_return, \
+    get_cumulative_return_series
+from .returns import get_total_return, get_final_value, get_total_loss, \
+    get_total_growth
+from .sharpe_ratio import get_sharpe_ratio, get_rolling_sharpe_ratio
+from .sortino_ratio import get_sortino_ratio
+from .volatility import get_annual_volatility
+from .win_rate import get_win_rate, get_win_loss_ratio, get_current_win_rate, \
+    get_current_win_loss_ratio
+from .trades import get_average_trade_duration, get_average_trade_size, \
+    get_number_of_trades, get_positive_trades, get_number_of_closed_trades, \
+    get_negative_trades, get_average_trade_return, get_number_of_open_trades, \
+    get_worst_trade, get_best_trade, get_average_trade_gain, \
+    get_average_trade_loss, get_median_trade_return, \
+    get_current_average_trade_gain, get_current_average_trade_return, \
+    get_current_average_trade_duration, get_current_average_trade_loss
+
+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
+) -> BacktestMetrics:
+    """
+    Create a BacktestMetrics instance and optionally save it to a file.
+
+    Args:
+        backtest_run (BacktestRun): The BacktestRun object containing
+            portfolio snapshots and trades.
+        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.
+
+    Returns:
+        BacktestMetrics: The computed backtest metrics.
+    """
+
+    if metrics is None:
+        metrics = [
+            "backtest_start_date",
+            "backtest_end_date",
+            "equity_curve",
+            "final_value",
+            "total_growth",
+            "total_growth_percentage",
+            "total_net_gain",
+            "total_net_gain_percentage",
+            "total_loss",
+            "total_loss_percentage",
+            "cumulative_return",
+            "cumulative_return_series",
+            "cagr",
+            "sharpe_ratio",
+            "rolling_sharpe_ratio",
+            "sortino_ratio",
+            "calmar_ratio",
+            "profit_factor",
+            "annual_volatility",
+            "monthly_returns",
+            "yearly_returns",
+            "drawdown_series",
+            "max_drawdown",
+            "max_drawdown_absolute",
+            "max_daily_drawdown",
+            "max_drawdown_duration",
+            "trades_per_year",
+            "trade_per_day",
+            "exposure_ratio",
+            "cumulative_exposure",
+            "best_trade",
+            "worst_trade",
+            "number_of_positive_trades",
+            "percentage_positive_trades",
+            "number_of_negative_trades",
+            "percentage_negative_trades",
+            "average_trade_duration",
+            "average_trade_size",
+            "average_trade_loss",
+            "average_trade_loss_percentage",
+            "average_trade_gain",
+            "average_trade_gain_percentage",
+            "average_trade_return",
+            "average_trade_return_percentage",
+            "median_trade_return",
+            "number_of_trades",
+            "number_of_trades_closed",
+            "number_of_trades_opened",
+            "number_of_trades_open_at_end",
+            "win_rate",
+            "current_win_rate",
+            "win_loss_ratio",
+            "current_win_loss_ratio",
+            "percentage_winning_months",
+            "percentage_winning_years",
+            "average_monthly_return",
+            "average_monthly_return_losing_months",
+            "average_monthly_return_winning_months",
+            "best_month",
+            "best_year",
+            "worst_month",
+            "worst_year",
+            "total_number_of_days",
+            "current_average_trade_gain",
+            "current_average_trade_return",
+            "current_average_trade_duration",
+            "current_average_trade_loss",
+        ]
+
+    backtest_metrics = BacktestMetrics(
+        backtest_start_date=backtest_run.backtest_start_date,
+        backtest_end_date=backtest_run.backtest_end_date,
+    )
+
+    def safe_set(metric_name, func, *args, index=None):
+        if metric_name in metrics:
+            try:
+                value = func(*args)
+                if index is not None and isinstance(value, (list, tuple)):
+                    setattr(backtest_metrics, metric_name, value[index])
+                else:
+                    setattr(backtest_metrics, metric_name, value)
+            except OperationalException as e:
+                logger.warning(f"{metric_name} failed: {e}")
+
+    # Grouped metrics needing special handling
+    if "total_net_gain" in metrics or "total_net_gain_percentage" in metrics:
+        try:
+            total_return = get_total_return(backtest_run.portfolio_snapshots)
+            if "total_net_gain" in metrics:
+                backtest_metrics.total_net_gain = total_return[0]
+            if "total_net_gain_percentage" in metrics:
+                backtest_metrics.total_net_gain_percentage = total_return[1]
+        except OperationalException as e:
+            logger.warning(f"total_return failed: {e}")
+
+    if "total_growth" in metrics or "total_growth_percentage" in metrics:
+        try:
+            total_growth = get_total_growth(backtest_run.portfolio_snapshots)
+            if "total_growth" in metrics:
+                backtest_metrics.total_growth = total_growth[0]
+            if "total_growth_percentage" in metrics:
+                backtest_metrics.total_growth_percentage = total_growth[1]
+        except OperationalException as e:
+            logger.warning(f"total_growth failed: {e}")
+
+    if "total_loss" in metrics or "total_loss_percentage" in metrics:
+        try:
+            total_loss = get_total_loss(backtest_run.portfolio_snapshots)
+            if "total_loss" in metrics:
+                backtest_metrics.total_loss = total_loss[0]
+            if "total_loss_percentage" in metrics:
+                backtest_metrics.total_loss_percentage = total_loss[1]
+        except OperationalException as e:
+            logger.warning(f"total_loss failed: {e}")
+
+    if ("average_trade_return" in metrics
+            or "average_trade_return_percentage" in metrics):
+        try:
+            avg_return = get_average_trade_return(backtest_run.trades)
+            if "average_trade_return" in metrics:
+                backtest_metrics.average_trade_return = avg_return[0]
+            if "average_trade_return_percentage" in metrics:
+                backtest_metrics.average_trade_return_percentage = \
+                    avg_return[1]
+        except OperationalException as e:
+            logger.warning(f"average_trade_return failed: {e}")
+
+    if ("average_trade_gain" in metrics
+            or "average_trade_gain_percentage" in metrics):
+        try:
+            avg_gain = get_average_trade_gain(backtest_run.trades)
+            if "average_trade_gain" in metrics:
+                backtest_metrics.average_trade_gain = avg_gain[0]
+            if "average_trade_gain_percentage" in metrics:
+                backtest_metrics.average_trade_gain_percentage = avg_gain[1]
+        except OperationalException as e:
+            logger.warning(f"average_trade_gain failed: {e}")
+
+    if ("average_trade_loss" in metrics
+            or "average_trade_loss_percentage" in metrics):
+        try:
+            avg_loss = get_average_trade_loss(backtest_run.trades)
+            if "average_trade_loss" in metrics:
+                backtest_metrics.average_trade_loss = avg_loss[0]
+            if "average_trade_loss_percentage" in metrics:
+                backtest_metrics.average_trade_loss_percentage = avg_loss[1]
+        except OperationalException as e:
+            logger.warning(f"average_trade_loss failed: {e}")
+
+    if ("current_average_trade_gain" in metrics
+            or "get_current_average_trade_gain_percentage" in metrics):
+        try:
+            current_avg_gain = get_current_average_trade_gain(
+                backtest_run.trades
+            )
+
+            if "current_average_trade_gain" in metrics:
+                backtest_metrics.current_average_trade_gain = \
+                    current_avg_gain[0]
+
+            if "current_average_trade_gain_percentage" in metrics:
+                backtest_metrics.current_average_trade_gain_percentage = \
+                    current_avg_gain[1]
+        except OperationalException as e:
+            logger.warning(f"current_average_trade_gain failed: {e}")
+
+    if ("current_average_trade_return" in metrics
+            or "current_average_trade_return_percentage" in metrics):
+        try:
+            current_avg_return = get_current_average_trade_return(
+                backtest_run.trades
+            )
+
+            if "current_average_trade_return" in metrics:
+                backtest_metrics.current_average_trade_return = \
+                    current_avg_return[0]
+            if "current_average_trade_return_percentage" in metrics:
+                backtest_metrics.current_average_trade_return_percentage =\
+                    current_avg_return[1]
+        except OperationalException as e:
+            logger.warning(f"current_average_trade_return failed: {e}")
+
+    if "current_average_trade_duration" in metrics:
+        try:
+            current_avg_duration = get_current_average_trade_duration(
+                backtest_run.trades, backtest_run
+            )
+            backtest_metrics.current_average_trade_duration = \
+                current_avg_duration
+        except OperationalException as e:
+            logger.warning(f"current_average_trade_duration failed: {e}")
+
+    if ("current_average_trade_loss" in metrics
+            or "current_average_trade_loss_percentage" in metrics):
+        try:
+            current_avg_loss = get_current_average_trade_loss(
+                backtest_run.trades
+            )
+            if "current_average_trade_loss" in metrics:
+                backtest_metrics.current_average_trade_loss = \
+                    current_avg_loss[0]
+            if "current_average_trade_loss_percentage" in metrics:
+                backtest_metrics.current_average_trade_loss_percentage = \
+                    current_avg_loss[1]
+        except OperationalException as e:
+            logger.warning(f"current_average_trade_loss failed: {e}")
+
+    safe_set("number_of_positive_trades", get_positive_trades, backtest_run.trades)
+    safe_set("percentage_positive_trades", get_positive_trades, backtest_run.trades, index=1)
+    safe_set("number_of_negative_trades", get_negative_trades, backtest_run.trades)
+    safe_set("percentage_negative_trades", get_negative_trades, backtest_run.trades, index=1)
+    safe_set("median_trade_return", get_median_trade_return, backtest_run.trades, index=0)
+    safe_set("median_trade_return_percentage", get_median_trade_return, backtest_run.trades, index=1)
+    safe_set("number_of_trades", get_number_of_trades, backtest_run.trades)
+    safe_set("number_of_trades_closed", get_number_of_closed_trades, backtest_run.trades)
+    safe_set("number_of_trades_opened", get_number_of_open_trades, backtest_run.trades)
+    safe_set("average_trade_duration", get_average_trade_duration, backtest_run.trades)
+    safe_set("average_trade_size", get_average_trade_size, backtest_run.trades)
+    safe_set("equity_curve", get_equity_curve, backtest_run.portfolio_snapshots)
+    safe_set("final_value", get_final_value, backtest_run.portfolio_snapshots)
+    safe_set("cagr", get_cagr, backtest_run.portfolio_snapshots)
+    safe_set("sharpe_ratio", get_sharpe_ratio, backtest_run.portfolio_snapshots, risk_free_rate)
+    safe_set("rolling_sharpe_ratio", get_rolling_sharpe_ratio, backtest_run.portfolio_snapshots, risk_free_rate)
+    safe_set("sortino_ratio", get_sortino_ratio, backtest_run.portfolio_snapshots, risk_free_rate)
+    safe_set("profit_factor", get_profit_factor, backtest_run.trades)
+    safe_set("calmar_ratio", get_calmar_ratio, backtest_run.portfolio_snapshots)
+    safe_set("annual_volatility", get_annual_volatility, backtest_run.portfolio_snapshots)
+    safe_set("monthly_returns", get_monthly_returns, backtest_run.portfolio_snapshots)
+    safe_set("yearly_returns", get_yearly_returns, backtest_run.portfolio_snapshots)
+    safe_set("drawdown_series", get_drawdown_series, backtest_run.portfolio_snapshots)
+    safe_set("max_drawdown", get_max_drawdown, backtest_run.portfolio_snapshots)
+    safe_set("max_drawdown_absolute", get_max_drawdown_absolute, backtest_run.portfolio_snapshots)
+    safe_set("max_daily_drawdown", get_max_daily_drawdown, backtest_run.portfolio_snapshots)
+    safe_set("max_drawdown_duration", get_max_drawdown_duration, backtest_run.portfolio_snapshots)
+    safe_set("trades_per_year", get_trades_per_year, backtest_run.trades, backtest_run.backtest_start_date, backtest_run.backtest_end_date)
+    safe_set("trades_per_day", get_trades_per_day, backtest_run.trades, backtest_run.backtest_start_date, backtest_run.backtest_end_date)
+    safe_set("exposure_ratio", get_exposure_ratio, backtest_run.trades, backtest_run.backtest_start_date, backtest_run.backtest_end_date)
+    safe_set("cumulative_exposure", get_cumulative_exposure, backtest_run.trades, backtest_run.backtest_start_date, backtest_run.backtest_end_date)
+    safe_set("best_trade", get_best_trade, backtest_run.trades)
+    safe_set("worst_trade", get_worst_trade, backtest_run.trades)
+    safe_set("win_rate", get_win_rate, backtest_run.trades)
+    safe_set("current_win_rate", get_current_win_rate, backtest_run.trades)
+    safe_set("win_loss_ratio", get_win_loss_ratio, backtest_run.trades)
+    safe_set("current_win_loss_ratio", get_current_win_loss_ratio, backtest_run.trades)
+    safe_set("percentage_winning_months", get_percentage_winning_months, backtest_run.portfolio_snapshots)
+    safe_set("percentage_winning_years", get_percentage_winning_years, backtest_run.portfolio_snapshots)
+    safe_set("average_monthly_return", get_average_monthly_return, backtest_run.portfolio_snapshots)
+    safe_set("average_monthly_return_winning_months", get_average_monthly_return_winning_months, backtest_run.portfolio_snapshots)
+    safe_set("average_monthly_return_losing_months", get_average_monthly_return_losing_months, backtest_run.portfolio_snapshots)
+    safe_set("best_month", get_best_month, backtest_run.portfolio_snapshots)
+    safe_set("best_year", get_best_year, backtest_run.portfolio_snapshots)
+    safe_set("worst_month", get_worst_month, backtest_run.portfolio_snapshots)
+    safe_set("worst_year", get_worst_year, backtest_run.portfolio_snapshots)
+    safe_set("gross_loss", get_gross_loss, backtest_run.trades)
+    safe_set("gross_profit", get_gross_profit, backtest_run.trades)
+    safe_set("cumulative_return_series", get_cumulative_return_series, backtest_run.portfolio_snapshots)
+    safe_set("cumulative_return", get_cumulative_return, backtest_run.portfolio_snapshots)
+    return backtest_metrics

investing_algorithm_framework/{app/reporting → services}/metrics/profit_factor.py

@@ -127,3 +127,39 @@ def get_profit_factor(trades: List[Trade]) -> float:
         return float('inf') if gross_profit > 0 else 0.0
 
     return gross_profit / gross_loss
+
+
+def get_gross_profit(trades: List[Trade]) -> float:
+    """
+    Function to calculate the total gross profit from a list of trades.
+
+    Args:
+        trades (List[Trade]): List of closed trades from the backtest report.
+
+    Returns:
+        float: The total gross profit from the trades.
+    """
+
+    gross_profit = 0.0
+    for trade in trades:
+        if trade.net_gain > 0:
+            gross_profit += trade.net_gain
+    return gross_profit
+
+
+def get_gross_loss(trades: List[Trade]) -> float:
+    """
+    Function to calculate the total gross loss from a list of trades.
+
+    Args:
+        trades (List[Trade]): List of closed trades from the backtest report.
+
+    Returns:
+        float: The total gross loss from the trades.
+    """
+
+    gross_loss = 0.0
+    for trade in trades:
+        if trade.net_gain < 0:
+            gross_loss += abs(trade.net_gain)
+    return gross_loss

investing_algorithm_framework/{app/reporting → services}/metrics/recovery.py

@@ -40,7 +40,7 @@ from typing import List
 
 from investing_algorithm_framework.domain import PortfolioSnapshot
 from .drawdown import get_max_drawdown_absolute
-from .returns import get_total_net_gain
+from .returns import get_total_return
 
 
 def get_recovery_factor(snapshots: List[PortfolioSnapshot]) -> float:
@@ -67,7 +67,7 @@ def get_recovery_factor(snapshots: List[PortfolioSnapshot]) -> float:
         return 0.0
 
     max_drawdown_absolute = get_max_drawdown_absolute(snapshots)
-    net_profit = get_total_net_gain(snapshots)
+    net_profit, _ = get_total_return(snapshots)
 
     if max_drawdown_absolute == 0:
         return float('inf') if net_profit > 0 else 0.0