Fix trade status in vector backtests

Author: MDUYN

investing_algorithm_framework/__init__.py

@@ -14,7 +14,7 @@
     Position, TimeFrame, INDEX_DATETIME, MarketCredential, \
     PortfolioConfiguration, RESOURCE_DIRECTORY, AWS_LAMBDA_LOGGING_CONFIG, \
     Trade, SYMBOLS, RESERVED_BALANCES, APP_MODE, AppMode, DATETIME_FORMAT, \
-    BacktestDateRange, convert_polars_to_pandas, \
+    BacktestDateRange, convert_polars_to_pandas, BacktestRun, \
     DEFAULT_LOGGING_CONFIG, DataType, DataProvider, \
     TradeStatus, TradeRiskType, generate_backtest_summary_metrics, \
     APPLICATION_DIRECTORY, DataSource, OrderExecutor, PortfolioProvider, \
@@ -189,4 +189,5 @@
     "get_negative_trades",
     "get_positive_trades",
     "get_number_of_trades",
+    "BacktestRun"
 ]

investing_algorithm_framework/domain/models/portfolio/portfolio_snapshot.py

@@ -150,23 +150,24 @@ def to_dict(self, datetime_format=None):
         if datetime_format is not None:
             created_at = self.created_at.strftime(datetime_format) \
                 if self.created_at else None
-
         else:
             created_at = self.created_at.strftime(DEFAULT_DATETIME_FORMAT)
 
         return {
-            "metadata": self.metadata,
-            "portfolio_id": self.portfolio_id,
-            "trading_symbol": self.trading_symbol,
-            "pending_value": self.pending_value,
-            "unallocated": self.unallocated,
-            "total_net_gain": self.total_net_gain,
-            "total_revenue": self.total_revenue,
-            "total_cost": self.total_cost,
-            "cash_flow": self.cash_flow,
-            "net_size": self.net_size,
-            "created_at": created_at,
-            "total_value": self.total_value,
+            "metadata": self.metadata if self.metadata else {},
+            "portfolio_id": self.portfolio_id if self.portfolio_id else "",
+            "trading_symbol": self.trading_symbol
+            if self.trading_symbol else "",
+            "pending_value": self.pending_value if self.pending_value else 0.0,
+            "unallocated": self.unallocated if self.unallocated else 0.0,
+            "total_net_gain": self.total_net_gain
+            if self.total_net_gain else 0.0,
+            "total_revenue": self.total_revenue if self.total_revenue else 0.0,
+            "total_cost": self.total_cost if self.total_cost else 0.0,
+            "cash_flow": self.cash_flow if self.cash_flow else 0.0,
+            "net_size": self.net_size if self.net_size else 0.0,
+            "created_at": created_at if created_at else "",
+            "total_value": self.total_value if self.total_value else 0.0,
         }
 
     @staticmethod

investing_algorithm_framework/domain/models/trade/trade.py

@@ -283,14 +283,14 @@ def to_dict(self, datetime_format=None):
             "trading_symbol": self.trading_symbol,
             "status": self.status,
             "amount": self.amount,
-            "remaining": self.remaining,
+            "remaining": self.remaining if self.remaining is not None else 0,
             "open_price": self.open_price,
             "last_reported_price": self.last_reported_price,
             "opened_at": opened_at,
             "closed_at": closed_at,
             "updated_at": updated_at,
-            "net_gain": self.net_gain,
-            "cost": self.cost,
+            "net_gain": self.net_gain if self.net_gain is not None else 0,
+            "cost": self.cost if self.cost is not None else 0,
             "stop_losses": [
                 stop_loss.to_dict(datetime_format=datetime_format)
                 for stop_loss in self.stop_losses

investing_algorithm_framework/services/backtesting/backtest_service.py

@@ -165,13 +165,19 @@ def create_vector_backtest(
             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
+        )
 
         # Load vectorized backtest data
         data = self._data_provider_service.get_vectorized_backtest_data(
@@ -188,7 +194,9 @@ def create_vector_backtest(
         index = pd.Index([])
 
         most_granular_ohlcv_data_source = \
-            self._get_most_granular_ohlcv_data_source(strategy.data_sources)
+            BacktestService.get_most_granular_ohlcv_data_source(
+                strategy.data_sources
+            )
         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,
@@ -212,6 +220,8 @@ def create_vector_backtest(
         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,
@@ -346,7 +356,7 @@ def create_vector_backtest(
                         {
                             "orders": trade_orders,
                             "closed_at": current_date,
-                            "trade_status": TradeStatus.CLOSED,
+                            "status": TradeStatus.CLOSED,
                             "updated_at": current_date,
                             "net_gain": net_gain_val
                         }
@@ -392,6 +402,7 @@ def create_vector_backtest(
             # total_net_gain = total_value - initial_amount
             snapshots.append(
                 PortfolioSnapshot(
+                    portfolio_id=portfolio.identifier,
                     created_at=interval_datetime,
                     unallocated=unallocated,
                     total_value=unallocated + allocated,
@@ -580,7 +591,7 @@ def create_backtest(
         )
 
     @staticmethod
-    def _get_most_granular_ohlcv_data_source(data_sources):
+    def get_most_granular_ohlcv_data_source(data_sources):
         """
         Get the most granular data source from a list of data sources.
 

investing_algorithm_framework/services/metrics/win_rate.py

@@ -55,6 +55,7 @@ def get_win_rate(trades: List[Trade]) -> float:
     trades = [
         trade for trade in trades if TradeStatus.CLOSED.equals(trade.status)
     ]
+    print(len(trades))
     positive_trades = sum(1 for trade in trades if trade.net_gain > 0)
     total_trades = len(trades)
 

tests/scenarios/vectorized_backtests/test_multiple_vectorized_backtests.py

@@ -3,13 +3,13 @@
 import pandas as pd
 from datetime import datetime, timedelta, timezone
 from unittest import TestCase
-from typing import Dict, Any, List
+from typing import Dict, Any
 
 from pyindicators import ema, rsi, crossover, crossunder, macd
 
 from investing_algorithm_framework import TradingStrategy, DataSource, \
     TimeUnit, DataType, create_app, BacktestDateRange, PositionSize, \
-    Algorithm, RESOURCE_DIRECTORY, SnapshotInterval
+    TradeStatus, RESOURCE_DIRECTORY, SnapshotInterval
 
 
 
@@ -290,6 +290,12 @@ def test_run(self):
         self.assertNotEqual(0, len(run.get_trades(target_symbol="ETH")))
         self.assertNotEqual(0, len(run.get_trades(target_symbol="BTC")))
 
+        # Get first trade
+        trade = run.get_trades(target_symbol="BTC")[0]
+        self.assertEqual("BTC", trade.target_symbol)
+        self.assertEqual("EUR", trade.trading_symbol)
+        self.assertTrue(TradeStatus.CLOSED.equals(trade.status))
+
     def test_run_without_data_sources_initialization(self):
         start_time = time.time()
         # RESOURCE_DIRECTORY should always point to the parent directory/resources

tests/services/metrics/test_generate_metrics.py

@@ -0,0 +1,26 @@
+import os
+from unittest import TestCase
+
+from investing_algorithm_framework import create_backtest_metrics, BacktestRun
+
+class TestGenerateMetrics(TestCase):
+    def setUp(self):
+        # Must point to /tests/resources
+        self.resource_directory = os.path.abspath(
+            os.path.join(os.path.dirname(__file__), '..', '..', 'resources')
+        )
+        self.test_data_directory = os.path.join(
+            self.resource_directory, 'test_data'
+        )
+        self.backtest_run_directory = os.path.join(
+            self.test_data_directory, 'backtest_runs'
+        )
+
+    def test_generate_metrics(self):
+        # This is a placeholder for the actual test implementation
+        backtest_run = BacktestRun.open(
+            os.path.join(self.backtest_run_directory, 'backtest_run_one')
+        )
+        backtest_metrics = create_backtest_metrics(
+            backtest_run, risk_free_rate=0.024
+        )