Fix string formatting in reporting tables

MDUYN · MDUYN · commit 24130c024114 · 2025-07-08T14:11:01.000+02:00
diff --git a/examples/backtest_example/resources/backtest_results/strategies/__init__.py b/examples/backtest_example/resources/backtest_results/strategies/__init__.py
@@ -0,0 +1,51 @@
+from investing_algorithm_framework import CCXTOHLCVMarketDataSource
+
+from .strategy_v1 import CrossOverStrategyV1
+
+
+
+def configure_strategy(
+    time_unit,
+    interval,
+    assets,
+    time_frame,
+    fast,
+    slow,
+    trend,
+    stop_loss_percentage,
+    stop_loss_sell_size,
+    take_profit_percentage,
+    take_profit_sell_size
+):
+    data_providers = []
+
+    for asset in assets:
+        data_providers.append(
+            CCXTOHLCVMarketDataSource(
+                identifier=f"{asset}-ohlcv-{time_frame.value}",
+                market="bitvavo",
+                symbol=asset,
+                time_frame=time_frame,
+                window_size=200
+            )
+        )
+
+    strategy = CrossOverStrategyV1(
+        time_unit=time_unit,
+        interval=interval,
+        symbol_pairs=assets,
+        market_data_sources=data_providers,
+        fast=fast,
+        slow=slow,
+        trend=trend,
+        stop_loss_percentage=stop_loss_percentage,
+        stop_loss_sell_size=stop_loss_sell_size,
+        take_profit_percentage=take_profit_percentage,
+        take_profit_sell_size=take_profit_sell_size
+    )
+    return strategy
+
+
+__all__ = [
+    "CrossOverStrategyV1",
+]
diff --git a/examples/backtest_example/resources/backtest_results/strategies/data_sources.py b/examples/backtest_example/resources/backtest_results/strategies/data_sources.py
@@ -0,0 +1,30 @@
+from investing_algorithm_framework import (
+    CCXTOHLCVMarketDataSource, CCXTTickerMarketDataSource
+)
+
+bitvavo_btc_eur_ohlcv_2h = CCXTOHLCVMarketDataSource(
+    identifier="BTC/EUR-ohlcv-2h",
+    market="BINANCE",
+    symbol="BTC/EUR",
+    time_frame="2h",
+    window_size=200
+)
+bitvavo_dot_eur_ohlcv_2h = CCXTOHLCVMarketDataSource(
+    identifier="DOT/EUR-ohlch-2h",
+    market="BINANCE",
+    symbol="DOT/EUR",
+    time_frame="2h",
+    window_size=200
+)
+bitvavo_dot_eur_ticker = CCXTTickerMarketDataSource(
+    identifier="DOT/EUR-ticker",
+    market="BINANCE",
+    symbol="DOT/EUR",
+    backtest_time_frame="2h",
+)
+bitvavo_btc_eur_ticker = CCXTTickerMarketDataSource(
+    identifier="BTC/EUR-ticker",
+    market="BINANCE",
+    symbol="BTC/EUR",
+    backtest_time_frame="2h",
+)
diff --git a/examples/backtest_example/resources/backtest_results/strategies/strategy_v1.py b/examples/backtest_example/resources/backtest_results/strategies/strategy_v1.py
@@ -0,0 +1,153 @@
+from pyindicators import ema, is_crossover, is_above, is_below, is_crossunder
+from investing_algorithm_framework import TradingStrategy, TimeUnit, Context, \
+    OrderSide
+
+from .data_sources import bitvavo_btc_eur_ohlcv_2h, bitvavo_btc_eur_ticker
+
+
+class CrossOverStrategyV1(TradingStrategy):
+    """
+    A simple trading strategy that uses EMA crossovers to generate buy and
+    sell signals. The strategy uses a 50-period EMA and a 100-period EMA
+    to detect golden and death crosses. It also uses a 200-period EMA to
+    determine the overall trend direction. The strategy trades BTC/EUR
+    on a 2-hour timeframe. The strategy is designed to be used with the
+    Investing Algorithm Framework and uses the PyIndicators library
+    to calculate the EMAs and crossover signals.
+
+    The strategy uses a trailing stop loss and take profit to manage
+    risk. The stop loss is set to 5% below the entry price and the
+    take profit is set to 10% above the entry price. The stop loss and
+    take profit are both trailing, meaning that they will move up
+    with the price when the price goes up.
+    """
+    time_unit = TimeUnit.HOUR
+    interval = 2
+    symbol_pairs = ["BTC/EUR"]
+    market_data_sources = [bitvavo_btc_eur_ohlcv_2h, bitvavo_btc_eur_ticker]
+    fast = 50
+    slow = 100
+    trend = 200
+    stop_loss_percentage = 2
+    stop_loss_sell_size = 50
+    take_profit_percentage = 8
+    take_profit_sell_size = 50
+
+    def __init__(
+        self,
+        time_unit: TimeUnit = TimeUnit.HOUR,
+        interval: int = 2,
+        symbol_pairs: list[str] = None,
+        market_data_sources=None,
+        fast: int = 50,
+        slow: int = 100,
+        trend: int = 200,
+        stop_loss_percentage: float = 2.0,
+        stop_loss_sell_size: float = 50.0,
+        take_profit_percentage: float = 8.0,
+        take_profit_sell_size: float = 50.0
+    ):
+        super().__init__(
+            time_unit=time_unit,
+            interval=interval,
+            market_data_sources=market_data_sources or self.market_data_sources
+        )
+        self.symbol_pairs = symbol_pairs or self.symbol_pairs
+        self.fast = fast
+        self.slow = slow
+        self.trend = trend
+        self.stop_loss_percentage = stop_loss_percentage
+        self.stop_loss_sell_size = stop_loss_sell_size
+        self.take_profit_percentage = take_profit_percentage
+        self.take_profit_sell_size = take_profit_sell_size
+
+    def apply_strategy(self, context: Context, market_data):
+
+        for pair in self.symbol_pairs:
+            symbol = pair.split('/')[0]
+
+            # Don't trade if there are open orders for the symbol
+            # This is important to avoid placing new orders while there are
+            # existing orders that are not yet filled
+            if context.has_open_orders(symbol):
+                continue
+
+            ohlcv_data = market_data[f"{pair}-ohlcv-2h"]
+            # ticker_data = market_data[f"{symbol}-ticker"]
+            # Add fast, slow, and trend EMAs to the data
+            ohlcv_data = ema(
+                ohlcv_data,
+                source_column="Close",
+                period=self.fast,
+                result_column=f"ema_{self.fast}"
+            )
+            ohlcv_data = ema(
+                ohlcv_data,
+                source_column="Close",
+                period=self.slow,
+                result_column=f"ema_{self.slow}"
+            )
+            ohlcv_data = ema(
+                ohlcv_data,
+                source_column="Close",
+                period=self.trend,
+                result_column=f"ema_{self.trend}"
+            )
+
+            price = ohlcv_data["Close"][-1]
+
+            if not context.has_position(symbol) \
+                    and self._is_buy_signal(ohlcv_data):
+                order = context.create_limit_order(
+                    target_symbol=symbol,
+                    order_side=OrderSide.BUY,
+                    price=price,
+                    percentage_of_portfolio=25,
+                    precision=4,
+                )
+                trade = context.get_trade(order_id=order.id)
+                context.add_stop_loss(
+                    trade=trade,
+                    trade_risk_type="trailing",
+                    percentage=self.stop_loss_percentage,
+                    sell_percentage=self.stop_loss_sell_size
+                )
+                context.add_take_profit(
+                    trade=trade,
+                    percentage=self.take_profit_percentage,
+                    trade_risk_type="trailing",
+                    sell_percentage=self.take_profit_sell_size
+                )
+
+            if context.has_position(symbol) \
+                    and self._is_sell_signal(ohlcv_data):
+                open_trades = context.get_open_trades(
+                    target_symbol=symbol
+                )
+
+                for trade in open_trades:
+                    context.close_trade(trade)
+
+    def _is_sell_signal(self, data):
+        return is_crossunder(
+            data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.slow}",
+            number_of_data_points=2
+        ) and is_below(
+            data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.trend}",
+        )
+
+    def _is_buy_signal(self, data):
+        return is_crossover(
+            data=data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.slow}",
+            number_of_data_points=2
+        ) and is_above(
+            data=data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.trend}",
+        )
diff --git a/investing_algorithm_framework/app/reporting/tables/key_metrics_table.py b/investing_algorithm_framework/app/reporting/tables/key_metrics_table.py
@@ -150,17 +150,19 @@ def highlight_max_drawdown(row):
 
 def create_html_key_metrics_table(results, report):
     copy_results = results.to_dict().copy()
+    format_str = "{:.2f}"
+
     # Format some values to percentages and floats
-    copy_results['Total Return'] = safe_format_percentage(copy_results['total_return'], "{:.2f}%")
-    copy_results['CAGR'] = safe_format_percentage(copy_results['cagr'], "{:.2f}%")
-    copy_results['Sharpe Ratio'] = safe_format(copy_results['sharpe_ratio'], "{:.2f}")
-    copy_results['Sortino Ratio'] = safe_format(copy_results['sortino_ratio'], "{:.2f}")
-    copy_results['Profit Factor'] = safe_format(copy_results['profit_factor'], "{:.2f}")
-    copy_results['Calmar Ratio'] = safe_format(copy_results['calmar_ratio'], "{:.2f}")
-    copy_results['Annual Volatility'] = safe_format_percentage(copy_results['annual_volatility'], "{:.2f}%")
-    copy_results['Max Drawdown'] = safe_format_percentage(copy_results['max_drawdown'], "{:.2f}%")
-    copy_results['Max Drawdown Absolute'] = safe_format(copy_results['max_drawdown_absolute'], "{:.2f} " + report.trading_symbol)
-    copy_results['Max Daily Drawdown'] = safe_format_percentage(copy_results['max_daily_drawdown'], "{:.2f}%")
+    copy_results['Total Return'] = f"{safe_format_percentage(copy_results['total_return'], format_str)}%"
+    copy_results['CAGR'] = f"{safe_format_percentage(copy_results['cagr'],format_str)}%"
+    copy_results['Sharpe Ratio'] = safe_format(copy_results['sharpe_ratio'], format_str)
+    copy_results['Sortino Ratio'] = safe_format(copy_results['sortino_ratio'], format_str)
+    copy_results['Profit Factor'] = safe_format(copy_results['profit_factor'], format_str)
+    copy_results['Calmar Ratio'] = safe_format(copy_results['calmar_ratio'], format_str)
+    copy_results['Annual Volatility'] = f"{safe_format_percentage(copy_results['annual_volatility'], format_str)}%"
+    copy_results['Max Drawdown'] = f"{safe_format_percentage(copy_results['max_drawdown'], format_str)}%"
+    copy_results['Max Drawdown Absolute'] = f"{safe_format(copy_results['max_drawdown_absolute'], format_str)} {report.trading_symbol}"
+    copy_results['Max Daily Drawdown'] = f"{safe_format_percentage(copy_results['max_daily_drawdown'], format_str)}%"
     copy_results['Max Drawdown Duration'] = f"{copy_results['max_drawdown_duration']} hours - {copy_results['max_drawdown_duration'] // 24} days"
 
     stats = {
diff --git a/investing_algorithm_framework/app/reporting/tables/time_metrics_table.py b/investing_algorithm_framework/app/reporting/tables/time_metrics_table.py
@@ -7,14 +7,15 @@ def create_html_time_metrics_table(results, report):
     copy_results = results.to_dict().copy()
     start_date = report.backtest_date_range.start_date
     end_date = report.backtest_date_range.end_date
+    string_format = "{:.2f}"
     # Format dates
     copy_results['Start Date'] = safe_format_date(start_date, "%Y-%m-%d %H:%M")
     copy_results['End Date'] = safe_format_date(end_date, "%Y-%m-%d %H:%M")
-    copy_results['Percentage Winning Months'] = safe_format_percentage(copy_results['percentage_winning_months'], "{:.2f}%")
-    copy_results['Percentage Winning Years'] = safe_format_percentage(copy_results['percentage_winning_years'], "{:.2f}%")
-    copy_results['Average Monthly Return'] = safe_format_percentage(copy_results['average_monthly_return'], "{:.2f}%")
-    copy_results['Average Monthly Return (Losing Months)'] = safe_format_percentage(copy_results['average_monthly_return_losing_months'], "{:.2f}%")
-    copy_results['Average Monthly Return (Winning Months)'] = safe_format_percentage(copy_results['average_monthly_return_winning_months'], "{:.2f}%")
+    copy_results['Percentage Winning Months'] = f"{safe_format_percentage(copy_results['percentage_winning_months'], string_format)}%"
+    copy_results['Percentage Winning Years'] = f"{safe_format_percentage(copy_results['percentage_winning_years'], string_format)}%"
+    copy_results['Average Monthly Return'] = f"{safe_format_percentage(copy_results['average_monthly_return'], string_format)}%"
+    copy_results['Average Monthly Return (Losing Months)'] = f"{safe_format_percentage(copy_results['average_monthly_return_losing_months'], string_format)}%"
+    copy_results['Average Monthly Return (Winning Months)'] = f"{safe_format_percentage(copy_results['average_monthly_return_winning_months'], string_format)}%"
 
     if isinstance(copy_results['best_month'], tuple):
         percentage = copy_results['best_month'][0]
@@ -34,13 +35,13 @@ def create_html_time_metrics_table(results, report):
         percentage = copy_results['best_year'][0]
         date = copy_results['best_year'][1]
         copy_results['Best Year'] = f"{safe_format_percentage(
-            percentage, '{:.2f}'
+            percentage, string_format
         )}% {safe_format_date(date, '%b %Y')}"
     if isinstance(copy_results['worst_year'], tuple):
         percentage = copy_results['worst_year'][0]
         date = copy_results['worst_year'][1]
         copy_results['Worst Year'] = f"{safe_format_percentage(
-            percentage, '{:.2f}'
+            percentage, string_format
         )}% {safe_format_date(date, '%b %Y')}"
 
     stats = {
diff --git a/investing_algorithm_framework/app/reporting/tables/trade_metrics_table.py b/investing_algorithm_framework/app/reporting/tables/trade_metrics_table.py
@@ -65,9 +65,10 @@ def highlight_win_loss_ratio(row):
 
 def create_html_trade_metrics_table(results, report):
     copy_results = results.to_dict().copy()
-    copy_results['Trades per Year'] = safe_format(copy_results['trades_per_year'], "{:.2f}")
-    copy_results['Trades per Day'] =  safe_format(copy_results['trade_per_day'], "{:.2f}")
-    copy_results['Exposure Factor'] =  safe_format(copy_results['exposure_factor'], "{:.2f}")
+    string_format = "{:.2f}"
+    copy_results['Trades per Year'] = safe_format(copy_results['trades_per_year'], string_format)
+    copy_results['Trades per Day'] =  safe_format(copy_results['trade_per_day'], string_format)
+    copy_results['Exposure Factor'] =  safe_format(copy_results['exposure_factor'],string_format)
     best_trade = copy_results['best_trade']
 
     if best_trade is None:
@@ -86,8 +87,8 @@ def create_html_trade_metrics_table(results, report):
         copy_results['Worst Trade'] = f"{copy_results['worst_trade'].net_gain:.2f} {report.trading_symbol} ({copy_results['worst_trade'].net_gain_percentage:.2f})%"
         copy_results['Worst Trade Date'] = copy_results['worst_trade_date'].strftime('%Y-%m-%d')
 
-    copy_results['Trades Average Gain'] = f"{safe_format(copy_results['trades_average_gain'][0], "{:.2f}")} {report.trading_symbol} {copy_results['trades_average_gain'][1]:.2f}%"
-    copy_results['Trades Average Loss'] = f"{safe_format(copy_results['trades_average_loss'][0], "{:.2f}")} {report.trading_symbol} {copy_results['trades_average_loss'][1]:.2f}%"
+    copy_results['Trades Average Gain'] = f"{safe_format(copy_results['trades_average_gain'][0], string_format)} {report.trading_symbol} {copy_results['trades_average_gain'][1]:.2f}%"
+    copy_results['Trades Average Loss'] = f"{safe_format(copy_results['trades_average_loss'][0], string_format)} {report.trading_symbol} {copy_results['trades_average_loss'][1]:.2f}%"
     copy_results['Average Trade Duration'] = f"{copy_results['average_trade_duration']:.2f} hours"
     copy_results['Number of Trades'] = f"{copy_results['number_of_trades']}"
     copy_results['Win Rate'] = f"{copy_results['win_rate']:.2f}%"
