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

investing_algorithm_framework/app/reporting/backtest_report.py

@@ -1,14 +1,84 @@
-import json
+import logging
 import os
-import sys
+from pathlib import Path
 import webbrowser
 from dataclasses import dataclass
-from IPython.display import display, HTML
+from dataclasses import field
+from typing import List, Union
+
+import pandas as pd
 from IPython import get_ipython
+from IPython.display import display, HTML
+from jinja2 import Environment, FileSystemLoader
+
+from investing_algorithm_framework.domain import TimeFrame, Backtest, \
+    OperationalException, BacktestDateRange
+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 .tables import create_html_time_metrics_table, \
+    create_html_trade_metrics_table, create_html_key_metrics_table, \
+    create_html_trades_table
+
+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.
 
-from investing_algorithm_framework.domain import OperationalException, \
-    BacktestResult
-from .generate import add_html_report, add_metrics
+    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}'."
+        )
 
 
 @dataclass
@@ -29,207 +99,251 @@ class BacktestReport:
         strategy_path (str): The path to the strategy directory used in the
             backtest.
     """
+    backtest: Backtest = None
     html_report: str = None
     html_report_path: str = None
-    metrics = None
-    results: BacktestResult = None
-    risk_free_rate: float = None
 
-    def __post_init__(self):
+    def show(
+        self,
+        backtest_date_range: BacktestDateRange,
+        browser: bool = False
+    ):
         """
-        Post-initialization method to create the metrics and HTML report
+        Display the HTML report in a Jupyter notebook cell.
         """
-        if self.metrics is None:
-            add_metrics(self, self.risk_free_rate)
 
-        if self.html_report is None:
-            add_html_report(self)
+        if not self.html_report:
+            # If the HTML report is not created, create it
+            self._create_html_report(backtest_date_range)
 
-    def show(self):
-        """
-        Display the HTML report in a Jupyter notebook cell.
-        """
-        if self.html_report:
+        # Save the html report to a tmp location
+        path = "/tmp/backtest_report.html"
+        with open(path, "w") as html_file:
+            html_file.write(self.html_report)
 
-            def in_jupyter_notebook():
-                try:
-                    shell = get_ipython().__class__.__name__
-                    return shell == 'ZMQInteractiveShell'
-                except (NameError, ImportError):
-                    return False
+        if browser:
+            webbrowser.open(f"file://{path}")
 
-            if in_jupyter_notebook():
-                display(HTML(self.html_report))
-            else:
-                webbrowser.open(f"file://{self.html_report_path}")
+        def in_jupyter_notebook():
+            try:
+                shell = get_ipython().__class__.__name__
+                return shell == 'ZMQInteractiveShell'
+            except (NameError, ImportError):
+                return False
+
+        if in_jupyter_notebook():
+            display(HTML(self.html_report))
         else:
-            raise OperationalException("No HTML report available to display.")
+            webbrowser.open(f"file://{path}")
 
-    @staticmethod
-    def open(file_path) -> "BacktestReport":
+    def _create_html_report(self, backtest_date_range: BacktestDateRange):
         """
-        Open the backtest report from a file.
+        Create an HTML report from the backtest metrics and results.
 
-        Args:
-            file_path (str): The file path from which the report will
-                be loaded.
+        This method generates various charts and tables from the backtest
+        metrics and results, and renders them into an HTML template using
+        Jinja2.
+
+        Raises:
+            OperationalException: If no backtests are available to
+                create a report.
 
         Returns:
-            BacktestReport: An instance of BacktestReport loaded from the file.
+            None
         """
-        if not os.path.exists(file_path):
+        # Get the first backtest
+        if not self.backtest:
             raise OperationalException(
-                "Backtest report file or folder does not exist"
+                "No backtest available to create a report."
             )
 
-        if os.path.isdir(file_path):
-            report_file_path = os.path.join(file_path, "report.json")
-            results = None
-            html_report = None
-
-            # Open the results file
-            if os.path.isfile(report_file_path):
-                with open(report_file_path, 'r') as json_file:
-                    data = json.load(json_file)
 
-                results = BacktestResult.from_dict(data)
-
-            # Open the html file
-            html_file_path = os.path.join(file_path, "report.html")
-            if os.path.isfile(html_file_path):
-                with open(html_file_path, 'r') as html_file:
-                    html_content = html_file.read()
-                html_report = html_content
+        metrics = self.backtest.get_backtest_metrics(backtest_date_range)
+        run = self.backtest.get_backtest_run(backtest_date_range)
+        # 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 = []
+        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>'
+                    )
 
-            if not results and not html_report:
-                raise OperationalException(
-                    "No report.json or report.html found in the directory"
+            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, run
+        )
+        trades_metrics_table_html = create_html_trade_metrics_table(
+            metrics, run
+        )
+        time_metrics_table_html = create_html_time_metrics_table(
+            metrics, run
+        )
+        trades_table_html = create_html_trades_table(run)
+
+        # 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=run,
+            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
+        )
+        self.html_report = html_rendered
 
-            return BacktestReport(
-                html_report=html_report,
-                results=results,
-                html_report_path=html_file_path
-            )
-        else:
-            return BacktestReport.open(file_path)
-
-    def save(
-        self,
-        path,
-        save_strategy=True,
-        algorithm=None,
-        strategy_directory_path=None
-    ):
+    @staticmethod
+    def _load_backtest(backtest_path: str) -> Backtest:
         """
-        Save the backtest report. When saving the report, the metrics
-        will be saved as a JSON, the backtest results will be saved as a
-        JSON, and the HTML report will be saved as an HTML file.
+        Load the backtest from a give path
+        and return an instance of Backtest.
 
         Args:
-            path (str): The file path where the report will be saved.
-            save_strategy (bool): If True, the strategy code will be copied
-                to the report directory. Defaults to True.
-            algorithm (Algorithm, optional): The algorithm used for the
-                backtest. If provided, the strategy code will be copied to
-                the report directory.
-            strategy_directory_path (str, optional): The path to the
-                strategy directory. If provided, the strategy code will be
-                copied to the report directory.
+            backtest_path (str): The path to the backtest directory.
 
         Returns:
-            None
+            Backtest: An instance of Backtest loaded from the
+                backtest directory.
         """
+        return Backtest.open(backtest_path)
 
-        if not os.path.exists(path):
-            os.makedirs(path)
-
-        print("Saving backtest report to", path)
-        print(f"save_strategy: {save_strategy}")
-        if save_strategy:
-            # If strategy_directory_path is set, copy the strategy code to
-            # the report directory
-            if strategy_directory_path is not None:
-                print("Saving strategy code from directory")
-                # check if the strategy directory exists
-                if not os.path.exists(strategy_directory_path) and \
-                        not os.path.isdir(strategy_directory_path):
-                    raise OperationalException(
-                        "Strategy directory does not exist"
-                    )
+    @staticmethod
+    def _is_backtest(backtest_path: Union[str, Path]) -> bool:
+        """
+        Check if the given path is a valid backtest report directory.
 
-                # Copy the strategy directory to the report directory
-                strategy_directory_name = os.path.basename(
-                    strategy_directory_path
-                )
-                output_strategy_directory = os.path.join(
-                    path, strategy_directory_name
-                )
-                if not os.path.exists(output_strategy_directory):
-                    os.makedirs(output_strategy_directory)
-
-                strategy_files = os.listdir(strategy_directory_path)
-                for file in strategy_files:
-                    source_file = os.path.join(strategy_directory_path, file)
-                    destination_file = os.path.join(
-                        output_strategy_directory, file
-                    )
+        Args:
+            backtest_path (Union[str, Path]): The path to check.
 
-                    if os.path.isfile(source_file):
-                        # Copy the file to the output directory
-                        with open(source_file, "rb") as src:
-                            with open(destination_file, "wb") as dst:
-                                dst.write(src.read())
-
-            elif algorithm is not None:
-                print("saving strategy code from algorithm")
-                strategy = algorithm.strategies[0]
-                mod = sys.modules[strategy.__module__]
-                strategy_directory_path = os.path.dirname(mod.__file__)
-                strategy_directory_name = os.path.basename(
-                    strategy_directory_path
-                )
-                strategy_files = os.listdir(strategy_directory_path)
-                output_strategy_directory = os.path.join(
-                    path, strategy_directory_name
-                )
+        Returns:
+            bool: True if the path is a valid backtest report directory,
+                False otherwise.
+        """
+        return (
+            os.path.exists(backtest_path) and
+            os.path.isdir(backtest_path) and
+            os.path.isfile(os.path.join(backtest_path, "results.json"))
+            and os.path.isfile(os.path.join(backtest_path, "metrics.json"))
+        )
 
-                if not os.path.exists(output_strategy_directory):
-                    os.makedirs(output_strategy_directory)
+    @staticmethod
+    def open(
+        backtests: List[Backtest] = [],
+        directory_path=None
+    ) -> "BacktestReport":
+        """
+        Open the backtest report from a file.
 
-                for file in strategy_files:
-                    source_file = os.path.join(strategy_directory_path, file)
-                    destination_file = os.path.join(
-                        output_strategy_directory, file
-                    )
+        Args:
+            backtests (List[Backtest], optional): A list of Backtest instances
+                to include in the report. If provided, it will use these
+                backtests as part of the report.
+            directory_path (str, optional): The directory path from
+                which the reports will be loaded.
+
+        Returns:
+            BacktestReport: An instance of BacktestReport loaded from the file.
 
-                    if os.path.isfile(source_file):
-                        # Copy the file to the output directory
-                        with open(source_file, "rb") as src:
-                            with open(destination_file, "wb") as dst:
-                                dst.write(src.read())
+        Raises:
+            OperationalException: If the backtest path is not a valid backtest
+                report directory.
+        """
+        loaded_backtests = []
 
-            else:
-                raise OperationalException(
-                    "No strategy directory or algorithm provided to save the "
-                    "strategy code."
+        if directory_path is not None:
+            # Check if the directory is a valid backtest report directory
+            if BacktestReport._is_backtest(directory_path):
+                backtests.append(
+                    Backtest.open(directory_path)
                 )
+            else:
+                # Loop over all subdirectories
+                for root, dirs, _ in os.walk(directory_path):
+                    for dir_name in dirs:
+                        subdir_path = os.path.join(root, dir_name)
+                        if BacktestReport._is_backtest(subdir_path):
+                            loaded_backtests.append(
+                                Backtest.open(directory_path=subdir_path)
+                            )
+
+        if len(backtests) > 0:
+
+            for backtest in backtests:
+                if not isinstance(backtest, Backtest):
+                    raise OperationalException(
+                        "The provided backtest is not a valid Backtest instance."
+                    )
 
-        # Save the results as a JSON file
-        if self.results is not None:
-            results_file_path = os.path.join(path, "report.json")
-            with open(results_file_path, 'w') as json_file:
-                json.dump(self.results.to_dict(), json_file, indent=4)
-
-        # Save the HTML report
-        if self.html_report is not None:
-            html_file_path = os.path.join(path, "report.html")
-            with open(html_file_path, 'w') as html_file:
-                html_file.write(self.html_report)
-            self.html_report_path = html_file_path
+            # Add the backtests to the backtests list
+            loaded_backtests.extend(backtests)
 
-        if self.results is not None:
-            data = self.results.to_dict()
+        if len(loaded_backtests) == 0:
+            raise OperationalException(
+                f"The directory {directory_path} is not a valid backtest report."
+            )
 
-            with open(os.path.join(path, "report.json"), 'w') as json_file:
-                json.dump(data, json_file, indent=4)
+        return BacktestReport(backtest=loaded_backtests)

investing_algorithm_framework/app/reporting/charts/__init__.py

@@ -1,11 +1,19 @@
 from .equity_curve_drawdown import get_equity_curve_with_drawdown_chart
-from .rolling_sharp_ratio import get_rolling_sharp_ratio_chart
+from .equity_curve import get_equity_curve_chart
+from .rolling_sharp_ratio import get_rolling_sharpe_ratio_chart
 from .monthly_returns_heatmap import get_monthly_returns_heatmap_chart
 from .yearly_returns_barchart import get_yearly_returns_bar_chart
+from .ohlcv_data_completeness import get_ohlcv_data_completeness_chart
+from .entry_exist_signals import get_entry_and_exit_signals
+from .line_chart import create_line_scatter
 
 __all__ = [
     "get_equity_curve_with_drawdown_chart",
-    "get_rolling_sharp_ratio_chart",
+    "get_rolling_sharpe_ratio_chart",
     "get_monthly_returns_heatmap_chart",
     "get_yearly_returns_bar_chart",
+    "get_ohlcv_data_completeness_chart",
+    "get_entry_and_exit_signals",
+    "create_line_scatter",
+    "get_equity_curve_chart"
 ]

investing_algorithm_framework/app/reporting/charts/entry_exist_signals.py

@@ -0,0 +1,66 @@
+import pandas as pd
+import plotly.graph_objects as go
+
+
+def get_entry_and_exit_signals(
+    entry_signals: pd.Series,
+    exit_signals: pd.Series,
+    price_data: pd.DataFrame
+):
+    """
+    Plots the price chart with entry and exit signals.
+
+    Args:
+        entry_signals (pd.Series): Series containing buy
+            signals with datetime index. Entry signals should
+            be boolean values.
+        exit_signals (pd.Series): Series containing exit signals
+            with datetime index. Exit signals should be boolean values.
+        price_data (pd.DataFrame): DataFrame containing price
+            data with datetime index and 'Close'
+
+    Returns:
+        go.Figure: Plotly figure with price chart and signals.
+    """
+    # Create the base candlestick or line chart
+    fig = go.Figure()
+
+    fig.add_trace(go.Scatter(
+        x=price_data.index,
+        y=price_data["Close"],
+        mode="lines",
+        name="Close Price",
+        line=dict(color="blue")
+    ))
+
+    # Entry points
+    entry_points = price_data[entry_signals]
+    fig.add_trace(go.Scatter(
+        x=entry_points.index,
+        y=entry_points["Close"],
+        mode="markers",
+        name="Entry",
+        marker=dict(symbol="triangle-up", color="green", size=10)
+    ))
+
+    # Exit points
+    exit_points = price_data[exit_signals]
+    fig.add_trace(go.Scatter(
+        x=exit_points.index,
+        y=exit_points["Close"],
+        mode="markers",
+        name="Exit",
+        marker=dict(symbol="triangle-down", color="red", size=10)
+    ))
+
+    # Layout settings
+    fig.update_layout(
+        title="Entry and Exit Signals",
+        xaxis_title="Date",
+        yaxis_title="Price",
+        legend=dict(x=0, y=1),
+        height=600,
+        template="plotly_white"
+    )
+
+    return fig

investing_algorithm_framework/app/reporting/charts/equity_curve.py

@@ -0,0 +1,37 @@
+import pandas as pd
+from plotly import graph_objects as go
+
+
+def get_equity_curve_chart(equity_curve_series):
+    equity_curve_df = pd.DataFrame(
+        equity_curve_series, columns=["value", "datetime"]
+    )
+
+    # Normalize equity to start at 1
+    equity_curve_df["value"] = (
+        equity_curve_df["value"] / equity_curve_df["value"].iloc[0]
+    )
+
+    fig = go.Figure()
+
+    # Draw equity curve
+    fig.add_trace(
+        go.Scatter(
+            x=equity_curve_df["datetime"],
+            y=equity_curve_df["value"],
+            mode="lines",
+            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>"
+        )
+    )
+
+    fig.update_layout(
+        xaxis=dict(title=None),
+        yaxis=dict(title="Cumulative Equity (log)", type="log"),
+        title="Equity Curve with Drawdown",
+        hovermode="x unified",
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1)
+    )
+
+    return fig