investing-algorithm-framework 7.22.3__tar.gz → 7.22.4__tar.gz

{investing_algorithm_framework-7.22.3 → investing_algorithm_framework-7.22.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investing-algorithm-framework
-Version: 7.22.3
+Version: 7.22.4
 Summary: A framework for creating trading bots
 Author: MDUYN
 Requires-Python: >=3.10

{investing_algorithm_framework-7.22.3 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/app/context.py

@@ -1196,11 +1196,10 @@ class Context:
         portfolio=None,
         status=None,
         order_id=None
-    ) -> List[Trade]:
+    ) -> Trade:
         """
-        Function to get all trades. This function will return all trades
-        that match the specified query parameters. If the market parameter
-        is specified, the trades with the specified market will be returned.
+        Function to retrieve a trade. This function will return the first
+        trade that matches the specified query parameters.
 
         Args:
             market: The market of the asset
@@ -1211,7 +1210,7 @@ class Context:
             trading_symbol: The trading symbol of the asset
 
         Returns:
-            List[Trade]: A list of trades that match the query parameters
+            Trade: A instance of a trade that matches the query parameters
         """
         query_params = {}
 

{investing_algorithm_framework-7.22.3 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/app/strategy.py

@@ -16,7 +16,12 @@ class TradingStrategy:
     strategy is a set of rules that defines when to buy or sell an asset.
 
     Attributes:
-        id (string): the unique id for your combined strategy instances
+        algorithm_id (string): the unique id for your
+            combined strategy instances. An algorithm consists out of one or
+            more strategy instances that run together. The algorithm_id
+            is used to uniquely indentify the combined strategy instances.
+            This is id is used in various places in the framework, e.g. for
+            backtesting results, logging, monitoring etc.
         time_unit (TimeUnit): the time unit of the strategy that defines
             when the strategy should run e.g. HOUR, DAY, WEEK, MONTH
         interval (int): the interval of the strategy that defines how often
@@ -34,7 +39,7 @@ class TradingStrategy:
             store additional information about the strategy, such as its
             author, version, description, params etc.
     """
-    id: str
+    algorithm_id: str
     time_unit: TimeUnit = None
     interval: int = None
     worker_id: str = None

{investing_algorithm_framework-7.22.3 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/domain/backtesting/backtest_metrics.py

@@ -21,8 +21,13 @@ class BacktestMetrics:
     and maximum drawdown.
 
     Attributes:
+        backtest_date_range_name (str): The name of the date range
+            used for the backtest.
         backtest_start_date (datetime): The start date of the backtest.
         backtest_end_date (datetime): The end date of the backtest.
+        trading_symbol (str): The trading symbol used in the backtest.
+        initial_unallocated (float): The initial unallocated cash
+            at the start of the backtest.
         final_value (float): The final value of the portfolio at the end
             of the backtest.
         equity_curve (List[Tuple[datetime, float]]): A list of
@@ -137,6 +142,9 @@ class BacktestMetrics:
     """
     backtest_start_date: datetime
     backtest_end_date: datetime
+    backtest_date_range_name: str = ""
+    trading_symbol: str = ""
+    initial_unallocated: float = 0.0
     equity_curve: List[Tuple[float, datetime]] = field(default_factory=list)
     total_growth: float = 0.0
     total_growth_percentage: float = 0.0
@@ -233,6 +241,9 @@ class BacktestMetrics:
         return {
             "backtest_start_date": ensure_iso(self.backtest_start_date),
             "backtest_end_date": ensure_iso(self.backtest_end_date),
+            "backtest_date_range_name": self.backtest_date_range_name,
+            "trading_symbol": self.trading_symbol,
+            "initial_unallocated": self.initial_unallocated,
             "equity_curve": [(value, ensure_iso(date))
                              for value, date in self.equity_curve],
             "final_value": self.final_value,

{investing_algorithm_framework-7.22.3 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/domain/backtesting/backtest_run.py

@@ -169,6 +169,23 @@ class BacktestRun:
                 f"The run file {run_file} does not exist."
             )
 
+        # Validate and set defaults for required fields
+        required_fields = {
+            "backtest_start_date": "2020-01-01 00:00:00",
+            "backtest_end_date": "2020-01-02 00:00:00",
+            "created_at": "2020-01-01 00:00:00",
+            "trading_symbol": "USD",
+            "initial_unallocated": 1000.0,
+            "number_of_runs": 1
+        }
+
+        for field_name, default_value in required_fields.items():
+            if field_name not in data:
+                logger.warning(f"Missing required field '{field_name}' in "
+                               f"backtest data, using "
+                               f"default: {default_value}")
+                data[field_name] = default_value
+
         # Parse datetime fields
         data["backtest_start_date"] = datetime.strptime(
             data["backtest_start_date"], "%Y-%m-%d %H:%M:%S"
@@ -186,27 +203,66 @@ class BacktestRun:
             "backtest_end_date"].replace(tzinfo=timezone.utc)
         data["created_at"] = data["created_at"].replace(tzinfo=timezone.utc)
 
-        # Parse orders
-        data["orders"] = [
-            Order.from_dict(order) for order in data.get("orders", [])
-        ]
-
-        # Parse positions
-        data["positions"] = [
-            Position.from_dict(position)
-            for position in data.get("positions", [])
-        ]
-
-        # Parse trades
-        data["trades"] = [
-            Trade.from_dict(trade) for trade in data.get("trades", [])
-        ]
-
-        # Parse portfolio snapshots
-        data["portfolio_snapshots"] = [
-            PortfolioSnapshot.from_dict(ps)
-            for ps in data.get("portfolio_snapshots", [])
-        ]
+        # Parse orders with error handling
+        orders = []
+        for order_data in data.get("orders", []):
+            try:
+                order = Order.from_dict(order_data)
+                orders.append(order)
+            except KeyError as e:
+                logger.error(f"Failed to parse order "
+                             f"data, missing field {e}: {order_data}")
+                continue
+            except Exception as e:
+                logger.error(f"Failed to parse order data: {e}")
+                continue
+        data["orders"] = orders
+
+        # Parse positions with error handling
+        positions = []
+        for position_data in data.get("positions", []):
+            try:
+                position = Position.from_dict(position_data)
+                positions.append(position)
+            except KeyError as e:
+                logger.error(f"Failed to parse position data, "
+                             f"missing field {e}: {position_data}")
+                continue
+            except Exception as e:
+                logger.error(f"Failed to parse position data: {e}")
+                continue
+        data["positions"] = positions
+
+        # Parse trades with error handling
+        trades = []
+        for trade_data in data.get("trades", []):
+            try:
+                trade = Trade.from_dict(trade_data)
+                trades.append(trade)
+            except KeyError as e:
+                logger.error(f"Failed to parse trade data, "
+                             f"missing field {e}: {trade_data}")
+                # Skip this trade and continue with the next one
+                continue
+            except Exception as e:
+                logger.error(f"Failed to parse trade data: {e}")
+                continue
+        data["trades"] = trades
+
+        # Parse portfolio snapshots with error handling
+        portfolio_snapshots = []
+        for ps_data in data.get("portfolio_snapshots", []):
+            try:
+                ps = PortfolioSnapshot.from_dict(ps_data)
+                portfolio_snapshots.append(ps)
+            except KeyError as e:
+                logger.error(f"Failed to parse portfolio snapshot data, "
+                             f"missing field {e}: {ps_data}")
+                continue
+            except Exception as e:
+                logger.error(f"Failed to parse portfolio snapshot data: {e}")
+                continue
+        data["portfolio_snapshots"] = portfolio_snapshots
 
         return BacktestRun(
             backtest_metrics=backtest_metrics,

{investing_algorithm_framework-7.22.3 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/domain/backtesting/backtest_utils.py

@@ -1,13 +1,12 @@
 import os
-from pathlib import Path
-from typing import List, Union, Callable
 from logging import getLogger
+from pathlib import Path
 from random import Random
+from typing import List, Union, Callable
 
-from .backtest import Backtest
 from investing_algorithm_framework.domain.exceptions import \
     OperationalException
-
+from .backtest import Backtest
 
 logger = getLogger("investing_algorithm_framework")
 
@@ -29,7 +28,7 @@ def save_backtests_to_directory(
         dir_name_generation_function (Callable[[Backtest], str], optional):
             A function that takes a Backtest object as input and returns
             a string to be used as the directory name for that backtest.
-            If not provided, the backtest's metadata 'id' will be used.
+            If not provided, the backtest's algorithm_id will be used.
             Defaults to None.
         number_of_backtests_to_save (int, optional): Maximum number of
             backtests to save. If None, all backtests will be saved.
@@ -74,7 +73,7 @@ def save_backtests_to_directory(
 
         if dir_name is None:
             logger.warning(
-                "Backtest metadata does not contain an 'id' field. "
+                "Backtest algorithm_id is None. "
                 "Generating a random directory name."
             )
             dir_name = str(Random().randint(100000, 999999))
@@ -123,16 +122,47 @@ def load_backtests_from_directory(
         file_path = os.path.join(directory_path, file_name)
 
         try:
-            backtest = Backtest.open(file_path)
+
+            # Add step-by-step debugging
+            try:
+                backtest = Backtest.open(file_path)
+            except KeyError as ke:
+                logger.error(
+                    f"KeyError during Backtest.open for {file_path}: {ke}"
+                )
+                import traceback
+                logger.error(
+                    f"Backtest.open KeyError "
+                    f"traceback: {traceback.format_exc()}"
+                )
+                continue  # Skip this backtest and continue with the next one
+            except Exception as be:
+                logger.error(
+                    f"Other error during Backtest.open for {file_path}: {be}"
+                )
+                import traceback
+                logger.error(
+                    f"Backtest.open error traceback: {traceback.format_exc()}"
+                )
+                continue  # Skip this backtest and continue with the next one
 
             if filter_function is not None:
-                if not filter_function(backtest):
+                try:
+                    if not filter_function(backtest):
+                        continue
+                except Exception as fe:
+                    logger.error(
+                        f"Error in filter_function for {file_path}: {fe}"
+                    )
                     continue
 
             backtests.append(backtest)
+
         except Exception as e:
             logger.error(
-                f"Failed to load backtest from {file_path}: {e}"
+                f"Unexpected top-level error loading "
+                f"backtest from {file_path}: {e}"
             )
+            import traceback
 
     return backtests

{investing_algorithm_framework-7.22.3 → investing_algorithm_framework-7.22.4}/investing_algorithm_framework/domain/models/trade/trade.py

@@ -341,13 +341,14 @@ class Trade(BaseModel):
                 Order.from_dict(order)
                 for order in data["orders"]
             ]
+
         return Trade(
             id=data.get("id", None),
             orders=orders,
-            target_symbol=data["target_symbol"],
-            trading_symbol=data["trading_symbol"],
-            amount=data["amount"],
-            open_price=data["open_price"],
+            target_symbol=data.get("target_symbol", ""),
+            trading_symbol=data.get("trading_symbol", ""),
+            amount=data.get("amount", 0),
+            open_price=data.get("open_price", 0),
             opened_at=opened_at,
             closed_at=closed_at,
             filled_amount=data.get("filled_amount", 0),
@@ -355,7 +356,7 @@ class Trade(BaseModel):
             remaining=data.get("remaining", 0),
             net_gain=data.get("net_gain", 0),
             last_reported_price=data.get("last_reported_price"),
-            status=TradeStatus.from_value(data["status"]).value,
+            status=TradeStatus.from_value(data.get("status", "OPEN")).value,
             cost=data.get("cost", 0),
             updated_at=updated_at,
             stop_losses=stop_losses,

{investing_algorithm_framework-7.22.3 → investing_algorithm_framework-7.22.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "investing-algorithm-framework"
-version = "v7.22.03"
+version = "v7.22.04"
 description = "A framework for creating trading bots"
 authors = ["MDUYN"]
 readme = "README.md"