Add current trade metrics

Author: MDUYN

investing_algorithm_framework/__init__.py

@@ -44,7 +44,11 @@
     get_rolling_sharpe_ratio, create_backtest_metrics, get_total_growth, \
     get_total_loss, get_cumulative_exposure, get_median_trade_return, \
     get_average_trade_return, get_risk_free_rate_us, get_cumulative_return, \
-    get_cumulative_return_series
+    get_cumulative_return_series, get_current_average_trade_return, \
+    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
 
 
 __all__ = [
@@ -175,5 +179,14 @@
     "get_total_loss",
     "get_total_growth",
     "generate_backtest_summary_metrics",
-    "get_equity_curve_chart"
+    "get_equity_curve_chart",
+    "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_negative_trades",
+    "get_positive_trades",
+    "get_number_of_trades",
 ]

investing_algorithm_framework/domain/backtesting/backtest_metrics.py

@@ -179,6 +179,13 @@ class BacktestMetrics:
     average_trade_gain_percentage: float = 0.0
     average_trade_return: float = 0.0
     average_trade_return_percentage: float = 0.0
+    current_average_trade_gain: float = 0.0
+    current_average_trade_gain_percentage: float = 0.0
+    current_average_trade_return: float = 0.0
+    current_average_trade_return_percentage: float = 0.0
+    current_average_trade_duration: float = 0.0
+    current_average_trade_loss: float = 0.0
+    current_average_trade_loss_percentage: float = 0.0
     median_trade_return: float = 0.0
     median_trade_return_percentage: float = 0.0
     number_of_trades: int = 0

investing_algorithm_framework/services/__init__.py

@@ -26,15 +26,18 @@
     get_average_trade_loss, get_average_monthly_return, \
     get_percentage_winning_months, get_average_trade_duration, \
     get_trade_frequency, get_win_rate, get_win_loss_ratio, \
-    get_calmar_ratio, get_max_drawdown_absolute, \
+    get_calmar_ratio, get_max_drawdown_absolute, get_current_win_loss_ratio, \
     get_max_drawdown_duration, get_max_daily_drawdown, get_trades_per_day, \
     get_trades_per_year, get_average_monthly_return_losing_months, \
     get_average_monthly_return_winning_months, get_percentage_winning_years, \
     get_rolling_sharpe_ratio, create_backtest_metrics, get_total_growth, \
     get_total_loss, get_risk_free_rate_us, get_median_trade_return, \
     get_average_trade_return, get_cumulative_return, \
     get_cumulative_return_series, get_average_trade_size, \
-    get_positive_trades, get_negative_trades, get_number_of_trades
+    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
 
 __all__ = [
     "OrderService",
@@ -118,4 +121,11 @@
     "get_number_of_trades",
     "get_cumulative_return",
     "get_cumulative_return_series",
+    "get_current_win_loss_ratio",
+    "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",
 ]

investing_algorithm_framework/services/metrics/__init__.py

@@ -24,15 +24,18 @@
 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
+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 .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_average_trade_loss, get_current_average_trade_loss, \
+    get_current_average_trade_duration, get_current_average_trade_gain, \
+    get_current_average_trade_return
 
 __all__ = [
     "get_annual_volatility",
@@ -97,4 +100,10 @@
     "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",
 ]

investing_algorithm_framework/services/metrics/generate.py

@@ -2,7 +2,7 @@
 from logging import getLogger
 
 from investing_algorithm_framework.domain import BacktestMetrics, \
-    TradeStatus, BacktestRun, OperationalException
+    BacktestRun, OperationalException
 from .cagr import get_cagr
 from .calmar_ratio import get_calmar_ratio
 from .drawdown import get_drawdown_series, get_max_drawdown, \
@@ -28,7 +28,9 @@
     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_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")
 
@@ -113,7 +115,11 @@ def create_backtest_metrics(
             "best_year",
             "worst_month",
             "worst_year",
-            "total_number_of_days"
+            "total_number_of_days",
+            "current_average_trade_gain",
+            "current_average_trade_return",
+            "current_average_trade_duration",
+            "current_average_trade_loss",
         ]
 
     backtest_metrics = BacktestMetrics(
@@ -197,6 +203,68 @@ def safe_set(metric_name, func, *args, index=None):
         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)
@@ -241,5 +309,4 @@ def safe_set(metric_name, func, *args, index=None):
     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/trades.py

@@ -1,7 +1,7 @@
 from typing import List, Tuple
 
 from investing_algorithm_framework.domain import Trade, TradeStatus, \
-    OperationalException
+    OperationalException, BacktestRun
 
 
 def get_positive_trades(
@@ -163,6 +163,41 @@ def get_average_trade_duration(
     return total_duration / number_of_trades if number_of_trades > 0 else 0.0
 
 
+def get_current_average_trade_duration(
+    trades: List[Trade], backtest_run: BacktestRun
+) -> float:
+    """
+    Calculate the average duration of currently closed and open trades
+    in hours.
+
+    Args:
+        trades (List[Trade]): List of Trade objects.
+        backtest_run (BacktestRun): The backtest run containing trades.
+
+    Returns:
+        float: The average trade duration in hours.
+    """
+    if trades is None or len(trades) == 0:
+        raise OperationalException(
+            "Trades list is None, cannot compute average trade duration."
+        )
+
+    total_duration = 0.0
+
+    for trade in trades:
+
+        if TradeStatus.CLOSED.equals(trade.status):
+            total_duration += (trade.closed_at - trade.opened_at)\
+                                  .total_seconds() / 3600
+        else:
+            total_duration += (
+                  backtest_run.backtest_end_date - trade.opened_at
+            ).total_seconds() / 3600
+
+    number_of_trades = len(trades)
+    return total_duration / number_of_trades if number_of_trades > 0 else 0.0
+
+
 def get_average_trade_size(
     trades: List[Trade]
 ) -> float:
@@ -220,6 +255,39 @@ def get_average_trade_return(trades: List[Trade]) -> Tuple[float, float]:
     return average_return, average_return_percentage
 
 
+def get_current_average_trade_return(
+    trades: List[Trade]
+) -> Tuple[float, float]:
+    """
+    Calculate the average return (absolute PnL) and
+    average return percentage (per trade) of closed and open trades.
+
+    Args:
+        trades (List[Trade]): List of trades.
+
+    Returns:
+        Tuple[float, float]: The average return
+        percentage of the average return
+    """
+    if not trades or len(trades) == 0:
+        raise OperationalException(
+            "Trades list is empty, cannot compute average return."
+        )
+
+    total_return = sum(t.net_gain for t in trades)
+    average_return = total_return / len(trades)
+
+    percentage_returns = [
+        (t.net_gain / t.cost) * 100.0 for t in trades if t.cost > 0
+    ]
+    average_return_percentage = (
+        sum(percentage_returns) / len(percentage_returns)
+        if percentage_returns else 0.0
+    )
+
+    return average_return, average_return_percentage
+
+
 def get_average_trade_gain(trades: List[Trade]) -> Tuple[float, float]:
     """
     Calculate the average gain from a list of trades.
@@ -249,6 +317,37 @@ def get_average_trade_gain(trades: List[Trade]) -> Tuple[float, float]:
     return average_gain, percentage
 
 
+def get_current_average_trade_gain(
+    trades: List[Trade]
+) -> Tuple[float, float]:
+    """
+    Calculate the average gain from a list of trades,
+    including both closed and open trades.
+
+    The average gain is calculated as the mean of all positive returns.
+
+    Args:
+        trades (List[Trade]): List of trades.
+    Returns:
+        Tuple[float, float]: The average gain
+        percentage of the average loss
+    """
+    if trades is None or len(trades) == 0:
+        raise OperationalException(
+            "Trades list is empty or None, cannot calculate average gain."
+        )
+
+    gains = [t.net_gain for t in trades if t.net_gain > 0]
+    cost = sum(t.cost for t in trades if t.net_gain > 0)
+
+    if not gains:
+        return 0.0, 0.0
+
+    average_gain = sum(gains) / len(gains)
+    percentage = (average_gain / cost) if cost > 0 else 0.0
+    return average_gain, percentage
+
+
 def get_average_trade_loss(trades: List[Trade]) -> Tuple[float, float]:
     """
     Calculate the average loss from a list of trades.
@@ -284,6 +383,44 @@ def get_average_trade_loss(trades: List[Trade]) -> Tuple[float, float]:
     return average_loss, average_return_percentage
 
 
+def get_current_average_trade_loss(
+    trades: List[Trade]
+) -> Tuple[float, float]:
+    """
+    Calculate the average loss from a list of trades,
+    including both closed and open trades.
+
+    The average loss is calculated as the mean of all negative returns.
+
+    Args:
+        trades (List[Trade]): List of trades.
+
+    Returns:
+        Tuple[float, float]: The average loss
+        percentage of the average loss
+    """
+    if trades is None or len(trades) == 0:
+        raise OperationalException(
+            "Trades list is empty or None, cannot calculate average loss."
+        )
+
+    losing_trades = [t for t in trades if t.net_gain < 0]
+
+    if not losing_trades or len(losing_trades) == 0:
+        return 0.0, 0.0
+
+    losses = [t.net_gain for t in losing_trades]
+    average_loss = sum(losses) / len(losses)
+    percentage_returns = [
+        (t.net_gain / t.cost) * 100.0 for t in losing_trades if t.cost > 0
+    ]
+    average_return_percentage = (
+        sum(percentage_returns) / len(percentage_returns)
+        if percentage_returns else 0.0
+    )
+    return average_loss, average_return_percentage
+
+
 def get_median_trade_return(trades: List[Trade]) -> Tuple[float, float]:
     """
     Calculate the median return from a list of trades.