investing-algorithm-framework 7.16.18__tar.gz → 7.19.1__tar.gz

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investing-algorithm-framework
-Version: 7.16.18
+Version: 7.19.1
 Summary: A framework for creating trading bots
 Author: MDUYN
 Requires-Python: >=3.10

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/__init__.py

@@ -1,16 +1,16 @@
 from .app import App, Algorithm, \
     TradingStrategy, StatelessAction, Task, AppHook, Context, \
-    add_html_report, BacktestReport, \
+    add_html_report, BacktestReport, save_backtests_to_directory, \
     pretty_print_trades, pretty_print_positions, \
     pretty_print_orders, pretty_print_backtest, select_backtest_date_ranges, \
-    get_equity_curve_with_drawdown_chart, \
+    get_equity_curve_with_drawdown_chart, load_backtests_from_directory, \
     get_rolling_sharpe_ratio_chart, rank_results, \
     get_monthly_returns_heatmap_chart, create_weights, \
     get_yearly_returns_bar_chart, get_entry_and_exit_signals, \
     get_ohlcv_data_completeness_chart, get_equity_curve_chart
 from .domain import ApiException, combine_backtests, PositionSize, \
     OrderType, OperationalException, OrderStatus, OrderSide, \
-    TimeUnit, TimeInterval, Order, Portfolio, Backtest, \
+    TimeUnit, TimeInterval, Order, Portfolio, Backtest, DataError, \
     Position, TimeFrame, INDEX_DATETIME, MarketCredential, \
     PortfolioConfiguration, RESOURCE_DIRECTORY, AWS_LAMBDA_LOGGING_CONFIG, \
     Trade, SYMBOLS, RESERVED_BALANCES, APP_MODE, AppMode, DATETIME_FORMAT, \
@@ -189,5 +189,8 @@ __all__ = [
     "get_negative_trades",
     "get_positive_trades",
     "get_number_of_trades",
-    "BacktestRun"
+    "BacktestRun",
+    "load_backtests_from_directory",
+    "save_backtests_to_directory",
+    "DataError"
 ]

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/app/__init__.py

@@ -14,7 +14,7 @@ from .reporting import add_html_report, \
     get_yearly_returns_bar_chart, get_equity_curve_chart, \
     get_ohlcv_data_completeness_chart, get_entry_and_exit_signals
 from .analysis import select_backtest_date_ranges, rank_results, \
-    create_weights
+    create_weights, load_backtests_from_directory, save_backtests_to_directory
 
 
 __all__ = [
@@ -41,5 +41,7 @@ __all__ = [
     "rank_results",
     "create_weights",
     "get_entry_and_exit_signals",
-    "get_equity_curve_chart"
+    "get_equity_curve_chart",
+    "load_backtests_from_directory",
+    "save_backtests_to_directory"
 ]

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/app/analysis/__init__.py

@@ -1,11 +1,15 @@
 from .backtest_data_ranges import select_backtest_date_ranges
 from .ranking import rank_results, create_weights, combine_backtest_metrics
 from .permutation import create_ohlcv_permutation
+from .backtest_utils import load_backtests_from_directory, \
+    save_backtests_to_directory
 
 __all__ = [
     "select_backtest_date_ranges",
     "rank_results",
     "create_weights",
     "create_ohlcv_permutation",
-    "combine_backtest_metrics"
+    "combine_backtest_metrics",
+    "load_backtests_from_directory",
+    "save_backtests_to_directory"
 ]

investing_algorithm_framework-7.19.1/investing_algorithm_framework/app/analysis/backtest_utils.py

@@ -0,0 +1,80 @@
+import os
+from pathlib import Path
+from typing import List, Union
+from logging import getLogger
+from random import Random
+
+from investing_algorithm_framework.domain import Backtest
+
+
+logger = getLogger("investing_algorithm_framework")
+
+
+def save_backtests_to_directory(
+    backtests: List[Backtest],
+    directory_path: Union[str, Path]
+) -> None:
+    """
+    Saves a list of Backtest objects to the specified directory.
+
+    Args:
+        backtests (List[Backtest]): List of Backtest objects to save.
+        directory_path (str): Path to the directory where backtests
+            will be saved.
+
+    Returns:
+        None
+    """
+
+    if not os.path.exists(directory_path):
+        os.makedirs(directory_path)
+
+    for backtest in backtests:
+        # Check if there is an ID in the backtest metadata
+        backtest_id = backtest.metadata.get('id')
+
+        if backtest_id is None:
+            logger.warning(
+                "Backtest is missing 'id' in metadata. "
+                "Generating a random ID as name for backtest file."
+            )
+            backtest_id = str(Random().randint(100000, 999999))
+
+        backtest.save(os.path.join(directory_path, backtest_id))
+
+
+def load_backtests_from_directory(
+    directory_path: Union[str, Path]
+) -> List[Backtest]:
+    """
+    Loads Backtest objects from the specified directory.
+
+    Args:
+        directory_path (str): Path to the directory from which backtests
+            will be loaded.
+
+    Returns:
+        List[Backtest]: List of loaded Backtest objects.
+    """
+
+    backtests = []
+
+    if not os.path.exists(directory_path):
+        logger.warning(
+            f"Directory {directory_path} does not exist. "
+            "No backtests loaded."
+        )
+        return backtests
+
+    for file_name in os.listdir(directory_path):
+        file_path = os.path.join(directory_path, file_name)
+
+        try:
+            backtest = Backtest.open(file_path)
+            backtests.append(backtest)
+        except Exception as e:
+            logger.error(
+                f"Failed to load backtest from {file_path}: {e}"
+            )
+
+    return backtests

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/app/app.py

@@ -5,6 +5,7 @@ import threading
 from datetime import datetime, timezone
 from typing import List, Optional, Any, Dict, Tuple
 
+import pandas as pd
 from flask import Flask
 
 from investing_algorithm_framework.app.algorithm import Algorithm
@@ -16,7 +17,7 @@ from investing_algorithm_framework.domain import DATABASE_NAME, TimeUnit, \
     SQLALCHEMY_DATABASE_URI, OperationalException, StateHandler, \
     BACKTESTING_START_DATE, BACKTESTING_END_DATE, APP_MODE, MarketCredential, \
     AppMode, BacktestDateRange, DATABASE_DIRECTORY_NAME, DataSource, \
-    BACKTESTING_INITIAL_AMOUNT, SNAPSHOT_INTERVAL, Backtest, \
+    BACKTESTING_INITIAL_AMOUNT, SNAPSHOT_INTERVAL, Backtest, DataError, \
     PortfolioConfiguration, SnapshotInterval, DataType, combine_backtests, \
     PortfolioProvider, OrderExecutor, ImproperlyConfigured, \
     DataProvider, INDEX_DATETIME, tqdm, BacktestPermutationTest, \
@@ -32,6 +33,7 @@ from .app_hook import AppHook
 from .eventloop import EventLoopService
 from .analysis import create_ohlcv_permutation
 
+
 logger = logging.getLogger("investing_algorithm_framework")
 COLOR_RESET = '\033[0m'
 COLOR_GREEN = '\033[92m'
@@ -789,6 +791,70 @@ class App:
             .market_credential_service()
         return market_credential_service.get_all()
 
+    def check_data_completeness(
+        self,
+        strategies: List[TradingStrategy],
+        backtest_date_range: BacktestDateRange
+    ) -> None:
+        """
+        Function to check the data completeness for a set of strategies
+        over a given backtest date range. This method checks if all data
+        sources required by the strategies have complete data for the
+        specified date range.
+
+        Args:
+            strategies (List[TradingStrategy]): List of strategy objects
+                to check data completeness for.
+            backtest_date_range (BacktestDateRange): The date range to
+                check data completeness for.
+        Returns:
+            None
+        """
+        data_sources = []
+
+        for strategy in strategies:
+            data_sources.extend(strategy.data_sources)
+
+        self.initialize_data_sources_backtest(
+            data_sources,
+            backtest_date_range,
+            show_progress=True
+        )
+        data_provider_service = self.container.data_provider_service()
+
+        for strategy in strategies:
+
+            for data_source in strategy.data_sources:
+
+                if DataType.OHLCV.equals(data_source.data_type):
+                    df = data_provider_service.get_ohlcv_data(
+                        symbol=data_source.symbol,
+                        start_date=backtest_date_range.start_date,
+                        end_date=backtest_date_range.end_date,
+                        pandas=True
+                    )
+                    df = df.copy()
+                    df['Datetime'] = pd.to_datetime(df['Datetime'])
+                    df = df.sort_values('Datetime')\
+                        .tail(data_source.window_size)
+                    start = df['Datetime'].iloc[0]
+                    end = df['Datetime'].iloc[-1]
+                    freq = pd.to_timedelta(data_source.time_frame.value)
+                    expected = pd.date_range(start, end, freq=freq)
+                    actual = df['Datetime']
+                    missing = expected.difference(actual)
+
+                    # Calculate the percentage completeness
+                    completeness = len(actual) / len(expected) * 100
+
+                    if completeness < 100:
+                        raise DataError(
+                            f"Data completeness for data source "
+                            f"{data_source.identifier} "
+                            f"({data_source.symbol}) is {completeness:.2f}% "
+                            f"complete. Missing data points: {len(missing)}"
+                        )
+
     def run_vector_backtests(
         self,
         initial_amount,
@@ -801,6 +867,7 @@ class App:
         show_progress: bool = True,
         market: Optional[str] = None,
         trading_symbol: Optional[str] = None,
+        continue_on_error: bool = False,
     ) -> List[Backtest]:
         """
         Run vectorized backtests for a set of strategies. The provided
@@ -848,6 +915,10 @@ class App:
             trading_symbol (str): The trading symbol to use for the backtest.
                 This is used to create a portfolio configuration if no
                 portfolio configuration is provided in the strategy.
+            continue_on_error (bool): Whether to continue running other
+                backtests if an error occurs in one of the backtests. If set
+                to True, the backtest will return an empty Backtest instance
+                in case of an error. If set to False, the error will be raised.
 
         Returns:
             List[Backtest]: List of Backtest instances for each strategy
@@ -956,7 +1027,8 @@ class App:
         show_data_initialization_progress: bool = True,
         initial_amount: float = None,
         market: str = None,
-        trading_symbol: str = None
+        trading_symbol: str = None,
+        continue_on_error: bool = False,
     ) -> Backtest:
         """
         Run vectorized backtests for a strategy. The provided
@@ -1008,6 +1080,10 @@ class App:
                 that the portfolio will start with. If not provided,
                 the initial amount from the portfolio configuration will
                 be used.
+            continue_on_error (bool): Whether to continue running other
+                backtests if an error occurs in one of the backtests. If set
+                to True, the backtest will return an empty Backtest instance
+                in case of an error. If set to False, the error will be raised.
 
         Returns:
             Backtest: Instance of Backtest
@@ -1040,21 +1116,35 @@ class App:
 
         backtest_service = self.container.backtest_service()
         backtest_service.validate_strategy_for_vector_backtest(strategy)
-        run = backtest_service.create_vector_backtest(
-            strategy=strategy,
-            backtest_date_range=backtest_date_range,
-            risk_free_rate=risk_free_rate,
-            market=market,
-            trading_symbol=trading_symbol,
-            initial_amount=initial_amount
-        )
-        backtest = Backtest(
-            backtest_runs=[run],
-            risk_free_rate=risk_free_rate,
-            backtest_summary=generate_backtest_summary_metrics(
-                [run.backtest_metrics]
+
+        try:
+            run = backtest_service.create_vector_backtest(
+                strategy=strategy,
+                backtest_date_range=backtest_date_range,
+                risk_free_rate=risk_free_rate,
+                market=market,
+                trading_symbol=trading_symbol,
+                initial_amount=initial_amount
             )
-        )
+            backtest = Backtest(
+                backtest_runs=[run],
+                risk_free_rate=risk_free_rate,
+                backtest_summary=generate_backtest_summary_metrics(
+                    [run.backtest_metrics]
+                )
+            )
+        except Exception as e:
+            logger.error(
+                f"Error occurred during vector backtest for strategy "
+                f"{strategy.strategy_id}: {str(e)}"
+            )
+            if continue_on_error:
+                backtest = Backtest(
+                    backtest_runs=[],
+                    risk_free_rate=risk_free_rate,
+                )
+            else:
+                raise e
 
         # Add the metadata to the backtest
         if metadata is None:

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/domain/__init__.py

@@ -15,7 +15,7 @@ from .constants import ITEMIZE, ITEMIZED, PER_PAGE, PAGE, ENVIRONMENT, \
 from .data_provider import DataProvider
 from .data_structures import PeekableQueue
 from .decimal_parsing import parse_decimal_to_string, parse_string_to_decimal
-from .exceptions import OperationalException, ApiException, \
+from .exceptions import OperationalException, ApiException, DataError, \
     PermissionDeniedApiException, ImproperlyConfigured, NetworkError
 from .models import OrderStatus, OrderSide, OrderType, TimeInterval, \
     TimeUnit, TimeFrame, PortfolioConfiguration, Portfolio, Position, \
@@ -143,5 +143,6 @@ __all__ = [
     "BacktestEvaluationFocus",
     'combine_backtests',
     'PositionSize',
-    'generate_backtest_summary_metrics'
+    'generate_backtest_summary_metrics',
+    'DataError'
 ]

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/domain/backtesting/backtest.py

@@ -14,6 +14,7 @@ from .backtest_run import BacktestRun
 from .backtest_permutation_test import BacktestPermutationTest
 from .backtest_date_range import BacktestDateRange
 from .backtest_summary_metrics import BacktestSummaryMetrics
+from .combine_backtests import generate_backtest_summary_metrics
 
 
 logger = getLogger(__name__)
@@ -177,13 +178,19 @@ class Backtest:
         }
 
     @staticmethod
-    def open(directory_path: Union[str, Path]) -> 'Backtest':
+    def open(
+        directory_path: Union[str, Path],
+        backtest_date_ranges: List[BacktestDateRange] = None
+    ) -> 'Backtest':
         """
         Open a backtest report from a directory and return a Backtest instance.
 
         Args:
             directory_path (str): The path to the directory containing the
                 backtest report files.
+            backtest_date_ranges (List[BacktestDateRange], optional): A list of
+                date ranges to filter the backtest runs. If provided, only
+                backtest runs matching these date ranges will be loaded.
 
         Returns:
             Backtest: An instance of Backtest with the loaded metrics
@@ -214,13 +221,59 @@ class Backtest:
                 except json.JSONDecodeError as e:
                     logger.error(f"Error decoding id JSON: {e}")
                     id = None
-        # Load combined backtest metrics if available
 
-        summary_file = os.path.join(directory_path, "summary.json")
+        # Load all backtest runs
+        runs_dir = os.path.join(directory_path, "runs")
+
+        if os.path.isdir(runs_dir):
+            for dir_name in os.listdir(runs_dir):
+                run_path = os.path.join(runs_dir, dir_name)
+                if os.path.isdir(run_path):
+
+                    if backtest_date_ranges is not None:
+                        temp_run = BacktestRun.open(run_path)
+                        match_found = False
+
+                        for date_range in backtest_date_ranges:
+                            if (
+                                temp_run.backtest_start_date ==
+                                date_range.start_date and
+                                temp_run.backtest_end_date ==
+                                date_range.end_date
+                            ):
+
+                                if date_range.name is not None:
+                                    if (
+                                        temp_run.backtest_date_range_name ==
+                                        date_range.name
+                                    ):
+                                        match_found = True
+                                        break
+                                else:
+                                    match_found = True
+                                    break
+
+                        if not match_found:
+                            continue
+
+                    backtest_runs.append(BacktestRun.open(run_path))
+
+        # Load combined backtests summary
+        if backtest_date_ranges is not None:
+            summary_file = os.path.join(directory_path, "summary.json")
+
+            if os.path.isfile(summary_file):
+                backtest_summary_metrics = \
+                    BacktestSummaryMetrics.open(summary_file)
+        else:
+            # Generate new summary from loaded backtest runs
+            temp_metrics = []
+            for br in backtest_runs:
+                if br.backtest_metrics:
+                    temp_metrics.append(br.backtest_metrics)
 
-        if os.path.isfile(summary_file):
             backtest_summary_metrics = \
-                BacktestSummaryMetrics.open(summary_file)
+                generate_backtest_summary_metrics(temp_metrics)
 
         # Load backtest permutation test metrics
         perm_test_dir = os.path.join(directory_path, "permutation_tests")
@@ -233,15 +286,6 @@ class Backtest:
                         BacktestPermutationTest.open(perm_test_file)
                     )
 
-        # Load all backtest runs
-        runs_dir = os.path.join(directory_path, "runs")
-
-        if os.path.isdir(runs_dir):
-            for dir_name in os.listdir(runs_dir):
-                run_path = os.path.join(runs_dir, dir_name)
-                if os.path.isdir(run_path):
-                    backtest_runs.append(BacktestRun.open(run_path))
-
         # Load metadata if available
         meta_file = os.path.join(directory_path, "metadata.json")
 

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/domain/backtesting/backtest_metrics.py

@@ -104,8 +104,12 @@ class BacktestMetrics:
             still open at the end of the backtest.
         win_rate (float): The win rate of the trades, expressed
             as a percentage.
+        current_win_rate (float): The current win rate of the trades,
+            including open trades.
         win_loss_ratio (float): The ratio of winning trades
             to losing trades.
+        current_win_loss_ratio (float): The current ratio of winning
+            trades to losing trades, including open trades.
         percentage_winning_months (float): The percentage of months
             with positive returns.
         percentage_winning_years (float): The percentage of years with
@@ -193,7 +197,9 @@ class BacktestMetrics:
     number_of_trades_opened: int = 0
     number_of_trades_open_at_end: int = 0
     win_rate: float = 0.0
+    current_win_rate: float = 0.0
     win_loss_ratio: float = 0.0
+    current_win_loss_ratio: float = 0.0
     percentage_winning_months: float = 0.0
     percentage_winning_years: float = 0.0
     average_monthly_return: float = 0.0
@@ -289,7 +295,9 @@ class BacktestMetrics:
             "number_of_trades_closed": self.number_of_trades_closed,
             "number_of_trades_opened": self.number_of_trades_opened,
             "win_rate": self.win_rate,
+            "current_win_rate": self.current_win_rate,
             "win_loss_ratio": self.win_loss_ratio,
+            "current_win_loss_ratio": self.current_win_loss_ratio,
             "percentage_winning_months": self.percentage_winning_months,
             "percentage_winning_years": self.percentage_winning_years,
             "average_monthly_return": self.average_monthly_return,

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/domain/backtesting/backtest_run.py

@@ -251,17 +251,41 @@ class BacktestRun:
             # Remove backtest_metrics to avoid redundancy
             data.pop("backtest_metrics", None)
 
-            data["backtest_start_date"] = self.backtest_start_date.strftime(
+            # Ensure datetime objects are in UTC before formatting
+            backtest_start_date = self.backtest_start_date
+
+            if backtest_start_date.tzinfo is None:
+                # Naive datetime - treat as UTC
+                backtest_start_date = backtest_start_date.replace(
+                    tzinfo=timezone.utc
+                )
+            else:
+                # Timezone-aware - convert to UTC
+                backtest_start_date = backtest_start_date.astimezone(
+                    timezone.utc
+                )
+
+            backtest_end_date = self.backtest_end_date
+            if backtest_end_date.tzinfo is None:
+                backtest_end_date = backtest_end_date.replace(
+                    tzinfo=timezone.utc
+                )
+            else:
+                backtest_end_date = backtest_end_date.astimezone(timezone.utc)
+
+            created_at = self.created_at
+            if created_at.tzinfo is None:
+                created_at = created_at.replace(tzinfo=timezone.utc)
+            else:
+                created_at = created_at.astimezone(timezone.utc)
+
+            data["backtest_start_date"] = backtest_start_date.strftime(
                 "%Y-%m-%d %H:%M:%S"
             )
-            data["backtest_end_date"] = self.backtest_end_date.strftime(
+            data["backtest_end_date"] = backtest_end_date.strftime(
                 "%Y-%m-%d %H:%M:%S"
             )
-
-            if self.created_at.tzinfo is None:
-                self.created_at = self.created_at.replace(tzinfo=timezone.utc)
-
-            data["created_at"] = self.created_at.strftime(
+            data["created_at"] = created_at.strftime(
                 "%Y-%m-%d %H:%M:%S"
             )
             json.dump(data, f, default=str)

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/domain/backtesting/backtest_summary_metrics.py

@@ -48,7 +48,9 @@ class BacktestSummaryMetrics:
         max_drawdown_duration (int): Duration of the maximum drawdown.
         trades_per_year (float): Average trades executed per year.
         win_rate (float): Percentage of winning trades.
+        current_win_rate (float): Win rate over recent trades.
         win_loss_ratio (float): Ratio of average win to average loss.
+        current_win_loss_ratio (float): Win/loss ratio over recent trades.
         number_of_trades (int): Total number of trades executed.
         cumulative_exposure (float): Total exposure over the backtest period.
         exposure_ratio (float): Ratio of exposure to available capital.
@@ -81,7 +83,9 @@ class BacktestSummaryMetrics:
     max_drawdown_duration: int = None
     trades_per_year: float = None
     win_rate: float = None
+    current_win_rate: float = None
     win_loss_ratio: float = None
+    current_win_loss_ratio: float = None
     number_of_trades: int = None
     number_of_trades_closed: int = None
     cumulative_exposure: float = None
@@ -123,7 +127,9 @@ class BacktestSummaryMetrics:
             "max_drawdown_duration": self.max_drawdown_duration,
             "trades_per_year": self.trades_per_year,
             "win_rate": self.win_rate,
+            "current_win_rate": self.current_win_rate,
             "win_loss_ratio": self.win_loss_ratio,
+            "current_win_loss_ratio": self.current_win_loss_ratio,
             "number_of_trades": self.number_of_trades,
             "number_of_trades_closed": self.number_of_trades_closed,
             "cumulative_exposure": self.cumulative_exposure,

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/domain/backtesting/combine_backtests.py

@@ -1,6 +1,5 @@
 from typing import List
 
-from .backtest import Backtest
 from .backtest_summary_metrics import BacktestSummaryMetrics
 from .backtest_metrics import BacktestMetrics
 
@@ -27,9 +26,7 @@ def safe_weighted_mean(values, weights):
     ) / total_weight if total_weight > 0 else None
 
 
-def combine_backtests(
-    backtests: List[Backtest],
-) -> Backtest:
+def combine_backtests(backtests):
     """
     Combine multiple backtests into a single backtest by aggregating
     their results.
@@ -72,6 +69,8 @@ def combine_backtests(
             risk_free_rate = backtest.risk_free_rate
             break
 
+    from .backtest import Backtest
+
     backtest = Backtest(
         backtest_summary=summary,
         metadata=metadata,
@@ -184,10 +183,18 @@ def generate_backtest_summary_metrics(
         [b.win_rate for b in backtest_metrics],
         [b.total_number_of_days for b in backtest_metrics]
     )
+    current_win_rate = safe_weighted_mean(
+        [b.current_win_rate for b in backtest_metrics],
+        [b.total_number_of_days for b in backtest_metrics]
+    )
     win_loss_ratio = safe_weighted_mean(
         [b.win_loss_ratio for b in backtest_metrics],
         [b.total_number_of_days for b in backtest_metrics]
     )
+    current_win_loss_ratio = safe_weighted_mean(
+        [b.current_win_loss_ratio for b in backtest_metrics],
+        [b.total_number_of_days for b in backtest_metrics]
+    )
     number_of_trades = sum(
         b.number_of_trades for b in backtest_metrics
         if b.number_of_trades is not None
@@ -251,7 +258,9 @@ def generate_backtest_summary_metrics(
         max_drawdown_duration=max_drawdown_duration,
         trades_per_year=trades_per_year,
         win_rate=win_rate,
+        current_win_rate=current_win_rate,
         win_loss_ratio=win_loss_ratio,
+        current_win_loss_ratio=current_win_loss_ratio,
         number_of_trades=number_of_trades,
         number_of_trades_closed=number_of_trades_closed,
         cumulative_exposure=cumulative_exposure,

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/domain/data_provider.py

@@ -240,6 +240,7 @@ class DataProvider(ABC):
         backtest_index_date: datetime,
         backtest_start_date: datetime = None,
         backtest_end_date: datetime = None,
+        data_source: DataSource = None,
     ) -> Any:
         """
         Fetches backtest data for a given datasource
@@ -251,6 +252,10 @@ class DataProvider(ABC):
                 backtest data.
             backtest_end_date (datetime): The end date for the
                 backtest data.
+            data_source (Optional[DataSource]): The data source
+                specification that is used to fetch the data.
+                This param is optional and can be used to
+                help identify errors in data fetching.
 
         Returns:
             Any: The data for the given symbol and date range.

{investing_algorithm_framework-7.16.18 → investing_algorithm_framework-7.19.1}/investing_algorithm_framework/domain/exceptions.py

@@ -84,3 +84,20 @@ class NetworkError(Exception):
             "status": "error",
             "message": self.error_message
         }
+
+
+class DataError(Exception):
+    """
+    Class DataError: Exception class indicating a problem occurred
+    during data retrieval or processing
+    """
+
+    def __init__(self, message) -> None:
+        super(DataError, self).__init__(message)
+        self.error_message = message
+
+    def to_response(self):
+        return {
+            "status": "error",
+            "message": self.error_message
+        }