investing-algorithm-framework 7.22.2__tar.gz → 7.22.4__tar.gz

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/PKG-INFO

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

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/__init__.py

@@ -1,9 +1,9 @@
 from .app import App, Algorithm, generate_strategy_id, \
     TradingStrategy, StatelessAction, Task, AppHook, Context, \
-    add_html_report, BacktestReport, save_backtests_to_directory, \
+    add_html_report, BacktestReport, \
     pretty_print_trades, pretty_print_positions, \
     pretty_print_orders, pretty_print_backtest, select_backtest_date_ranges, \
-    get_equity_curve_with_drawdown_chart, load_backtests_from_directory, \
+    get_equity_curve_with_drawdown_chart, \
     get_rolling_sharpe_ratio_chart, rank_results, \
     get_monthly_returns_heatmap_chart, create_weights, \
     get_yearly_returns_bar_chart, get_entry_and_exit_signals, \
@@ -13,12 +13,13 @@ from .domain import ApiException, combine_backtests, PositionSize, \
     TimeUnit, TimeInterval, Order, Portfolio, Backtest, DataError, \
     Position, TimeFrame, INDEX_DATETIME, MarketCredential, TakeProfitRule, \
     PortfolioConfiguration, RESOURCE_DIRECTORY, AWS_LAMBDA_LOGGING_CONFIG, \
-    Trade, APP_MODE, AppMode, DATETIME_FORMAT, \
+    Trade, APP_MODE, AppMode, DATETIME_FORMAT, load_backtests_from_directory, \
     BacktestDateRange, convert_polars_to_pandas, BacktestRun, \
     DEFAULT_LOGGING_CONFIG, DataType, DataProvider, StopLossRule, \
     TradeStatus, generate_backtest_summary_metrics, \
     APPLICATION_DIRECTORY, DataSource, OrderExecutor, PortfolioProvider, \
-    SnapshotInterval, AWS_S3_STATE_BUCKET_NAME, BacktestEvaluationFocus
+    SnapshotInterval, AWS_S3_STATE_BUCKET_NAME, BacktestEvaluationFocus, \
+    save_backtests_to_directory
 from .infrastructure import AzureBlobStorageStateHandler, \
     CSVOHLCVDataProvider, CCXTOHLCVDataProvider, PandasOHLCVDataProvider, \
     AWSS3StorageStateHandler

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/app/__init__.py

@@ -14,8 +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, load_backtests_from_directory, \
-    save_backtests_to_directory, generate_strategy_id
+    create_weights, generate_strategy_id
 
 
 __all__ = [
@@ -43,7 +42,5 @@ __all__ = [
     "create_weights",
     "get_entry_and_exit_signals",
     "get_equity_curve_chart",
-    "load_backtests_from_directory",
-    "save_backtests_to_directory",
     "generate_strategy_id"
 ]

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/app/analysis/__init__.py

@@ -1,8 +1,6 @@
 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
 from .strategy_id import generate_strategy_id
 
 __all__ = [
@@ -11,7 +9,5 @@ __all__ = [
     "create_weights",
     "create_ohlcv_permutation",
     "combine_backtest_metrics",
-    "load_backtests_from_directory",
-    "save_backtests_to_directory",
     "generate_strategy_id"
 ]

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/app/app.py

@@ -1,5 +1,3 @@
-import gc
-import shutil
 import inspect
 import logging
 import os
@@ -20,11 +18,11 @@ from investing_algorithm_framework.domain import DATABASE_NAME, TimeUnit, \
     BACKTESTING_START_DATE, BACKTESTING_END_DATE, APP_MODE, MarketCredential, \
     AppMode, BacktestDateRange, DATABASE_DIRECTORY_NAME, DataSource, \
     BACKTESTING_INITIAL_AMOUNT, SNAPSHOT_INTERVAL, Backtest, DataError, \
-    PortfolioConfiguration, SnapshotInterval, DataType, combine_backtests, \
+    PortfolioConfiguration, SnapshotInterval, DataType, \
     PortfolioProvider, OrderExecutor, ImproperlyConfigured, TimeFrame, \
     DataProvider, INDEX_DATETIME, tqdm, BacktestPermutationTest, \
-    LAST_SNAPSHOT_DATETIME, BACKTESTING_FLAG, \
-    generate_backtest_summary_metrics, DATA_DIRECTORY
+    LAST_SNAPSHOT_DATETIME, BACKTESTING_FLAG, DATA_DIRECTORY, \
+    generate_backtest_summary_metrics
 from investing_algorithm_framework.infrastructure import setup_sqlalchemy, \
     create_all_tables, CCXTOrderExecutor, CCXTPortfolioProvider, \
     BacktestOrderExecutor, CCXTOHLCVDataProvider, clear_db, \
@@ -34,9 +32,7 @@ from investing_algorithm_framework.services import OrderBacktestService, \
     DefaultTradeOrderEvaluator, get_risk_free_rate_us
 from .app_hook import AppHook
 from .eventloop import EventLoopService
-from .analysis import create_ohlcv_permutation, save_backtests_to_directory, \
-    load_backtests_from_directory
-
+from .analysis import create_ohlcv_permutation
 
 logger = logging.getLogger("investing_algorithm_framework")
 COLOR_RESET = '\033[0m'
@@ -1021,14 +1017,13 @@ class App:
             List[Backtest]: List of Backtest instances for each strategy
                 that was backtested.
         """
-        backtests = []
-        strategy_ids = [strategy.id for strategy in strategies]
-        strategy_id_selection = strategy_ids.copy()
-        data_sources = []
+        backtest_service = self.container.backtest_service()
 
-        # Only used when backtest_storage_directory is None and
-        # backtest_date_ranges is provided
-        backtests_ordered_by_strategy = {}
+        if use_checkpoints and backtest_storage_directory is None:
+            raise OperationalException(
+                "backtest_storage_directory must be provided when "
+                "use_checkpoints is set to True"
+            )
 
         if backtest_date_range is None and backtest_date_ranges is None:
             raise OperationalException(
@@ -1036,198 +1031,54 @@ class App:
                 "provided"
             )
 
-        for strategy in strategies:
-            data_sources.extend(strategy.data_sources)
-
-        if risk_free_rate is None:
-            logger.info("No risk free rate provided, retrieving it...")
-            risk_free_rate = get_risk_free_rate_us()
-
-            if risk_free_rate is None:
-                raise OperationalException(
-                    "Could not retrieve risk free rate for backtest metrics."
-                    "Please provide a risk free as an argument when running "
-                    "your backtest or make sure you have an internet "
-                    "connection"
-                )
-
-        if backtest_date_range is not None:
-            backtest_results = []
-            if not skip_data_sources_initialization:
-                self.initialize_data_sources_backtest(
-                    data_sources,
-                    backtest_date_range,
-                    show_progress=show_progress
-                )
-
-            for strategy in tqdm(
-                strategies, colour="green", desc="Running backtests"
-            ):
-                backtests.append(
-                    self.run_vector_backtest(
-                        backtest_date_range=backtest_date_range,
-                        initial_amount=initial_amount,
-                        strategy=strategy,
-                        snapshot_interval=snapshot_interval,
-                        risk_free_rate=risk_free_rate,
-                        skip_data_sources_initialization=True,
-                        market=market,
-                        trading_symbol=trading_symbol,
-                        continue_on_error=continue_on_error,
-                        use_checkpoints=use_checkpoints,
-                        backtest_storage_directory=backtest_storage_directory,
-                    )
-                )
-
-            # Apply filter function if set
-            if filter_function is not None:
-                backtests = filter_function(backtests, backtest_date_range)
+        if not skip_data_sources_initialization:
+            print("adding default data providers")
+            data_provider_service = self.container.data_provider_service()
+            data_provider_service.reset()
 
-            # Save to storage directory if provided
-            if backtest_storage_directory is not None:
-                save_backtests_to_directory(
-                    backtests=backtests,
-                    directory_path=backtest_storage_directory,
+            for data_provider_tuple in self._data_providers:
+                data_provider_service.add_data_provider(
+                    data_provider_tuple[0], priority=data_provider_tuple[1]
                 )
 
-            return backtests
-        else:
-            active_strategies = strategies.copy()
-            storage_directories = {}
-
-            # Make sure that the backtest date ranges are sorted by start date
-            # and unique
-            unique_date_ranges = set(backtest_date_ranges)
-            backtest_date_ranges = sorted(
-                unique_date_ranges, key=lambda x: x.start_date
+            # Add the default data providers
+            data_provider_service.add_data_provider(
+                CCXTOHLCVDataProvider()
             )
 
-            for backtest_date_range in tqdm(
-                backtest_date_ranges,
-                colour="green",
-                desc="Running backtests for all date ranges"
-            ):
-                backtest_results = []
-                if not skip_data_sources_initialization:
-                    self.initialize_data_sources_backtest(
-                        data_sources,
-                        backtest_date_range,
-                        show_progress=show_progress
-                    )
-
-                start_date = backtest_date_range\
-                    .start_date.strftime('%Y-%m-%d')
-                end_date = backtest_date_range.end_date.strftime('%Y-%m-%d')
-
-                if backtest_storage_directory is not None:
-                    storage_directories[backtest_date_range] = os.path.join(
-                        backtest_storage_directory,
-                        f"{start_date}_to_{end_date}"
-                    )
-
-                # Run backtests for active strategies only
-                for strategy in tqdm(
-                    active_strategies,
-                        colour="green",
-                        desc=f"Running backtests for "
-                             f"{start_date} to {end_date}"
-                ):
-                    backtest_results.append(
-                        self.run_vector_backtest(
-                            backtest_date_range=backtest_date_range,
-                            initial_amount=initial_amount,
-                            strategy=strategy,
-                            snapshot_interval=snapshot_interval,
-                            risk_free_rate=risk_free_rate,
-                            skip_data_sources_initialization=True,
-                            market=market,
-                            trading_symbol=trading_symbol,
-                            use_checkpoints=use_checkpoints,
-                            backtest_storage_directory=(
-                                backtest_storage_directory
-                            )
-                        )
-                    )
-
-                # Apply filter function after each date range to determine
-                # which strategies continue to the next period
-                if filter_function is not None:
-                    backtest_results = filter_function(
-                        backtest_results, backtest_date_range
-                    )
-                    strategy_id_selection = [
-                        backtest.metadata["id"] for backtest
-                        in backtest_results
-                    ]
-                    active_strategies = [
-                        strategy for strategy in active_strategies
-                        if strategy.id in strategy_id_selection
-                    ]
-
-                # Save the intermediate backtests to a temp storage location
-                # if backtest_storage_directory is provided and clean up memory
-                if backtest_storage_directory is not None:
-                    path = storage_directories[backtest_date_range]
-                    save_backtests_to_directory(
-                        backtests=backtest_results, directory_path=path,
-                    )
-
-                else:
-                    for backtest in backtest_results:
-                        backtests_ordered_by_strategy.setdefault(
-                            backtest.metadata["id"], []
-                        ).append(backtest)
-
-                del backtest_results
-
-                # Free up memory
-                gc.collect()
-
-            def load_backtest_filter_fn(bt: Backtest) -> bool:
-                return bt.metadata["id"] in strategy_id_selection
-
-            # load all backtests from storage directories and combine them
-            if backtest_storage_directory is not None:
-                strategy_id_selection = [
-                    strategy.id for strategy in active_strategies
-                ]
-                for backtest_range in storage_directories:
-
-                    path = storage_directories[backtest_range]
-                    loaded_backtests = load_backtests_from_directory(
-                        directory_path=path,
-                        filter_function=load_backtest_filter_fn
-                    )
-
-                    for backtest in loaded_backtests:
-                        backtests_ordered_by_strategy.setdefault(
-                            backtest.metadata["id"], []
-                        ).append(backtest)
-
-                    # Remove all temp storage directories
-                    shutil.rmtree(path)
-            else:
-                # Remove all strategies that are not in the final selection
-                backtests_ordered_by_strategy = {
-                    strategy_id: backtests
-                    for strategy_id, backtests in
-                    backtests_ordered_by_strategy.items()
-                    if strategy_id in strategy_id_selection
-                }
-
-            for strategy in backtests_ordered_by_strategy:
-                backtests.append(
-                    combine_backtests(backtests_ordered_by_strategy[strategy])
-                )
-
-            if backtest_storage_directory is not None:
-                # Save final combined backtests to storage directory
-                save_backtests_to_directory(
-                    backtests=backtests,
-                    directory_path=backtest_storage_directory,
-                )
-
-        return backtests
+        if use_checkpoints:
+            sdsi = skip_data_sources_initialization
+            return backtest_service.run_vector_backtests_with_checkpoints(
+                strategies=strategies,
+                backtest_date_range=backtest_date_range,
+                backtest_date_ranges=backtest_date_ranges,
+                snapshot_interval=snapshot_interval,
+                risk_free_rate=risk_free_rate,
+                initial_amount=initial_amount,
+                skip_data_sources_initialization=sdsi,
+                show_progress=show_progress,
+                market=market,
+                trading_symbol=trading_symbol,
+                continue_on_error=continue_on_error,
+                backtest_storage_directory=backtest_storage_directory,
+                filter_function=filter_function
+            )
+        sdsi = skip_data_sources_initialization
+        return backtest_service.run_vector_backtests(
+            strategies=strategies,
+            backtest_date_range=backtest_date_range,
+            backtest_date_ranges=backtest_date_ranges,
+            snapshot_interval=snapshot_interval,
+            risk_free_rate=risk_free_rate,
+            initial_amount=initial_amount,
+            skip_data_sources_initialization=sdsi,
+            show_progress=show_progress,
+            market=market,
+            trading_symbol=trading_symbol,
+            continue_on_error=continue_on_error,
+            filter_function=filter_function,
+            backtest_storage_directory=backtest_storage_directory,
+        )
 
     def run_vector_backtest(
         self,
@@ -1237,18 +1088,18 @@ class App:
         metadata: Optional[Dict[str, str]] = None,
         risk_free_rate: Optional[float] = None,
         skip_data_sources_initialization: bool = False,
-        show_data_initialization_progress: bool = True,
         initial_amount: float = None,
         market: str = None,
         trading_symbol: str = None,
         continue_on_error: bool = False,
         backtest_storage_directory: Optional[Union[str, Path]] = None,
-        use_checkpoints: bool = True
+        use_checkpoints: bool = False,
+        show_progress=False,
     ) -> Backtest:
         """
         Run vectorized backtests for a strategy. The provided
-        strategy needs to have its 'buy_signal_vectorized' and
-        'sell_signal_vectorized' methods implemented to support vectorized
+        strategy needs to have its 'generate_buy_signals' and
+        'generate_sell_signals' methods implemented to support vectorized
         backtesting.
 
         Args:
@@ -1279,8 +1130,6 @@ class App:
                 initialization step. This will speed up the backtesting
                 process, but make sure that the data sources are already
                 initialized before calling this method.
-            show_data_initialization_progress (bool): Whether to show the
-                progress bar when initializing data sources.
             market (str): The market to use for the backtest. This is used
                 to create a portfolio configuration if no portfolio
                 configuration is provided in the strategy.
@@ -1307,6 +1156,9 @@ class App:
                 backtest exists, it will be loaded
                 instead of running a new backtest. This is useful for
                 long-running backtests that might take a while to complete.
+            show_progress (bool): Whether to show progress bars during
+                data source initialization. This is useful for long-running
+                initialization processes.
 
         Returns:
             Backtest: Instance of Backtest
@@ -1328,7 +1180,7 @@ class App:
             self.initialize_data_sources_backtest(
                 strategy.data_sources,
                 backtest_date_range,
-                show_progress=show_data_initialization_progress
+                show_progress=show_progress
             )
 
         if risk_free_rate is None:
@@ -1360,6 +1212,16 @@ class App:
                 )
         else:
             try:
+
+                if show_progress:
+                    start_date = backtest_date_range \
+                        .start_date.strftime('%Y-%m-%d')
+                    end_date = backtest_date_range.end_date.strftime(
+                        '%Y-%m-%d')
+                    print(
+                        f"Running backtests for {start_date} to {end_date}"
+                    )
+
                 run = backtest_service.create_vector_backtest(
                     strategy=strategy,
                     backtest_date_range=backtest_date_range,
@@ -1369,6 +1231,7 @@ class App:
                     initial_amount=initial_amount
                 )
                 backtest = Backtest(
+                    algorithm_id=strategy.algorithm_id,
                     backtest_runs=[run],
                     risk_free_rate=risk_free_rate,
                     backtest_summary=generate_backtest_summary_metrics(
@@ -1380,8 +1243,10 @@ class App:
                     f"Error occurred during vector backtest for strategy "
                     f"{strategy.strategy_id}: {str(e)}"
                 )
+
                 if continue_on_error:
                     backtest = Backtest(
+                        algorithm_id=strategy.algorithm_id,
                         backtest_runs=[],
                         risk_free_rate=risk_free_rate,
                     )

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/app/context.py

@@ -1196,11 +1196,10 @@ class Context:
         portfolio=None,
         status=None,
         order_id=None
-    ) -> List[Trade]:
+    ) -> Trade:
         """
-        Function to get all trades. This function will return all trades
-        that match the specified query parameters. If the market parameter
-        is specified, the trades with the specified market will be returned.
+        Function to retrieve a trade. This function will return the first
+        trade that matches the specified query parameters.
 
         Args:
             market: The market of the asset
@@ -1211,7 +1210,7 @@ class Context:
             trading_symbol: The trading symbol of the asset
 
         Returns:
-            List[Trade]: A list of trades that match the query parameters
+            Trade: A instance of a trade that matches the query parameters
         """
         query_params = {}
 

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/app/strategy.py

@@ -16,7 +16,12 @@ class TradingStrategy:
     strategy is a set of rules that defines when to buy or sell an asset.
 
     Attributes:
-        id (string): the unique id for your combined strategy instances
+        algorithm_id (string): the unique id for your
+            combined strategy instances. An algorithm consists out of one or
+            more strategy instances that run together. The algorithm_id
+            is used to uniquely indentify the combined strategy instances.
+            This is id is used in various places in the framework, e.g. for
+            backtesting results, logging, monitoring etc.
         time_unit (TimeUnit): the time unit of the strategy that defines
             when the strategy should run e.g. HOUR, DAY, WEEK, MONTH
         interval (int): the interval of the strategy that defines how often
@@ -34,7 +39,7 @@ class TradingStrategy:
             store additional information about the strategy, such as its
             author, version, description, params etc.
     """
-    id: str
+    algorithm_id: str
     time_unit: TimeUnit = None
     interval: int = None
     worker_id: str = None
@@ -52,7 +57,7 @@ class TradingStrategy:
 
     def __init__(
         self,
-        id,
+        algorithm_id=None,
         strategy_id=None,
         time_unit=None,
         interval=None,
@@ -66,7 +71,29 @@ class TradingStrategy:
         worker_id=None,
         decorated=None
     ):
-        self.id = id
+        if metadata is None:
+            metadata = {}
+
+        self.metadata = metadata
+
+        if worker_id is not None:
+            self.worker_id = worker_id
+        elif self.decorated:
+            self.worker_id = decorated.__name__
+        else:
+            self.worker_id = self.__class__.__name__
+
+        if strategy_id is not None:
+            self.strategy_id = strategy_id
+        else:
+            self.strategy_id = self.worker_id
+
+        if algorithm_id is not None:
+            self.algorithm_id = algorithm_id
+
+        if "algorithm_id" in self.metadata:
+            self.algorithm_id = self.metadata["algorithm_id"]
+
         if time_unit is not None:
             self.time_unit = TimeUnit.from_value(time_unit)
         else:
@@ -85,29 +112,9 @@ class TradingStrategy:
         if data_sources is not None:
             self.data_sources = data_sources
 
-        if metadata is None:
-            metadata = {}
-
-        self.metadata = metadata
-
-        if "id" not in self.metadata:
-            self.metadata["id"] = self.id
-
         if decorated is not None:
             self.decorated = decorated
 
-        if worker_id is not None:
-            self.worker_id = worker_id
-        elif self.decorated:
-            self.worker_id = decorated.__name__
-        else:
-            self.worker_id = self.__class__.__name__
-
-        if strategy_id is not None:
-            self.strategy_id = strategy_id
-        else:
-            self.strategy_id = self.worker_id
-
         if position_sizes is not None:
             self.position_sizes = position_sizes
 

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/dependency_container.py

@@ -3,13 +3,13 @@ from dependency_injector import containers, providers
 from investing_algorithm_framework.app.algorithm import AlgorithmFactory
 from investing_algorithm_framework.app.context import Context
 from investing_algorithm_framework.infrastructure import SQLOrderRepository, \
-    SQLPositionRepository, SQLPortfolioRepository, \
+    SQLPositionRepository, SQLPortfolioRepository, BacktestService, \
     SQLPortfolioSnapshotRepository, SQLTradeRepository, \
     SQLPositionSnapshotRepository, SQLTradeStopLossRepository, \
     SQLTradeTakeProfitRepository, SQLOrderMetadataRepository
 from investing_algorithm_framework.services import OrderService, \
     PositionService, PortfolioService, PortfolioConfigurationService, \
-    BacktestService, ConfigurationService, PortfolioSnapshotService, \
+    ConfigurationService, PortfolioSnapshotService, \
     PositionSnapshotService, MarketCredentialService, TradeService, \
     PortfolioSyncService, OrderExecutorLookup, PortfolioProviderLookup, \
     DataProviderService, TradeTakeProfitService, TradeStopLossService

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/domain/__init__.py

@@ -37,7 +37,8 @@ from .utils import random_string, append_dict_as_row_to_csv, \
 from .backtesting import BacktestRun, BacktestSummaryMetrics, \
     BacktestDateRange, Backtest, BacktestMetrics, combine_backtests, \
     BacktestPermutationTest, BacktestEvaluationFocus, \
-    generate_backtest_summary_metrics
+    generate_backtest_summary_metrics, load_backtests_from_directory, \
+    save_backtests_to_directory
 
 __all__ = [
     "OrderStatus",
@@ -143,5 +144,7 @@ __all__ = [
     'generate_backtest_summary_metrics',
     'DataError',
     'TakeProfitRule',
-    'StopLossRule'
+    'StopLossRule',
+    "load_backtests_from_directory",
+    "save_backtests_to_directory",
 ]

{investing_algorithm_framework-7.22.2 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/domain/backtesting/__init__.py

@@ -7,6 +7,8 @@ from .backtest_permutation_test import BacktestPermutationTest
 from .backtest_evaluation_focuss import BacktestEvaluationFocus
 from .combine_backtests import combine_backtests, \
     generate_backtest_summary_metrics
+from .backtest_utils import load_backtests_from_directory, \
+    save_backtests_to_directory
 
 __all__ = [
     "Backtest",
@@ -17,5 +19,7 @@ __all__ = [
     "BacktestPermutationTest",
     "BacktestEvaluationFocus",
     "combine_backtests",
-    "generate_backtest_summary_metrics"
+    "generate_backtest_summary_metrics",
+    "load_backtests_from_directory",
+    "save_backtests_to_directory",
 ]