investing-algorithm-framework 7.19.14__py3-none-any.whl

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/services/metrics/mean_daily_return.py

@@ -0,0 +1,83 @@
+import pandas as pd
+import numpy as np
+
+from .cagr import get_cagr
+
+
+def get_mean_daily_return(snapshots):
+    """
+    Calculate the mean daily return from the total value of the snapshots.
+
+    This function computes the mean daily return based on the list of
+    snapshots in the report. If the snapshots have a granularity of less
+    than a day, the function will resample to daily frequency and compute
+    average daily returns.
+
+    If there is less data then for a year, it will use cagr to
+    calculate the mean daily return.
+
+    Args:
+        snapshots (List[PortfolioSnapshot]): List of portfolio snapshots
+
+    Returns:
+        float: The mean daily return.
+    """
+
+    if len(snapshots) < 2:
+        return 0.0  # Not enough data
+
+    # Create DataFrame from snapshots
+    data = [(s.created_at, s.total_value) for s in snapshots]
+    df = pd.DataFrame(data, columns=["created_at", "total_value"])
+    df['created_at'] = pd.to_datetime(df['created_at'])
+    df = df.sort_values('created_at').drop_duplicates('created_at')\
+        .set_index('created_at')
+
+    start_date = df.iloc[0].name
+    end_date = df.iloc[-1].name
+
+    # Check if the period is less than a year
+    if (end_date - start_date).days < 365:
+        # Use CAGR to calculate mean daily return
+        cagr = get_cagr(snapshots)
+        if cagr == 0.0:
+            return 0.0
+        return (1 + cagr) ** (1 / 365) - 1
+
+    # Resample to daily frequency using last value of the day
+    daily_df = df.resample('1D').last().dropna()
+
+    # Calculate daily returns
+    daily_df['return'] = daily_df['total_value'].pct_change()
+    daily_df = daily_df.dropna()
+
+    if daily_df.empty:
+        return 0.0
+
+    mean_return = daily_df['return'].mean()
+
+    if np.isnan(mean_return):
+        return 0.0
+
+    return mean_return
+
+
+def get_mean_yearly_return(report, periods_per_year=365):
+    """
+    Calculate the mean yearly return from a backtest report by
+    annualizing the mean daily return.
+
+    Args:
+        report (BacktestReport): The report containing the snapshots.
+        periods_per_year (int): Number of periods in a year (e.g., 365 for daily data).
+
+    Returns:
+        float: The mean yearly return (annualized).
+    """
+    mean_daily_return = get_mean_daily_return(report)
+
+    if mean_daily_return == 0.0:
+        return 0.0
+
+    return (1 + mean_daily_return) ** periods_per_year - 1
+

investing_algorithm_framework/services/metrics/price_efficiency.py

@@ -0,0 +1,57 @@
+import logging
+from pandas import DataFrame, DatetimeIndex
+from investing_algorithm_framework.domain.exceptions import \
+    OperationalException
+
+logger = logging.getLogger(__name__)
+
+
+def get_price_efficiency_ratio(data: DataFrame):
+    """
+    Calculate the price efficiency ratio (noise) for each symbol.
+
+    The price efficiency ratio is calculated as follows:
+
+    1. Calculate the net price change over the period
+    2. Calculate the sum of absolute daily price changes
+    3. Calculate Efficiency Ratio = Net Price Change / Sum of Absolute
+    Daily Price Changes
+
+    The price efficiency ratio is a measure of the efficiency of the
+    price movement over the period. A higher efficiency ratio indicates
+    a more efficient price movement.
+
+    Args:
+        data (dict): A pandas DataFrame containing a column with either a
+        'Close' or 'Price' label and a datetime index.
+
+    returns:
+        float: The price efficiency ratio
+    """
+
+    # Check if close value and index is a datetime object
+    if 'Close' not in data.columns:
+        raise OperationalException(
+            "Close column not found in data, "
+            "required for price efficiency ratio calculation"
+        )
+
+    if not isinstance(data.index, DatetimeIndex):
+        raise OperationalException(
+            "Index is not a datetime object,"
+            "required for price efficiency ratio calculation"
+        )
+
+    # Calculate daily price changes
+    data['Daily Change'] = data['Close'].diff()
+
+    # Calculate net price change over the period
+    net_price_change = abs(
+        data['Close'].iloc[-1] - data['Close'].iloc[0])
+
+    # Calculate the sum of absolute daily price changes
+    sum_absolute_changes = data['Daily Change'] \
+        .abs().sum()
+
+    # Calculate Efficiency Ratio
+    return net_price_change / sum_absolute_changes

investing_algorithm_framework/services/metrics/profit_factor.py

@@ -0,0 +1,165 @@
+"""
+Module for calculating profit factor metrics from backtest trades.
+
+| **Profit Factor** | **Interpretation**                                                                        |
+| ----------------- | ----------------------------------------------------------------------------------------- |
+| **< 1.0**         | **Losing strategy** — losses outweigh profits                                             |
+| **1.0 – 1.3**     | Weak or barely breakeven — needs improvement or may not be sustainable                    |
+| **1.3 – 1.6**     | Average — possibly profitable but sensitive to market regime changes                      |
+| **1.6 – 2.0**     | Good — generally indicates a solid, sustainable edge                                      |
+| **2.0 – 3.0**     | Very good — strong edge with lower drawdown risk                                          |
+| **> 3.0**         | Excellent — rare in real markets; often associated with low-frequency or niche strategies |
+
+"""
+
+from collections import deque
+from datetime import datetime
+from typing import List, Tuple
+
+from investing_algorithm_framework.domain.models import Trade
+
+
+def get_cumulative_profit_factor_series(
+    trades: List[Trade]
+) -> list[tuple[datetime, float]]:
+    """
+    Calculates the cumulative profit factor over time from a backtest report.
+
+    Args:
+        trades (List[Trade]): List of closed trades from the backtest report.
+
+    Returns:
+        List of (datetime, float) tuples: (timestamp, cumulative profit factor)
+    """
+    results = []
+    gross_profit = 0.0
+    gross_loss = 0.0
+
+    for trade in trades:
+        close_time = trade.closed_at
+        profit = trade.net_gain
+
+        if profit >= 0:
+            gross_profit += profit
+        else:
+            gross_loss += abs(profit)
+
+        # Calculate profit factor with division-by-zero protection
+        if gross_loss > 0:
+            profit_factor = gross_profit / gross_loss
+        else:
+            profit_factor = float('inf') if gross_profit > 0 else 0.0
+
+        results.append((close_time, profit_factor))
+
+    return results
+
+
+def get_rolling_profit_factor_series(
+    trades: List[Trade], window_size: int = 20
+) -> List[Tuple[datetime, float]]:
+    """
+    Calculates the rolling profit factor over time from a backtest report.
+
+    The rolling profit factor is computed using the most recent
+    `window_size` trades and updated after each closed trade.
+
+    Args:
+        backtest_report (BacktestReport): A instance of BacktestReport
+            containing closed trades.
+        window_size: The number of most recent trades to include in
+            each rolling calculation.
+
+    Returns:
+        A list of tuples, where each tuple contains:
+            - datetime: The close time of the trade (or aligned date).
+            - float: The rolling profit factor at that time.
+    """
+
+    results = []
+    trade_window = deque(maxlen=window_size)
+
+    for trade in trades:
+        close_time = trade.closed_at
+        profit = trade.net_gain
+
+        trade_window.append(profit)
+
+        gross_profit = sum(p for p in trade_window if p >= 0)
+        gross_loss = sum(abs(p) for p in trade_window if p < 0)
+
+        if gross_loss > 0:
+            profit_factor = gross_profit / gross_loss
+        else:
+            profit_factor = float('inf') if gross_profit > 0 else 0.0
+
+        results.append((close_time, profit_factor))
+
+    return results
+
+
+def get_profit_factor(trades: List[Trade]) -> float:
+    """
+    Calculates the total profit factor at the end of the backtest.
+
+    The profit factor is defined as:
+        Total Gross Profit / Total Gross Loss
+
+    Args:
+        trades (List[Trade]): List of closed trades from the backtest report.
+
+    Returns:
+        float: The profit factor at the end of the backtest.
+               Returns float('inf') if there are no losses,
+               and 0.0 if there are no profits and losses.
+    """
+    gross_profit = 0.0
+    gross_loss = 0.0
+
+    for trade in trades:
+        profit = trade.net_gain
+        if profit > 0:
+            gross_profit += profit
+        elif profit < 0:
+            gross_loss += abs(profit)
+
+    if gross_loss == 0:
+        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