investing-algorithm-framework 7.16.10__tar.gz → 7.16.12__tar.gz

{investing_algorithm_framework-7.16.10 → investing_algorithm_framework-7.16.12}/PKG-INFO

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

{investing_algorithm_framework-7.16.10 → investing_algorithm_framework-7.16.12}/investing_algorithm_framework/__init__.py

@@ -14,7 +14,7 @@ from .domain import ApiException, combine_backtests, PositionSize, \
     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 @@ __all__ = [
     "get_negative_trades",
     "get_positive_trades",
     "get_number_of_trades",
+    "BacktestRun"
 ]

investing_algorithm_framework-7.16.12/investing_algorithm_framework/domain/backtesting/backtest_evaluation_focuss.py

@@ -0,0 +1,242 @@
+from enum import Enum
+
+
+class BacktestEvaluationFocus(Enum):
+    """
+    Enumeration for backtest evaluation focus areas.
+
+    The available metrics are:
+        - backtest_start_date
+        - backtest_end_date
+        - equity_curve
+        - final_value
+        - total_growth
+        - total_growth_percentage
+        - total_net_gain
+        - total_net_gain_percentage
+        - total_loss
+        - total_loss_percentage
+        - cumulative_return
+        - cumulative_return_series
+        - cagr
+        - sharpe_ratio
+        - rolling_sharpe_ratio
+        - sortino_ratio
+        - calmar_ratio
+        - profit_factor
+        - annual_volatility
+        - monthly_returns
+        - yearly_returns
+        - drawdown_series
+        - max_drawdown
+        - max_drawdown_absolute
+        - max_daily_drawdown
+        - max_drawdown_duration
+        - trades_per_year
+        - trade_per_day
+        - exposure_ratio
+        - cumulative_exposure
+        - best_trade
+        - worst_trade
+        - number_of_positive_trades
+        - percentage_positive_trades
+        - number_of_negative_trades
+        - percentage_negative_trades
+        - average_trade_duration
+        - average_trade_size
+        - average_trade_loss
+        - average_trade_loss_percentage
+        - average_trade_gain
+        - average_trade_gain_percentage
+        - average_trade_return
+        - average_trade_return_percentage
+        - median_trade_return
+        - number_of_trades
+        - number_of_trades_closed
+        - number_of_trades_opened
+        - number_of_trades_open_at_end
+        - win_rate
+        - current_win_rate
+        - win_loss_ratio
+        - current_win_loss_ratio
+        - percentage_winning_months
+        - percentage_winning_years
+        - average_monthly_return
+        - average_monthly_return_losing_months
+        - average_monthly_return_winning_months
+        - best_month
+        - best_year
+        - worst_month
+        - worst_year
+        - total_number_of_days
+        - current_average_trade_gain
+        - current_average_trade_return
+        - current_average_trade_duration
+        - current_average_trade_loss
+    """
+    BALANCED = "balanced"
+    PROFIT = "profit"
+    FREQUENCY = "frequency"
+    RISK_ADJUSTED = "risk_adjusted"
+
+    @staticmethod
+    def from_string(value: str):
+
+        if isinstance(value, str):
+
+            for entry in BacktestEvaluationFocus:
+
+                if value.upper() == entry.value:
+                    return entry
+
+            raise ValueError(
+                f"Could not convert {value} to BacktestEvaluationFocus"
+            )
+        return None
+
+    @staticmethod
+    def from_value(value):
+
+        if isinstance(value, str):
+            return BacktestEvaluationFocus.from_string(value)
+
+        if isinstance(value, BacktestEvaluationFocus):
+
+            for entry in BacktestEvaluationFocus:
+
+                if value == entry:
+                    return entry
+
+        raise ValueError(
+            f"Could not convert {value} to BacktestEvaluationFocus"
+        )
+
+    def equals(self, other):
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+        else:
+            return BacktestEvaluationFocus.from_string(other) == self
+
+    def get_weights(self):
+        """
+        Get evaluation weights for different focus areas.
+        Returns a dictionary with metric weights where:
+        - Positive weights favor higher values
+        - Negative weights favor lower values (penalties)
+        - Zero weights ignore the metric
+        """
+
+        if self == BacktestEvaluationFocus.BALANCED:
+            return {
+                # Core profitability metrics (moderate weight)
+                "total_net_gain_percentage": 2.0,
+                "cagr": 1.5,
+                "average_trade_return_percentage": 1.0,
+
+                # Risk-adjusted returns (important for balance)
+                "sharpe_ratio": 2.0,
+                "sortino_ratio": 1.5,
+                "calmar_ratio": 1.0,
+                "profit_factor": 1.5,
+
+                # Risk management (penalties for bad metrics)
+                "max_drawdown": -1.5,
+                "max_drawdown_duration": -0.5,
+                "annual_volatility": -0.8,
+
+                # Trading consistency
+                "win_rate": 1.5,
+                "win_loss_ratio": 1.0,
+                "number_of_trades": 0.8,  # Some activity needed
+
+                # Efficiency metrics
+                "exposure_ratio": 0.5,
+                "trades_per_year": 0.3,
+            }
+
+        elif self == BacktestEvaluationFocus.PROFIT:
+            return {
+                # Maximize absolute and relative profits
+                "total_net_gain_percentage": 3.0,
+                "cagr": 2.5,
+                "total_net_gain": 2.0,
+                "average_trade_return_percentage": 1.5,
+                "best_trade": 1.0,
+
+                # Profit consistency
+                "win_rate": 2.0,
+                "profit_factor": 2.0,
+                "percentage_positive_trades": 1.0,
+
+                # Risk secondary (but still important)
+                "sharpe_ratio": 1.0,
+                "max_drawdown": -1.0,
+
+                # Activity level (need some trades)
+                "number_of_trades": 0.5,
+
+                # Monthly/yearly consistency
+                "percentage_winning_months": 0.8,
+                "average_monthly_return": 1.0,
+            }
+
+        elif self == BacktestEvaluationFocus.FREQUENCY:
+            return {
+                # High trading activity with good results
+                "number_of_trades": 3.0,
+                "trades_per_year": 2.5,
+                "exposure_ratio": 2.0,
+
+                # Profitability per trade (scaled for frequency)
+                "average_trade_return_percentage": 2.0,
+                "win_rate": 2.5,
+                "total_net_gain_percentage": 1.5,
+
+                # Consistency across many trades
+                "win_loss_ratio": 1.5,
+                "percentage_positive_trades": 1.0,
+
+                # Risk management for frequent trading
+                "max_drawdown": -1.5,
+                "sharpe_ratio": 1.0,
+                "profit_factor": 1.2,
+
+                # Duration efficiency
+                "average_trade_duration": -0.3,  # Prefer shorter trades
+            }
+
+        elif self == BacktestEvaluationFocus.RISK_ADJUSTED:
+            return {
+                # Risk-adjusted performance metrics (highest priority)
+                "sharpe_ratio": 3.0,
+                "sortino_ratio": 2.5,
+                "calmar_ratio": 2.0,
+
+                # Risk management (strong penalties)
+                "max_drawdown": -3.0,
+                "max_drawdown_duration": -1.5,
+                "annual_volatility": -2.0,
+                "worst_trade": -1.0,
+
+                # Consistent performance
+                "win_rate": 2.0,
+                "win_loss_ratio": 1.5,
+                "percentage_winning_months": 1.5,
+
+                # Stable returns
+                "average_trade_return_percentage": 1.5,
+                "total_net_gain_percentage": 1.0,
+                "profit_factor": 1.8,
+
+                # Reasonable activity
+                "number_of_trades": 0.5,
+
+                # Downside protection
+                "average_trade_loss_percentage": -1.0,
+                "percentage_negative_trades": -1.0,
+            }
+
+        # Fallback to balanced if unknown focus
+        return self.get_weights() \
+            if self != BacktestEvaluationFocus.BALANCED else {}

{investing_algorithm_framework-7.16.10 → investing_algorithm_framework-7.16.12}/investing_algorithm_framework/domain/models/portfolio/portfolio_snapshot.py

@@ -150,23 +150,24 @@ class PortfolioSnapshot(BaseModel):
         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-7.16.10 → investing_algorithm_framework-7.16.12}/investing_algorithm_framework/domain/models/trade/trade.py

@@ -283,14 +283,14 @@ class Trade(BaseModel):
             "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-7.16.10 → investing_algorithm_framework-7.16.12}/investing_algorithm_framework/services/backtesting/backtest_service.py

@@ -165,13 +165,19 @@ class BacktestService:
             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 @@ class BacktestService:
         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 @@ class BacktestService:
         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,
@@ -268,6 +278,11 @@ class BacktestService:
             # 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)):
 
@@ -341,7 +356,7 @@ class BacktestService:
                         {
                             "orders": trade_orders,
                             "closed_at": current_date,
-                            "trade_status": TradeStatus.CLOSED,
+                            "status": TradeStatus.CLOSED,
                             "updated_at": current_date,
                             "net_gain": net_gain_val
                         }
@@ -387,6 +402,7 @@ class BacktestService:
             # total_net_gain = total_value - initial_amount
             snapshots.append(
                 PortfolioSnapshot(
+                    portfolio_id=portfolio.identifier,
                     created_at=interval_datetime,
                     unallocated=unallocated,
                     total_value=unallocated + allocated,
@@ -575,7 +591,7 @@ class BacktestService:
         )
 
     @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-7.16.10 → investing_algorithm_framework-7.16.12}/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)
 

{investing_algorithm_framework-7.16.10 → investing_algorithm_framework-7.16.12}/pyproject.toml

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

investing_algorithm_framework-7.16.10/investing_algorithm_framework/domain/backtesting/backtest_evaluation_focuss.py

@@ -1,116 +0,0 @@
-from enum import Enum
-
-
-default_weights = {
-    # Profitability
-    "total_net_gain": 3.0,
-    "gross_loss": 0.0,
-    "growth": 0.0,
-    "trades_average_return": 0.0,
-
-    # Risk-adjusted returns
-    "sharpe_ratio": 1.0,
-    "sortino_ratio": 1.0,
-    "profit_factor": 1.0,
-
-    # Risk
-    "max_drawdown": -2.0,
-    "max_drawdown_duration": -0.5,
-
-    # Trading activity
-    "number_of_trades": 2.0,
-    "win_rate": 3.0,
-
-    # Exposure
-    "cumulative_exposure": 0.5,
-    "exposure_ratio": 0.0,
-}
-
-
-class BacktestEvaluationFocus(Enum):
-    BALANCED = "balanced"
-    PROFIT = "profit"
-    FREQUENCY = "frequency"
-    RISK_ADJUSTED = "risk_adjusted"
-
-    @staticmethod
-    def from_string(value: str):
-
-        if isinstance(value, str):
-
-            for entry in BacktestEvaluationFocus:
-
-                if value.upper() == entry.value:
-                    return entry
-
-            raise ValueError(
-                f"Could not convert {value} to BacktestEvaluationFocus"
-            )
-        return None
-
-    @staticmethod
-    def from_value(value):
-
-        if isinstance(value, str):
-            return BacktestEvaluationFocus.from_string(value)
-
-        if isinstance(value, BacktestEvaluationFocus):
-
-            for entry in BacktestEvaluationFocus:
-
-                if value == entry:
-                    return entry
-
-        raise ValueError(
-            f"Could not convert {value} to BacktestEvaluationFocus"
-        )
-
-    def equals(self, other):
-
-        if isinstance(other, Enum):
-            return self.value == other.value
-        else:
-            return BacktestEvaluationFocus.from_string(other) == self
-
-    def get_weights(self):
-        # default / balanced
-        base = {
-            "total_net_gain": 3.0,
-            "win_rate": 3.0,
-            "number_of_trades": 2.0,
-            "sharpe_ratio": 1.0,
-            "sortino_ratio": 1.0,
-            "profit_factor": 1.0,
-            "max_drawdown": -2.0,
-            "max_drawdown_duration": -0.5,
-            "total_net_loss": 0.0,
-            "total_return": 0.0,
-            "avg_return_per_trade": 0.0,
-            "exposure_factor": 0.5,
-            "exposure_ratio": 0.0,
-            "exposure_time": 0.0,
-        }
-
-        if self != BacktestEvaluationFocus.BALANCED:
-
-            # apply presets
-            if self == BacktestEvaluationFocus.PROFIT:
-                base.update({
-                    "total_net_gain": 3.0,
-                    "win_rate": 2.0,
-                    "number_of_trades": 1.0,
-                })
-            elif self == BacktestEvaluationFocus.FREQUENCY:
-                base.update({
-                    "number_of_trades": 3.0,
-                    "win_rate": 2.0,
-                    "total_net_gain": 2.0,
-                })
-            elif self == BacktestEvaluationFocus.RISK_ADJUSTED:
-                base.update({
-                    "sharpe_ratio": 3.0,
-                    "sortino_ratio": 3.0,
-                    "max_drawdown": -3.0,
-                })
-
-        return base