Fix backtesting portfolio configuration

Author: MDUYN

examples/deployments/azure_function/app_entry.py

@@ -0,0 +1,48 @@
+from dotenv import load_dotenv
+
+from investing_algorithm_framework import create_app, PortfolioConfiguration, \
+    TimeUnit, CCXTOHLCVMarketDataSource, Algorithm, \
+    CCXTTickerMarketDataSource, MarketCredential, AzureBlobStorageStateHandler
+
+load_dotenv()
+
+# Define market data sources OHLCV data for candles
+bitvavo_btc_eur_ohlcv_2h = CCXTOHLCVMarketDataSource(
+    identifier="BTC-ohlcv",
+    market="BITVAVO",
+    symbol="BTC/EUR",
+    time_frame="2h",
+    window_size=200
+)
+# Ticker data for orders, trades and positions
+bitvavo_btc_eur_ticker = CCXTTickerMarketDataSource(
+    identifier="BTC-ticker",
+    market="BITVAVO",
+    symbol="BTC/EUR",
+)
+app = create_app(state_handler=AzureBlobStorageStateHandler())
+app.add_market_data_source(bitvavo_btc_eur_ohlcv_2h)
+algorithm = Algorithm()
+app.add_market_credential(MarketCredential(market="bitvavo"))
+app.add_portfolio_configuration(
+    PortfolioConfiguration(
+        market="bitvavo",
+        trading_symbol="EUR",
+        initial_balance=20
+    )
+)
+app.add_algorithm(algorithm)
+
+@algorithm.strategy(
+    # Run every two hours
+    time_unit=TimeUnit.HOUR,
+    interval=2,
+    # Specify market data sources that need to be passed to the strategy
+    market_data_sources=[bitvavo_btc_eur_ticker, "BTC-ohlcv"]
+)
+def perform_strategy(algorithm: Algorithm, market_data: dict):
+    # By default, ohlcv data is passed as polars df in the form of
+    # {"<identifier>": <dataframe>}  https://pola.rs/,
+    # call to_pandas() to convert to pandas
+    polars_df = market_data["BTC-ohlcv"]
+    print(f"I have access to {len(polars_df)} candles of ohlcv data")

investing_algorithm_framework/__init__.py

@@ -11,7 +11,8 @@
     pretty_print_backtest_reports_evaluation, load_backtest_reports, \
     RESERVED_BALANCES, APP_MODE, AppMode, DATETIME_FORMAT, \
     load_backtest_report, BacktestDateRange, convert_polars_to_pandas, \
-    DateRange, get_backtest_report, DEFAULT_LOGGING_CONFIG
+    DateRange, get_backtest_report, DEFAULT_LOGGING_CONFIG, \
+    BacktestReport
 from investing_algorithm_framework.infrastructure import \
     CCXTOrderBookMarketDataSource, CCXTOHLCVMarketDataSource, \
     CCXTTickerMarketDataSource, CSVOHLCVMarketDataSource, \
@@ -88,5 +89,6 @@
     "is_divergence",
     "get_backtest_report",
     "AzureBlobStorageStateHandler",
-    "DEFAULT_LOGGING_CONFIG"
+    "DEFAULT_LOGGING_CONFIG",
+    "BacktestReport"
 ]

investing_algorithm_framework/app/algorithm.py

@@ -163,23 +163,14 @@ def name(self):
     def data_sources(self):
         return self._data_sources
 
-    @property
-    def identifier(self):
-        """
-        Function to get a config instance. This allows users when
-        having access to the algorithm instance also to read the
-        configs of the app.
-        """
-        return self.configuration_service.config
-
     @property
     def config(self):
         """
         Function to get a config instance. This allows users when
         having access to the algorithm instance also to read the
         configs of the app.
         """
-        return self.configuration_service.config
+        return self.configuration_service.get_config()
 
     @property
     def description(self):
@@ -489,6 +480,16 @@ def get_portfolio(self, market=None) -> Portfolio:
 
         return self.portfolio_service.find({{"market": market}})
 
+    def get_portfolios(self):
+        """
+        Function to get all portfolios of the algorithm. This function
+        will return all portfolios of the algorithm.
+
+        Returns:
+            List[Portfolio]: A list of all portfolios of the algorithm
+        """
+        return self.portfolio_service.get_all()
+
     def get_unallocated(self, market=None) -> float:
         """
         Function to get the unallocated balance of the portfolio. This
@@ -834,7 +835,7 @@ def get_position_percentage_of_portfolio(
         return (position.amount * ticker["bid"] / total) * 100
 
     def get_position_percentage_of_portfolio_by_net_size(
-            self, symbol, market=None, identifier=None
+        self, symbol, market=None, identifier=None
     ) -> float:
         """
         Returns the percentage of the portfolio that is allocated to a

investing_algorithm_framework/app/app.py

@@ -498,6 +498,9 @@ def _initialize_algorithm_for_backtest(self, algorithm):
         if portfolio_configuration_service.count() == 0:
             raise OperationalException("No portfolios configured")
 
+        # Initialize all portfolios that are registered
+
+
         strategy_orchestrator_service = \
             self.container.strategy_orchestrator_service()
         market_credential_service = self.container.market_credential_service()
@@ -518,17 +521,6 @@ def _initialize_algorithm_for_backtest(self, algorithm):
             trade_service=self.container.trade_service(),
         )
 
-        # Create all portfolios
-        portfolio_configuration_service = self.container \
-            .portfolio_configuration_service()
-        portfolio_configurations = portfolio_configuration_service.get_all()
-        portfolio_service = self.container.portfolio_service()
-
-        for portfolio_configuration in portfolio_configurations:
-            portfolio_service.create_portfolio_from_configuration(
-                portfolio_configuration
-            )
-
     def run(
         self,
         payload: dict = None,
@@ -774,20 +766,24 @@ def get_portfolio_configurations(self):
 
     def run_backtest(
         self,
-        algorithm,
         backtest_date_range: BacktestDateRange,
+        initial_amount=None,
         pending_order_check_interval=None,
-        output_directory=None
+        output_directory=None,
+        algorithm: Algorithm = None
     ) -> BacktestReport:
         """
         Run a backtest for an algorithm. This method should be called when
         running a backtest.
 
         Parameters:
-            algorithm: The algorithm to run a backtest for (instance of
-                Algorithm)
             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.
+            algorithm: The algorithm to run a backtest for (instance of
+                Algorithm)
             pending_order_check_interval: str - pending_order_check_interval:
               The interval at which to check pending orders (e.g. 1h, 1d, 1w)
             output_directory: str - The directory to
@@ -796,8 +792,11 @@ def run_backtest(
         Returns:
             Instance of BacktestReport
         """
-        logger.info("Initializing backtest")
-        self.algorithm = algorithm
+        if algorithm is not None:
+            self.algorithm = algorithm
+
+        if self.algorithm is None:
+            raise OperationalException("No algorithm registered")
 
         self._initialize_app_for_backtest(
             backtest_date_range=backtest_date_range,
@@ -807,18 +806,20 @@ def run_backtest(
         self._initialize_algorithm_for_backtest(
             algorithm=self.algorithm
         )
+
         backtest_service = self.container.backtest_service()
-        configuration_service = self.container.configuration_service()
-        config = configuration_service.get_config()
-        backtest_service.resource_directory = config[RESOURCE_DIRECTORY]
 
         # Run the backtest with the backtest_service and collect the report
         report = backtest_service.run_backtest(
-            algorithm=self.algorithm, backtest_date_range=backtest_date_range
+            algorithm=self.algorithm,
+            initial_amount=initial_amount,
+            backtest_date_range=backtest_date_range
         )
         backtest_report_writer_service = self.container \
             .backtest_report_writer_service()
 
+        config = self.container.configuration_service().get_config()
+
         if output_directory is None:
             output_directory = os.path.join(
                 config[RESOURCE_DIRECTORY], "backtest_reports"

investing_algorithm_framework/dependency_container.py

@@ -126,10 +126,11 @@ class DependencyContainer(containers.DeclarativeContainer):
         BacktestService,
         configuration_service=configuration_service,
         order_service=order_service,
-        portfolio_repository=portfolio_repository,
+        portfolio_service=portfolio_service,
         performance_service=performance_service,
         position_repository=position_repository,
         market_data_source_service=market_data_source_service,
+        portfolio_configuration_service=portfolio_configuration_service,
     )
     backtest_report_writer_service = providers.Factory(
         BacktestReportWriterService,

investing_algorithm_framework/domain/models/backtesting/backtest_report.py

@@ -358,15 +358,7 @@ def time_unit(self, value):
         self._time_unit = value
 
     def get_runs_per_day(self):
-
-        if self.time_unit is None:
-            return 0
-        elif TimeUnit.SECOND.equals(self.time_unit):
-            return 86400 / self.interval
-        elif TimeUnit.MINUTE.equals(self.time_unit):
-            return 1440 / self.interval
-        else:
-            return 24 / self.interval
+        return self.number_of_runs / self.number_of_days
 
     @property
     def backtest_start_date(self):
@@ -525,6 +517,9 @@ def get_growth_percentage(self) -> float:
     def get_trading_symbol(self) -> str:
         return self.trading_symbol
 
+    def get_initial_unallocated(self) -> float:
+        return self.initial_unallocated
+
     def add_symbol(self, symbol):
 
         if symbol not in self.symbols:

investing_algorithm_framework/domain/models/portfolio/portfolio.py

@@ -2,6 +2,35 @@
 
 
 class Portfolio(BaseModel):
+    """
+    Portfolio base class.
+
+    A portfolio is a collection of positions that are managed by an algorithm.
+
+    Attributes:
+    * identifier: str, unique identifier of the portfolio
+    * trading_symbol: str, trading symbol of the portfolio
+    * unallocated: float, the size of the trading symbol that is not
+      allocated. For example, if the trading symbol is USDT and the unallocated
+      is 1000, it means that the portfolio has 1000 USDT that is not allocated to any position.
+    * net_size: float, net size of the portfolio is the initial balance of the
+        portfolio plus the all the net gains of the trades. The
+    * realized: float, the realized gain of the portfolio is the sum of all the
+        realized gains of the trades.
+    * total_revenue: float, the total revenue of the portfolio is the sum
+        of all the orders (price * size)
+    * total_cost: float, the total cost of the portfolio is the sum of all the
+        costs of the trades (price * size (for buy orders) or -price * size (for sell orders))
+    * total_net_gain: float, the total net gain of the portfolio is the sum of
+        all the net gains of the trades
+    * total_trade_volume: float, the total trade volume of the
+        portfolio is the sum of all the sizes of the trades
+    * market: str, the market of the portfolio (e.g. BITVAVO, BINANCE)
+    * created_at: datetime, the datetime when the portfolio was created
+    * updated_at: datetime, the datetime when the portfolio was last updated
+    * initialized: bool, whether the portfolio is initialized or not
+    * initial_balance: float, the initial balance of the portfolio
+    """
 
     def __init__(
         self,

investing_algorithm_framework/domain/models/portfolio/portfolio_configuration.py

@@ -6,6 +6,22 @@
 
 
 class PortfolioConfiguration(BaseModel):
+    """
+    This class represents a portfolio configuration. It is used to
+    configure the portfolio that the user wants to create.
+
+    The portfolio configuration will have the following attributes:
+    - market: The market where the portfolio will be created
+    - trading_symbol: The trading symbol of the portfolio
+    - track_from: The date from which the portfolio will be tracked
+    - identifier: The identifier of the portfolio
+    - initial_balance: The initial balance of the portfolio
+
+    For backtesting, a portfolio configuration is used to create a
+    portfolio that will be used to simulate the trading of the algorithm. if
+    the user does not provide an initial balance, the portfolio will be created
+    with a balance of according to the initial balanace of the PortfolioConfiguration class.
+    """
 
     def __init__(
         self,
@@ -22,7 +38,9 @@ def __init__(
         self._initial_balance = initial_balance
 
         if self.identifier is None:
-            self._identifier = market.lower()
+            self._identifier = market.upper()
+        else:
+            self._identifier = identifier.upper()
 
         if track_from:
             self._track_from = parse(track_from)
@@ -35,8 +53,8 @@ def __init__(
     @property
     def market(self):
 
-        if hasattr(self._market, "lower"):
-            return self._market.lower()
+        if hasattr(self._market, "upper"):
+            return self._market.upper()
 
         return self._market
 

investing_algorithm_framework/infrastructure/repositories/portfolio_repository.py

@@ -20,7 +20,7 @@ def _apply_query_params(self, db, query, query_params):
             query = query.filter_by(market=market_query_param.upper())
 
         if identifier_query_param:
-            query = query.filter_by(identifier=identifier_query_param.lower())
+            query = query.filter_by(identifier=identifier_query_param.upper())
 
         if position_query_param:
             position = db.query(SQLPosition)\

investing_algorithm_framework/infrastructure/repositories/repository.py

@@ -71,6 +71,7 @@ def delete(self, object_id):
             try:
                 delete_object = self.get(object_id)
                 db.delete(delete_object)
+                db.commit()
                 return delete_object
             except SQLAlchemyError as e:
                 logger.error(e)