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

investing_algorithm_framework/services/backtesting/backtest_service.py

@@ -1,278 +1,497 @@
-import json
 import logging
 import os
-import re
+import sys
+from collections import defaultdict
 from datetime import datetime, timedelta, timezone
+from typing import Dict, List, Union
+from uuid import uuid4
 
+import numpy as np
 import pandas as pd
-from dateutil import parser
-from tqdm import tqdm
-
-from investing_algorithm_framework.domain import BacktestResult, \
-    BACKTESTING_INDEX_DATETIME, TimeUnit, TradingDataType, \
-    OperationalException, MarketDataSource, Observable, Event, \
-    SYMBOLS, BacktestDateRange, DATETIME_FORMAT_BACKTESTING
-from investing_algorithm_framework.services.market_data_source_service import \
-    MarketDataSourceService
+import polars as pl
+
+from investing_algorithm_framework.domain import BacktestRun, OrderType, \
+    TimeUnit, Trade, OperationalException, BacktestDateRange, TimeFrame, \
+    Backtest, TradeStatus, PortfolioSnapshot, Order, OrderStatus, OrderSide, \
+    Portfolio, DataType, generate_backtest_summary_metrics, \
+    PortfolioConfiguration
+from investing_algorithm_framework.services.data_providers import \
+    DataProviderService
+from investing_algorithm_framework.services.portfolios import \
+    PortfolioConfigurationService
+from investing_algorithm_framework.services.metrics import \
+    create_backtest_metrics
 
 logger = logging.getLogger(__name__)
-BACKTEST_REPORT_FILE_NAME_PATTERN = (
-    r"^report_\w+_backtest-start-date_\d{4}-\d{2}-\d{2}:\d{2}:\d{2}_"
-    r"backtest-end-date_\d{4}-\d{2}-\d{2}:\d{2}:\d{2}_"
-    r"created-at_\d{4}-\d{2}-\d{2}:\d{2}:\d{2}\.json$"
-)
-BACKTEST_REPORT_DIRECTORY_PATTERN = (
-    r"^report_\w+_backtest-start-date_\d{4}-\d{2}-\d{2}:\d{2}:\d{2}_"
-    r"backtest-end-date_\d{4}-\d{2}-\d{2}:\d{2}:\d{2}_"
-    r"created-at_\d{4}-\d{2}-\d{2}:\d{2}:\d{2}$"
-)
-
-
-class BacktestService(Observable):
+
+
+class BacktestService:
     """
     Service that facilitates backtests for algorithm objects.
     """
 
     def __init__(
         self,
-        market_data_source_service: MarketDataSourceService,
+        data_provider_service: DataProviderService,
         order_service,
         portfolio_service,
         portfolio_snapshot_service,
         position_repository,
         trade_service,
-        performance_service,
         configuration_service,
         portfolio_configuration_service,
-        strategy_orchestrator_service
     ):
         super().__init__()
-        self._resource_directory = None
         self._order_service = order_service
         self._trade_service = trade_service
         self._portfolio_service = portfolio_service
-        self._data_index = {
-            TradingDataType.OHLCV: {},
-            TradingDataType.TICKER: {}
-        }
-        self._performance_service = performance_service
         self._portfolio_snapshot_service = portfolio_snapshot_service
         self._position_repository = position_repository
-        self._market_data_source_service: MarketDataSourceService \
-            = market_data_source_service
-        self._backtest_market_data_sources = []
         self._configuration_service = configuration_service
-        self._portfolio_configuration_service = portfolio_configuration_service
-        self._strategy_orchestrator_service = strategy_orchestrator_service
+        self._portfolio_configuration_service: PortfolioConfigurationService \
+            = portfolio_configuration_service
+        self._data_provider_service = data_provider_service
 
-    @property
-    def resource_directory(self):
-        return self._resource_directory
+    def validate_strategy_for_vector_backtest(self, strategy):
+        """
+        Validate if the strategy is suitable for backtesting.
 
-    @resource_directory.setter
-    def resource_directory(self, resource_directory):
-        self._resource_directory = resource_directory
+        Args:
+            strategy: The strategy to validate.
 
-    def run_backtest(
-        self,
-        algorithm,
-        context,
-        strategy_orchestrator_service,
-        backtest_date_range: BacktestDateRange,
-        initial_amount=None
-    ) -> BacktestResult:
+        Raises:
+            OperationalException: If the strategy does not have the required
+                buy/sell signal functions.
         """
-        Run a backtest for the given algorithm. This function will run
-        a backtest for the given algorithm and return a backtest report.
+        if not hasattr(strategy, 'generate_buy_signals'):
+            raise OperationalException(
+                "Strategy must define a vectorized buy signal function "
+                "(buy_signal_vectorized)."
+            )
+        if not hasattr(strategy, 'generate_sell_signals'):
+            raise OperationalException(
+                "Strategy must define a vectorized sell signal function "
+                "(sell_signal_vectorized)."
+            )
 
-        A schedule is generated for the given algorithm and the strategies
-        are run for each date in the schedule.
+    def _get_data_frame_index(self, data: Union[pl.DataFrame, pd.DataFrame]):
+        """
+        Function to return the index for a given df. If the provided
+        data is of type pandas Dataframe, first will be checked if
+        it has a index. If this is not the case the function will
+        check if there is a 'DateTime' column and add this
+        as the index.
+
+        For a polars DataFrame, the 'DateTime' column will be
+        used as the index if it exists.
 
-        Also, all backtest data is downloaded (if not already downloaded) and
-        the backtest is run for each date in the schedule.
+        If no index is found an exception will be raised.
 
         Args:
-            algorithm: The algorithm to run the backtest for
-            backtest_date_range: The backtest date range
-            initial_amount: The initial amount of the backtest portfolio
-            strategy_orchestrator_service: The strategy orchestrator service
-            context (Context): The context of the object of the application
+            data: The data frame to process.
+
+        Raises:
+            OperationalException: If no valid index is found.
 
         Returns:
-            BacktestResult - The backtest report
+            The index of the data frame.
         """
-        logging.info(
-            f"Running backtest for algorithm with name {algorithm.name}"
-        )
+        if isinstance(data, pl.DataFrame):
+            if "Datetime" in data.columns:
+                return data["Datetime"]
+            else:
+                raise OperationalException("No valid index found.")
+        elif isinstance(data, pd.DataFrame):
+            if data.index is not None:
+                return data.index
+            elif "Datetime" in data.columns:
+                return data["Datetime"]
+            else:
+                raise OperationalException("No valid index found.")
+        else:
+            raise ValueError("Unsupported data frame type.")
+
+    def create_vector_backtest(
+        self,
+        strategy,
+        backtest_date_range: BacktestDateRange,
+        risk_free_rate: float = 0.027,
+        initial_amount: float = None,
+        trading_symbol: str = None,
+        market: str = None,
+    ) -> BacktestRun:
+        """
+        Vectorized backtest for multiple assets using strategy
+        buy/sell signals.
 
-        # Create backtest portfolio
-        portfolio_configurations = \
-            self._portfolio_configuration_service.get_all()
+        Args:
+            strategy: The strategy to backtest.
+            backtest_date_range: The date range for the backtest.
+            risk_free_rate: The risk-free rate to use for the backtest
+                metrics. Default is 0.027 (2.7%).
+            initial_amount: The initial amount to use for the backtest.
+                If None, the initial amount will be taken from the first
+                portfolio configuration.
+            trading_symbol: The trading symbol to use for the backtest.
+                If None, the trading symbol will be taken from the first
+                portfolio configuration.
+            market: The market to use for the backtest. If None, the market
+                will be taken from the first portfolio configuration.
 
-        for portfolio_configuration in portfolio_configurations:
+        Returns:
+            BacktestRun: The backtest run containing the results and metrics.
+        """
+        portfolio_configurations = self._portfolio_configuration_service\
+            .get_all()
+
+        if (
+                portfolio_configurations is None
+                or len(portfolio_configurations) == 0
+        ) and (
+                initial_amount is None
+                or trading_symbol is None
+                or market is None
+        ):
+            raise OperationalException(
+                "No initial amount, trading symbol or market provided "
+                "for the backtest and no portfolio configurations found. "
+                "please register a portfolio configuration "
+                "or specify the initial amount, trading symbol and "
+                "market parameters before running a backtest."
+            )
 
-            if self._portfolio_service.exists(
-                {"identifier": portfolio_configuration.identifier}
-            ):
-                # Delete existing portfolio
-                portfolio = self._portfolio_service.find(
-                    {"identifier": portfolio_configuration.identifier}
+        if portfolio_configurations is None \
+                or len(portfolio_configurations) == 0:
+            portfolio_configurations = []
+            portfolio_configurations.append(
+                PortfolioConfiguration(
+                    identifier="vector_backtest",
+                    market=market,
+                    trading_symbol=trading_symbol,
+                    initial_balance=initial_amount
                 )
-                self._portfolio_service.delete(portfolio.id)
-
-            # Check if the portfolio configuration has an initial balance
-            self._portfolio_service.create_portfolio_from_configuration(
-                portfolio_configuration,
-                initial_amount=initial_amount,
-                created_at=backtest_date_range.start_date,
             )
 
-        strategy_profiles = []
-        portfolios = self._portfolio_service.get_all()
-        initial_unallocated = 0
-
-        for portfolio in portfolios:
-            initial_unallocated += portfolio.unallocated
-
-        for strategy in algorithm.strategies:
-            strategy_profiles.append(strategy.strategy_profile)
+        portfolio_configuration = portfolio_configurations[0]
 
-        # Check if required market data sources are registered
-        self._check_if_required_market_data_sources_are_registered()
+        trading_symbol = portfolio_configurations[0].trading_symbol
+        portfolio = Portfolio.from_portfolio_configuration(
+            portfolio_configuration
+        )
 
-        schedule = self.generate_schedule(
-            strategies=algorithm.strategies,
+        # Load vectorized backtest data
+        data = self._data_provider_service.get_vectorized_backtest_data(
+            data_sources=strategy.data_sources,
             start_date=backtest_date_range.start_date,
             end_date=backtest_date_range.end_date
         )
 
-        logger.info(f"Prepared backtests for {len(schedule)} strategies")
+        # Compute signals from strategy
+        buy_signals = strategy.generate_buy_signals(data)
+        sell_signals = strategy.generate_sell_signals(data)
 
-        for index, row in tqdm(
-            schedule.iterrows(),
-            total=len(schedule),
-            desc=f"Running backtest for algorithm with name {algorithm.name}",
-            colour="GREEN"
-        ):
-            strategy_profile = self.get_strategy_from_strategy_profiles(
-                strategy_profiles, row['id']
+        # Build master index (union of all indices in signal dict)
+        index = pd.Index([])
+
+        most_granular_ohlcv_data_source = \
+            BacktestService.get_most_granular_ohlcv_data_source(
+                strategy.data_sources
             )
-            index_date = parser.parse(str(index))
-            self._configuration_service.add_value(
-                BACKTESTING_INDEX_DATETIME, index_date
+        most_granular_ohlcv_data = self._data_provider_service.get_ohlcv_data(
+                symbol=most_granular_ohlcv_data_source.symbol,
+                start_date=backtest_date_range.start_date,
+                end_date=backtest_date_range.end_date,
+                pandas=True
             )
-            config = self._configuration_service.get_config()
-            strategy = algorithm.get_strategy(strategy_profile.strategy_id)
-            strategy_orchestrator_service.run_backtest_strategy(
-                context=context, strategy=strategy, config=config
+
+        # Make sure to filter out the buy and sell signals that are before
+        # the backtest start date
+        buy_signals = {k: v[v.index >= backtest_date_range.start_date]
+                       for k, v in buy_signals.items()}
+        sell_signals = {k: v[v.index >= backtest_date_range.start_date]
+                        for k, v in sell_signals.items()}
+
+        index = index.union(most_granular_ohlcv_data.index)
+        index = index.sort_values()
+
+        # Initialize trades and portfolio values
+        trades = []
+        orders = []
+        granular_ohlcv_data_order_by_symbol = {}
+        snapshots = [
+            PortfolioSnapshot(
+                trading_symbol=trading_symbol,
+                portfolio_id=portfolio.identifier,
+                created_at=backtest_date_range.start_date,
+                unallocated=initial_amount,
+                total_value=initial_amount,
+                total_net_gain=0.0
             )
-            self.notify_observers(Event.STRATEGY_RUN, {
-                "created_at": index_date,
-            })
-
-        report = self.create_backtest_report(
-            algorithm,
-            context,
-            len(schedule),
-            backtest_date_range,
-            initial_unallocated
-        )
+        ]
+
+        for symbol in buy_signals.keys():
+            full_symbol = f"{symbol}/{trading_symbol}"
+            # find PositionSize object
+            pos_size_obj = next(
+                (p for p in strategy.position_sizes if
+                 p.symbol == symbol), None
+            )
+            # Load most granular OHLCV data for the symbol
+            df = self._data_provider_service.get_ohlcv_data(
+                symbol=full_symbol,
+                start_date=backtest_date_range.start_date,
+                end_date=backtest_date_range.end_date,
+                pandas=True
+            )
+            granular_ohlcv_data_order_by_symbol[full_symbol] = df
+
+            # Align signals with most granular OHLCV data
+            close = df["Close"]
+            buy_signal = buy_signals[symbol].reindex(index, fill_value=False)
+            sell_signal = sell_signals[symbol].reindex(index, fill_value=False)
+
+            signal = pd.Series(0, index=index)
+            signal[buy_signal] = 1
+            signal[sell_signal] = -1
+            signal = signal.replace(0, np.nan).ffill().shift(1).fillna(0)
+            signal = signal.astype(float)
+
+            if pos_size_obj is None:
+                raise OperationalException(
+                    f"No position size object defined "
+                    f"for symbol {symbol}, please make sure to "
+                    f"register a PositionSize object in the strategy."
+                )
 
-        # Cleanup backtest portfolio
-        portfolio_configurations = \
-            self._portfolio_configuration_service.get_all()
+            capital_for_trade = pos_size_obj.get_size(
+                Portfolio(
+                    unallocated=initial_amount,
+                    initial_balance=initial_amount,
+                    trading_symbol=trading_symbol,
+                    net_size=0,
+                    market="BACKTEST",
+                    identifier="vector_backtest"
+                ) if pos_size_obj else (initial_amount / len(buy_signals)),
+                asset_price=close.iloc[0]
+            )
 
-        for portfolio_configuration in portfolio_configurations:
-            portfolio = self._portfolio_service.find(
-                {"identifier": portfolio_configuration.identifier}
+            # Trade generation
+            last_trade = None
+
+            # Align signals with most granular OHLCV data
+            close = df["Close"].reindex(index, method='ffill')
+            buy_signal = buy_signals[symbol].reindex(index, fill_value=False)
+            sell_signal = sell_signals[symbol].reindex(index, fill_value=False)
+
+            # Loop over all timestamps in the backtest
+            for i in range(len(index)):
+
+                # 1 = buy, -1 = sell, 0 = hold
+                current_signal = signal.iloc[i]
+                current_price = float(close.iloc[i])
+                current_date = index[i]
+
+                # Convert the pd.Timestamp to an utc datetime object
+                if isinstance(current_date, pd.Timestamp):
+                    current_date = current_date.to_pydatetime()
+
+                if current_date.tzinfo is None:
+                    current_date = current_date.replace(tzinfo=timezone.utc)
+
+                # If we are not in a position, and we get a buy signal
+                if current_signal == 1 and last_trade is None:
+                    amount = float(capital_for_trade / current_price)
+                    buy_order = Order(
+                        id=uuid4(),
+                        target_symbol=symbol,
+                        trading_symbol=trading_symbol,
+                        order_type=OrderType.LIMIT,
+                        price=current_price,
+                        amount=amount,
+                        status=OrderStatus.CLOSED,
+                        created_at=current_date,
+                        updated_at=current_date,
+                        order_side=OrderSide.BUY
+                    )
+                    orders.append(buy_order)
+                    trade = Trade(
+                        id=uuid4(),
+                        orders=[buy_order],
+                        target_symbol=symbol,
+                        trading_symbol=trading_symbol,
+                        available_amount=amount,
+                        remaining=0,
+                        filled_amount=amount,
+                        open_price=current_price,
+                        opened_at=current_date,
+                        closed_at=None,
+                        amount=amount,
+                        status=TradeStatus.OPEN.value,
+                        cost=capital_for_trade
+                    )
+                    last_trade = trade
+                    trades.append(trade)
+
+                # If we are in a position, and we get a sell signal
+                if current_signal == -1 and last_trade is not None:
+                    net_gain_val = (
+                        current_price - last_trade.open_price
+                    ) * last_trade.available_amount
+                    sell_order = Order(
+                        id=uuid4(),
+                        target_symbol=symbol,
+                        trading_symbol=trading_symbol,
+                        order_type=OrderType.LIMIT,
+                        price=current_price,
+                        amount=last_trade.available_amount,
+                        status=OrderStatus.CLOSED,
+                        created_at=current_date,
+                        updated_at=current_date,
+                        order_side=OrderSide.SELL
+                    )
+                    orders.append(sell_order)
+                    trade_orders = last_trade.orders
+                    trade_orders.append(sell_order)
+                    last_trade.update(
+                        {
+                            "orders": trade_orders,
+                            "closed_at": current_date,
+                            "status": TradeStatus.CLOSED,
+                            "updated_at": current_date,
+                            "net_gain": net_gain_val
+                        }
+                    )
+                    last_trade = None
+
+        unallocated = initial_amount
+        total_net_gain = 0.0
+        open_trades = []
+
+        # Create portfolio snapshots
+        for ts in index:
+            allocated = 0
+            interval_datetime = pd.Timestamp(ts).to_pydatetime()
+            interval_datetime = interval_datetime.replace(tzinfo=timezone.utc)
+
+            for trade in trades:
+
+                if trade.opened_at == interval_datetime:
+                    # Snapshot taken at the moment a trade is opened
+                    unallocated -= trade.cost
+                    open_trades.append(trade)
+
+                if trade.closed_at == interval_datetime:
+                    # Snapshot taken at the moment a trade is closed
+                    unallocated += trade.cost + trade.net_gain
+                    total_net_gain += trade.net_gain
+                    open_trades.remove(trade)
+
+            for open_trade in open_trades:
+                ohlcv = granular_ohlcv_data_order_by_symbol[
+                    f"{open_trade.target_symbol}/{trading_symbol}"
+                ]
+                try:
+                    price = ohlcv.loc[:ts, "Close"].iloc[-1]
+                    open_trade.last_reported_price = price
+                except IndexError:
+                    continue  # skip if no price yet
+
+                allocated += open_trade.filled_amount * price
+
+            # total_value = invested_value + unallocated
+            # total_net_gain = total_value - initial_amount
+            snapshots.append(
+                PortfolioSnapshot(
+                    portfolio_id=portfolio.identifier,
+                    created_at=interval_datetime,
+                    unallocated=unallocated,
+                    total_value=unallocated + allocated,
+                    total_net_gain=total_net_gain
+                )
             )
-            self._portfolio_service.delete(portfolio.id)
 
-        return report
+        unique_symbols = set()
+        for trade in trades:
+            unique_symbols.add(trade.target_symbol)
 
-    def run_backtest_for_profile(
-        self, context, algorithm, strategy, index_date
-    ):
-        self._configuration_service.add_value(
-            BACKTESTING_INDEX_DATETIME, index_date
+        number_of_trades_closed = len(
+            [t for t in trades if TradeStatus.CLOSED.equals(t.status)]
+        )
+        number_of_trades_open = len(
+            [t for t in trades if TradeStatus.OPEN.equals(t.status)]
+        )
+        # Create a backtest run object
+        run = BacktestRun(
+            trading_symbol=trading_symbol,
+            initial_unallocated=initial_amount,
+            number_of_runs=1,
+            portfolio_snapshots=snapshots,
+            trades=trades,
+            orders=orders,
+            positions=[],
+            created_at=datetime.now(timezone.utc),
+            backtest_start_date=backtest_date_range.start_date,
+            backtest_end_date=backtest_date_range.end_date,
+            backtest_date_range_name=backtest_date_range.name,
+            number_of_days=(
+                backtest_date_range.end_date - backtest_date_range.end_date
+            ).days,
+            number_of_trades=len(trades),
+            number_of_orders=len(orders),
+            number_of_trades_closed=number_of_trades_closed,
+            number_of_trades_open=number_of_trades_open,
+            number_of_positions=len(unique_symbols),
+            symbols=list(buy_signals.keys())
         )
-        algorithm.config[BACKTESTING_INDEX_DATETIME] = index_date
-        market_data = {}
-
-        if strategy.strategy_profile.market_data_sources is not None:
-
-            for data_id in strategy.strategy_profile.market_data_sources:
-
-                if isinstance(data_id, MarketDataSource):
-                    market_data[data_id.get_identifier()] = \
-                        self._market_data_source_service.get_data(
-                            data_id.get_identifier()
-                        )
-                else:
-                    market_data[data_id] = \
-                        self._market_data_source_service.get_data(data_id)
-
-        strategy.run_strategy(context=context, market_data=market_data)
 
-    def run_backtest_v2(self, strategy, context):
-        config = self._configuration_service.get_config()
-        self._strategy_orchestrator_service.run_backtest_strategy(
-            context=context, strategy=strategy, config=config
+        # Create backtest metrics
+        run.backtest_metrics = create_backtest_metrics(
+            run, risk_free_rate=risk_free_rate
         )
+        return run
 
     def generate_schedule(
-        self, strategies, start_date, end_date
-    ) -> pd.DataFrame:
+        self,
+        strategies,
+        tasks,
+        start_date,
+        end_date
+    ) -> Dict[datetime, Dict[str, List[str]]]:
         """
-        Generate a schedule for the given strategies. This function will
-        calculate when the strategies should run based on the given start
-        and end date. The schedule will be stored in a pandas DataFrame.
-
-        Args:
-            strategies: The strategies to generate the schedule for
-            start_date: The start date of the schedule
-            end_date: The end date of the schedule
-
-        Returns:
-            pd.DataFrame: The schedule DataFrame
+        Generates a dict-based schedule: datetime => {strategy_ids, task_ids}
         """
-        data = []
+        schedule = defaultdict(
+            lambda: {"strategy_ids": set(), "task_ids": set(tasks)}
+        )
 
         for strategy in strategies:
-            id = strategy.strategy_profile.strategy_id
-            time_unit = strategy.strategy_profile.time_unit
+            strategy_id = strategy.strategy_profile.strategy_id
             interval = strategy.strategy_profile.interval
-            current_time = start_date
-
-            while current_time <= end_date:
-                data.append({
-                    "id": id,
-                    'run_time': current_time,
-                })
-
-                if TimeUnit.SECOND.equals(time_unit):
-                    current_time += timedelta(seconds=interval)
-                elif TimeUnit.MINUTE.equals(time_unit):
-                    current_time += timedelta(minutes=interval)
-                elif TimeUnit.HOUR.equals(time_unit):
-                    current_time += timedelta(hours=interval)
-                elif TimeUnit.DAY.equals(time_unit):
-                    current_time += timedelta(days=interval)
-                else:
-                    raise ValueError(f"Unsupported time unit: {time_unit}")
-
-        schedule_df = pd.DataFrame(data)
-
-        if schedule_df.empty:
-            raise OperationalException(
-                "Could not generate schedule "
-                "for backtest, do you have a strategy "
-                "registered for your algorithm?"
-            )
+            time_unit = strategy.strategy_profile.time_unit
 
-        schedule_df.sort_values(by='run_time', inplace=True)
-        schedule_df.set_index('run_time', inplace=True)
-        return schedule_df
+            if time_unit == TimeUnit.SECOND:
+                step = timedelta(seconds=interval)
+            elif time_unit == TimeUnit.MINUTE:
+                step = timedelta(minutes=interval)
+            elif time_unit == TimeUnit.HOUR:
+                step = timedelta(hours=interval)
+            elif time_unit == TimeUnit.DAY:
+                step = timedelta(days=interval)
+            else:
+                raise ValueError(f"Unsupported time unit: {time_unit}")
+
+            t = start_date
+            while t <= end_date:
+                schedule[t]["strategy_ids"].add(strategy_id)
+                t += step
+
+        return {
+            ts: {
+                "strategy_ids": sorted(data["strategy_ids"]),
+                "task_ids": sorted(data["task_ids"])
+            }
+            for ts, data in schedule.items()
+        }
 
     def get_strategy_from_strategy_profiles(self, strategy_profiles, id):
 
@@ -283,309 +502,150 @@ class BacktestService(Observable):
 
         raise ValueError(f"Strategy profile with id {id} not found.")
 
-    def create_backtest_report(
-        self,
-        algorithm,
-        context,
-        number_of_runs,
-        backtest_date_range: BacktestDateRange,
-        initial_unallocated=0
-    ) -> BacktestResult:
+    def _get_initial_unallocated(self) -> float:
         """
-        Create a backtest report for the given algorithm. This function
-        will create a backtest report for the given algorithm and return
-        the backtest report instance.
-
-        It will calculate various performance metrics for the backtest.
-        Also, it will add all traces to the backtest report. The traces
-        are collected from each strategy that was run during the backtest.
-
-        Args:
-            algorithm: The algorithm to create the backtest report for
-            number_of_runs: The number of runs
-            backtest_date_range: The backtest date range of the backtest
-            initial_unallocated: The initial unallocated amount
+        Get the initial unallocated amount for the backtest.
 
         Returns:
-            BacktestResult: The backtest report instance of BacktestResult
+            float: The initial unallocated amount.
         """
+        portfolios = self._portfolio_service.get_all()
+        initial_unallocated = 0.0
 
-        for portfolio in self._portfolio_service.get_all():
-            ids = [strategy.strategy_id for strategy in algorithm.strategies]
-
-            # Check if strategy_id is None
-            if None in ids:
-                # Remove None from ids
-                ids = [x for x in ids if x is not None]
-
-            positions = self._position_repository.get_all({
-                "portfolio": portfolio.id
-            })
-            tickers = {}
-
-            for position in positions:
-
-                if position.symbol != portfolio.trading_symbol:
-                    ticker_symbol = \
-                        f"{position.symbol}/{portfolio.trading_symbol}"
-
-                    if not self._market_data_source_service\
-                            .has_ticker_market_data_source(
-                                symbol=ticker_symbol, market=portfolio.market
-                            ):
-                        raise OperationalException(
-                            f"Ticker market data source for "
-                            f"symbol {ticker_symbol} and market "
-                            f"{portfolio.market} not found, please make "
-                            f"sure you register a ticker market data "
-                            f"source for this symbol and market in "
-                            f"backtest mode. Otherwise, the backtest "
-                            f"report cannot be generated."
-                        )
-                    tickers[ticker_symbol] = \
-                        self._market_data_source_service.get_ticker(
-                            f"{position.symbol}/{portfolio.trading_symbol}",
-                            market=portfolio.market
-                        )
-
-            positions = self._position_repository.get_all({
-                "portfolio": portfolio.id
-            })
-
-            # Create the last snapshot of the portfolio
-            self._portfolio_snapshot_service.create_snapshot(
-                portfolio=portfolio,
-                created_at=backtest_date_range.end_date
-            )
-
-            backtest_report = BacktestResult(
-                name=algorithm.name,
-                backtest_date_range=backtest_date_range,
-                initial_unallocated=initial_unallocated,
-                trading_symbol=portfolio.trading_symbol,
-                created_at=datetime.now(tz=timezone.utc),
-                portfolio_snapshots=self._portfolio_snapshot_service.get_all(
-                    {"portfolio_id": portfolio.id}
-                ),
-                number_of_runs=number_of_runs,
-                trades=self._trade_service.get_all(
-                    {"portfolio": portfolio.id}
-                ),
-                orders=self._order_service.get_all(
-                    {"portfolio": portfolio.id}
-                ),
-                positions=self._position_repository.get_all(
-                    {"portfolio": portfolio.id}
-                ),
-            )
-
-            # Calculate metrics for the backtest report
-            return backtest_report
-
-    def set_backtest_market_data_sources(self, market_data_sources):
-        self._backtest_market_data_sources = market_data_sources
-
-    def get_backtest_market_data_sources(self):
-        return self._backtest_market_data_sources
-
-    def get_backtest_market_data_source(self, symbol, market):
-
-        for market_data_source in self._backtest_market_data_sources:
-            if market_data_source.symbol == symbol \
-                    and market_data_source.market == market:
-                return market_data_source
-        raise OperationalException(
-            f"Market data source for "
-            f"symbol {symbol} and market {market} not found"
-        )
-
-    def _check_if_required_market_data_sources_are_registered(self):
-        """
-        Check if the required market data sources are registered.
+        for portfolio in portfolios:
+            initial_unallocated += portfolio.initial_balance
 
-        It will iterate over all registered symbols and markets and check
-        if a ticker market data source is registered for the symbol and market.
-        """
-        symbols = self._configuration_service.config[SYMBOLS]
-
-        if symbols is not None:
-
-            for symbol in symbols:
-                if not self._market_data_source_service\
-                        .has_ticker_market_data_source(
-                            symbol=symbol
-                        ):
-                    raise OperationalException(
-                        f"Ticker market data source for symbol {symbol} not "
-                        f"found, please make sure you register a ticker "
-                        f"market data source for this symbol in backtest "
-                        f"mode. Otherwise, the backtest report "
-                        f"cannot be generated."
-                    )
+        return initial_unallocated
 
-    def get_report(
+    def create_backtest(
         self,
-        algorithm_name: str,
+        algorithm,
+        number_of_runs,
         backtest_date_range: BacktestDateRange,
-        directory: str
-    ) -> BacktestResult:
-        """
-        Function to get a report based on the algorithm name and
-        backtest date range if it exists.
-
-        Args:
-            algorithm_name: str - The name of the algorithm
-            backtest_date_range: BacktestDateRange - The backtest date range
-            directory: str - The output directory
-
-        Returns:
-            BacktestResult - The backtest report if it exists, otherwise None
+        risk_free_rate,
+        strategy_directory_path=None
+    ) -> Backtest:
         """
+        Create a backtest for the given algorithm.
 
-        # Loop through all files in the output directory
-        for root, _, files in os.walk(directory):
-            for file in files:
-                # Check if the file contains the algorithm name
-                # and backtest date range
-                if self._is_backtest_report(os.path.join(root, file)):
-                    # Read the file
-                    with open(os.path.join(root, file), "r") as json_file:
-
-                        name = \
-                            self._get_algorithm_name_from_backtest_report_file(
-                                os.path.join(root, file)
-                            )
-
-                        if name == algorithm_name:
-                            backtest_start_date = \
-                                self._get_start_date_from_backtest_report_file(
-                                    os.path.join(root, file)
-                                )
-                            backtest_end_date = \
-                                self._get_end_date_from_backtest_report_file(
-                                    os.path.join(root, file)
-                                )
-
-                            if backtest_start_date == \
-                                    backtest_date_range.start_date \
-                                    and backtest_end_date == \
-                                    backtest_date_range.end_date:
-                                # Parse the JSON file
-                                report = json.load(json_file)
-                                # Convert the JSON file to a
-                                # BacktestResult object
-                                return BacktestResult.from_dict(report)
-
-        return None
-
-    def _get_start_date_from_backtest_report_file(self, path: str) -> datetime:
-        """
-        Function to get the backtest start date from a backtest report file.
+        It will store all results and metrics in a Backtest object through
+        the BacktestResults and BacktestMetrics objects. Optionally,
+        it will also store the strategy related paths and backtest
+        data file paths.
 
         Args:
-            path: str - The path to the backtest report file
+            algorithm: The algorithm to create the backtest report for
+            number_of_runs: The number of runs
+            backtest_date_range: The backtest date range of the backtest
+            risk_free_rate: The risk-free rate to use for the backtest metrics
+            strategy_directory_path (optional, str): The path to the
+                strategy directory
 
         Returns:
-            datetime - The backtest start date
+            Backtest: The backtest containing the results and metrics.
         """
 
-        # Get the backtest start date from the file name
-        backtest_start_date = os.path.basename(path).split("_")[3]
-
-        try:
-            # Parse the backtest start date
-            return datetime.strptime(
-                backtest_start_date, DATETIME_FORMAT_BACKTESTING
-            )
-        except ValueError:
-            # Try to parse the backtest start date with a different format
-            return parser.parse(backtest_start_date)
+        # Get the first portfolio
+        portfolio = self._portfolio_service.get_all()[0]
 
-    def _get_end_date_from_backtest_report_file(self, path: str) -> datetime:
-        """
-        Function to get the backtest end date from a backtest report file.
+        # List all strategy related files in the strategy directory
+        strategy_related_paths = []
 
-        Args:
-            path: str - The path to the backtest report file
-
-        Returns:
-            datetime - The backtest end date
-        """
-
-        # Get the backtest end date from the file name
-        backtest_end_date = os.path.basename(path).split("_")[5]
+        if strategy_directory_path is not None:
+            if not os.path.exists(strategy_directory_path) or \
+                    not os.path.isdir(strategy_directory_path):
+                raise OperationalException(
+                    "Strategy directory does not exist"
+                )
 
-        try:
-            # Parse the backtest end date
-            return datetime.strptime(
-                backtest_end_date, DATETIME_FORMAT_BACKTESTING
+            strategy_files = os.listdir(strategy_directory_path)
+            for file in strategy_files:
+                source_file = os.path.join(strategy_directory_path, file)
+                if os.path.isfile(source_file):
+                    strategy_related_paths.append(source_file)
+        else:
+            if algorithm is not None and hasattr(algorithm, 'strategies'):
+                for strategy in algorithm.strategies:
+                    mod = sys.modules[strategy.__module__]
+                    strategy_directory_path = os.path.dirname(mod.__file__)
+                    strategy_files = os.listdir(strategy_directory_path)
+                    for file in strategy_files:
+                        source_file = os.path.join(
+                            strategy_directory_path, file
+                        )
+                        if os.path.isfile(source_file):
+                            strategy_related_paths.append(source_file)
+
+        run = BacktestRun(
+            backtest_start_date=backtest_date_range.start_date,
+            backtest_end_date=backtest_date_range.end_date,
+            backtest_date_range_name=backtest_date_range.name,
+            initial_unallocated=self._get_initial_unallocated(),
+            trading_symbol=portfolio.trading_symbol,
+            created_at=datetime.now(tz=timezone.utc),
+            portfolio_snapshots=self._portfolio_snapshot_service.get_all(
+                {"portfolio_id": portfolio.id}
+            ),
+            number_of_runs=number_of_runs,
+            trades=self._trade_service.get_all(
+                {"portfolio": portfolio.id}
+            ),
+            orders=self._order_service.get_all(
+                {"portfolio": portfolio.id}
+            ),
+            positions=self._position_repository.get_all(
+                {"portfolio": portfolio.id}
+            ),
+        )
+        backtest_metrics = create_backtest_metrics(
+            run, risk_free_rate=risk_free_rate
+        )
+        run.backtest_metrics = backtest_metrics
+        return Backtest(
+            backtest_runs=[run],
+            backtest_summary=generate_backtest_summary_metrics(
+                [backtest_metrics]
             )
-        except ValueError:
-            # Try to parse the backtest end date with a different format
-            return parser.parse(backtest_end_date)
-
-    def _get_algorithm_name_from_backtest_report_file(self, path: str) -> str:
-        """
-        Function to get the algorithm name from a backtest report file.
-
-        Args:
-            path: str - The path to the backtest report file
-
-        Returns:
-            str - The algorithm name
-        """
-        # Get the word between "report_" and "_backtest_start_date"
-        # it can contain _
-        # Get the algorithm name from the file name
-        algorithm_name = os.path.basename(path).split("_")[1]
-        return algorithm_name
+        )
 
-    def _is_backtest_report(self, path: str) -> bool:
+    @staticmethod
+    def get_most_granular_ohlcv_data_source(data_sources):
         """
-        Function to check if a file is a backtest report file.
+        Get the most granular data source from a list of data sources.
 
         Args:
-            path: str - The path to the file
+            data_sources: List of data sources.
 
         Returns:
-            bool - True if the file is a backtest report file, otherwise False
+            The most granular data source.
         """
+        granularity_order = {
+            TimeFrame.ONE_MINUTE: 1,
+            TimeFrame.FIVE_MINUTE: 5,
+            TimeFrame.FIFTEEN_MINUTE: 15,
+            TimeFrame.ONE_HOUR: 60,
+            TimeFrame.TWO_HOUR: 120,
+            TimeFrame.FOUR_HOUR: 240,
+            TimeFrame.TWELVE_HOUR: 720,
+            TimeFrame.ONE_DAY: 1440,
+            TimeFrame.ONE_WEEK: 10080,
+            TimeFrame.ONE_MONTH: 43200
+        }
 
-        # Check if the file is a JSON file
-        if path.endswith(".json"):
+        most_granular = None
+        highest_granularity = float('inf')
 
-            # Check if the file name matches the backtest
-            # report file name pattern
-            if re.match(
-                BACKTEST_REPORT_FILE_NAME_PATTERN, os.path.basename(path)
-            ):
-                return True
+        ohlcv_data_sources = [
+            ds for ds in data_sources if DataType.OHLCV.equals(ds.data_type)
+        ]
 
-        return False
+        if len(ohlcv_data_sources) == 0:
+            raise OperationalException("No OHLCV data sources found")
 
-    @staticmethod
-    def create_report_directory_name(report) -> str:
-        """
-        Function to create a directory name for a backtest report.
-        The directory name will be automatically generated based on the
-        algorithm name and creation date.
+        for source in ohlcv_data_sources:
 
-        Args:
-            report: BacktestResult - The backtest report to create a
-                directory for.
+            if granularity_order[source.time_frame] < highest_granularity:
+                highest_granularity = granularity_order[source.time_frame]
+                most_granular = source
 
-        Returns:
-            directory_name: str The directory name for the
-                backtest report file.
-        """
-        created_at = report.results\
-            .created_at.strftime(DATETIME_FORMAT_BACKTESTING)
-        backtest_start_date = report.results.backtest_date_range.start_date
-        backtest_end_date = report.results.backtest_date_range.end_date
-        name = report.results.name
-
-        start_date = backtest_start_date.strftime(DATETIME_FORMAT_BACKTESTING)
-        end_date = backtest_end_date.strftime(DATETIME_FORMAT_BACKTESTING)
-        directory_name = f"report_{name}_backtest-start-date_" \
-            f"{start_date}_backtest-end-date_{end_date}_{created_at}"
-        return directory_name
+        return most_granular