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

investing_algorithm_framework/services/metrics/win_rate.py

@@ -0,0 +1,177 @@
+"""
+| Metric             | High Value Means...         | Weakness if Used Alone              |
+| ------------------ | --------------------------- | ----------------------------------- |
+| **Win Rate**       | Many trades are profitable  | Doesn't say how big wins/losses are |
+| **Win/Loss Ratio** | Big wins relative to losses | Doesn’t say how *often* you win     |
+
+
+Example of Non-Overlap:
+Strategy A: 90% win rate, but average win is $1, average loss is $10 → not profitable.
+
+Strategy B: 30% win rate, but average win is $300, average loss is $50 → highly profitable.
+
+| Win Rate          | Win/Loss Ratio | Comment                            |
+| ----------------- | -------------- | ---------------------------------- |
+| High (>60%)       | <1             | Can still be profitable            |
+| Moderate (40-60%) | \~1 or >1      | Ideal sweet spot                   |
+| Low (<40%)        | >1             | Possible if big wins offset losses |
+
+
+Practical Example:
+* Win rate 40% with win/loss ratio 2: Good — you win less often but your
+wins are twice as big.
+* Win rate 60% with win/loss ratio 0.7: Also good — you win often
+but your wins are smaller than losses.
+
+What’s “good”?
+* Typical win/loss ratio ranges from 0.5 to 3 depending on strategy style.
+* Many profitable traders target win/loss ratio between 1.5 and 2.5.
+* Very aggressive strategies might have a lower win rate but
+higher win/loss ratio.
+"""
+
+from typing import List
+from investing_algorithm_framework.domain import TradeStatus, Trade
+
+
+def get_win_rate(trades: List[Trade]) -> float:
+    """
+    Calculate the win rate of the portfolio based on the backtest report.
+
+    Win Rate is defined as the percentage of trades that were profitable.
+    The percentage of trades that are profitable.
+
+    Formula:
+        Win Rate = Number of Profitable Trades / Total Number of Trades
+
+    Example: If 60 out of 100 trades are profitable, the win rate is 60%.
+
+    Args:
+        trades (List[Trade]): List of trades from the backtest report.
+
+    Returns:
+        float: The win rate as a percentage (e.g., o.75 for 75% win rate).
+    """
+    trades = [
+        trade for trade in trades if TradeStatus.CLOSED.equals(trade.status)
+    ]
+    positive_trades = sum(1 for trade in trades if trade.net_gain > 0)
+    total_trades = len(trades)
+
+    if total_trades == 0:
+        return 0.0
+
+    return positive_trades / total_trades
+
+def get_current_win_rate(trades: List[Trade]) -> float:
+    """
+    Calculate the current win rate of the portfolio based on a list
+    of recent trades.
+
+    Current Win Rate is defined as the percentage of the most recent trades
+    that were profitable. This metric also includes trades that are still open.
+
+    Formula:
+        Current Win Rate = Number of Profitable Recent Trades
+            / Total Number of Recent Trades
+
+    Args:
+        trades (List[Trade]): List of recent trades.
+
+    Returns:
+        float: The current win rate as a percentage (e.g., 0.75 for
+            75% win rate).
+    """
+    if not trades:
+        return 0.0
+
+    positive_trades = sum(1 for trade in trades if trade.net_gain_absolute > 0)
+    total_trades = len(trades)
+
+    return positive_trades / total_trades
+
+
+def get_win_loss_ratio(trades: List[Trade]) -> float:
+    """
+    Calculate the win/loss ratio of the portfolio based on the backtest report.
+
+    Win/Loss Ratio is defined as the average profit of winning trades divided by
+    the average loss of losing trades.
+
+    Formula:
+        Win/Loss Ratio = Average Profit of Winning Trades
+            / Average Loss of Losing Trades
+
+    Example: If the average profit of winning trades is $200 and the
+            average loss of losing trades is $100, the win/loss ratio is 2.0.
+
+    Args:
+        trades (List[Trade]): List of trades from the backtest report.
+
+    Returns:
+        float: The win/loss ratio.
+    """
+    trades = [
+        trade for trade in trades if TradeStatus.CLOSED.equals(trade.status)
+    ]
+
+    if not trades:
+        return 0.0
+
+    # Separate winning and losing trades
+    winning_trades = [t for t in trades if t.net_gain > 0]
+    losing_trades = [t for t in trades if t.net_gain < 0]
+
+    if not winning_trades or not losing_trades:
+        return 0.0
+
+    # Compute averages
+    avg_win = sum(t.net_gain for t in winning_trades) / len(winning_trades)
+    avg_loss = abs(
+        sum(t.net_gain for t in losing_trades) / len(losing_trades))
+
+    # Avoid division by zero
+    if avg_loss == 0:
+        return float('inf')
+
+    return avg_win / avg_loss
+
+
+def get_current_win_loss_ratio(trades: List[Trade]) -> float:
+    """
+    Calculate the current win/loss ratio of the portfolio based on a list
+    of recent trades.
+
+    Current Win/Loss Ratio is defined as the average profit of winning
+    recent trades divided by the average loss of losing recent trades.
+    This metric also includes trades that are still open.
+
+    Formula:
+        Current Win/Loss Ratio = Average Profit of Winning Recent Trades
+            / Average Loss of Losing Recent Trades
+    Args:
+        trades (List[Trade]): List of recent trades.
+
+    Returns:
+        float: The current win/loss ratio.
+    """
+    if not trades:
+        return 0.0
+
+    # Separate winning and losing trades
+    winning_trades = [t for t in trades if t.net_gain_absolute > 0]
+    losing_trades = [t for t in trades if t.net_gain_absolute < 0]
+
+    if not winning_trades or not losing_trades:
+        return 0.0
+
+    # Compute averages
+    avg_win = sum(t.net_gain_absolute for t in winning_trades) / len(winning_trades)
+    avg_loss = abs(
+        sum(t.net_gain_absolute for t in losing_trades) / len(losing_trades))
+
+    # Avoid division by zero
+    if avg_loss == 0:
+        return float('inf')
+
+    return avg_win / avg_loss

investing_algorithm_framework/services/order_service/__init__.py

@@ -1,7 +1,9 @@
 from .order_backtest_service import OrderBacktestService
 from .order_service import OrderService
+from .order_executor_lookup import OrderExecutorLookup
 
 __all__ = [
     "OrderService",
-    "OrderBacktestService"
+    "OrderBacktestService",
+    "OrderExecutorLookup",
 ]

investing_algorithm_framework/services/order_service/order_backtest_service.py

@@ -2,11 +2,8 @@ import logging
 
 import polars as pl
 
-from investing_algorithm_framework.domain import BACKTESTING_INDEX_DATETIME, \
-    OrderStatus, BACKTESTING_PENDING_ORDER_CHECK_INTERVAL, \
-    OperationalException, OrderSide, Order
-from investing_algorithm_framework.services.market_data_source_service \
-    import BacktestMarketDataSourceService
+from investing_algorithm_framework.domain import INDEX_DATETIME, \
+    OrderStatus, OrderSide, Order, DataType
 from .order_service import OrderService
 
 logger = logging.getLogger("investing_algorithm_framework")
@@ -17,90 +14,86 @@ class OrderBacktestService(OrderService):
     def __init__(
         self,
         order_repository,
-        position_repository,
+        trade_service,
+        position_service,
         portfolio_repository,
         portfolio_configuration_service,
         portfolio_snapshot_service,
         configuration_service,
-        market_data_source_service: BacktestMarketDataSourceService,
     ):
-        super(OrderService, self).__init__(order_repository)
-        self.order_repository = order_repository
-        self.position_repository = position_repository
-        self.portfolio_repository = portfolio_repository
-        self.portfolio_configuration_service = portfolio_configuration_service
-        self.portfolio_snapshot_service = portfolio_snapshot_service
+        super().__init__(
+            configuration_service=configuration_service,
+            order_repository=order_repository,
+            position_service=position_service,
+            portfolio_repository=portfolio_repository,
+            portfolio_configuration_service=portfolio_configuration_service,
+            portfolio_snapshot_service=portfolio_snapshot_service,
+            trade_service=trade_service,
+        )
         self.configuration_service = configuration_service
-        self._market_data_source_service: BacktestMarketDataSourceService = \
-            market_data_source_service
 
     def create(self, data, execute=True, validate=True, sync=True) -> Order:
+        """
+        Override the create method to set the created_at and
+        updated_at attributes to the current backtest time.
+
+        Args:
+            data (dict): Dictionary containing the order data
+            execute (bool): Flag to execute the order
+            validate (bool): Flag to validate the order
+            sync (bool): Flag to sync the order
+
+        Returns:
+            Order: Created order object
+        """
+        config = self.configuration_service.get_config()
         # Make sure the created_at is set to the current backtest time
-        data["created_at"] = self.configuration_service\
-            .config[BACKTESTING_INDEX_DATETIME]
+        data["created_at"] = config[INDEX_DATETIME]
+        data["updated_at"] = config[INDEX_DATETIME]
         # Call super to have standard behavior
         return super(OrderBacktestService, self)\
             .create(data, execute, validate, sync)
 
-    def execute_order(self, order_id, portfolio):
-        order = self.get(order_id)
-        order = self.update(
-            order_id,
-            {
-                "status": OrderStatus.OPEN.value,
-                "remaining": order.remaining,
-                "updated_at": self.configuration_service
-                .config[BACKTESTING_INDEX_DATETIME]
-            }
-        )
+    def execute_order(self, order, portfolio):
+        order.status = OrderStatus.OPEN.value
+        order.remaining = order.get_amount()
+        order.filled = 0
+        order.updated_at = self.configuration_service.config[
+            INDEX_DATETIME
+        ]
         return order
 
-    def check_pending_orders(self):
+    def check_pending_orders(self, market_data):
+        """
+        Function to check if any pending orders have executed. It querys the
+        open orders and checks if the order has executed based on the OHLCV
+        data. If the order has executed, the order status is set to CLOSED
+        and the filled amount is set to the order amount.
+
+        Args:
+            market_data (dict): Dictionary containing the market data
+
+        Returns:
+            None
+        """
         pending_orders = self.get_all({"status": OrderStatus.OPEN.value})
-        logger.info(f"Checking {len(pending_orders)} open orders")
-        config = self.configuration_service.get_config()
+        meta_data = market_data["metadata"]
 
         for order in pending_orders:
-            symbol = f"{order.target_symbol.upper()}" \
-                     f"/{order.trading_symbol.upper()}"
-            position = self.position_repository.get(order.position_id)
-            portfolio = self.portfolio_repository.get(position.portfolio_id)
-            timeframe = None
-
-            if BACKTESTING_PENDING_ORDER_CHECK_INTERVAL in \
-                    self.configuration_service.config:
-                timeframe = self.configuration_service\
-                    .config[BACKTESTING_PENDING_ORDER_CHECK_INTERVAL]
-
-            if not self._market_data_source_service\
-                    .is_ohlcv_data_source_present(
-                        symbol=symbol,
-                        market=portfolio.market,
-                        time_frame=timeframe
-                    ):
-                raise OperationalException(
-                    f"OHLCV data source not found for {symbol} "
-                    f"and market {portfolio.market} for order check "
-                    f"time frame "
-                    f"{config[BACKTESTING_PENDING_ORDER_CHECK_INTERVAL]}. "
-                    f"Cannot check pending orders for symbol {symbol} "
-                    f"with market {portfolio.market}. Please add a ohlcv data"
-                    f"source for {symbol} and market {portfolio.market} with "
-                    f"time frame "
-                    f"{config[BACKTESTING_PENDING_ORDER_CHECK_INTERVAL]} "
-                )
+            ohlcv_meta_data = meta_data[DataType.OHLCV]
 
-            df = self._market_data_source_service.get_ohlcv(
-                symbol=symbol,
-                market=portfolio.market,
-                time_frame=timeframe,
-                to_timestamp=self.configuration_service.config.get(
-                    BACKTESTING_INDEX_DATETIME
-                ),
-                from_timestamp=order.get_created_at(),
+            if order.get_symbol() not in ohlcv_meta_data:
+                continue
+
+            timeframes = ohlcv_meta_data[order.get_symbol()].keys()
+            sorted_timeframes = sorted(timeframes)
+            most_granular_interval = sorted_timeframes[0]
+            identifier = (
+                ohlcv_meta_data[order.get_symbol()][most_granular_interval]
             )
+            data = market_data[identifier]
 
-            if self.has_executed(order, df):
+            if self.has_executed(order, data):
                 self.update(
                     order.id,
                     {
@@ -108,10 +101,9 @@ class OrderBacktestService(OrderService):
                         "filled": order.get_amount(),
                         "remaining": 0,
                         "updated_at": self.configuration_service
-                        .config[BACKTESTING_INDEX_DATETIME]
+                        .config[INDEX_DATETIME]
                     }
                 )
-                break
 
     def cancel_order(self, order):
         self.check_pending_orders()
@@ -126,11 +118,11 @@ class OrderBacktestService(OrderService):
                         "status": OrderStatus.CANCELED.value,
                         "remaining": 0,
                         "updated_at": self.configuration_service
-                        .config[BACKTESTING_INDEX_DATETIME]
+                        .config[INDEX_DATETIME]
                     }
                 )
 
-    def has_executed(self, order, ohlcv_data_frame):
+    def has_executed(self, order, ohlcv_data_frame: pl.DataFrame):
         """
         Check if the order has executed based on the OHLCV data.
 
@@ -138,7 +130,7 @@ class OrderBacktestService(OrderService):
         order price. Example: If the order price is 1000 and the low price
         drops below or equals 1000, the order is executed. This simulates the
         situation where a buyer is willing to pay a higher price than the
-        the lowest price in the ohlcv data.
+        lowest price in the ohlcv data.
 
         A sell order is executed if the high price goes above or equals the
         order price. Example: If the order price is 1000 and the high price
@@ -146,27 +138,22 @@ class OrderBacktestService(OrderService):
         situation where a seller is willing to accept a higher price for its
         sell order.
 
-        :param order: Order object
-        :param ohlcv_data_frame: OHLCV data frame
-        :return: True if the order has executed, False otherwise
+        Args:
+            order: Order object
+            ohlcv_data_frame: OHLCV data frame
+            True if the order has executed, False otherwise
+
+        Returns:
+            bool: True if the order has executed, False otherwise
         """
 
         # Extract attributes from the order object
         created_at = order.get_created_at()
         order_side = order.get_order_side()
         order_price = order.get_price()
-        column_type = ohlcv_data_frame['Datetime'].dtype
-
-        if isinstance(column_type, pl.Datetime):
-            ohlcv_data_after_order = ohlcv_data_frame.filter(
-                pl.col('Datetime') >= created_at
-            )
-        else:
-            ohlcv_data_after_order = ohlcv_data_frame.filter(
-                pl.col('Datetime') >= created_at.strftime(
-                    self.configuration_service.config["DATETIME_FORMAT"]
-                )
-            )
+        ohlcv_data_after_order = ohlcv_data_frame.filter(
+            pl.col('Datetime') >= created_at
+        )
 
         # Check if the order execution conditions are met
         if OrderSide.BUY.equals(order_side):
@@ -185,7 +172,7 @@ class OrderBacktestService(OrderService):
 
         if created_at is None:
             created_at = self.configuration_service \
-                .config[BACKTESTING_INDEX_DATETIME]
+                .config[INDEX_DATETIME]
 
         super(OrderBacktestService, self)\
             .create_snapshot(portfolio_id, created_at=created_at)

investing_algorithm_framework/services/order_service/order_executor_lookup.py

@@ -0,0 +1,110 @@
+from collections import defaultdict
+from typing import List
+
+from investing_algorithm_framework.domain import OrderExecutor, \
+    ImproperlyConfigured
+
+
+class OrderExecutorLookup:
+    """
+    Efficient lookup for order executors based on market in O(1) time.
+
+    Attributes:
+        order_executors (List[OrderExecutor]): List of order executors
+        order_executor_lookup (dict): Dictionary to store the lookup
+            for order executors based on market.
+    """
+    def __init__(self, order_executors=[]):
+        self.order_executors = order_executors
+
+        # These will be our lookup tables
+        self.order_executor_lookup = defaultdict()
+
+    def add_order_executor(self, order_executor: OrderExecutor):
+        """
+        Add an order executor to the lookup.
+
+        Args:
+            order_executor (OrderExecutor): The order executor to be added.
+
+        Returns:
+            None
+        """
+        self.order_executors.append(order_executor)
+
+    def register_order_executor_for_market(self, market) -> None:
+        """
+        Register an order executor for a specific market.
+        This method will create a lookup table for efficient access to
+        order executors based on market. It will use the
+        order executors that are currently registered in the
+        order_executors list. The lookup table will be a dictionary
+        where the key is the market and the value is the portfolio provider.
+
+        This method will also check if the portfolio provider supports
+        the market. If no portfolio provider is found for the market,
+        it will raise an ImproperlyConfigured exception.
+
+        If multiple order executors are found for the market,
+        it will sort them by priority and pick the best one.
+
+        Args:
+            market:
+
+        Returns:
+            None
+        """
+        matches = []
+
+        for order_executor in self.order_executors:
+
+            if order_executor.supports_market(market):
+                matches.append(order_executor)
+
+        if len(matches) == 0:
+            raise ImproperlyConfigured(
+                f"No portfolio provider found for market "
+                f"{market}. Cannot configure portfolio."
+                f" Please make sure that you have registered a portfolio "
+                f"provider for the market you are trying to use"
+            )
+
+        # Sort by priority and pick the best one
+        best_provider = sorted(matches, key=lambda x: x.priority)[0]
+        self.order_executor_lookup[market] = best_provider
+
+    def get_order_executor(self, market: str):
+        """
+        Get the order executor for a specific market.
+        This method will return the order executor for the market
+        that was registered in the lookup table. If no order executor
+        was found for the market, it will return None.
+
+        Args:
+            market:
+
+        Returns:
+            OrderExecutor: The order executor for the market.
+        """
+        return self.order_executor_lookup.get(market, None)
+
+    def get_all(self) -> List[OrderExecutor]:
+        """
+        Get all order executors.
+        This method will return all order executors that are currently
+        registered in the order_executors list.
+
+        Returns:
+            List[OrderExecutor]: A list of all order executors.
+        """
+        return self.order_executors
+
+    def reset(self):
+        """
+        Function to reset the order executor lookup table
+
+        Returns:
+            None
+        """
+        self.order_executor_lookup = defaultdict()
+        self.order_executors = []