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

investing_algorithm_framework/cli/templates/readme.md.template

@@ -0,0 +1,135 @@
+# README created by investing_algorithm_framework
+
+You can find the documentation for the investing_algorithm_framework
+[here](https://coding-kitties.github.io/investing-algorithm-framework).
+
+
+## Getting Started
+
+This project was created using the investing_algorithm_framework CLI. It provides a template for building a trading algorithm using the investing_algorithm_framework.
+
+This repository contains a simple trading algorithm that uses the
+`investing_algorithm_framework` to fetch data from [bitvavo](https://www.bitvavo.com/en/) and execute trades on the [bitvavo exchange](https://www.bitvavo.com/en/).
+
+The trading strategy is a simple moving average crossover strategy that uses the 50 and 100 day moving averages and the 200 day moving average as a trend filter. The strategy is implemented in the `strategy.py` file. The data provider is implemented in the `data_providers.py` file.
+
+All indicators are implemented with the [pyindicators](https://github.com/coding-kitties/PyIndicators) library.
+
+
+#### 1. Install the requirements
+
+You can install the requirements using the following command:
+```bash
+pip install -r requirements.txt
+```
+
+This will install the `investing_algorithm_framework`, `pyindicators`, and
+`python-dotenv` libraries. If you use the azure functions type option, it will also install the `azure-functions` library.
+
+
+#### 2. Create a `.env` file
+You need to create a `.env` file in the root of the project. You can use the `.env.example` file as a template. The `.env` file should contain the following environment variables:
+
+```bash
+BITVAVO_API_KEY=your_api_key
+BITVAVO_API_SECRET=your_api_secret
+```
+
+##### 2.1 Changing the exchange
+You can change the exchange in the `app.py` file. The default is set to `bitvavo`, but you can change it to any exchange you want. You can find the list of supported exchanges [here](https://investing-algorithm-framework.com/Getting%20Started/markets).
+
+##### 2.2 Azure Functions `.env` file
+If you are using the azure functions type option, you also need to add the following environment variables:
+
+```
+AZURE_STORAGE_CONNECTION_STRING=your_azure_storage_connection_string
+AZURE_STORAGE_CONTAINER_NAME=your_azure_storage_container_name
+```
+
+If you would like to have guidance on how to create the azure storage connection string, you can find it [here](https://learn.microsoft.com/en-us/azure/storage/common/storage-account-create?tabs=azure-portal).
+
+#### 3. Run the app (Skip this step if you have not backtested your strategy)
+> This will run the app as if it was run in production. It will execute live
+> trades on your connected exchange. Please only run this if you are
+> comfortable with this and have backtested your strategy.
+
+You can run the app using the following command:
+```bash
+python app.py
+```
+
+This will start the app and run the trading algorithm. The app will fetch data from the bitvavo exchange and execute trades based on the trading strategy.
+
+#### 3.1 Run the app with azure functions locally
+> Make sure to have the azure functions core tools installed. You can find the
+> installation instructions [here](https://learn.microsoft.com/en-us/azure/azure-functions/functions-run-local).
+
+If you are using the azure functions type option, you can run the app locally using the following command:
+```bash
+func start
+```
+
+#### 4. Run the backtest
+You can run the backtest using the following command:
+
+```bash
+python run_backtest.py
+```
+
+#### 5. Deployment
+You can deploy your trading bot in varous ways.
+
+##### 5.1 Azure Functions
+You can deploy your trading bot to azure functions using the following command:
+
+```bash
+investing-algorithm-framework deploy --type function --cloud azure
+```
+This will deploy your trading bot to azure functions. You can find the deployment instructions [here](https://investing-algorithm-framework.com/Getting%20Started/deployment).
+
+## Project Structure
+
+> We highly recommend to keep the file structure as is, as it is
+> designed to work with the investing_algorithm_framework CLI.
+> You can add your own files and folders as needed, however, we
+> recommend to keep the `strategies` folder for your strategies
+> and the `app.py` file for your app entry point.
+
+```yaml
+.
+├── app.py
+├── requirements.txt
+├── strategies
+│   ├── data_providers.py
+│   └── strategy.py
+├── .gitignore
+├── .env.example
+└── README.md
+```
+
+If you're using the azure functions type option, you will also have an `function_app.py`, `local.settings.json`, and `function.json` file. The `function_app.py` file is the entry point for the azure function, and the `local.settings.json` file is used to configure the local environment for the azure function. The `function.json` file is used to configure the function itself.
+
+> You can change the time trigger in the `function_app.py` when
+> using the azure functions type option. The default is set to
+> every 30 seconds. You can change it to any time you want,
+> but make sure to use the correct format for the time trigger.
+
+## Requirements
+
+The project requires Python 3.10 or higher. You can create a virtual environment and install the requirements using the following commands:
+
+```bash
+virtualenv venv
+source venv/bin/activate  # On Windows use `venv\Scripts\activate`
+pip install -r requirements.txt
+```
+
+By default pyindicators is installed as its specified in the requirements.txt file. This is a requirement for the example strategy in the `strategy.py` file. You can always remove it from the requirements.txt file if you don't need it.
+
+## Deployment
+
+You can deploy your trading bot to azure functions using the following cli command:
+
+```bash
+investing-algorithm-framework deploy --type function --cloud azure
+```

investing_algorithm_framework/cli/templates/requirements.txt.template

@@ -0,0 +1,2 @@
+investing-algorithm-framework>=6.8.2
+pyindicators>=0.5.4

investing_algorithm_framework/cli/templates/run_backtest.py.template

@@ -0,0 +1,20 @@
+from datetime import datetime
+
+from investing_algorithm_framework import BacktestDateRange
+from investing_algorithm_framework import create_app
+from strategies.strategy import MyTradingStrategy
+
+app = create_app()
+app.add_strategy(MyTradingStrategy)
+app.add_market(market="BITVAVO", trading_symbol="EUR")
+
+
+if __name__ == "__main__":
+    backtest_date_range = BacktestDateRange(
+        start_date=datetime(2023, 1, 1),
+        end_date=datetime(2023, 12, 31),
+    )
+    report = app.run_backtest(
+        backtest_date_range=backtest_date_range, initial_amount=1000
+    )
+    report.show()

investing_algorithm_framework/cli/templates/strategy.py.template

@@ -0,0 +1,124 @@
+from investing_algorithm_framework import TimeUnit, TradingStrategy, Context, \
+    OrderSide
+from .data_providers import btc_eur_ohlcv_2h, btc_eur_ticker
+from pyindicators import ema, is_crossover, is_above, is_below, is_crossunder
+
+
+class MyTradingStrategy(TradingStrategy):
+    """
+    A simple trading strategy that uses EMA crossovers to generate buy and
+    sell signals. The strategy uses a 50-period EMA and a 100-period EMA
+    to detect golden and death crosses. It also uses a 200-period EMA to
+    determine the overall trend direction. The strategy trades BTC/EUR
+    on a 2-hour timeframe. The strategy is designed to be used with the
+    Investing Algorithm Framework and uses the PyIndicators library
+    to calculate the EMAs and crossover signals.
+
+    The strategy uses a trailing stop loss and take profit to manage
+    risk. The stop loss is set to 5% below the entry price and the
+    take profit is set to 10% above the entry price. The stop loss and
+    take profit are both trailing, meaning that they will move up
+    with the price when the price goes up.
+    """
+    time_unit = TimeUnit.HOUR
+    interval = 2
+    symbol_pairs = ["BTC/EUR"]
+    market_data_sources = [btc_eur_ohlcv_2h, btc_eur_ticker]
+    fast = 50
+    slow = 100
+    trend = 200
+    stop_loss_percentage = 2
+    stop_loss_sell_size = 50
+    take_profit_percentage = 8
+    take_profit_sell_size = 50
+
+    def apply_strategy(self, context: Context, market_data):
+
+        for pair in self.symbol_pairs:
+            symbol = pair.split('/')[0]
+
+            # Don't trade if there are open orders for the symbol
+            # This is important to avoid placing new orders while there are
+            # existing orders that are not yet filled
+            if context.has_open_orders(symbol):
+                continue
+
+            ohlvc_data = market_data[f"{pair}-ohlcv-2h"]
+            # ticker_data = market_data[f"{symbol}-ticker"]
+            # Add fast, slow, and trend EMAs to the data
+            ohlvc_data = ema(
+                ohlvc_data,
+                source_column="Close",
+                period=self.fast,
+                result_column=f"ema_{self.fast}"
+            )
+            ohlvc_data = ema(
+                ohlvc_data,
+                source_column="Close",
+                period=self.slow,
+                result_column=f"ema_{self.slow}"
+            )
+            ohlvc_data = ema(
+                ohlvc_data,
+                source_column="Close",
+                period=self.trend,
+                result_column=f"ema_{self.trend}"
+            )
+
+            price = ohlvc_data["Close"][-1]
+
+            if not context.has_position(symbol) \
+                    and self._is_buy_signal(ohlvc_data):
+                order = context.create_limit_order(
+                    target_symbol=symbol,
+                    order_side=OrderSide.BUY,
+                    price=price,
+                    percentage_of_portfolio=25,
+                    precision=4,
+                )
+                trade = context.get_trade(order_id=order.id)
+                context.add_stop_loss(
+                    trade=trade,
+                    trade_risk_type="trailing",
+                    percentage=self.stop_loss_percentage,
+                    sell_percentage=self.stop_loss_sell_size
+                )
+                context.add_take_profit(
+                    trade=trade,
+                    percentage=self.take_profit_percentage,
+                    trade_risk_type="trailing",
+                    sell_percentage=self.take_profit_sell_size
+                )
+
+            if context.has_position(symbol) \
+                    and self._is_sell_signal(ohlvc_data):
+                open_trades = context.get_open_trades(
+                    target_symbol=symbol
+                )
+
+                for trade in open_trades:
+                    context.close_trade(trade)
+
+    def _is_sell_signal(self, data):
+        return is_crossunder(
+            data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.slow}",
+            number_of_data_points=2
+        ) and is_below(
+            data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.trend}",
+        )
+
+    def _is_buy_signal(self, data):
+        return is_crossover(
+            data=data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.slow}",
+            number_of_data_points=2
+        ) and is_above(
+            data=data,
+            first_column=f"ema_{self.fast}",
+            second_column=f"ema_{self.trend}",
+        )

investing_algorithm_framework/create_app.py

@@ -0,0 +1,54 @@
+import os
+import logging
+import inspect
+from dotenv import load_dotenv
+
+from .app import App
+from .dependency_container import setup_dependency_container
+from .domain import AppMode, APPLICATION_DIRECTORY, APP_MODE
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+def create_app(
+    config: dict = None,
+    state_handler=None,
+    web: bool = False,
+    name=None
+) -> App:
+    """
+    Factory method to create an app instance.
+
+    Args:
+        config (dict): Configuration dictionary
+        web (bool): Whether to create a web app
+        state_handler (StateHandler): State handler for the app
+        name (str): Name of the app
+
+    Returns:
+        App: App instance
+    """
+    # Load the environment variables
+    load_dotenv()
+
+    app = App(state_handler=state_handler)
+    app = setup_dependency_container(
+        app,
+        ["investing_algorithm_framework"],
+        ["investing_algorithm_framework"]
+    )
+    app.name = name
+
+    if config is not None:
+        app.set_config_with_dict(config)
+
+    if web:
+        app.set_config(APP_MODE, AppMode.WEB.value)
+
+    # Add the application directory to the config
+    caller_frame = inspect.stack()[1]
+    caller_path = os.path.abspath(caller_frame.filename)
+    app.set_config(APPLICATION_DIRECTORY, caller_path)
+
+    logger.info("Investing algorithm framework app created")
+    return app

investing_algorithm_framework/dependency_container.py

@@ -0,0 +1,155 @@
+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, \
+    SQLPortfolioSnapshotRepository, SQLTradeRepository, \
+    SQLPositionSnapshotRepository, SQLTradeStopLossRepository, \
+    SQLTradeTakeProfitRepository, SQLOrderMetadataRepository
+from investing_algorithm_framework.services import OrderService, \
+    PositionService, PortfolioService, PortfolioConfigurationService, \
+    BacktestService, ConfigurationService, PortfolioSnapshotService, \
+    PositionSnapshotService, MarketCredentialService, TradeService, \
+    PortfolioSyncService, OrderExecutorLookup, PortfolioProviderLookup, \
+    DataProviderService
+
+
+def setup_dependency_container(app, modules=None, packages=None):
+    app.container = DependencyContainer()
+    app.container.wire(modules=modules, packages=packages)
+    return app
+
+
+class DependencyContainer(containers.DeclarativeContainer):
+    """
+    Dependency container for the app. It is responsible for managing the
+    dependencies of the app.
+    """
+    config = providers.Configuration()
+    wiring_config = containers.WiringConfiguration()
+    configuration_service = providers.ThreadSafeSingleton(
+        ConfigurationService,
+    )
+    market_credential_service = providers.ThreadSafeSingleton(
+        MarketCredentialService
+    )
+    order_repository = providers.Factory(SQLOrderRepository)
+    order_executor_lookup = providers.ThreadSafeSingleton(
+        OrderExecutorLookup
+    )
+    order_metadata_repository = providers.Factory(SQLOrderMetadataRepository)
+    position_repository = providers.Factory(SQLPositionRepository)
+    portfolio_provider_lookup = providers.ThreadSafeSingleton(
+        PortfolioProviderLookup,
+    )
+    portfolio_repository = providers.Factory(SQLPortfolioRepository)
+    position_snapshot_repository = providers.Factory(
+        SQLPositionSnapshotRepository
+    )
+    portfolio_snapshot_repository = providers.Factory(
+        SQLPortfolioSnapshotRepository
+    )
+    trade_repository = providers.Factory(SQLTradeRepository)
+    trade_take_profit_repository = providers\
+        .Factory(SQLTradeTakeProfitRepository)
+    trade_stop_loss_repository = providers.Factory(SQLTradeStopLossRepository)
+    data_provider_service = providers.ThreadSafeSingleton(
+        DataProviderService,
+        configuration_service=configuration_service,
+        market_credential_service=market_credential_service
+    )
+    position_snapshot_service = providers.Factory(
+        PositionSnapshotService,
+        repository=position_snapshot_repository,
+    )
+    portfolio_snapshot_service = providers.Factory(
+        PortfolioSnapshotService,
+        order_repository=order_repository,
+        repository=portfolio_snapshot_repository,
+        portfolio_repository=portfolio_repository,
+        position_snapshot_service=position_snapshot_service,
+        position_repository=position_repository,
+        data_provider_service=data_provider_service,
+    )
+    portfolio_configuration_service = providers.ThreadSafeSingleton(
+        PortfolioConfigurationService,
+        portfolio_repository=portfolio_repository,
+        position_repository=position_repository,
+    )
+    trade_service = providers.Factory(
+        TradeService,
+        order_repository=order_repository,
+        trade_take_profit_repository=trade_take_profit_repository,
+        trade_stop_loss_repository=trade_stop_loss_repository,
+        configuration_service=configuration_service,
+        trade_repository=trade_repository,
+        portfolio_repository=portfolio_repository,
+        position_repository=position_repository,
+        order_metadata_repository=order_metadata_repository,
+    )
+    position_service = providers.Factory(
+        PositionService,
+        portfolio_repository=portfolio_repository,
+        repository=position_repository,
+    )
+    order_service = providers.Factory(
+        OrderService,
+        configuration_service=configuration_service,
+        order_repository=order_repository,
+        portfolio_repository=portfolio_repository,
+        position_service=position_service,
+        market_credential_service=market_credential_service,
+        portfolio_configuration_service=portfolio_configuration_service,
+        portfolio_snapshot_service=portfolio_snapshot_service,
+        trade_service=trade_service,
+        order_executor_lookup=order_executor_lookup,
+        portfolio_provider_lookup=portfolio_provider_lookup
+    )
+    portfolio_service = providers.Factory(
+        PortfolioService,
+        configuration_service=configuration_service,
+        market_credential_service=market_credential_service,
+        order_service=order_service,
+        position_service=position_service,
+        portfolio_repository=portfolio_repository,
+        portfolio_configuration_service=portfolio_configuration_service,
+        portfolio_snapshot_service=portfolio_snapshot_service,
+        portfolio_provider_lookup=portfolio_provider_lookup
+    )
+    portfolio_sync_service = providers.Factory(
+        PortfolioSyncService,
+        trade_service=trade_service,
+        configuration_service=configuration_service,
+        order_service=order_service,
+        position_repository=position_repository,
+        portfolio_repository=portfolio_repository,
+        portfolio_configuration_service=portfolio_configuration_service,
+        market_credential_service=market_credential_service,
+        portfolio_provider_lookup=portfolio_provider_lookup,
+    )
+    backtest_service = providers.Factory(
+        BacktestService,
+        configuration_service=configuration_service,
+        order_service=order_service,
+        trade_service=trade_service,
+        portfolio_service=portfolio_service,
+        position_repository=position_repository,
+        portfolio_configuration_service=portfolio_configuration_service,
+        portfolio_snapshot_service=portfolio_snapshot_service,
+        data_provider_service=data_provider_service,
+    )
+    context = providers.Factory(
+        Context,
+        configuration_service=configuration_service,
+        portfolio_configuration_service=portfolio_configuration_service,
+        portfolio_service=portfolio_service,
+        position_service=position_service,
+        order_service=order_service,
+        market_credential_service=market_credential_service,
+        trade_service=trade_service,
+        data_provider_service=data_provider_service,
+    )
+    algorithm_factory = providers.Factory(
+        AlgorithmFactory,
+    )

investing_algorithm_framework/domain/__init__.py

@@ -0,0 +1,148 @@
+from .config import Environment, DEFAULT_LOGGING_CONFIG, \
+    AWS_LAMBDA_LOGGING_CONFIG
+from .constants import ITEMIZE, ITEMIZED, PER_PAGE, PAGE, ENVIRONMENT, \
+    DATABASE_DIRECTORY_PATH, DATABASE_NAME, DEFAULT_PER_PAGE_VALUE, \
+    DEFAULT_PAGE_VALUE, SQLALCHEMY_DATABASE_URI, RESOURCE_DIRECTORY, \
+    DATETIME_FORMAT, DATETIME_FORMAT_BACKTESTING, BACKTESTING_FLAG, \
+    BACKTESTING_START_DATE, CCXT_DATETIME_FORMAT, \
+    BACKTEST_DATA_DIRECTORY_NAME, TICKER_DATA_TYPE, OHLCV_DATA_TYPE, \
+    CURRENT_UTC_DATETIME, BACKTESTING_END_DATE, SYMBOLS, \
+    CCXT_DATETIME_FORMAT_WITH_TIMEZONE, RESERVED_BALANCES, \
+    APP_MODE, DATABASE_DIRECTORY_NAME, BACKTESTING_INITIAL_AMOUNT, \
+    APPLICATION_DIRECTORY, SNAPSHOT_INTERVAL, AWS_S3_STATE_BUCKET_NAME, \
+    LAST_SNAPSHOT_DATETIME, DATA_DIRECTORY, INDEX_DATETIME, \
+    DATETIME_FORMAT_FILE_NAME, DEFAULT_DATETIME_FORMAT
+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, DataError, \
+    PermissionDeniedApiException, ImproperlyConfigured, NetworkError
+from .models import OrderStatus, OrderSide, OrderType, TimeInterval, \
+    TimeUnit, TimeFrame, PortfolioConfiguration, Portfolio, Position, \
+    Order, TradeStatus, StrategyProfile, Trade, MarketCredential, \
+    AppMode, DataType, DataSource, PortfolioSnapshot, PositionSnapshot, \
+    TradeRiskType, TradeTakeProfit, TradeStopLoss, Event, SnapshotInterval
+from .order_executor import OrderExecutor
+from .portfolio_provider import PortfolioProvider
+from .services import MarketCredentialService, AbstractPortfolioSyncService, \
+    RoundingService, StateHandler
+from .stateless_actions import StatelessActions
+from .strategy import Strategy
+from .utils import random_string, append_dict_as_row_to_csv, \
+    add_column_headers_to_csv, get_total_amount_of_rows, \
+    convert_polars_to_pandas, random_number, is_jupyter_notebook, \
+    csv_to_list, StoppableThread, load_csv_into_dict, tqdm, \
+    is_timezone_aware, sync_timezones, get_timezone
+from .backtesting import BacktestRun, BacktestSummaryMetrics, \
+    BacktestDateRange, Backtest, BacktestMetrics, combine_backtests, \
+    BacktestPermutationTest, BacktestEvaluationFocus, \
+    generate_backtest_summary_metrics
+from .positions import PositionSize
+
+__all__ = [
+    "OrderStatus",
+    "OrderSide",
+    "OrderType",
+    "OperationalException",
+    "ApiException",
+    "PermissionDeniedApiException",
+    "ImproperlyConfigured",
+    "TimeInterval",
+    "TimeUnit",
+    "TimeFrame",
+    "ITEMIZED",
+    "PER_PAGE",
+    "PAGE",
+    "ITEMIZE",
+    "DEFAULT_PER_PAGE_VALUE",
+    "DEFAULT_PAGE_VALUE",
+    "SQLALCHEMY_DATABASE_URI",
+    "random_string",
+    "append_dict_as_row_to_csv",
+    "add_column_headers_to_csv",
+    "get_total_amount_of_rows",
+    "csv_to_list",
+    "DATABASE_DIRECTORY_PATH",
+    "DATABASE_NAME",
+    "PortfolioConfiguration",
+    "RESOURCE_DIRECTORY",
+    'ENVIRONMENT',
+    'Environment',
+    "StoppableThread",
+    "Portfolio",
+    "Position",
+    "Order",
+    "Strategy",
+    "DATETIME_FORMAT",
+    "StatelessActions",
+    "parse_decimal_to_string",
+    "parse_string_to_decimal",
+    "BacktestRun",
+    "DATETIME_FORMAT_BACKTESTING",
+    "BACKTESTING_FLAG",
+    "PortfolioSnapshot",
+    "BACKTESTING_START_DATE",
+    "StrategyProfile",
+    "CCXT_DATETIME_FORMAT",
+    "BACKTEST_DATA_DIRECTORY_NAME",
+    "Trade",
+    "TICKER_DATA_TYPE",
+    "OHLCV_DATA_TYPE",
+    "CURRENT_UTC_DATETIME",
+    "MarketCredential",
+    "PeekableQueue",
+    "BACKTESTING_END_DATE",
+    "PositionSnapshot",
+    "MarketCredentialService",
+    "TradeStatus",
+    "CCXT_DATETIME_FORMAT_WITH_TIMEZONE",
+    "load_csv_into_dict",
+    "SYMBOLS",
+    "RESERVED_BALANCES",
+    "AbstractPortfolioSyncService",
+    "APP_MODE",
+    "AppMode",
+    "RoundingService",
+    "BacktestDateRange",
+    "convert_polars_to_pandas",
+    "DEFAULT_LOGGING_CONFIG",
+    "DATABASE_DIRECTORY_NAME",
+    "BACKTESTING_INITIAL_AMOUNT",
+    "TradeRiskType",
+    "TradeTakeProfit",
+    "TradeStopLoss",
+    "StateHandler",
+    "APPLICATION_DIRECTORY",
+    "DataProvider",
+    "NetworkError",
+    "DataSource",
+    "OrderExecutor",
+    "PortfolioProvider",
+    "random_number",
+    "is_timezone_aware",
+    "sync_timezones",
+    "get_timezone",
+    "Event",
+    "SNAPSHOT_INTERVAL",
+    "SnapshotInterval",
+    "AWS_S3_STATE_BUCKET_NAME",
+    "AWS_LAMBDA_LOGGING_CONFIG",
+    "DataType",
+    "DataSource",
+    "Backtest",
+    "BacktestMetrics",
+    "BacktestSummaryMetrics",
+    "BacktestPermutationTest",
+    "LAST_SNAPSHOT_DATETIME",
+    "DATA_DIRECTORY",
+    "INDEX_DATETIME",
+    "DATETIME_FORMAT_FILE_NAME",
+    "is_jupyter_notebook",
+    "tqdm",
+    "DEFAULT_DATETIME_FORMAT",
+    "BacktestEvaluationFocus",
+    'combine_backtests',
+    'PositionSize',
+    'generate_backtest_summary_metrics',
+    'DataError'
+]

investing_algorithm_framework/domain/backtesting/__init__.py

@@ -0,0 +1,21 @@
+from .backtest_summary_metrics import BacktestSummaryMetrics
+from .backtest_date_range import BacktestDateRange
+from .backtest_metrics import BacktestMetrics
+from .backtest_run import BacktestRun
+from .backtest import Backtest
+from .backtest_permutation_test import BacktestPermutationTest
+from .backtest_evaluation_focuss import BacktestEvaluationFocus
+from .combine_backtests import combine_backtests, \
+    generate_backtest_summary_metrics
+
+__all__ = [
+    "Backtest",
+    "BacktestSummaryMetrics",
+    "BacktestDateRange",
+    "BacktestMetrics",
+    "BacktestRun",
+    "BacktestPermutationTest",
+    "BacktestEvaluationFocus",
+    "combine_backtests",
+    "generate_backtest_summary_metrics"
+]