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

investing_algorithm_framework/app/app.py

@@ -2,14 +2,12 @@ import inspect
 import logging
 import os
 import threading
-from time import sleep
-from typing import List, Optional, Any
+from datetime import datetime, timezone, timedelta
+from typing import List, Optional, Any, Dict, Tuple
 
 from flask import Flask
 
-from investing_algorithm_framework.app.algorithm import Algorithm, \
-    AlgorithmFactory
-from investing_algorithm_framework.app.stateless import ActionHandler
+from investing_algorithm_framework.app.algorithm import Algorithm
 from investing_algorithm_framework.app.strategy import TradingStrategy
 from investing_algorithm_framework.app.task import Task
 from investing_algorithm_framework.app.web import create_flask_app
@@ -17,17 +15,23 @@ from investing_algorithm_framework.domain import DATABASE_NAME, TimeUnit, \
     DATABASE_DIRECTORY_PATH, RESOURCE_DIRECTORY, ENVIRONMENT, Environment, \
     SQLALCHEMY_DATABASE_URI, OperationalException, StateHandler, \
     BACKTESTING_START_DATE, BACKTESTING_END_DATE, APP_MODE, MarketCredential, \
-    AppMode, BacktestDateRange, DATABASE_DIRECTORY_NAME, \
-    BACKTESTING_INITIAL_AMOUNT, SNAPSHOT_INTERVAL, \
-    MarketDataSource, PortfolioConfiguration, SnapshotInterval, \
-    PortfolioProvider, OrderExecutor, ImproperlyConfigured
+    AppMode, BacktestDateRange, DATABASE_DIRECTORY_NAME, DataSource, \
+    BACKTESTING_INITIAL_AMOUNT, SNAPSHOT_INTERVAL, Backtest, DataError, \
+    PortfolioConfiguration, SnapshotInterval, DataType, combine_backtests, \
+    PortfolioProvider, OrderExecutor, ImproperlyConfigured, TimeFrame, \
+    DataProvider, INDEX_DATETIME, tqdm, BacktestPermutationTest, \
+    LAST_SNAPSHOT_DATETIME, BACKTESTING_FLAG, generate_backtest_summary_metrics
 from investing_algorithm_framework.infrastructure import setup_sqlalchemy, \
-    create_all_tables, CCXTOrderExecutor, CCXTPortfolioProvider
+    create_all_tables, CCXTOrderExecutor, CCXTPortfolioProvider, \
+    BacktestOrderExecutor, CCXTOHLCVDataProvider, clear_db, \
+    PandasOHLCVDataProvider
 from investing_algorithm_framework.services import OrderBacktestService, \
-    BacktestMarketDataSourceService, BacktestPortfolioService, \
-    BacktestService
+    BacktestPortfolioService, BacktestTradeOrderEvaluator, \
+    DefaultTradeOrderEvaluator, get_risk_free_rate_us
 from .app_hook import AppHook
-from .reporting import BacktestReport
+from .eventloop import EventLoopService
+from .analysis import create_ohlcv_permutation
+
 
 logger = logging.getLogger("investing_algorithm_framework")
 COLOR_RESET = '\033[0m'
@@ -43,8 +47,6 @@ class App:
     Attributes:
         container: The dependency container for the app. This is used
             to store all the services and repositories for the app.
-        algorithm: The algorithm to run. This is used to run the
-            trading bot.
         _flask_app: The flask app instance. This is used to run the
             web app.
         _state_handler: The state handler for the app. This is used
@@ -55,9 +57,6 @@ class App:
             started or not.
         _tasks (List[Task]): List of task that need to be run by the
             application.
-        _algorithm (Algorithm): The algorithm instance. An algorithm is a
-            bundle of tasks and strategies. The algorithm is only
-            initialized when the application in started.
     """
 
     def __init__(self, state_handler=None, name=None):
@@ -66,12 +65,12 @@ class App:
         self._started = False
         self._tasks = []
         self._strategies = []
-        self._market_data_sources = []
+        self._data_providers: List[Tuple[DataProvider, int]] = []
         self._on_initialize_hooks = []
         self._on_strategy_run_hooks = []
         self._on_after_initialize_hooks = []
+        self._trade_order_evaluator = None
         self._state_handler = state_handler
-        self._strategy_orchestrator_service = None
         self._run_history = None
         self._name = name
 
@@ -79,6 +78,56 @@ class App:
     def context(self):
         return self.container.context()
 
+    @property
+    def resource_directory_path(self):
+        """
+        Returns the resource directory path from the configuration.
+        This directory is used to store resources such as market data,
+        database files, and other resources required by the app.
+        """
+        config = self.config
+        resource_directory_path = config.get(RESOURCE_DIRECTORY, None)
+
+        # Check if the resource directory is set
+        if resource_directory_path is None:
+            logger.info(
+                "Resource directory not set, setting" +
+                " to current working directory"
+            )
+            resource_directory_path = os.path.join(os.getcwd(), "resources")
+            configuration_service = self.container.configuration_service()
+            configuration_service.add_value(
+                RESOURCE_DIRECTORY, resource_directory_path
+            )
+
+        return resource_directory_path
+
+    @property
+    def database_directory_path(self):
+        """
+        Returns the database directory path from the configuration.
+        This directory is used to store database files required by the app.
+        """
+        config = self.config
+        database_directory_path = config.get(DATABASE_DIRECTORY_PATH, None)
+
+        # Check if the database directory is set
+        if database_directory_path is None:
+            logger.info(
+                "Database directory not set, setting" +
+                " to current working directory"
+            )
+            resource_directory_path = self.resource_directory_path
+            database_directory_path = os.path.join(
+                resource_directory_path, "databases"
+            )
+            configuration_service = self.container.configuration_service()
+            configuration_service.add_value(
+                DATABASE_DIRECTORY_PATH, database_directory_path
+            )
+
+        return database_directory_path
+
     @property
     def name(self):
         return self._name
@@ -131,9 +180,22 @@ class App:
             None
         """
         self.add_strategies(algorithm.strategies)
-        self.add_data_sources(algorithm.data_sources)
         self.add_tasks(algorithm.tasks)
 
+    def add_trade_order_evaluator(self, trade_order_evaluator):
+        """
+        Function to add a trade order evaluator to the app. This is used
+        to evaluate trades and orders based on OHLCV data.
+
+        Args:
+            trade_order_evaluator: The trade order evaluator to add to the app.
+                This should be an instance of TradeOrderEvaluator.
+
+        Returns:
+            None
+        """
+        self._trade_order_evaluator = trade_order_evaluator
+
     def set_config(self, key: str, value: Any) -> None:
         """
         Function to add a key-value pair to the app's configuration.
@@ -148,55 +210,276 @@ class App:
         configuration_service = self.container.configuration_service()
         configuration_service.add_value(key, value)
 
-    def set_config_with_dict(self, dictionary) -> None:
+    def set_config_with_dict(self, config: dict) -> None:
         """
-        Function to add a dictionary to the app's configuration.
-        This method is useful for adding multiple configuration values
+        Function to set the configuration for the app with a dictionary.
+        This is useful for setting multiple configuration values at once.
 
         Args:
-            dictionary (Dict): A dictionary containing key-value pairs
-                to add to the configuration
+            config (dict): A dictionary containing the configuration
 
         Returns:
             None
         """
         configuration_service = self.container.configuration_service()
-        configuration_service.add_dict(dictionary)
+        configuration_service.initialize_from_dict(config)
 
-    def initialize_services(self) -> None:
+    def initialize_config(self):
         """
-        Method to initialize the services for the app. This method should
-        be called before running the application. This method initializes
-        all services so that they are ready to be used.
+        Function to initialize the configuration for the app. This method
+        should be called before running the algorithm.
 
         Returns:
             None
         """
-        self._initialize_default_order_executors()
-        self._initialize_default_portfolio_providers()
+        data = {
+            ENVIRONMENT: self.config.get(ENVIRONMENT, Environment.PROD.value),
+            DATABASE_DIRECTORY_NAME: "databases",
+            LAST_SNAPSHOT_DATETIME: None
+        }
+        configuration_service = self.container.configuration_service()
+        configuration_service.initialize_from_dict(data)
+        config = configuration_service.get_config()
 
-        # Initialize all market credentials
-        market_credential_service = self.container.market_credential_service()
-        market_credential_service.initialize()
+        if INDEX_DATETIME not in config or config[INDEX_DATETIME] is None:
+            configuration_service.add_value(
+                INDEX_DATETIME, datetime.now(timezone.utc)
+            )
+
+        if Environment.TEST.equals(config[ENVIRONMENT]):
+            configuration_service.add_value(
+                DATABASE_NAME, "test-database.sqlite3"
+            )
+        elif Environment.PROD.equals(config[ENVIRONMENT]):
+            configuration_service.add_value(
+                DATABASE_NAME, "prod-database.sqlite3"
+            )
+        else:
+            configuration_service.add_value(
+                DATABASE_NAME, "dev-database.sqlite3"
+            )
+
+        resource_dir = config[RESOURCE_DIRECTORY]
+        database_dir_name = config.get(DATABASE_DIRECTORY_NAME)
+        configuration_service.add_value(
+            DATABASE_DIRECTORY_PATH,
+            os.path.join(resource_dir, database_dir_name)
+        )
+        config = configuration_service.get_config()
+
+        if SQLALCHEMY_DATABASE_URI not in config \
+                or config[SQLALCHEMY_DATABASE_URI] is None:
+            path = "sqlite:///" + os.path.join(
+                configuration_service.config[DATABASE_DIRECTORY_PATH],
+                configuration_service.config[DATABASE_NAME]
+            )
+            configuration_service.add_value(SQLALCHEMY_DATABASE_URI, path)
+
+    def initialize_backtest_config(
+        self,
+        backtest_date_range: BacktestDateRange,
+        initial_amount=None,
+        snapshot_interval: SnapshotInterval = None
+    ):
+        """
+        Function to initialize the configuration for the app in backtest mode.
+        This method should be called before running the algorithm in backtest
+        mode. It sets the environment to BACKTEST and initializes the
+        configuration accordingly.
+
+        Args:
+            backtest_date_range (BacktestDateRange): The date range for the
+                backtest. This should be an instance of BacktestDateRange.
+            initial_amount (float): The initial amount to start the backtest
+                with. This will be the amount of trading currency that the
+                backtest portfolio will start with.
+            snapshot_interval (SnapshotInterval): The snapshot interval to
+                use for the backtest. This is used to determine how often the
+                portfolio snapshot should be taken during the backtest.
+
+        Returns:
+            None
+        """
+        logger.info("Initializing backtest configuration")
+        data = {
+            ENVIRONMENT: Environment.BACKTEST.value,
+            BACKTESTING_START_DATE: backtest_date_range.start_date,
+            BACKTESTING_END_DATE: backtest_date_range.end_date,
+            DATABASE_NAME: "backtest-database.sqlite3",
+            DATABASE_DIRECTORY_NAME: "backtest_databases",
+            DATABASE_DIRECTORY_PATH: os.path.join(
+                self.resource_directory_path,
+                "backtest_databases"
+            ),
+            BACKTESTING_INITIAL_AMOUNT: initial_amount,
+            INDEX_DATETIME: backtest_date_range.start_date,
+            LAST_SNAPSHOT_DATETIME: None,
+            BACKTESTING_FLAG: True
+        }
+        configuration_service = self.container.configuration_service()
+        configuration_service.initialize_from_dict(data)
+
+        if snapshot_interval is not None:
+            configuration_service.add_value(
+                SNAPSHOT_INTERVAL,
+                SnapshotInterval.from_value(snapshot_interval).value
+            )
+
+    def initialize_storage(self, remove_database_if_exists: bool = False):
+        """
+        Function to initialize the storage for the app. The given
+        resource directory will be created if it does not exist.
+        The database directory will also be created if it does not
+        exist.
+        """
+        resource_directory_path = self.resource_directory_path
+
+        if not os.path.exists(resource_directory_path):
+            os.makedirs(resource_directory_path)
+            logger.info(
+                f"Resource directory created at {resource_directory_path}"
+            )
+
+        database_directory_path = self.database_directory_path
+
+        if not os.path.exists(database_directory_path):
+            os.makedirs(database_directory_path)
+            logger.info(
+                f"Database directory created at {database_directory_path}"
+            )
+
+        database_path = os.path.join(
+            database_directory_path, self.config[DATABASE_NAME]
+        )
+
+        if remove_database_if_exists:
+
+            if os.path.exists(database_path):
+                logger.info(
+                    f"Removing existing database at {database_path}"
+                )
+                os.remove(database_path)
+
+        # Create the sqlalchemy database uri
+        path = f"sqlite:///{database_path}"
+        self.set_config(SQLALCHEMY_DATABASE_URI, path)
+
+        # Setup sql if needed
+        setup_sqlalchemy(self)
+        create_all_tables()
+
+    def initialize_data_sources(
+        self,
+        data_sources: List[DataSource],
+    ):
+        """
+        Function to initialize the data sources for the app. This method
+        should be called before running the algorithm. This method
+        initializes all data sources so that they are ready to be used.
+
+        Args:
+            data_sources (List[DataSource]): The data sources to initialize.
+                This should be a list of DataSource instances.
+
+        Returns:
+            None
+        """
+        logger.info("Initializing data sources")
+
+        if data_sources is None or len(data_sources) == 0:
+            return
+
+        data_provider_service = self.container.data_provider_service()
+        data_provider_service.reset()
+
+        for data_provider_tuple in self._data_providers:
+            data_provider_service.add_data_provider(
+                data_provider_tuple[0], priority=data_provider_tuple[1]
+            )
+
+        # Add the default data providers
+        data_provider_service.add_data_provider(CCXTOHLCVDataProvider())
+
+        # Initialize all data sources
+        data_provider_service.index_data_providers(data_sources)
+
+    def initialize_data_sources_backtest(
+        self,
+        data_sources: List[DataSource],
+        backtest_date_range: BacktestDateRange,
+        show_progress: bool = True
+    ):
+        """
+        Function to initialize the data sources for the app in backtest mode.
+        This method should be called before running the algorithm in backtest
+        mode. It initializes all data sources so that they are
+        ready to be used.
+
+        Args:
+            data_sources (List[DataSource]): The data sources to initialize.
+            backtest_date_range (BacktestDateRange): The date range for the
+                backtest. This should be an instance of BacktestDateRange.
+            show_progress (bool): Whether to show a progress bar when
+                preparing the backtest data for each data provider.
 
-    def initialize_services_backtest(self) -> None:
+        Returns:
+            None
         """
-        Method to initialize the services for the app in backtest mode.
-        This method should be called before running the application.
-        This method initializes all services so that they are ready to
-        be used.
+        logger.info("Initializing data sources for backtest")
+
+        if data_sources is None or len(data_sources) == 0:
+            return
+
+        data_provider_service = self.container.data_provider_service()
+        data_provider_service.reset()
+
+        for data_provider_tuple in self._data_providers:
+            data_provider_service.add_data_provider(
+                data_provider_tuple[0], priority=data_provider_tuple[1]
+            )
+
+        # Add the default data providers
+        data_provider_service.add_data_provider(CCXTOHLCVDataProvider())
+
+        # Initialize all data sources
+        data_provider_service.index_backtest_data_providers(
+            data_sources, backtest_date_range, show_progress=show_progress
+        )
+
+        description = "Preparing backtest data for all data sources"
+        data_providers = data_provider_service.data_provider_index.get_all()
+
+        # Prepare the backtest data for each data provider
+        if not show_progress:
+            for _, data_provider in data_providers:
 
-        The method overrides the portfolio service, market data source
-        service and order service with the backtest equivalents.
+                data_provider.prepare_backtest_data(
+                    backtest_start_date=backtest_date_range.start_date,
+                    backtest_end_date=backtest_date_range.end_date
+                )
+        else:
+            for _, data_provider in \
+                    tqdm(
+                        data_providers, desc=description, colour="green"
+                    ):
+
+                data_provider.prepare_backtest_data(
+                    backtest_start_date=backtest_date_range.start_date,
+                    backtest_end_date=backtest_date_range.end_date
+                )
 
-        App hooks are not added when running in backtest mode.
+    def initialize_backtest_services(self):
+        """
+        Function to initialize the backtest services for the app. This method
+        should be called before running the algorithm in backtest mode.
+        It initializes the backtest services so that they are ready to be used.
 
         Returns:
             None
         """
         configuration_service = self.container.configuration_service()
-        self._initialize_default_order_executors()
-        self._initialize_default_portfolio_providers()
+        self.initialize_order_executors()
+        self.initialize_portfolio_providers()
         portfolio_conf_service = self.container \
             .portfolio_configuration_service()
         portfolio_snap_service = self.container \
@@ -218,25 +501,11 @@ class App:
             )
         )
 
-        # Override the market data source service with the backtest market
-        # data source service
-        self.container.market_data_source_service.override(
-            BacktestMarketDataSourceService(
-                market_service=self.container.market_service(),
-                market_credential_service=self.container
-                .market_credential_service(),
-                configuration_service=self.container
-                .configuration_service(),
-            )
-        )
-
         portfolio_conf_service = self.container. \
             portfolio_configuration_service()
         portfolio_snap_service = self.container. \
             portfolio_snapshot_service()
         configuration_service = self.container.configuration_service()
-        market_data_source_service = self.container. \
-            market_data_source_service()
         # Override the order service with the backtest order service
         self.container.order_service.override(
             OrderBacktestService(
@@ -247,107 +516,10 @@ class App:
                 portfolio_configuration_service=portfolio_conf_service,
                 portfolio_snapshot_service=portfolio_snap_service,
                 configuration_service=configuration_service,
-                market_data_source_service=market_data_source_service
             )
         )
 
-    def initialize_config(self):
-        """
-        Function to initialize the configuration for the app. This method
-        should be called before running the algorithm.
-        """
-        logger.info("Initializing configuration")
-        configuration_service = self.container.configuration_service()
-        config = configuration_service.get_config()
-
-        # Check if the resource directory is set
-        if RESOURCE_DIRECTORY not in config \
-                or config[RESOURCE_DIRECTORY] is None:
-            logger.info(
-                "Resource directory not set, setting" +
-                " to current working directory"
-            )
-            path = os.path.join(os.getcwd(), "resources")
-            configuration_service.add_value(RESOURCE_DIRECTORY, path)
-
-        config = configuration_service.get_config()
-        logger.info(f"Resource directory set to {config[RESOURCE_DIRECTORY]}")
-
-        if DATABASE_NAME not in config or config[DATABASE_NAME] is None:
-            configuration_service.add_value(
-                DATABASE_NAME, "prod-database.sqlite3"
-            )
-
-        # Set the database directory name
-        if Environment.BACKTEST.equals(config[ENVIRONMENT]):
-            configuration_service.add_value(
-                DATABASE_DIRECTORY_NAME, "backtest_databases"
-            )
-            configuration_service.add_value(
-                DATABASE_NAME, "backtest-database.sqlite3"
-            )
-        else:
-            configuration_service.add_value(
-                DATABASE_DIRECTORY_NAME, "databases"
-            )
-
-            if Environment.TEST.equals(config[ENVIRONMENT]):
-                configuration_service.add_value(
-                    DATABASE_NAME, "test-database.sqlite3"
-                )
-            elif Environment.PROD.equals(config[ENVIRONMENT]):
-                configuration_service.add_value(
-                    DATABASE_NAME, "prod-database.sqlite3"
-                )
-            else:
-                configuration_service.add_value(
-                    DATABASE_NAME, "dev-database.sqlite3"
-                )
-
-        config = configuration_service.get_config()
-        resource_dir = config[RESOURCE_DIRECTORY]
-        database_dir_name = config.get(DATABASE_DIRECTORY_NAME)
-        configuration_service.add_value(
-            DATABASE_DIRECTORY_PATH,
-            os.path.join(resource_dir, database_dir_name)
-        )
-        config = configuration_service.get_config()
-
-        if SQLALCHEMY_DATABASE_URI not in config \
-                or config[SQLALCHEMY_DATABASE_URI] is None:
-            path = "sqlite:///" + os.path.join(
-                configuration_service.config[DATABASE_DIRECTORY_PATH],
-                configuration_service.config[DATABASE_NAME]
-            )
-            configuration_service.add_value(SQLALCHEMY_DATABASE_URI, path)
-
-        config = configuration_service.get_config()
-
-        if APP_MODE not in config:
-            configuration_service.add_value(APP_MODE, AppMode.DEFAULT.value)
-
-    def initialize_data_sources(self, algorithm):
-        """
-        Function to initialize the data sources for the app. This method
-        should be called before running the algorithm. This method
-        initializes all data sources so that they are ready to be used.
-
-        Returns:
-            None
-        """
-        logger.info("Initializing data sources")
-        market_data_source_service = self.container \
-            .market_data_source_service()
-        market_data_source_service.clear_market_data_sources()
-
-        # Add all market data sources of the strategies to the market
-        # data source service
-        market_data_source_service.market_data_sources = algorithm.data_sources
-
-        # Initialize the market data source service
-        market_data_source_service.initialize_market_data_sources()
-
-    def initialize(self):
+    def initialize_services(self):
         """
         Method to initialize the app. This method should be called before
         running the algorithm. It initializes the services and the algorithm
@@ -359,44 +531,26 @@ class App:
             None
         """
         logger.info("Initializing app")
+        self.initialize_order_executors()
+        self.initialize_portfolio_providers()
 
-        # Ensure that all resource directories exist
-        self._create_resources_if_not_exists()
-
-        # Set up the database
-        setup_sqlalchemy(self)
-        create_all_tables()
-
-        # Check if environment is in backtest mode
-        config = self.container.configuration_service().get_config()
-
-        # Initialize services in backtest
-        if Environment.BACKTEST.equals(config[ENVIRONMENT]):
-            self.initialize_services_backtest()
-        else:
-            self.initialize_services()
-
+        # Initialize all market credentials
+        market_credential_service = self.container.market_credential_service()
+        market_credential_service.initialize()
         portfolio_configuration_service = self.container \
             .portfolio_configuration_service()
 
-        # Re-init the market service because the portfolio configuration
-        # service is a singleton
-        portfolio_configuration_service.market_service \
-            = self.container.market_service()
-
         if portfolio_configuration_service.count() == 0:
             raise OperationalException("No portfolios configured")
 
         configuration_service = self.container.configuration_service()
+        config = configuration_service.get_config()
 
-        if config[APP_MODE] == AppMode.WEB.value:
+        if AppMode.WEB.equals(config[APP_MODE]):
             configuration_service.add_value(APP_MODE, AppMode.WEB.value)
             self._initialize_web()
 
-        if not Environment.BACKTEST.equals(config[ENVIRONMENT]):
-            self._initialize_portfolios()
-
-    def run(self, payload: dict = None, number_of_iterations: int = None):
+    def run(self, number_of_iterations: int = None):
         """
         Entry point to run the application. This method should be called to
         start the trading bot. This method can be called in three modes:
@@ -421,27 +575,17 @@ class App:
          initializes the algorithm with the services and the configuration.
 
         Args:
-            payload (dict): The payload to handle for the algorithm
             number_of_iterations (int): The number of iterations to run the
-            algorithm for
+                algorithm for
 
         Returns:
             None
         """
-        strategy_orchestrator_service = None
+        self.initialize_config()
+        self.initialize_storage()
+        event_loop_service = None
 
         try:
-            configuration_service = self.container.configuration_service()
-            config = configuration_service.get_config()
-
-            # Run method should never be called with environment set to
-            # backtest, if it is, then set the environment to prod
-            if config[ENVIRONMENT] == Environment.BACKTEST.value:
-                configuration_service.add_value(
-                    ENVIRONMENT, Environment.PROD.value
-                )
-
-            self.initialize_config()
 
             # Load the state if a state handler is provided
             if self._state_handler is not None:
@@ -450,44 +594,18 @@ class App:
                 config = self.container.configuration_service().get_config()
                 self._state_handler.load(config[RESOURCE_DIRECTORY])
 
-            self.initialize()
             logger.info("App initialization complete")
 
             # Run all on_initialize hooks
             for hook in self._on_initialize_hooks:
                 hook.on_run(self.context)
 
-            configuration_service = self.container.configuration_service()
-            config = configuration_service.get_config()
-
-            algorithm_factory: AlgorithmFactory = \
-                self.container.algorithm_factory()
-            algorithm = algorithm_factory.create_algorithm(
-                name=self._name,
-                strategies=self._strategies,
-                tasks=self._tasks,
-                data_sources=self._market_data_sources,
-                on_strategy_run_hooks=self._on_strategy_run_hooks,
-            )
-            self.initialize_data_sources(algorithm)
-
-            strategy_orchestrator_service = \
-                self.container.strategy_orchestrator_service()
-            strategy_orchestrator_service.initialize(algorithm)
-
-            # Run in payload mode if payload is provided
-            if payload is not None:
-                logger.info("Running with payload")
-                context = self.container.context()
-                action_handler = ActionHandler.of(payload)
-                response = action_handler.handle(
-                    payload=payload,
-                    context=context,
-                    strategy_orchestrator_service=strategy_orchestrator_service
-                )
-                return response
+            algorithm = self.get_algorithm()
+            self.initialize_data_sources(algorithm.data_sources)
+            self.initialize_services()
+            self.initialize_portfolios()
 
-            if AppMode.WEB.equals(config[APP_MODE]):
+            if AppMode.WEB.equals(self.config[APP_MODE]):
                 logger.info("Running web")
                 flask_thread = threading.Thread(
                     name='Web App',
@@ -497,31 +615,44 @@ class App:
                 flask_thread.daemon = True
                 flask_thread.start()
 
-            number_of_iterations_since_last_orders_check = 1
-            strategy_orchestrator_service.start(
-                context=self.context, number_of_iterations=number_of_iterations
+            trade_order_evaluator = DefaultTradeOrderEvaluator(
+                trade_service=self.container.trade_service(),
+                order_service=self.container.order_service(),
+                trade_stop_loss_service=self.container
+                .trade_stop_loss_service(),
+                trade_take_profit_service=self.container
+                .trade_take_profit_service(),
+                configuration_service=self.container.configuration_service()
+            )
+            event_loop_service = EventLoopService(
+                configuration_service=self.container.configuration_service(),
+                portfolio_snapshot_service=self.container
+                .portfolio_snapshot_service(),
+                context=self.context,
+                order_service=self.container.order_service(),
+                portfolio_service=self.container.portfolio_service(),
+                data_provider_service=self.container.data_provider_service(),
+                trade_service=self.container.trade_service(),
+            )
+            event_loop_service.initialize(
+                algorithm, trade_order_evaluator=trade_order_evaluator
             )
 
             try:
-                while strategy_orchestrator_service.running:
-                    if number_of_iterations_since_last_orders_check == 30:
-                        logger.info("Checking pending orders")
-                        number_of_iterations_since_last_orders_check = 1
-
-                    strategy_orchestrator_service.run_pending_jobs()
-                    number_of_iterations_since_last_orders_check += 1
-                    sleep(1)
+                event_loop_service.start(
+                    number_of_iterations=number_of_iterations
+                )
             except KeyboardInterrupt:
                 exit(0)
         except Exception as e:
             logger.error(e)
             raise e
         finally:
-            self._run_history = strategy_orchestrator_service.history
 
-            try:
-                strategy_orchestrator_service.stop()
+            if event_loop_service is not None:
+                self._run_history = event_loop_service.history
 
+            try:
                 # Upload state if state handler is provided
                 if self._state_handler is not None:
                     logger.info("Detected state handler, saving state")
@@ -616,109 +747,540 @@ class App:
         parameters for web mode and overriding the services with the
         web services equivalents.
 
-        Web has the following implications:
-        - db
-            - sqlite
-        - services
-            - Flask app
-            - Investing Algorithm Framework App
-            - Algorithm
-        """
-        configuration_service = self.container.configuration_service()
-        self._flask_app = create_flask_app(configuration_service)
+        Web has the following implications:
+        - db
+            - sqlite
+        - services
+            - Flask app
+            - Investing Algorithm Framework App
+            - Algorithm
+        """
+        configuration_service = self.container.configuration_service()
+        self._flask_app = create_flask_app(configuration_service)
+
+    def get_portfolio_configurations(self):
+        portfolio_configuration_service = self.container \
+            .portfolio_configuration_service()
+        return portfolio_configuration_service.get_all()
+
+    def get_market_credential(self, market: str) -> MarketCredential:
+        """
+        Function to get a market credential from the app. This method
+        should be called when you want to get a market credential.
+
+        Args:
+            market (str): The market to get the credential for
+
+        Returns:
+            MarketCredential: Instance of MarketCredential
+        """
+
+        market_credential_service = self.container \
+            .market_credential_service()
+        market_credential = market_credential_service.get(market)
+        if market_credential is None:
+            raise OperationalException(
+                f"Market credential for {market} not found"
+            )
+        return market_credential
+
+    def get_market_credentials(self) -> List[MarketCredential]:
+        """
+        Function to get all market credentials from the app. This method
+        should be called when you want to get all market credentials.
+
+        Returns:
+            List of MarketCredential instances
+        """
+        market_credential_service = self.container \
+            .market_credential_service()
+        return market_credential_service.get_all()
+
+    def check_data_completeness(
+        self,
+        strategies: List[TradingStrategy],
+        backtest_date_range: BacktestDateRange,
+        show_progress: bool = True
+    ) -> Tuple[bool, Dict[str, Any]]:
+        """
+        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.
+            show_progress (bool): Whether to show a progress bar when
+                checking data completeness.
+        Returns:
+            Tuple[bool, Dict[str, Any]]: A tuple containing a boolean
+                indicating if the data is complete and a dictionary
+                with information about missing data for each data source.
+        """
+        data_sources = []
+        missing_data_info = {}
+
+        for strategy in strategies:
+            data_sources.extend(strategy.data_sources)
+
+        self.initialize_data_sources_backtest(
+            data_sources,
+            backtest_date_range,
+            show_progress=show_progress
+        )
+        data_provider_service = self.container.data_provider_service()
+        unique_data_sources = set(data_sources)
+
+        for data_source in unique_data_sources:
+
+            if DataType.OHLCV.equals(data_source.data_type):
+                required_start_date = backtest_date_range.start_date - \
+                    timedelta(
+                        minutes=TimeFrame.from_value(
+                            data_source.time_frame
+                        ).amount_of_minutes * data_source.window_size
+                    )
+                number_of_required_data_points = \
+                    data_source.get_number_of_required_data_points(
+                        backtest_date_range.start_date,
+                        backtest_date_range.end_date
+                    )
+
+                try:
+                    data_provider = data_provider_service.get(data_source)
+                    number_of_available_data_points = \
+                        data_provider.get_number_of_data_points(
+                            backtest_date_range.start_date,
+                            backtest_date_range.end_date
+                        )
+
+                    missing_dates = \
+                        data_provider.get_missing_data_dates(
+                            required_start_date,
+                            backtest_date_range.end_date
+                        )
+                    if len(missing_dates) > 0:
+                        missing_data_info[data_source.identifier] = {
+                            "data_source_id": data_source.identifier,
+                            "completeness_percentage": (
+                                (
+                                    number_of_available_data_points /
+                                    number_of_required_data_points
+                                ) * 100
+                            ),
+                            "missing_data_points": len(
+                                missing_dates
+                            ),
+                            "missing_dates": missing_dates,
+                            "data_source_file_path":
+                                data_provider.get_data_source_file_path()
+                        }
+
+                except Exception as e:
+                    raise DataError(
+                        f"Error getting data provider for data source "
+                        f"{data_source.identifier} "
+                        f"({data_source.symbol}): {str(e)}"
+                    )
+
+        if len(missing_data_info.keys()) > 0:
+            return False, missing_data_info
+
+        return True, missing_data_info
+
+    def run_vector_backtests(
+        self,
+        initial_amount,
+        strategies: List[TradingStrategy],
+        backtest_date_range: BacktestDateRange = None,
+        backtest_date_ranges: List[BacktestDateRange] = None,
+        snapshot_interval: SnapshotInterval = SnapshotInterval.DAILY,
+        risk_free_rate: Optional[float] = None,
+        skip_data_sources_initialization: bool = False,
+        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
+        set of strategies need to have their 'buy_signal_vectorized' and
+        'sell_signal_vectorized' methods implemented to support vectorized
+        backtesting.
+
+        Args:
+            initial_amount: The initial amount to start the backtest with.
+                This will be the amount of trading currency that the backtest
+                portfolio will start with.
+            strategies (List[TradingStrategy]): List of strategy objects
+                that need to be backtested. Each strategy should implement
+                the 'buy_signal_vectorized' and 'sell_signal_vectorized'
+                methods to support vectorized backtesting.
+            backtest_date_range: The date range to run the backtest for
+                (instance of BacktestDateRange). This is used when
+                backtest_date_ranges is not provided.
+            backtest_date_ranges: List of date ranges to run the backtests for
+                (List of BacktestDateRange instances). If this is provided,
+                the backtests will be run for each date range in the list.
+                If this is not provided, the backtest_date_range will be used
+            snapshot_interval (SnapshotInterval): The snapshot
+                interval to use for the backtest. This is used to determine
+                how often the portfolio snapshot should be taken during the
+                backtest. The default is TRADE_CLOSE, which means that the
+                portfolio snapshot will be taken at the end of each trade.
+            risk_free_rate (Optional[float]): The risk-free rate to use for
+                the backtest. This is used to calculate the Sharpe ratio
+                and other performance metrics. If not provided, the default
+                risk-free rate will be tried to be fetched from the
+                US Treasury website.
+            skip_data_sources_initialization (bool): Whether to skip the
+                initialization of data sources. This is useful when the data
+                sources are already initialized, and you want to skip the
+                initialization step. This will speed up the backtesting
+                process, but make sure that the data sources are already
+                initialized before calling this method.
+            show_progress (bool): Whether to show progress bars during
+                data source initialization. This is useful for long-running
+                initialization processes.
+            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.
+            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
+                that was backtested.
+        """
+        backtests = []
+        backtests_ordered_by_strategy = {}
+        data_sources = []
+
+        if backtest_date_range is None and backtest_date_ranges is None:
+            raise OperationalException(
+                "Either backtest_date_range or backtest_date_ranges must be "
+                "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:
+            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"
+            ):
+                backtest = 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
+                )
+                backtests.append(backtest)
+        else:
+            for backtest_date_range in tqdm(
+                backtest_date_ranges,
+                colour="green",
+                desc="Running backtests for all date ranges"
+            ):
+                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')
+
+                for strategy in tqdm(
+                    strategies,
+                        colour="green",
+                        desc=f"Running backtests for "
+                             f"{start_date} to {end_date}"
+                ):
+
+                    if strategy not in backtests_ordered_by_strategy:
+                        backtests_ordered_by_strategy[strategy] = []
+
+                    backtests_ordered_by_strategy[strategy].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,
+                        )
+                    )
+
+            for strategy in backtests_ordered_by_strategy:
+                backtests.append(
+                    combine_backtests(backtests_ordered_by_strategy[strategy])
+                )
+
+        return backtests
 
-    def _create_resources_if_not_exists(self):
-        """
-        Function to create the resources required by the app if they
-          do not exist. This function will check if the resource directory
-          exists and check if the database directory exists. If they do
-          not exist, it will create them.
+    def run_vector_backtest(
+        self,
+        backtest_date_range: BacktestDateRange,
+        strategy: TradingStrategy,
+        snapshot_interval: SnapshotInterval = SnapshotInterval.DAILY,
+        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:
+        """
+        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
+        backtesting.
+
+        Args:
+            backtest_date_range: The date range to run the backtest for
+                (instance of BacktestDateRange)
+            initial_amount: The initial amount to start the backtest with.
+                This will be the amount of trading currency that the backtest
+                portfolio will start with.
+            strategy (TradingStrategy) (Optional): The strategy object
+                that needs to be backtested.
+            snapshot_interval (SnapshotInterval): The snapshot
+                interval to use for the backtest. This is used to determine
+                how often the portfolio snapshot should be taken during the
+                backtest. The default is TRADE_CLOSE, which means that the
+                portfolio snapshot will be taken at the end of each trade.
+            risk_free_rate (Optional[float]): The risk-free rate to use for
+                the backtest. This is used to calculate the Sharpe ratio
+                and other performance metrics. If not provided, the default
+                risk-free rate will be tried to be fetched from the
+                US Treasury website.
+            metadata (Optional[Dict[str, str]]): Metadata to attach to the
+                backtest report. This can be used to store additional
+                information about the backtest, such as the author, version,
+                parameters or any other relevant information.
+            skip_data_sources_initialization (bool): Whether to skip the
+                initialization of data sources. This is useful when the data
+                sources are already initialized, and you want to skip the
+                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.
+            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.
+            initial_amount (float): The initial amount to start the
+                backtest with. This will be the amount of trading currency
+                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:
-            None
+            Backtest: Instance of Backtest
         """
-        configuration_service = self.container.configuration_service()
-        config = configuration_service.get_config()
-        resource_dir = config[RESOURCE_DIRECTORY]
-        database_dir = config[DATABASE_DIRECTORY_PATH]
+        # Initialize configuration for vectorized backtesting
+        self.initialize_backtest_config(
+            backtest_date_range=backtest_date_range,
+            snapshot_interval=snapshot_interval,
+            initial_amount=initial_amount
+        )
 
-        if resource_dir is None:
-            raise OperationalException(
-                "Resource directory is not specified in the config, please "
-                "specify the resource directory in the config with the key "
-                "RESOURCE_DIRECTORY"
+        if not skip_data_sources_initialization:
+            self.initialize_data_sources_backtest(
+                strategy.data_sources,
+                backtest_date_range,
+                show_progress=show_data_initialization_progress
             )
 
-        if not os.path.isdir(resource_dir):
-            try:
-                os.makedirs(resource_dir)
-            except OSError as e:
-                logger.error(e)
+        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 create resource directory"
+                    "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 not os.path.isdir(database_dir):
-            try:
-                os.makedirs(database_dir)
-            except OSError as e:
-                logger.error(e)
-                raise OperationalException(
-                    "Could not create database directory"
+        backtest_service = self.container.backtest_service()
+        backtest_service.validate_strategy_for_vector_backtest(strategy)
+
+        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
 
-    def get_portfolio_configurations(self):
-        portfolio_configuration_service = self.container \
-            .portfolio_configuration_service()
-        return portfolio_configuration_service.get_all()
+        # Add the metadata to the backtest
+        if metadata is None:
 
-    def get_market_credential(self, market: str) -> MarketCredential:
+            if strategy.metadata is None:
+                backtest.metadata = {}
+            else:
+                backtest.metadata = strategy.metadata
+        else:
+            backtest.metadata = metadata
+
+        return backtest
+
+    def run_backtests(
+        self,
+        backtest_date_ranges,
+        initial_amount=None,
+        strategy: Optional[TradingStrategy] = None,
+        algorithm: Optional[Algorithm] = None,
+        algorithms: Optional[List[Algorithm]] = None,
+        snapshot_interval: SnapshotInterval = SnapshotInterval.DAILY,
+        risk_free_rate: Optional[float] = None,
+    ) -> List[Backtest]:
         """
-        Function to get a market credential from the app. This method
-        should be called when you want to get a market credential.
+        Function to run multiple backtests for a list of algorithms over
+        a list of date ranges. This function will run each algorithm
+        for each date range and return a list of backtest reports.
 
         Args:
-            market (str): The market to get the credential for
+            algorithms: List of Algorithm instances to run backtests for.
+            backtest_date_ranges (List[BacktestDateRange]): List of date ranges
+            initial_amount (float): The initial amount to start the
+                backtest with. This will be the amount of trading currency
+                that the backtest portfolio will start with.
+            snapshot_interval (SnapshotInterval): The snapshot interval to use
+                for the backtest. This is used to determine how often the
+                portfolio snapshot should be taken during the backtest.
+            risk_free_rate (Optional[float]): The risk-free rate to use for
+                the backtest. This is used to calculate the Sharpe ratio
+                and other performance metrics. If not provided, the default
+                risk-free rate will be tried to be fetched from the
+                US Treasury website.
 
         Returns:
-            MarketCredential: Instance of MarketCredential
+            List[Backtest]: List of Backtest instances containing the results
         """
+        backtests = []
 
-        market_credential_service = self.container \
-            .market_credential_service()
-        market_credential = market_credential_service.get(market)
-        if market_credential is None:
+        if algorithms is not None:
+            final_algorithms = algorithms
+        elif strategy is not None:
+            algorithm_factory = self.container.algorithm_factory()
+            algorithm = algorithm_factory.create_algorithm(
+                strategy=strategy
+            )
+            final_algorithms = [algorithm]
+        elif algorithm is not None:
+            final_algorithms = [algorithm]
+        else:
             raise OperationalException(
-                f"Market credential for {market} not found"
+                "No algorithms or strategy provided for backtesting"
             )
-        return market_credential
 
-    def get_market_credentials(self) -> List[MarketCredential]:
-        """
-        Function to get all market credentials from the app. This method
-        should be called when you want to get all market credentials.
+        if risk_free_rate is None:
+            logger.info("No risk free rate provided, retrieving it...")
+            risk_free_rate = get_risk_free_rate_us()
 
-        Returns:
-            List of MarketCredential instances
-        """
-        market_credential_service = self.container \
-            .market_credential_service()
-        return market_credential_service.get_all()
+            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"
+                )
+
+        for date_range in backtest_date_ranges:
+            for algorithm in final_algorithms:
+                backtest = self.run_backtest(
+                    backtest_date_range=date_range,
+                    initial_amount=initial_amount,
+                    algorithm=algorithm,
+                    snapshot_interval=snapshot_interval,
+                    risk_free_rate=risk_free_rate
+                )
+                backtests.append(backtest)
+
+        return backtests
 
     def run_backtest(
         self,
         backtest_date_range: BacktestDateRange,
         name: str = None,
         initial_amount=None,
-        output_directory=None,
         algorithm=None,
         strategy=None,
         strategies: List = None,
-        save_strategy=True,
-        snapshot_interval: SnapshotInterval = SnapshotInterval.TRADE_CLOSE,
-        strategy_directory_path: Optional[str] = None,
-        report_name: Optional[str] = None
-    ) -> BacktestReport:
+        snapshot_interval: SnapshotInterval = SnapshotInterval.DAILY,
+        risk_free_rate: Optional[float] = None,
+        metadata: Optional[Dict[str, str]] = None,
+    ) -> Backtest:
         """
         Run a backtest for an algorithm.
 
@@ -732,59 +1294,51 @@ class App:
                 portfolio will start with.
             strategy (TradingStrategy) (Optional): The strategy object
                 that needs to be backtested.
-            strategies (List[TradingStrategy) (Optional): List of strategy
+            strategies (List[TradingStrategy]) (Optional): List of strategy
                 objects that need to be backtested
-            algorithm:
-            output_directory: str - The directory to
-              write the backtest report to
-            save_strategy: bool - Whether to save the strategy
-                as part of the backtest report. You can only save in-memory
-                strategies when running multiple backtests. This is because
+            algorithm (Algorithm) (Optional): The algorithm object that needs
+                to be backtested. If this is provided, then the strategies
+                and tasks of the algorithm will be used for the backtest.
             snapshot_interval (SnapshotInterval): The snapshot
                 interval to use for the backtest. This is used to determine
                 how often the portfolio snapshot should be taken during the
                 backtest. The default is TRADE_CLOSE, which means that the
                 portfolio snapshot will be taken at the end of each trade.
-            strategy_directory_path (Optional[str]): The directory path
-                where the strategy is located. This is used to save the
-                strategy if save_strategy is True. If not provided,
-                the framework tries to determine the path via the
-                algorithm or strategy object.
-            report_name (Optional[str]): The name of the report. If not
-                provided, the framework will generate a name based on the
-                algorithm name and the backtest date range and the current
-                date and time.
+            risk_free_rate (Optional[float]): The risk-free rate to use for
+                the backtest. This is used to calculate the Sharpe ratio
+                and other performance metrics. If not provided, the default
+                risk-free rate will be tried to be fetched from the
+                US Treasury website.
+            metadata (Optional[Dict[str, str]]): Metadata to attach to the
+                backtest report. This can be used to store additional
+                information about the backtest, such as the author, version,
+                parameters or any other relevant information.
 
         Returns:
-            Instance of BacktestReport
+            Backtest: Instance of Backtest
         """
-
-        # Add backtest configuration to the config
-        self.set_config_with_dict({
-            ENVIRONMENT: Environment.BACKTEST.value,
-            BACKTESTING_START_DATE: backtest_date_range.start_date,
-            BACKTESTING_END_DATE: backtest_date_range.end_date,
-            DATABASE_NAME: "backtest-database.sqlite3",
-            DATABASE_DIRECTORY_NAME: "backtest_databases",
-            BACKTESTING_INITIAL_AMOUNT: initial_amount,
-            SNAPSHOT_INTERVAL: snapshot_interval.value,
-        })
-
-        self.initialize_config()
-        configuration_service = self.container.configuration_service()
-        config = configuration_service.get_config()
-        path = os.path.join(
-            config[DATABASE_DIRECTORY_PATH], config[DATABASE_NAME]
+        self.initialize_backtest_config(
+            backtest_date_range=backtest_date_range,
+            snapshot_interval=snapshot_interval,
+            initial_amount=initial_amount
         )
+        self.initialize_storage(remove_database_if_exists=True)
+        self.initialize_backtest_services()
+        self.initialize_backtest_portfolios()
 
-        # Remove the previous backtest db if it exists
-        if os.path.exists(path):
-            os.remove(path)
+        if risk_free_rate is None:
+            logger.info("No risk free rate provided, retrieving it...")
+            risk_free_rate = get_risk_free_rate_us()
 
-        self.initialize()
+            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"
+                )
 
-        algorithm_factory = self.container.algorithm_factory()
-        algorithm = algorithm_factory.create_algorithm(
+        algorithm = self.container.algorithm_factory().create_algorithm(
             name=name if name else self._name,
             strategies=(
                 self._strategies if strategies is None else strategies
@@ -792,247 +1346,264 @@ class App:
             algorithm=algorithm,
             strategy=strategy,
             tasks=self._tasks,
-            data_sources=self._market_data_sources,
             on_strategy_run_hooks=self._on_strategy_run_hooks,
         )
-        self.initialize_data_sources(algorithm)
-        strategy_orchestrator_service = \
-            self.container.strategy_orchestrator_service()
-        strategy_orchestrator_service.initialize(algorithm)
+        self.initialize_data_sources_backtest(
+            algorithm.data_sources, backtest_date_range
+        )
         backtest_service = self.container.backtest_service()
 
-        # Setup snapshot service as observer
-        backtest_service.clear_observers()
-        portfolio_snapshot_service = \
-            self.container.portfolio_snapshot_service()
-        backtest_service.add_observer(portfolio_snapshot_service)
-        context = self.container.context()
-        order_service = self.container.order_service()
-        order_service.clear_observers()
-        order_service.add_observer(portfolio_snapshot_service)
-        portfolio_service = self.container.portfolio_service()
-        portfolio_service.clear_observers()
-        portfolio_service.add_observer(portfolio_snapshot_service)
+        # Create backtest schedule
+        schedule = backtest_service.generate_schedule(
+            algorithm.strategies,
+            algorithm.tasks,
+            backtest_date_range.start_date,
+            backtest_date_range.end_date
+        )
+
+        # Initialize event loop
+        event_loop_service = EventLoopService(
+            configuration_service=self.container.configuration_service(),
+            portfolio_snapshot_service=self.container
+            .portfolio_snapshot_service(),
+            context=self.context,
+            order_service=self.container.order_service(),
+            portfolio_service=self.container.portfolio_service(),
+            data_provider_service=self.container.data_provider_service(),
+            trade_service=self.container.trade_service(),
+        )
+        trade_order_evaluator = BacktestTradeOrderEvaluator(
+            trade_service=self.container.trade_service(),
+            order_service=self.container.order_service(),
+            trade_stop_loss_service=self.container.trade_stop_loss_service(),
+            trade_take_profit_service=self.container
+            .trade_take_profit_service(),
+            configuration_service=self.container.configuration_service()
+        )
+        event_loop_service.initialize(
+            algorithm=algorithm,
+            trade_order_evaluator=trade_order_evaluator
+        )
+        event_loop_service.start(schedule=schedule, show_progress=True)
+        self._run_history = event_loop_service.history
 
-        # Run the backtest with the backtest_service and collect and
-        # save the report
-        results = backtest_service.run_backtest(
+        # Convert the current run to a backtest
+        backtest = backtest_service.create_backtest(
             algorithm=algorithm,
-            context=context,
-            strategy_orchestrator_service=strategy_orchestrator_service,
-            initial_amount=initial_amount,
-            backtest_date_range=backtest_date_range
+            number_of_runs=event_loop_service.total_number_of_runs,
+            backtest_date_range=backtest_date_range,
+            risk_free_rate=risk_free_rate,
         )
-        report = BacktestReport(results=results)
 
-        if output_directory is None:
-            output_directory = os.path.join(
-                config[RESOURCE_DIRECTORY], "backtest_reports"
-            )
+        # Add the metadata to the backtest
+        if metadata is None:
 
-        if report_name is None:
-            report_name = BacktestService.create_report_directory_name(report)
+            if algorithm.metadata is not None:
+                backtest.metadata = algorithm.metadata
+            else:
+                backtest.metadata = {}
+        else:
+            backtest.metadata = metadata
 
-        output_directory = os.path.join(output_directory, report_name)
-        report.save(
-            path=output_directory,
-            algorithm=algorithm,
-            strategy_directory_path=strategy_directory_path,
-            save_strategy=save_strategy
-        )
-        # print(report.html_report)
-        # backtest_service.save_report(
-        #     report=report,
-        #     algorithm=algorithm,
-        #     output_directory=output_directory,
-        #     save_strategy=save_strategy,
-        # )
-        return report
+        self.cleanup_backtest_resources()
+        return backtest
 
-    def run_backtests(
+    def run_permutation_test(
         self,
-        algorithms=None,
-        strategies=None,
-        initial_amount=None,
-        backtest_date_ranges: List[BacktestDateRange] = None,
-        output_directory=None,
-        checkpoint=False,
-        save_strategy=False,
-    ) -> List[BacktestReport]:
-        """
-        Run a backtest for a set algorithm. This method should be called when
-        running a backtest.
+        strategy: TradingStrategy,
+        backtest_date_range: BacktestDateRange,
+        number_of_permutations: int = 100,
+        initial_amount: float = 1000.0,
+        market: str = None,
+        trading_symbol: str = None,
+        risk_free_rate: Optional[float] = None
+    ) -> BacktestPermutationTest:
+        """
+        Run a permutation test for a given strategy over a specified
+        date range. This test is used to determine the statistical
+        significance of the strategy's performance by comparing it
+        against a set of random permutations of the market data.
+
+        The permutation test will run the main backtest and then
+        generate a number of random permutations of the market data
+        to create a distribution of returns. The p value will be
+        calculated based on the performance of the main backtest
+        compared to the distribution of returns from the permutations.
 
         Args:
-            algorithms (List[Algorithm]) (Optional): The algorithms to run
-                backtests for. This param is optional. Either algorithms or
-                strategies should be provided. If both are provided, then the
-                algorithms will be used.
-            strategies (List[TradingStrategy]) (Optional): The strategies to
-                run backtests for. This param is optional. Either algorithms
-                or strategies should be provided. If both are provided, then
-                the algorithms will be used.
-            backtest_date_ranges: List[BacktestDateRange] - The date ranges
-                to run the backtests for
-            initial_amount: The initial amount to start the backtest with.
-            output_directory: str - The directory to write the backtest
-              report to.
-            checkpoint: bool - Whether to checkpoint the backtest,
-              If True, then it will be checked if for a given algorithm name
-                and date range, a backtest report already exists. If it does,
-                then the backtest will not be run again. This is useful
-                when running backtests for a large number of algorithms
-                and date ranges where some of the backtests may fail
-                and you want to re-run only the failed backtests.
-            save_strategy: bool - Whether to save the strategy as part
-                of the backtest report. You can only save in-memory strategies
-                when running multiple backtests. This is because we can't
-                differentiate between which folders belong to a specific
-                strategy.
-
-        Returns
-            List of BacktestReport instances
-        """
-        logger.info("Initializing backtests")
-        reports = []
-
-        if algorithms is None and strategies is None:
-            raise OperationalException(
-                "No algorithms or strategies provided for backtest"
-            )
+            strategy (TradingStrategy): The strategy to test.
+            backtest_date_range (BacktestDateRange): The date range for the
+                backtest.
+            number_of_permutations (int): The number of permutations to run.
+                Default is 100.
+            initial_amount (float): The initial amount for the backtest.
+                Default is 1000.0.
+            risk_free_rate (Optional[float]): The risk-free rate to use for
+                the backtest metrics. If not provided, it will try to fetch
+                the risk-free rate from the US Treasury website.
+            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. If not provided,
+                the first portfolio configuration found will be used.
+            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. If not
+                provided, the first trading symbol found in the portfolio
+                configuration will be used.
+
+        Raises:
+            OperationalException: If the risk-free rate cannot be retrieved.
 
-        # Create or validate all algorithms with the algorithm factory
-        algorithm_factory = self.container.algorithm_factory()
+        Returns:
+            Backtest: The backtest report containing the results of the
+                main backtest and the p value from the permutation test.
+        """
 
-        if algorithms is not None:
-            to_be_validated_algorithms = algorithms
-            algorithms = []
+        if risk_free_rate is None:
+            logger.info("No risk free rate provided, retrieving it...")
+            risk_free_rate = get_risk_free_rate_us()
 
-            for algorithm in to_be_validated_algorithms:
-                algorithm = algorithm_factory.create_algorithm(
-                    algorithm=algorithm
+            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"
                 )
-                algorithms.append(algorithm)
-        else:
-            algorithms = []
 
-        if strategies is not None:
-            for strategy in strategies:
-                algorithms.append(
-                    algorithm_factory.create_algorithm(strategy=strategy)
-                )
+        data_provider_service = self.container.data_provider_service()
+        backtest = self.run_vector_backtest(
+            backtest_date_range=backtest_date_range,
+            initial_amount=initial_amount,
+            strategy=strategy,
+            snapshot_interval=SnapshotInterval.DAILY,
+            risk_free_rate=risk_free_rate,
+            market=market,
+            trading_symbol=trading_symbol
+        )
+        backtest_metrics = backtest.get_backtest_metrics(backtest_date_range)
 
-        for date_range in backtest_date_ranges:
-            print(
-                f"{COLOR_YELLOW}Running backtests for date "
-                f"range:{COLOR_RESET} {COLOR_GREEN}{date_range.name} "
-                f"{date_range.start_date} - "
-                f"{date_range.end_date} for a "
-                f"total of {len(algorithms)} algorithms.{COLOR_RESET}"
+        if backtest_metrics.number_of_trades == 0:
+            raise OperationalException(
+                "The strategy did not make any trades during the backtest. "
+                "Cannot perform permutation test."
             )
 
-            for algorithm in algorithms:
+        # Select the ohlcv data from the strategy's data sources
+        data_sources = strategy.data_sources
+        original_data_combinations = []
+        permuted_metrics = []
+        permuted_datasets_ordered_by_symbol = {}
+        original_datasets_ordered_by_symbol = {}
 
-                if checkpoint:
-                    backtest_service = self.container.backtest_service()
-                    report = backtest_service.get_report(
-                        algorithm_name=algorithm.name,
-                        backtest_date_range=date_range,
-                        directory=output_directory
+        for data_source in data_sources:
+            if DataType.OHLCV.equals(data_source.data_type):
+                data_provider = data_provider_service.get(data_source)
+                data = data_provider_service.get_data(
+                    data_source=data_source,
+                    start_date=data_provider._start_date_data_source,
+                    end_date=backtest_date_range.end_date
+                )
+                original_data_combinations.append((data_source, data))
+                original_datasets_ordered_by_symbol[data_source.symbol] = \
+                    data_provider_service.get_data(
+                        data_source=data_source,
+                        start_date=data_provider._start_date_data_source,
+                        end_date=backtest_date_range.end_date
                     )
 
-                    if report is not None:
-                        print(
-                            f"{COLOR_YELLOW}Backtest already exists "
-                            f"for algorithm {algorithm.name} date "
-                            f"range:{COLOR_RESET} {COLOR_GREEN} "
-                            f"{date_range.name} "
-                            f"{date_range.start_date} - "
-                            f"{date_range.end_date}"
-                        )
-                        reports.append(report)
-                        continue
-
-                report = self.run_backtest(
-                    backtest_date_range=date_range,
-                    initial_amount=initial_amount,
-                    output_directory=output_directory,
-                    algorithm=algorithm,
-                    save_strategy=save_strategy
+        for _ in tqdm(
+            range(number_of_permutations),
+            desc="Running Permutation Test",
+            colour="green"
+        ):
+            permutated_datasets = []
+            data_provider_service.reset()
+
+            for combi in original_data_combinations:
+                # Permute the data for the data source
+                permutated_data = create_ohlcv_permutation(data=combi[1])
+                permutated_datasets.append((combi[0], permutated_data))
+
+                if combi[0].symbol not in permuted_datasets_ordered_by_symbol:
+                    permuted_datasets_ordered_by_symbol[combi[0].symbol] = \
+                        [permutated_data]
+                else:
+                    permuted_datasets_ordered_by_symbol[combi[0].symbol]\
+                        .append(permutated_data)
+
+            self._data_providers = []
+
+            for combi in permutated_datasets:
+                data_source = combi[0]
+                data_provider = PandasOHLCVDataProvider(
+                    dataframe=combi[1],
+                    symbol=data_source.symbol,
+                    market=data_source.market,
+                    window_size=data_source.window_size,
+                    time_frame=data_source.time_frame,
+                    data_provider_identifier=data_source
+                    .data_provider_identifier,
+                    pandas=data_source.pandas,
                 )
-                reports.append(report)
-
-        return reports
-
-    def add_data_source(self, data_source) -> None:
-        """
-        Function to add a data source to the app. The data source should
-        be an instance of DataSource.
-
-        Args:
-            data_source: Instance of DataSource
-
-        Returns:
-            None
-        """
-        if inspect.isclass(data_source):
-            if not issubclass(data_source, MarketDataSource):
-                raise OperationalException(
-                    "Data source should be an instance of MarketDataSource"
+                # Add pandas ohlcv data provider to the data provider service
+                data_provider_service.register_data_provider(
+                    data_source=data_source,
+                    data_provider=data_provider
                 )
 
-            data_source = data_source()
-
-        # Check if data source is already registered
-        # for market_data_source in self._market_data_sources:
-        #     if market_data_source.get_identifier() == \
-        #             data_source.get_identifier():
-        #         return
-
-        self._market_data_sources.append(data_source)
-
-    def add_data_sources(self, data_sources) -> None:
-        """
-        Function to add a list of data sources to the app. The data sources
-        should be instances of DataSource.
+            # Run the backtest with the permuted strategy
+            permuted_backtest = self.run_vector_backtest(
+                backtest_date_range=backtest_date_range,
+                initial_amount=initial_amount,
+                strategy=strategy,
+                snapshot_interval=SnapshotInterval.DAILY,
+                risk_free_rate=risk_free_rate,
+                skip_data_sources_initialization=True,
+                market=market,
+                trading_symbol=trading_symbol
+            )
 
-        Args:
-            data_sources: List of DataSource
+            # Add the results of the permuted backtest to the main backtest
+            permuted_metrics.append(
+                permuted_backtest.get_backtest_metrics(backtest_date_range)
+            )
 
-        Returns:
-            None
-        """
-        for data_source in data_sources:
-            self.add_data_source(data_source)
+        # Create a BacktestPermutationTestMetrics object
+        permutation_test_metrics = BacktestPermutationTest(
+            real_metrics=backtest_metrics,
+            permutated_metrics=permuted_metrics,
+            ohlcv_permutated_datasets=permuted_datasets_ordered_by_symbol,
+            ohlcv_original_datasets=original_datasets_ordered_by_symbol,
+            backtest_start_date=backtest_date_range.start_date,
+            backtest_end_date=backtest_date_range.end_date,
+            backtest_date_range_name=backtest_date_range.name
+        )
+        return permutation_test_metrics
 
-    def add_market_data_source(self, market_data_source):
+    def add_data_provider(self, data_provider, priority=3) -> None:
         """
-        Function to add a market data source to the app. The market data
-        source should be an instance of MarketDataSource.
-
-        This is a seperate function from the market data source service. This
-        is because the market data source service can be re-initialized.
-        Therefore, we need a persistent list of market data sources in the app.
+        Function to add a data provider to the app. The data provider should
+        be an instance of DataProvider or a DataProviderClass.
 
         Args:
-            market_data_source: Instance of MarketDataSource
+            data_provider: Instance or class of DataProvider
+            priority: Optional priority for the data provider. If not
+                provided, the data provider will be added with the default
+                priority (3).
 
         Returns:
             None
         """
+        if inspect.isclass(data_provider):
+            if not issubclass(data_provider, DataProvider):
+                raise OperationalException(
+                    "Data provider should be an instance of DataProvider"
+                )
 
-        # Check if the market data source is an instance of MarketDataSource
-        if not isinstance(market_data_source, MarketDataSource):
-            return
-
-        # Check if there is already a market data source with the same
-        # identifier
-        for existing_market_data_source in self._market_data_sources:
-            if existing_market_data_source.get_identifier() == \
-                    market_data_source.get_identifier():
-                return
+            data_provider = data_provider()
 
-        self._market_data_sources.append(market_data_source)
+        self._data_providers.append((data_provider, priority))
 
     def add_market_credential(
         self, market_credential: MarketCredential
@@ -1108,7 +1679,7 @@ class App:
         function=None,
         time_unit=TimeUnit.MINUTE,
         interval=10,
-        market_data_sources=None
+        data_sources=None
     ):
         """
         Decorator for registering a strategy. This decorator can be used
@@ -1120,7 +1691,7 @@ class App:
                 a TradingStrategy
             time_unit (TimeUnit): instance of TimeUnit Enum
             interval (int): interval of the schedule ( interval - TimeUnit )
-            market_data_sources (List): List of data sources that the
+            data_sources (List): List of data sources that the
                 trading strategy function uses.
 
         Returns:
@@ -1133,7 +1704,7 @@ class App:
                 decorated=function,
                 time_unit=time_unit,
                 interval=interval,
-                market_data_sources=market_data_sources
+                data_sources=data_sources
             )
             self.add_strategy(strategy_object)
             return strategy_object
@@ -1145,7 +1716,7 @@ class App:
                         decorated=f,
                         time_unit=time_unit,
                         interval=interval,
-                        market_data_sources=market_data_sources,
+                        data_sources=data_sources,
                         worker_id=f.__name__
                     )
                 )
@@ -1221,10 +1792,6 @@ class App:
                 "with the same id in the algorithm"
             )
 
-        if strategy.market_data_sources is not None:
-            logger.info("Adding market data sources from strategy")
-            self.add_data_sources(strategy.market_data_sources)
-
         self._strategies.append(strategy)
 
     def add_state_handler(self, state_handler):
@@ -1360,7 +1927,37 @@ class App:
         portfolio_provider_lookup = self.container.portfolio_provider_lookup()
         return portfolio_provider_lookup.get_all()
 
-    def _initialize_portfolios(self):
+    def initialize_order_executors(self):
+        """
+        Function to initialize the order executors. This function will
+        first check if the app is running in backtest mode or not. If it is
+        running in backtest mode, all order executors will be removed and
+        a single BacktestOrderExecutor will be added to the order executors.
+
+        If it is not running in backtest mode, it will add the default
+        CCXTOrderExecutor with a priority 3.
+        """
+        logger.info("Adding order executors")
+        order_executor_lookup = self.container.order_executor_lookup()
+        environment = self.config[ENVIRONMENT]
+
+        if Environment.BACKTEST.equals(environment):
+            # If the app is running in backtest mode,
+            # remove all order executors
+            # and add a single BacktestOrderExecutor
+            order_executor_lookup.reset()
+            order_executor_lookup.add_order_executor(
+                BacktestOrderExecutor(priority=1)
+            )
+        else:
+            order_executor_lookup.add_order_executor(
+                CCXTOrderExecutor(priority=3)
+            )
+
+        for order_executor in order_executor_lookup.get_all():
+            order_executor.config = self.config
+
+    def initialize_portfolios(self):
         """
         Function to initialize the portfolios. This function will
         first check if the app is running in backtest mode or not. If it is
@@ -1370,8 +1967,6 @@ class App:
 
         """
         logger.info("Initializing portfolios")
-        config = self.config
-
         portfolio_configuration_service = self.container \
             .portfolio_configuration_service()
         portfolio_service = self.container.portfolio_service()
@@ -1380,178 +1975,187 @@ class App:
         if portfolio_configuration_service.count() == 0:
             raise OperationalException("No portfolios configured")
 
-        if Environment.BACKTEST.equals(config[ENVIRONMENT]):
-            logger.info("Setting up backtest portfolios")
-            initial_backtest_amount = config.get(
-                BACKTESTING_INITIAL_AMOUNT, None
-            )
+        # Check if there are already existing portfolios
+        portfolios = portfolio_service.get_all()
+        portfolio_configurations = portfolio_configuration_service\
+            .get_all()
+        portfolio_provider_lookup = \
+            self.container.portfolio_provider_lookup()
 
-            for portfolio_configuration \
-                    in portfolio_configuration_service.get_all():
+        if len(portfolios) > 0:
 
-                if not portfolio_service.exists(
-                    {"identifier": portfolio_configuration.identifier}
-                ):
-                    portfolio = (
-                        portfolio_service.create_portfolio_from_configuration(
-                            portfolio_configuration,
-                            initial_amount=initial_backtest_amount,
-                        )
+            # Check if there are matching portfolio configurations
+            for portfolio in portfolios:
+                logger.info(
+                    f"Checking if there is an matching portfolio "
+                    "configuration "
+                    f"for portfolio {portfolio.identifier}"
+                )
+                portfolio_configuration = \
+                    portfolio_configuration_service.get(
+                        portfolio.market
                     )
-        else:
-            # Check if there are already existing portfolios
-            portfolios = portfolio_service.get_all()
-            portfolio_configurations = portfolio_configuration_service\
-                .get_all()
-
-            if len(portfolios) > 0:
-
-                # Check if there are matching portfolio configurations
-                for portfolio in portfolios:
-                    logger.info(
-                        f"Checking if there is an matching portfolio "
-                        "configuration "
-                        f"for portfolio {portfolio.identifier}"
+
+                if portfolio_configuration is None:
+                    raise ImproperlyConfigured(
+                        f"No matching portfolio configuration found for "
+                        f"existing portfolio {portfolio.market}, "
+                        f"please make sure that you have configured your "
+                        f"app with the right portfolio configurations "
+                        f"for the existing portfolios."
+                        f"If you want to create a new portfolio, please "
+                        f"remove the existing database (WARNING!!: this "
+                        f"will remove all existing history of your "
+                        f"trading bot.)"
                     )
-                    portfolio_configuration = \
-                        portfolio_configuration_service.get(
-                            portfolio.market
-                        )
 
-                    if portfolio_configuration is None:
-                        raise ImproperlyConfigured(
-                            f"No matching portfolio configuration found for "
-                            f"existing portfolio {portfolio.market}, "
-                            f"please make sure that you have configured your "
-                            f"app with the right portfolio configurations "
-                            f"for the existing portfolios."
-                            f"If you want to create a new portfolio, please "
-                            f"remove the existing database (WARNING!!: this "
-                            f"will remove all existing history of your "
-                            f"trading bot.)"
-                        )
+                # Check if the portfolio configuration is still inline
+                # with the initial balance
 
-                    # Check if the portfolio configuration is still inline
-                    # with the initial balance
+                if portfolio_configuration.initial_balance != \
+                        portfolio.initial_balance:
+                    logger.warning(
+                        "The initial balance of the portfolio "
+                        "configuration is different from the existing "
+                        "portfolio. Checking if the existing portfolio "
+                        "can be updated..."
+                    )
 
-                    if portfolio_configuration.initial_balance != \
-                            portfolio.initial_balance:
-                        logger.warning(
-                            "The initial balance of the portfolio "
-                            "configuration is different from the existing "
-                            "portfolio. Checking if the existing portfolio "
-                            "can be updated..."
+                    # Register a portfolio provider for the portfolio
+                    portfolio_provider_lookup \
+                        .register_portfolio_provider_for_market(
+                            portfolio_configuration.market
                         )
+                    initial_balance = portfolio_configuration\
+                        .initial_balance
 
-                        portfolio_provider_lookup = \
-                            self.container.portfolio_provider_lookup()
-                        # Register a portfolio provider for the portfolio
-                        portfolio_provider_lookup \
-                            .register_portfolio_provider_for_market(
-                                portfolio_configuration.market
-                            )
-                        initial_balance = portfolio_configuration\
-                            .initial_balance
-
-                        if initial_balance != portfolio.initial_balance:
-                            raise ImproperlyConfigured(
-                                "The initial balance of the portfolio "
-                                "configuration is different then that of "
-                                "the existing portfolio. Please make sure "
-                                "that the initial balance of the portfolio "
-                                "configuration is the same as that of the "
-                                "existing portfolio. "
-                                f"Existing portfolio initial balance: "
-                                f"{portfolio.initial_balance}, "
-                                f"Portfolio configuration initial balance: "
-                                f"{portfolio_configuration.initial_balance}"
-                                "If this is intentional, please remove "
-                                "the database and re-run the app. "
-                                "WARNING!!: this will remove all existing "
-                                "history of your trading bot."
-                            )
-
-            portfolio_provider_lookup = \
-                self.container.portfolio_provider_lookup()
-            order_executor_lookup = self.container.order_executor_lookup()
-            market_credential_service = \
-                self.container.market_credential_service()
-            # Register portfolio providers and order executors
-            for portfolio_configuration in portfolio_configurations:
-
-                # Register a portfolio provider for the portfolio
-                portfolio_provider_lookup\
-                    .register_portfolio_provider_for_market(
-                        portfolio_configuration.market
-                    )
+                    if initial_balance != portfolio.initial_balance:
+                        raise ImproperlyConfigured(
+                            "The initial balance of the portfolio "
+                            "configuration is different then that of "
+                            "the existing portfolio. Please make sure "
+                            "that the initial balance of the portfolio "
+                            "configuration is the same as that of the "
+                            "existing portfolio. "
+                            f"Existing portfolio initial balance: "
+                            f"{portfolio.initial_balance}, "
+                            f"Portfolio configuration initial balance: "
+                            f"{portfolio_configuration.initial_balance}"
+                            "If this is intentional, please remove "
+                            "the database and re-run the app. "
+                            "WARNING!!: this will remove all existing "
+                            "history of your trading bot."
+                        )
 
-                # Register an order executor for the portfolio
-                order_executor_lookup.register_order_executor_for_market(
+        order_executor_lookup = self.container.order_executor_lookup()
+        market_credential_service = \
+            self.container.market_credential_service()
+        # Register portfolio providers and order executors
+        for portfolio_configuration in portfolio_configurations:
+
+            # Register a portfolio provider for the portfolio
+            portfolio_provider_lookup\
+                .register_portfolio_provider_for_market(
                     portfolio_configuration.market
                 )
 
-                market_credential = \
-                    market_credential_service.get(
-                        portfolio_configuration.market
-                    )
+            # Register an order executor for the portfolio
+            order_executor_lookup.register_order_executor_for_market(
+                portfolio_configuration.market
+            )
 
-                if market_credential is None:
-                    raise ImproperlyConfigured(
-                        f"No market credential found for existing "
-                        f"portfolio {portfolio_configuration.market} "
-                        "with market "
-                        "Cannot initialize portfolio configuration."
-                    )
+            market_credential = \
+                market_credential_service.get(
+                    portfolio_configuration.market
+                )
 
-                if not portfolio_service.exists(
-                    {"identifier": portfolio_configuration.identifier}
-                ):
-                    portfolio_service.create_portfolio_from_configuration(
-                        portfolio_configuration
-                    )
+            if market_credential is None:
+                raise ImproperlyConfigured(
+                    f"No market credential found for existing "
+                    f"portfolio {portfolio_configuration.market} "
+                    "with market "
+                    "Cannot initialize portfolio configuration."
+                )
 
-            logger.info("Portfolio configurations complete")
-            logger.info("Syncing portfolios")
+            if not portfolio_service.exists(
+                {"identifier": portfolio_configuration.identifier}
+            ):
+                portfolio_service.create_portfolio_from_configuration(
+                    portfolio_configuration
+                )
 
-            portfolio_service = self.container.portfolio_service()
-            portfolio_sync_service = self.container.portfolio_sync_service()
+        logger.info("Portfolio configurations complete")
+        logger.info("Syncing portfolios")
+        portfolio_service = self.container.portfolio_service()
+        portfolio_sync_service = self.container.portfolio_sync_service()
 
-            for portfolio in portfolio_service.get_all():
-                logger.info(f"Syncing portfolio {portfolio.identifier}")
-                portfolio_sync_service.sync_unallocated(portfolio)
-                portfolio_sync_service.sync_orders(portfolio)
+        for portfolio in portfolio_service.get_all():
+            logger.info(f"Syncing portfolio {portfolio.identifier}")
+            portfolio_sync_service.sync_unallocated(portfolio)
+            portfolio_sync_service.sync_orders(portfolio)
 
-    def _initialize_default_portfolio_providers(self):
+    def initialize_backtest_portfolios(self):
         """
-        Function to initialize the default portfolio providers.
-        This function will create a default portfolio provider for
-        each market that is configured in the app. The default portfolio
-        provider will be used to create portfolios for the app.
+        Function to initialize the backtest portfolios. This function will
+        create a default portfolio provider for each market that is configured
+        in the app. The default portfolio provider will be used to create
+        portfolios for the app.
 
         Returns:
             None
         """
-        logger.info("Adding default portfolio providers")
-        portfolio_provider_lookup = self.container.portfolio_provider_lookup()
-        portfolio_provider_lookup.add_portfolio_provider(
-            CCXTPortfolioProvider(priority=2)
+        logger.info("Initializing backtest portfolios")
+        config = self.config
+        portfolio_configuration_service = self.container \
+            .portfolio_configuration_service()
+        portfolio_service = self.container.portfolio_service()
+
+        # Throw an error if no portfolios are configured
+        if portfolio_configuration_service.count() == 0:
+            raise OperationalException("No portfolios configured")
+
+        logger.info("Setting up backtest portfolios")
+        initial_backtest_amount = config.get(
+            BACKTESTING_INITIAL_AMOUNT, None
         )
 
-    def _initialize_default_order_executors(self):
+        for portfolio_configuration \
+                in portfolio_configuration_service.get_all():
+            if not portfolio_service.exists(
+                {"identifier": portfolio_configuration.identifier}
+            ):
+                portfolio_service.create_portfolio_from_configuration(
+                    portfolio_configuration,
+                    initial_amount=initial_backtest_amount,
+                )
+
+    def initialize_portfolio_providers(self):
         """
-        Function to initialize the default order executors.
-        This function will create a default order executor for
-        each market that is configured in the app. The default order
-        executor will be used to create orders for the app.
+        Function to initialize the default portfolio providers.
+        This function will create a default portfolio provider for
+        each market that is configured in the app. The default portfolio
+        provider will be used to create portfolios for the app.
 
         Returns:
             None
         """
-        logger.info("Adding default order executors")
-        order_executor_lookup = self.container.order_executor_lookup()
-        order_executor_lookup.add_order_executor(
-            CCXTOrderExecutor(priority=2)
-        )
+        logger.info("Adding portfolio providers")
+        portfolio_provider_lookup = self.container\
+            .portfolio_provider_lookup()
+        environment = self.config[ENVIRONMENT]
+
+        if Environment.BACKTEST.equals(environment):
+            # If the app is running in backtest mode,
+            # remove all order executors
+            # and add a single BacktestOrderExecutor
+            portfolio_provider_lookup.reset()
+        else:
+            portfolio_provider_lookup.add_portfolio_provider(
+                CCXTPortfolioProvider(priority=3)
+            )
+
+        for portfolio_provider in portfolio_provider_lookup.get_all():
+            portfolio_provider.config = self.config
 
     def get_run_history(self):
         """
@@ -1594,6 +2198,17 @@ class App:
             name=self._name,
             strategies=self._strategies,
             tasks=self._tasks,
-            data_sources=self._market_data_sources,
             on_strategy_run_hooks=self._on_strategy_run_hooks,
         )
+
+    def cleanup_backtest_resources(self):
+        """
+        Clean up the backtest database and remove SQLAlchemy models/tables.
+        """
+        logger.info("Cleaning up backtest resources")
+        config = self.config
+        environment = config[ENVIRONMENT]
+
+        if Environment.BACKTEST.equals(environment):
+            db_uri = config.get(SQLALCHEMY_DATABASE_URI)
+            clear_db(db_uri)