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

investing_algorithm_framework/services/backtesting/backtest_service.py

@@ -1,15 +1,28 @@
-from datetime import datetime, timedelta
-
+import logging
+import os
+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
+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
 
-from investing_algorithm_framework.domain import BacktestReport, \
-    BACKTESTING_INDEX_DATETIME, TimeUnit, BacktestPosition, \
-    TradingDataType, OrderStatus, OperationalException, MarketDataSource, \
-    OrderSide, SYMBOLS, BacktestDateRange
-from investing_algorithm_framework.services.market_data_source_service import \
-    MarketDataSourceService
+logger = logging.getLogger(__name__)
 
 
 class BacktestService:
@@ -18,192 +31,467 @@ class BacktestService:
     """
 
     def __init__(
-            self,
-            market_data_source_service: MarketDataSourceService,
-            order_service,
-            portfolio_repository,
-            position_repository,
-            performance_service,
-            configuration_service
+        self,
+        data_provider_service: DataProviderService,
+        order_service,
+        portfolio_service,
+        portfolio_snapshot_service,
+        position_repository,
+        trade_service,
+        configuration_service,
+        portfolio_configuration_service,
     ):
-        self._resource_directory = None
+        super().__init__()
         self._order_service = order_service
-        self._portfolio_repository = portfolio_repository
-        self._data_index = {
-            TradingDataType.OHLCV: {},
-            TradingDataType.TICKER: {}
-        }
-        self._performance_service = performance_service
+        self._trade_service = trade_service
+        self._portfolio_service = portfolio_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: 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, backtest_date_range: BacktestDateRange
-    ) -> BacktestReport:
+        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.
 
-        Also, all backtest data is downloaded (if not already downloaded) and
-        the backtest is run for each date in the schedule.
+        For a polars DataFrame, the 'DateTime' column will be
+        used as the index if it exists.
 
-        At the end of the run all traces
+        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
+            data: The data frame to process.
+
+        Raises:
+            OperationalException: If no valid index is found.
 
-        return:
-            BacktestReport: The backtest report
+        Returns:
+            The index of the data frame.
+        """
+        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:
         """
-        strategy_profiles = []
-        portfolios = self._portfolio_repository.get_all()
-        initial_unallocated = 0
+        Vectorized backtest for multiple assets using strategy
+        buy/sell signals.
 
-        for portfolio in portfolios:
-            initial_unallocated += portfolio.unallocated
+        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 strategy in algorithm.strategies:
-            strategy_profiles.append(strategy.strategy_profile)
+        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."
+            )
 
-        # Check if required market data sources are registered
-        self._check_if_required_market_data_sources_are_registered()
+        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
+                )
+            )
+
+        portfolio_configuration = portfolio_configurations[0]
+
+        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
         )
 
-        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']
+        # Compute signals from strategy
+        buy_signals = strategy.generate_buy_signals(data)
+        sell_signals = strategy.generate_sell_signals(data)
+
+        # 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.run_backtest_for_profile(
-                algorithm=algorithm,
-                strategy=algorithm.get_strategy(strategy_profile.strategy_id),
-                index_date=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
             )
-        return self.create_backtest_report(
-            algorithm, len(schedule), backtest_date_range, initial_unallocated
-        )
 
-    def run_backtests(
-        self, algorithms, backtest_date_range: BacktestDateRange
-    ):
-        """
-        Run backtests for the given algorithms. This function will run
-        backtests for the given algorithms and return a list of backtest
-        reports.
+        # 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
+            )
+        ]
+
+        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."
+                )
 
-        :param algorithms: The algorithms to run the backtests for
-        :param backtest_date_range: The backtest date range of the backtests
-        :return: A list of backtest reports
-        """
-        backtest_reports = []
+            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 algorithm in algorithms:
-            backtest_reports.append(
-                self.run_backtest(
-                    algorithm=algorithm,
-                    backtest_date_range=backtest_date_range
+            # 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
                 )
             )
 
-        return backtest_reports
-
-    def run_backtest_for_profile(self, algorithm, strategy, index_date):
-        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:
+        unique_symbols = set()
+        for trade in trades:
+            unique_symbols.add(trade.target_symbol)
 
-                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)
+        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())
+        )
 
-        strategy.context = algorithm.context
-        strategy.run_strategy(algorithm=algorithm, market_data=market_data)
+        # 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):
 
@@ -214,231 +502,150 @@ class BacktestService:
 
         raise ValueError(f"Strategy profile with id {id} not found.")
 
-    def create_backtest_report(
+    def _get_initial_unallocated(self) -> float:
+        """
+        Get the initial unallocated amount for the backtest.
+
+        Returns:
+            float: The initial unallocated amount.
+        """
+        portfolios = self._portfolio_service.get_all()
+        initial_unallocated = 0.0
+
+        for portfolio in portfolios:
+            initial_unallocated += portfolio.initial_balance
+
+        return initial_unallocated
+
+    def create_backtest(
         self,
         algorithm,
         number_of_runs,
         backtest_date_range: BacktestDateRange,
-        initial_unallocated=0
-    ) -> BacktestReport:
+        risk_free_rate,
+        strategy_directory_path=None
+    ) -> Backtest:
         """
-        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.
+        Create a backtest for the given algorithm.
 
-        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.
+        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:
             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
+            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:
-            BacktestReport: The backtest report instance of BacktestReport
+            Backtest: The backtest containing the results and metrics.
         """
 
-        for portfolio in self._portfolio_repository.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]
-
-            backtest_report = BacktestReport(
-                name=algorithm.name,
-                strategy_identifiers=ids,
-                backtest_date_range=backtest_date_range,
-                initial_unallocated=initial_unallocated,
-                trading_symbol=portfolio.trading_symbol,
-                created_at=datetime.utcnow(),
-            )
-            backtest_report.number_of_runs = number_of_runs
-            backtest_report.number_of_orders = self._order_service.count({
-                "portfolio": portfolio.id
-            })
-            backtest_report.number_of_positions = \
-                self._position_repository.count({
-                    "portfolio": portfolio.id,
-                    "amount_gt": 0
-                })
-            backtest_report.percentage_negative_trades = \
-                self._performance_service \
-                    .get_percentage_negative_trades(portfolio.id)
-            backtest_report.percentage_positive_trades = \
-                self._performance_service \
-                    .get_percentage_positive_trades(portfolio.id)
-            backtest_report.number_of_trades_closed = \
-                self._performance_service \
-                    .get_number_of_trades_closed(portfolio.id)
-            backtest_report.number_of_trades_open = \
-                self._performance_service \
-                    .get_number_of_trades_open(portfolio.id)
-            backtest_report.total_cost = portfolio.total_cost
-            backtest_report.total_net_gain = portfolio.total_net_gain
-            backtest_report.total_net_gain_percentage = \
-                self._performance_service \
-                    .get_total_net_gain_percentage_of_backtest(
-                        portfolio.id, backtest_report
-                    )
-            positions = self._position_repository.get_all({
-                "portfolio": portfolio.id
-            })
-            orders = self._order_service.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
-                        )
+        # Get the first portfolio
+        portfolio = self._portfolio_service.get_all()[0]
 
-            backtest_report.growth_rate = self._performance_service \
-                .get_growth_rate_of_backtest(
-                    portfolio.id, tickers, backtest_report
-                )
-            backtest_report.growth = self._performance_service \
-                .get_growth_of_backtest(
-                    portfolio.id, tickers, backtest_report
+        # List all strategy related files in the strategy directory
+        strategy_related_paths = []
+
+        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"
                 )
-            backtest_report.total_value = self._performance_service \
-                .get_total_value(portfolio.id, tickers, backtest_report)
-            backtest_report.average_trade_duration = \
-                self._performance_service \
-                    .get_average_trade_duration(portfolio.id)
-            backtest_report.average_trade_size = \
-                self._performance_service.get_average_trade_size(portfolio.id)
-            positions = self._position_repository.get_all({
-                "portfolio": portfolio.id
-            })
-            backtest_positions = []
-
-            for position in positions:
-
-                if position.symbol == portfolio.trading_symbol:
-                    backtest_position = BacktestPosition(
-                        position,
-                        trading_symbol=True,
-                        total_value_portfolio=backtest_report.total_value
-                    )
-                    backtest_position.price = 1
-                else:
-                    pending_buy_orders = self._order_service.get_all({
-                        "portfolio": portfolio.id,
-                        "target_symbol": position.symbol,
-                        "status": OrderStatus.OPEN.value,
-                        "order_side": OrderSide.BUY.value
-                    })
-                    amount_in_pending_buy_orders = 0
-
-                    for order in pending_buy_orders:
-                        amount_in_pending_buy_orders += order.amount
-
-                    pending_sell_orders = self._order_service.get_all({
-                        "portfolio": portfolio.id,
-                        "target_symbol": position.symbol,
-                        "status": OrderStatus.OPEN.value,
-                        "order_side": OrderSide.SELL.value
-                    })
-                    amount_in_pending_sell_orders = 0
-
-                    for order in pending_sell_orders:
-                        amount_in_pending_sell_orders += order.amount
-
-                    backtest_position = BacktestPosition(
-                        position,
-                        amount_pending_buy=amount_in_pending_buy_orders,
-                        amount_pending_sell=amount_in_pending_sell_orders,
-                        total_value_portfolio=backtest_report.total_value
-                    )
 
-                    # Probably not needed
-                    ticker = self._market_data_source_service \
-                        .get_ticker(
-                            symbol=f"{position.symbol}"
-                                   f"/{portfolio.trading_symbol}",
-                            market=portfolio.market
+            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
                         )
-                    backtest_position.price = ticker["bid"]
-                backtest_positions.append(backtest_position)
-            backtest_report.positions = backtest_positions
-            backtest_report.trades = algorithm.get_trades()
-            backtest_report.orders = orders
-            backtest_report.context = algorithm.context
-            traces = {}
-
-            # Add traces to the backtest report
-            for strategy in algorithm.strategies:
-                strategy_traces = strategy.get_traces()
-                traces[strategy.strategy_id] = strategy_traces
-
-            backtest_report.traces = traces
-
-            # Calculate metrics for the backtest report
-            backtest_report.calculate_metrics()
-            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"
+                        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]
+            )
         )
 
-    def _check_if_required_market_data_sources_are_registered(self):
+    @staticmethod
+    def get_most_granular_ohlcv_data_source(data_sources):
         """
-        Check if the required market data sources are registered.
+        Get the most granular data source from a list of data sources.
 
-        It will iterate over all registered symbols and markets and check
-        if a ticker market data source is registered for the symbol and market.
+        Args:
+            data_sources: List of data sources.
+
+        Returns:
+            The most granular data source.
         """
-        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."
-                    )
+        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
+        }
+
+        most_granular = None
+        highest_granularity = float('inf')
+
+        ohlcv_data_sources = [
+            ds for ds in data_sources if DataType.OHLCV.equals(ds.data_type)
+        ]
+
+        if len(ohlcv_data_sources) == 0:
+            raise OperationalException("No OHLCV data sources found")
+
+        for source in ohlcv_data_sources:
+
+            if granularity_order[source.time_frame] < highest_granularity:
+                highest_granularity = granularity_order[source.time_frame]
+                most_granular = source
+
+        return most_granular