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

investing_algorithm_framework/app/reporting/charts/equity_curve_drawdown.py

@@ -5,19 +5,16 @@ from plotly import graph_objects as go
 
 def get_equity_curve_with_drawdown_chart(equity_curve_series, drawdown_series):
     equity_curve_df = pd.DataFrame(
-        equity_curve_series, columns=["datetime", "value"]
+        equity_curve_series, columns=["value", "datetime"]
     )
     drawdown_df = pd.DataFrame(
-        drawdown_series, columns=["datetime", "value"]
+        drawdown_series, columns=["value", "datetime"]
     )
 
     # Normalize equity to start at 1
-    equity_curve_df["value"] = (equity_curve_df["value"] /
-                                equity_curve_df["value"].iloc[0])
-
-    # Split into above and below 1
-    above_1 = equity_curve_df[equity_curve_df["value"] >= 1]
-    below_1 = equity_curve_df[equity_curve_df["value"] < 1]
+    equity_curve_df["value"] = (
+        equity_curve_df["value"] / equity_curve_df["value"].iloc[0]
+    )
 
     fig = make_subplots(
         rows=2,
@@ -28,27 +25,15 @@ def get_equity_curve_with_drawdown_chart(equity_curve_series, drawdown_series):
         subplot_titles=["", ""]
     )
 
-    # Equity curve - gains (green)
-    fig.add_trace(
-        go.Scatter(
-            x=above_1["datetime"],
-            y=above_1["value"],
-            mode="lines",
-            line=dict(color="rgba(34, 139, 34, 0.9)", width=1.5),
-            name="Cumulative Equity (Gains)"
-        ),
-        row=1,
-        col=1
-    )
-
-    # Equity curve - losses (red)
+    # Draw equity curve
     fig.add_trace(
         go.Scatter(
-            x=below_1["datetime"],
-            y=below_1["value"],
+            x=equity_curve_df["datetime"],
+            y=equity_curve_df["value"],
             mode="lines",
-            line=dict(color="rgba(220, 20, 60, 0.9)", width=1.5),
-            name="Cumulative Equity (Loss)"
+            line=dict(color="rgba(0, 128, 0, 0.8)", width=1),
+            name="Equity Curve",
+            hovertemplate="<b>Equity</b><br>%{x}<br>Value: %{y:.2f}<extra></extra>"
         ),
         row=1,
         col=1

investing_algorithm_framework/app/reporting/charts/line_chart.py

@@ -0,0 +1,11 @@
+import plotly.graph_objects as go
+
+
+def create_line_scatter(x, y, name, colour = 'blue'):
+    return go.Scatter(
+        x=x,
+        y=y,
+        mode='lines',
+        name=name,
+        line=dict(color=colour)
+    )

investing_algorithm_framework/app/reporting/charts/ohlcv_data_completeness.py

@@ -0,0 +1,51 @@
+import plotly.graph_objects as go
+import pandas as pd
+import plotly.io as pio
+
+def get_ohlcv_data_completeness_chart(
+    df,
+    timeframe='1min',
+    windowsize=100,
+    title="OHLCV Data completenes"
+):
+    df = df.copy()
+    df['Datetime'] = pd.to_datetime(df['Datetime'])
+    df = df.sort_values('Datetime').tail(windowsize)
+    start = df['Datetime'].iloc[0]
+    end = df['Datetime'].iloc[-1]
+    freq = pd.to_timedelta(timeframe)
+    expected = pd.date_range(start, end, freq=freq)
+    actual = df['Datetime']
+    missing = expected.difference(actual)
+
+    # Calculte the percentage completeness
+    completeness = len(actual) / len(expected) * 100
+    title += f" ({completeness:.2f}% complete)"
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scatter(
+            x=actual,
+            y=[1]*len(actual),
+            mode='markers',
+            name='Present',
+            marker=dict(color='green', size=6)
+        )
+    )
+    fig.add_trace(
+        go.Scatter(
+            x=missing,
+            y=[1]*len(missing),
+            mode='markers',
+            name='Missing',
+            marker=dict(color='red', size=6, symbol='x')
+        )
+    )
+    fig.update_layout(
+        title=title,
+        xaxis_title='Datetime',
+        yaxis=dict(showticklabels=False),
+        height=300,
+        showlegend=True
+    )
+
+    return pio.to_html(fig, full_html=False, include_plotlyjs='cdn')

investing_algorithm_framework/app/reporting/charts/rolling_sharp_ratio.py

@@ -2,7 +2,7 @@ import pandas as pd
 import plotly.graph_objects as go
 
 
-def get_rolling_sharp_ratio_chart(rolling_sharpe_ratio_series):
+def get_rolling_sharpe_ratio_chart(rolling_sharpe_ratio_series):
     """
     Generates a Plotly figure showing the rolling Sharpe ratio series.
 

investing_algorithm_framework/app/reporting/generate.py

@@ -1,126 +1,77 @@
 import os
+import logging
+import pandas as pd
 from jinja2 import Environment, FileSystemLoader
 
 from .tables import create_html_time_metrics_table, \
     create_html_trade_metrics_table, create_html_key_metrics_table, \
     create_html_trades_table
 from .charts import get_equity_curve_with_drawdown_chart, \
-    get_rolling_sharp_ratio_chart, get_monthly_returns_heatmap_chart, \
-    get_yearly_returns_bar_chart
-from .metrics import get_equity_curve, get_total_return, get_cagr, \
-    get_sharpe_ratio, get_rolling_sharpe_ratio, get_sortino_ratio, \
-    get_profit_factor, get_calmar_ratio, get_annual_volatility, \
-    get_monthly_returns, get_yearly_returns, get_drawdown_series, \
-    get_max_drawdown, get_max_drawdown_absolute, get_max_daily_drawdown, \
-    get_max_drawdown_duration, get_trade_frequency, \
-    get_exposure, get_win_rate, get_average_gain, get_average_loss, \
-    get_best_trade, get_best_trade_date, get_worst_trade, \
-    get_worst_trade_date, get_average_trade_duration, \
-    get_percentage_winning_months, get_percentage_winning_years, \
-    get_average_monthly_return, \
-    get_average_monthly_return_losing_months, get_win_loss_ratio, \
-    get_average_monthly_return_winning_months, get_best_month, \
-    get_best_year, get_worst_month, get_worst_year, get_trades_per_year
-
-
-def add_metrics(report, risk_free_rate=None) -> "BacktestReport":
+    get_rolling_sharpe_ratio_chart, get_monthly_returns_heatmap_chart, \
+    get_yearly_returns_bar_chart, get_ohlcv_data_completeness_chart
+from investing_algorithm_framework.domain import TimeFrame
+
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+def get_symbol_from_file_name(file_name: str) -> str:
     """
-    Add metrics to the report.results.
+    Extract the symbol from the file name.
 
     Args:
-        report (BacktestReport): The backtest report.results to
-            which the metrics will be added.
-        risk_free_rate (float, optional): The risk-free rate to be used in
-            the report.results calculations. Defaults to None. If none, the
-            risk-free rate will be retrieved from the US Treasury (10-year
-            yield) using the `get_risk_free_rate` function.
+        file_name (str): The file name from which to extract the symbol.
+
+    Returns:
+        str: The extracted symbol.
     """
-    results = {
-        "backtest_start_date": report.results.backtest_start_date,
-        "backtest_end_date": report.results.backtest_end_date,
-        "Equity Curve": get_equity_curve(report.results.portfolio_snapshots),
-        "Total Return": get_total_return(report.results.portfolio_snapshots),
-        "CAGR": get_cagr(report.results.portfolio_snapshots),
-        "Sharpe Ratio": get_sharpe_ratio(report.results.portfolio_snapshots),
-        "Rolling Sharpe Ratio": get_rolling_sharpe_ratio(
-            report.results.portfolio_snapshots, risk_free_rate=risk_free_rate
-        ),
-        "Sortino Ratio": get_sortino_ratio(
-            report.results.portfolio_snapshots, risk_free_rate=risk_free_rate
-        ),
-        "Profit Factor": get_profit_factor(report.results.get_trades()),
-        "Calmar Ratio": get_calmar_ratio(report.results.portfolio_snapshots),
-        "Annual Volatility": get_annual_volatility(
-            report.results.portfolio_snapshots
-        ),
-        "Monthly Returns": get_monthly_returns(
-            report.results.portfolio_snapshots
-        ),
-        "Yearly Returns": get_yearly_returns(
-            report.results.portfolio_snapshots
-        ),
-        "Drawdown series": get_drawdown_series(
-            report.results.portfolio_snapshots
-        ),
-        "Max Drawdown": get_max_drawdown(
-            report.results.portfolio_snapshots
-        ),
-        "Max Drawdown Absolute": get_max_drawdown_absolute(
-            report.results.portfolio_snapshots),
-        "Max Daily Drawdown": get_max_daily_drawdown(
-            report.results.portfolio_snapshots
-        ),
-        "Max Drawdown Duration": get_max_drawdown_duration(
-            report.results.portfolio_snapshots
-        ),
-        "Trades per Year": get_trades_per_year(
-            report.results.get_trades(),
-            report.results.backtest_start_date,
-            report.results.backtest_end_date
-        ),
-        "Trade per day": get_trade_frequency(
-            report.results.get_trades(),
-            report.results.backtest_start_date,
-            report.results.backtest_end_date
-        ),
-        "Exposure": get_exposure(
-            report.results.get_trades(),
-            report.results.backtest_start_date,
-            report.results.backtest_end_date
-        ),
-        "Trades winning percentage": get_win_rate(report.results.get_trades()),
-        "Trades average gain": get_average_gain(report.results.get_trades()),
-        "Trades average loss": get_average_loss(report.results.get_trades()),
-        "Best Trade": get_best_trade(report.results.get_trades()),
-        "Best Trade Date": get_best_trade_date(report.results.get_trades()),
-        "Worst Trade": get_worst_trade(report.results.get_trades()),
-        "Worst Trade Date": get_worst_trade_date(report.results.get_trades()),
-        "Average Trade Duration": get_average_trade_duration(
-            report.results.get_trades()),
-        "Number of Trades": len(report.results.get_trades()),
-        "Win Rate": get_win_rate(report.results.get_trades()),
-        "Win/Loss Ratio": get_win_loss_ratio(report.results.get_trades()),
-        "Percentage Winning Months": get_percentage_winning_months(
-            report.results.portfolio_snapshots),
-        "Percentage Winning Years": get_percentage_winning_years(
-            report.results.portfolio_snapshots),
-        "Average Monthly Return": get_average_monthly_return(
-            report.results.portfolio_snapshots),
-        "Average Monthly Return (Losing Months)":
-            get_average_monthly_return_losing_months(
-                report.results.portfolio_snapshots
-            ),
-        "Average Monthly Return (Winning Months)":
-            get_average_monthly_return_winning_months(
-                report.results.portfolio_snapshots
-            ),
-        "Best Month": get_best_month(report.results.portfolio_snapshots),
-        "Best Year": get_best_year(report.results.portfolio_snapshots),
-        "Worst Month": get_worst_month(report.results.portfolio_snapshots),
-        "Worst Year": get_worst_year(report.results.portfolio_snapshots),
-    }
-    report.metrics = results
-    return report
+    # Assuming the file name format is "symbol_timeframe.csv"
+    return file_name.split('_')[0].upper()
+
+def get_market_from_file_name(file_name: str) -> str:
+    """
+    Extract the market from the file name.
+
+    Args:
+        file_name (str): The file name from which to extract the market.
+
+    Returns:
+        str: The extracted market.
+    """
+    # Assuming the file name format is "symbol_market_timeframe.csv"
+    parts = file_name.split('_')
+    if len(parts) < 2:
+        raise ValueError("File name does not contain a valid market.")
+    return parts[1].upper()
+
+
+def get_time_frame_from_file_name(file_name: str) -> TimeFrame:
+    """
+    Extract the time frame from the file name.
+
+    Args:
+        file_name (str): The file name from which to extract the time frame.
+
+    Returns:
+        TimeFrame: The extracted time frame.
+    """
+    parts = file_name.split('_')
+
+    if len(parts) < 3:
+        raise ValueError(
+            "File name does not contain a valid time frame."
+        )
+    time_frame_str = parts[3]
+
+    try:
+        return TimeFrame.from_string(time_frame_str)
+    except ValueError:
+        raise ValueError(
+            f"Could not extract time frame from file name: {file_path}. "
+            f"Expected format 'OHLCV_<SYMBOL>_<MARKET>_<TIME_FRAME>_<START_DATE>_<END_DATE>.csv', "
+            f"got '{time_frame_str}'."
+        )
+
 
 def add_html_report(report) -> "BacktestReport":
     """
@@ -131,7 +82,7 @@ def add_html_report(report) -> "BacktestReport":
             content will be added.
 
     Returns:
-        Backtestreport.results: The updated report.results with HTML content.
+        Backtestreport: The updated report with HTML content.
     """
     metrics = report.metrics
     # Create plots
@@ -142,7 +93,7 @@ def add_html_report(report) -> "BacktestReport":
         full_html=False, include_plotlyjs='cdn',
         config={'responsive': True}, default_width="90%"
     )
-    rolling_sharpe_ratio_fig = get_rolling_sharp_ratio_chart(
+    rolling_sharpe_ratio_fig = get_rolling_sharpe_ratio_chart(
         metrics["Rolling Sharpe Ratio"]
     )
     rolling_sharpe_ratio_plot_html = rolling_sharpe_ratio_fig.to_html(
@@ -164,6 +115,40 @@ def add_html_report(report) -> "BacktestReport":
         config={'responsive': True}
     )
 
+    # Create OHLCV data completeness charts
+    data_files = report.data_files
+    ohlcv_data_completeness_charts_html = ""
+
+    for file in data_files:
+        try:
+            if file.endswith('.csv'):
+                df = pd.read_csv(file, parse_dates=['Datetime'])
+                file_name = os.path.basename(file)
+                symbol = get_symbol_from_file_name(file_name)
+                market = get_market_from_file_name(file_name)
+                time_frame = get_time_frame_from_file_name(file_name)
+                title = f"OHLCV Data Completeness for {market} - {symbol} - {time_frame.value}"
+                ohlcv_data_completeness_chart_html = \
+                    get_ohlcv_data_completeness_chart(
+                        df,
+                        timeframe=time_frame.value,
+                        windowsize=200,
+                        title=title
+                    )
+
+                ohlcv_data_completeness_charts_html += (
+                    '<div class="ohlcv-data-completeness-chart">'
+                    f'{ohlcv_data_completeness_chart_html}'
+                    '</div>'
+                )
+
+        except Exception as e:
+            logger.warning(
+                "Error creating OHLCV data completeness " +
+                f"chart for {file}: {e}"
+            )
+            continue
+
     # Create HTML tables
     key_metrics_table_html = create_html_key_metrics_table(
         metrics, report.results
@@ -194,6 +179,7 @@ def add_html_report(report) -> "BacktestReport":
         trades_metrics_table_html=trades_metrics_table_html,
         time_metrics_table_html=time_metrics_table_html,
         trades_table_html=trades_table_html,
+        data_completeness_charts_html=ohlcv_data_completeness_charts_html
     )
     report.html_report = html_rendered
     return report

investing_algorithm_framework/app/reporting/tables/key_metrics_table.py

@@ -1,6 +1,6 @@
 import pandas as pd
 
-from .utils import safe_format, safe_format_date, safe_format_percentage
+from .utils import safe_format, safe_format_percentage
 
 
 def highlight_sharpe_and_sortino(row):
@@ -138,7 +138,6 @@ def highlight_max_drawdown(row):
         if value < 5:
             styles['Value'] = 'color: #006400; font-weight: bold;'  # dark green
         elif 10 >= value > 5:
-            print("10 >= value > 5")
             styles['Value'] = 'color: #32CD32; font-weight: bold;'  # lime green
         elif 20 >= value > 10:
             styles['Value'] = 'color: #FFD700; font-weight: bold;'  # gold
@@ -150,42 +149,51 @@ def highlight_max_drawdown(row):
 
 
 def create_html_key_metrics_table(results, report):
-    copy_results = results.copy()
+    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['Max Drawdown Duration'] = f"{copy_results['Max Drawdown Duration']} hours - {copy_results['Max Drawdown Duration'] // 24} days"
-
-    # copy_results['Total Return'] = f"{copy_results['Total Return']:.2f}%"
-    # copy_results['CAGR'] = f"{copy_results['CAGR'] * 100:.2f}%"
-    # copy_results['Sharpe Ratio'] = f"{copy_results['Sharpe Ratio']:.2f}"
-    # copy_results['Sortino Ratio'] = f"{copy_results['Sortino Ratio']:.2f}"
-    # copy_results['Profit Factor'] = f"{copy_results['Profit Factor']:.2f}"
-    # copy_results['Calmar Ratio'] = f"{copy_results['Calmar Ratio']:.2f}"
-    # copy_results['Annual Volatility'] = f"{copy_results['Annual Volatility'] * 100:.2f}%"
-    # copy_results['Max Drawdown'] = f"{copy_results['Max Drawdown'] * 100:.2f}%"
-    # copy_results['Max Drawdown Absolute'] = f"{copy_results['Max Drawdown Absolute']:.2f} {report.trading_symbol}"
-    # copy_results['Max Daily Drawdown'] = f"{copy_results['Max Daily Drawdown'] * 100:.2f}%"
-    # copy_results['Max Drawdown Duration'] = f"{copy_results['Max Drawdown Duration']} hours - {copy_results['Max Drawdown Duration'] // 24} days"
+    copy_results['Total Return'] = (
+        f"{safe_format(copy_results['total_net_gain'], format_str)} "
+        f"({safe_format_percentage(copy_results['total_net_gain_percentage'], 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 = {
         "Metric": [
-            "Total Return", "CAGR", "Sharpe Ratio", "Sortino Ratio",
-            "Profit Factor", "Calmar Ratio", "Annual Volatility", "Max Drawdown", "Max Drawdown Absolute", "Max Daily Drawdown", "Max Drawdown Duration"
+            "Total Return",
+            "CAGR",
+            "Sharpe Ratio",
+            "Sortino Ratio",
+            "Profit Factor",
+            "Calmar Ratio",
+            "Annual Volatility",
+            "Max Drawdown",
+            "Max Drawdown Absolute",
+            "Max Daily Drawdown",
+            "Max Drawdown Duration"
         ],
         "Value": [
-            copy_results['Total Return'], copy_results['CAGR'], copy_results['Sharpe Ratio'],
-            copy_results['Sortino Ratio'], copy_results['Profit Factor'], copy_results['Calmar Ratio'],
-            copy_results['Annual Volatility'], copy_results['Max Drawdown'], copy_results['Max Drawdown Absolute'],
-            copy_results['Max Daily Drawdown'], copy_results['Max Drawdown Duration']
+            copy_results['Total Return'],
+            copy_results['CAGR'],
+            copy_results['Sharpe Ratio'],
+            copy_results['Sortino Ratio'],
+            copy_results['Profit Factor'],
+            copy_results['Calmar Ratio'],
+            copy_results['Annual Volatility'],
+            copy_results['Max Drawdown'],
+            copy_results['Max Drawdown Absolute'],
+            copy_results['Max Daily Drawdown'],
+            copy_results['Max Drawdown Duration']
         ]
     }
 

investing_algorithm_framework/app/reporting/tables/time_metrics_table.py

@@ -1,40 +1,45 @@
 import pandas as pd
 
-from .utils import safe_format, safe_format_percentage, safe_format_date
+from .utils import safe_format_percentage, safe_format_date
 
 
 def create_html_time_metrics_table(results, report):
-    copy_results = results.copy()
-    copy_results['Percentage Winning Months'] = safe_format(copy_results['Percentage Winning Months'], "{:.2f}")
-    copy_results['Percentage Winning Years'] = safe_format(copy_results['Percentage Winning Years'], "{:.2f}")
-    copy_results['Average Monthly Return'] = safe_format(copy_results['Average Monthly Return'], "{:.2f}")
-    copy_results['Average Monthly Return (Losing Months)'] = safe_format(copy_results['Average Monthly Return (Losing Months)'], "{:.2f}%")
-    copy_results['Average Monthly Return (Winning Months)'] = safe_format(copy_results['Average Monthly Return (Winning Months)'], "{:.2f}%")
+    copy_results = results.to_dict().copy()
+    start_date = report.backtest_start_date
+    end_date = report.backtest_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'] = 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):
-        copy_results['Best Month'] = (
-            safe_format_percentage(copy_results['Best Month'][0], "{:.2f}%"),
-            safe_format_date(copy_results['Best Month'][1], "%b %Y")
-        )
+    if isinstance(copy_results['best_month'], tuple):
+        percentage = copy_results['best_month'][0]
+        date = copy_results['best_month'][1]
+        copy_results['Best Month'] = f"{safe_format_percentage(percentage, string_format)}% {safe_format_date(date, '%b %Y')}"
 
-    if isinstance(copy_results['Worst Month'], tuple):
-        copy_results['Worst Month'] = (
-            safe_format_percentage(copy_results['Worst Month'][0], "{:.2f}%"),
-            safe_format_date(copy_results['Worst Month'][1], "%b %Y")
-        )
-    if isinstance(copy_results['Best Year'], tuple):
-        copy_results['Best Year'] = (
-            safe_format_percentage(copy_results['Best Year'][0], "{:.2f}%"),
-            safe_format_date(copy_results['Best Year'][1], "%Y")
-        )
-    if isinstance(copy_results['Worst Year'], tuple):
-        copy_results['Worst Year'] = (
-            safe_format_percentage(copy_results['Worst Year'][0], "{:.2f}%"),
-            safe_format_date(copy_results['Worst Year'][1], "%Y")
-        )
+    if isinstance(copy_results['worst_month'], tuple):
+        percentage = copy_results['worst_month'][0]
+        date = copy_results['worst_month'][1]
+        copy_results['Worst Month'] = f"{safe_format_percentage(percentage, string_format)}% {safe_format_date(date, '%b %Y')}"
+
+    if isinstance(copy_results['best_year'], tuple):
+        percentage = copy_results['best_year'][0]
+        date = copy_results['best_year'][1]
+        copy_results['Best Year'] = f"{safe_format_percentage(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, string_format)}% {safe_format_date(date, '%b %Y')}"
 
     stats = {
         "Metric": [
+            "Start Date",
+            "End Date",
             "% Winning Months",
             "% Winning Years",
             "AVG Mo Return",
@@ -46,6 +51,8 @@ def create_html_time_metrics_table(results, report):
             "Worst Year",
         ],
         "Value": [
+            copy_results['Start Date'],
+            copy_results['End Date'],
             copy_results['Percentage Winning Months'],
             copy_results['Percentage Winning Years'],
             copy_results['Average Monthly Return'],