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

investing_algorithm_framework/app/reporting/charts/rolling_sharp_ratio.py

@@ -0,0 +1,79 @@
+import pandas as pd
+import plotly.graph_objects as go
+
+
+def get_rolling_sharpe_ratio_chart(rolling_sharpe_ratio_series):
+    """
+    Generates a Plotly figure showing the rolling Sharpe ratio series.
+
+    Args:
+        rolling_sharpe_ratio_series: List of tuples with rolling Sharpe
+            ratio data. Each tuple should contain a Sharpe ratio
+            value and the corresponding timestamp.
+    Returns:
+        plotly.graph_objects.Figure: A Plotly figure containing
+        the rolling Sharpe ratio chart.
+    """
+    results = rolling_sharpe_ratio_series
+    rolling_sharpe_ratio_df = pd.DataFrame(
+        results, columns=['sharpe_ratio', 'timestamp']
+    )
+    rolling_sharpe_ratio_df['timestamp'] = pd.to_datetime(
+        rolling_sharpe_ratio_df['timestamp']
+    )
+
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scatter(
+            x=rolling_sharpe_ratio_df['timestamp'],
+            y=rolling_sharpe_ratio_df['sharpe_ratio'],
+            mode='lines',
+            name='Rolling Sharpe Ratio',
+            line=dict(color='#1f77b4', width=2)
+        )
+    )
+
+    last_nan_row = rolling_sharpe_ratio_df[
+        rolling_sharpe_ratio_df['sharpe_ratio'].isna()
+    ]
+    if not last_nan_row.empty:
+        last_nan_date = last_nan_row['timestamp'].max()
+        fig.add_vline(
+            x=last_nan_date,
+            line=dict(color='grey', width=1, dash='dash')
+        )
+
+    fig.update_layout(
+        xaxis=dict(
+            showgrid=True,
+            gridcolor='lightgray',
+            tickformat='%b %Y',
+            tickfont=dict(color='black'),
+            showline=True,
+            linecolor='black',
+            ticks='outside',
+            tickcolor='black'
+        ),
+        yaxis=dict(
+            title='Rolling Sharpe Ratio',
+            showgrid=True,
+            gridcolor='lightgray',
+            tickfont=dict(color='black'),
+            showline=True,
+            linecolor='black',
+            ticks='outside',
+            tickcolor='black'
+        ),
+        plot_bgcolor='white',
+        paper_bgcolor='white',
+        font=dict(color='black'),
+        hovermode='x unified',
+        legend=dict(
+            font=dict(color='black'),
+            bgcolor='rgba(0,0,0,0)',
+            bordercolor='black'
+        ),
+        height=300,
+        margin=dict(l=20, r=20, t=30, b=20)
+    )
+    return fig

investing_algorithm_framework/app/reporting/charts/yearly_returns_barchart.py

@@ -0,0 +1,55 @@
+import pandas as pd
+import plotly.express as px
+
+
+def get_yearly_returns_bar_chart(yearly_returns_series):
+    """
+    Create a bar chart showing yearly returns.
+    This chart visualizes the yearly returns of the backtest report.
+
+    Args:
+        yearly_returns_series: The yearly returns data as a series.
+
+    Returns:
+        A Plotly Figure object representing the yearly returns bar chart.
+    """
+    # Convert the series to a DataFrame
+    df = pd.DataFrame(yearly_returns_series, columns=["Return", "Year"])
+
+    # Ensure the 'Year' column is datetime-like
+    df["Year"] = pd.to_datetime(df["Year"], errors="coerce")
+
+    # Extract the year from the datetime
+    df["Year"] = df["Year"].dt.year
+
+    # Convert returns to percentage
+    df["Return"] = df["Return"] * 100  # Convert to percentage
+
+    # Ensure that there are no floating point numbers in the Return column
+    df["Return"] = df["Return"].round(0).astype(int)
+
+    # Create the bar chart
+    fig = px.bar(
+        df,
+        x="Year",
+        y="Return",
+        text="Return",
+        title="Yearly Returns (%)",
+        color="Return",
+        color_continuous_scale=["red", "green"]
+    )
+
+    # Update layout for padding and formatting
+    fig.update_layout(
+        xaxis=dict(title="Time", tickmode="linear"),
+        yaxis=dict(title=None, tickformat="", range=[-10, 30]),
+        showlegend=False,
+        coloraxis_showscale=False,  # Disable the color scale legend
+        height=350,
+        margin=dict(l=0, r=0, t=40, b=20),
+    )
+
+    # Format bar text
+    fig.update_traces(texttemplate="%{text}", textposition="outside")
+    return fig
+

investing_algorithm_framework/app/reporting/generate.py

@@ -0,0 +1,185 @@
+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_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:
+    """
+    Extract the symbol from the file name.
+
+    Args:
+        file_name (str): The file name from which to extract the symbol.
+
+    Returns:
+        str: The extracted symbol.
+    """
+    # 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":
+    """
+    Add HTML content to the report.results.
+
+    Args:
+        report.results (Backtestreport.results): The backtest report.results to which the HTML
+            content will be added.
+
+    Returns:
+        Backtestreport: The updated report with HTML content.
+    """
+    metrics = report.metrics
+    # Create plots
+    equity_with_drawdown_fig = get_equity_curve_with_drawdown_chart(
+        metrics["Equity Curve"], metrics["Drawdown series"]
+    )
+    equity_with_drawdown_plot_html = equity_with_drawdown_fig.to_html(
+        full_html=False, include_plotlyjs='cdn',
+        config={'responsive': True}, default_width="90%"
+    )
+    rolling_sharpe_ratio_fig = get_rolling_sharpe_ratio_chart(
+        metrics["Rolling Sharpe Ratio"]
+    )
+    rolling_sharpe_ratio_plot_html = rolling_sharpe_ratio_fig.to_html(
+        full_html=False, include_plotlyjs='cdn',
+        config={'responsive': True}, default_width="90%"
+    )
+    monthly_returns_heatmap_fig = get_monthly_returns_heatmap_chart(
+        metrics["Monthly Returns"]
+    )
+    monthly_returns_heatmap_html = monthly_returns_heatmap_fig.to_html(
+        full_html=False, include_plotlyjs='cdn',
+        config={'responsive': True}
+    )
+    yearly_returns_histogram_fig = get_yearly_returns_bar_chart(
+        metrics["Yearly Returns"]
+    )
+    yearly_returns_histogram_html = yearly_returns_histogram_fig.to_html(
+        full_html=False, include_plotlyjs='cdn',
+        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
+    )
+    trades_metrics_table_html = create_html_trade_metrics_table(
+        metrics, report.results
+    )
+    time_metrics_table_html = create_html_time_metrics_table(
+        metrics, report.results
+    )
+    trades_table_html = create_html_trades_table(
+        report.results
+    )
+
+    # Jinja2 environment setup
+    template_dir = os.path.join(os.path.dirname(__file__), 'templates')
+    env = Environment(loader=FileSystemLoader(template_dir))
+    template = env.get_template('report_template.html.j2')
+
+    # Render template with variables
+    html_rendered = template.render(
+        report=report,
+        equity_with_drawdown_plot_html=equity_with_drawdown_plot_html,
+        rolling_sharpe_ratio_plot_html=rolling_sharpe_ratio_plot_html,
+        monthly_returns_heatmap_html=monthly_returns_heatmap_html,
+        yearly_returns_histogram_html=yearly_returns_histogram_html,
+        key_metrics_table_html=key_metrics_table_html,
+        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/__init__.py

@@ -0,0 +1,11 @@
+from .trades_table import create_html_trades_table
+from .key_metrics_table import create_html_key_metrics_table
+from .trade_metrics_table import create_html_trade_metrics_table
+from .time_metrics_table import create_html_time_metrics_table
+
+__all__ = [
+    "create_html_trades_table",
+    "create_html_key_metrics_table",
+    "create_html_trade_metrics_table",
+    "create_html_time_metrics_table"
+]

investing_algorithm_framework/app/reporting/tables/key_metrics_table.py

@@ -0,0 +1,217 @@
+import pandas as pd
+
+from .utils import safe_format, safe_format_percentage
+
+
+def highlight_sharpe_and_sortino(row):
+    """
+    | -------------- | ------------------------------------------- |
+    | **< 0**        | Bad: Underperforms risk-free asset          |
+    | **0.0 – 1.0**  | Suboptimal: Returns do not justify risk     |
+    | **1.0 – 1.99** | Acceptable: Reasonable risk-adjusted return |
+    | **2.0 – 2.99** | Good: Strong risk-adjusted performance      |
+    | **3.0+**       | Excellent: Exceptional risk-adjusted return |
+    """
+    metric = row['Metric']
+    try:
+        value = float(row['Value'])
+    except Exception:
+        value = None
+    styles = pd.Series('', index=row.index)
+    if metric in ['Sharpe Ratio', 'Sortino Ratio'] and value is not None:
+
+        if value < 0:
+            styles['Value'] = 'color: #B22222; font-weight: bold;'  # red
+        elif 0 <= value < 1:
+            styles['Value'] = 'color: #FFA500; font-weight: bold;'  # orange
+        elif 1 <= value < 2:
+            styles['Value'] = 'color: #FFD700; font-weight: bold;'  # gold
+        elif 2 <= value < 3:
+            styles['Value'] = 'color: #32CD32; font-weight: bold;' # lime green
+        elif value >= 3:
+            styles['Value'] = 'color: #228B22; font-weight: bold;' # dark green
+    return styles
+
+
+def highlight_profit_factor(row):
+    """
+    | **< 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 |
+    """
+    metric = row['Metric']
+    try:
+        value = float(row['Value'])
+    except Exception:
+        value = None
+    styles = pd.Series('', index=row.index)
+    if metric == 'Profit Factor' and value is not None:
+        if value < 1.0:
+            styles['Value'] = 'color: #B22222; font-weight: bold;'  # red
+        elif 1.0 <= value < 1.3:
+            styles['Value'] = 'color: #FFA500; font-weight: bold;'  # orange
+        elif 1.3 <= value < 1.6:
+            styles['Value'] = 'color: #FFD700; font-weight: bold;'  # gold
+        elif 1.6 <= value < 2.0:
+            styles['Value'] = 'color: #32CD32; font-weight: bold;'  # lime green
+        elif 2.0 <= value < 3.0:
+            styles['Value'] = 'color: #228B22; font-weight: bold;'  # dark green
+        elif value >= 3.0:
+            styles['Value'] = 'color: #006400; font-weight: bold;'  # dark green
+    return styles
+
+def highlight_calmar_ratio(row):
+    """
+    | **> 3.0**        | **Excellent** – strong return vs. drawdown                  |
+    | **2.0 – 3.0**    | **Very Good** – solid risk-adjusted performance             |
+    | **1.0 – 2.0**    | **Acceptable** – decent, especially for volatile strategies |
+    | **< 1.0**        | **Poor** – high drawdowns relative to return                |
+    """
+    metric = row['Metric']
+    try:
+        value = float(row['Value'])
+    except Exception:
+        value = None
+    styles = pd.Series('', index=row.index)
+    if metric == 'Calmar Ratio' and value is not None:
+        if value > 3.0:
+            styles['Value'] = 'color: #006400; font-weight: bold;'  # dark green
+        elif 2.0 <= value <= 3.0:
+            styles['Value'] = 'color: #228B22; font-weight: bold;'  # green
+        elif 1.0 <= value < 2.0:
+            styles['Value'] = 'color: #32CD32; font-weight: bold;'  # lime green
+        elif value < 1.0:
+            styles['Value'] = 'color: #B22222; font-weight: bold;'  # red
+    return styles
+
+
+def highlight_annual_volatility(row):
+    """
+    | **Annual Volatility** | **Risk Level** | **Typical for...**                                                     | **Comments**                                                                    |
+    | --------------------- | -------------- | ---------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
+    | **< 5%**              | Very Low Risk  | Cash equivalents, short-term bonds                                     | Low return expectations; often used for capital preservation                    |
+    | **5% – 10%**          | Low Risk       | Diversified bond portfolios, conservative allocation strategies        | Suitable for risk-averse investors                                              |
+    | **10% – 15%**         | Moderate Risk  | Balanced portfolios, large-cap equity indexes (e.g., S\&P 500 ≈ \~15%) | Standard for traditional diversified portfolios                                 |
+    | **15% – 25%**         | High Risk      | Growth stocks, hedge funds, active equity strategies                   | Higher return potential, but more drawdowns                                     |
+    | **> 25%**             | Very High Risk | Crypto, leveraged ETFs, speculative strategies                         | High potential returns, but prone to large losses; often not suitable long-term |
+    """
+    metric = row['Metric']
+    try:
+        value = float(row['Value'].strip('%')) / 100  # Convert percentage string to float
+    except Exception:
+        value = None
+    styles = pd.Series('', index=row.index)
+    if metric == 'Annual Volatility' and value is not None:
+        if value < 0.05:
+            styles['Value'] = 'color: #006400; font-weight: bold;'  # dark green
+        elif 0.05 <= value < 0.10:
+            styles['Value'] = 'color: #32CD32; font-weight: bold;'  # lime green
+        elif 0.10 <= value < 0.15:
+            styles['Value'] = 'color: #FFD700; font-weight: bold;'  # gold
+        elif 0.15 <= value < 0.25:
+            styles['Value'] = 'color: #FFA500; font-weight: bold;'  # orange
+        elif value >= 0.25:
+            styles['Value'] = 'color: #B22222; font-weight: bold;'  # red
+    return styles
+
+
+def highlight_max_drawdown(row):
+    """
+    | **Max Drawdown (%)** | **Interpretation**                                                   |
+    |-----------------------|----------------------------------------------------------------------|
+    | **0% to -5%**         | 🟢 Excellent — Very low risk, typical for conservative strategies     |
+    | **-5% to -10%**       | ✅ Good — Moderate volatility, acceptable for balanced portfolios     |
+    | **-10% to -20%**      | ⚠️ Elevated Risk — Common in growth or actively managed strategies    |
+    | **-20% to -40%**      | 🔻 High Risk — Significant drawdown, typical of aggressive strategies |
+    | **> -40%**            | 🚨 Very High Risk — Risk of capital loss or strategy failure          |
+    """
+    metric = row['Metric']
+    try:
+        value = float(row['Value'].strip('%'))
+    except Exception:
+        value = None
+    styles = pd.Series('', index=row.index)
+    if metric == 'Max Drawdown' and value is not None:
+        if value < 5:
+            styles['Value'] = 'color: #006400; font-weight: bold;'  # dark green
+        elif 10 >= value > 5:
+            styles['Value'] = 'color: #32CD32; font-weight: bold;'  # lime green
+        elif 20 >= value > 10:
+            styles['Value'] = 'color: #FFD700; font-weight: bold;'  # gold
+        elif 40 >= value > 20:
+            styles['Value'] = 'color: #FFA500; font-weight: bold;'  # orange
+        elif value >= 40:
+            styles['Value'] = 'color: #B22222; font-weight: bold;'  # red
+    return styles
+
+
+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'] = (
+        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"
+        ],
+        "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']
+        ]
+    }
+
+    df_stats = pd.DataFrame(stats)
+
+    table_html = (
+        df_stats.style
+        .apply(highlight_sharpe_and_sortino, axis=1)
+        .apply(highlight_profit_factor, axis=1)
+        .apply(highlight_calmar_ratio, axis=1)
+        .apply(highlight_annual_volatility, axis=1)
+        .apply(highlight_max_drawdown, axis=1)
+        .set_table_styles([
+            {'selector': 'th', 'props': [('background-color', '#f2f2f2'), ('font-weight', 'bold')]},
+            {'selector': 'td', 'props': [('font-size', '14px')]},
+            {'selector': 'tr:nth-child(even)', 'props': [('background-color', '#fafafa')]}
+        ])
+        .hide(axis='index')
+        .to_html()
+    )
+    return table_html

investing_algorithm_framework/app/reporting/tables/time_metrics_table.py

@@ -0,0 +1,80 @@
+import pandas as pd
+
+from .utils import safe_format_percentage, safe_format_date
+
+
+def create_html_time_metrics_table(results, report):
+    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):
+        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):
+        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",
+            "AVG Mo Return (Losing Months)",
+            "AVG Mo Return (Winning Months)",
+            "Best Month",
+            "Worst Month",
+            "Best Year",
+            "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'],
+            copy_results['Average Monthly Return (Losing Months)'],
+            copy_results['Average Monthly Return (Winning Months)'],
+            copy_results['Best Month'],
+            copy_results['Worst Month'],
+            copy_results['Best Year'],
+            copy_results['Worst Year'],
+        ]
+    }
+
+    df_stats = pd.DataFrame(stats)
+
+    table_html = (
+        df_stats.style
+        .set_table_styles([
+            {'selector': 'th', 'props': [('background-color', '#f2f2f2'), ('font-weight', 'bold')]},
+            {'selector': 'td', 'props': [('font-size', '14px')]},
+            {'selector': 'tr:nth-child(even)', 'props': [('background-color', '#fafafa')]}
+        ])
+        .hide(axis='index')
+        .to_html()
+    )
+    return table_html