investing-algorithm-framework 7.19.14__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

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

investing_algorithm_framework/services/order_service/order_backtest_service.py

@@ -0,0 +1,178 @@
+import logging
+
+import polars as pl
+
+from investing_algorithm_framework.domain import INDEX_DATETIME, \
+    OrderStatus, OrderSide, Order, DataType
+from .order_service import OrderService
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class OrderBacktestService(OrderService):
+
+    def __init__(
+        self,
+        order_repository,
+        trade_service,
+        position_service,
+        portfolio_repository,
+        portfolio_configuration_service,
+        portfolio_snapshot_service,
+        configuration_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
+
+    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"] = 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, 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, 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})
+        meta_data = market_data["metadata"]
+
+        for order in pending_orders:
+            ohlcv_meta_data = meta_data[DataType.OHLCV]
+
+            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, data):
+                self.update(
+                    order.id,
+                    {
+                        "status": OrderStatus.CLOSED.value,
+                        "filled": order.get_amount(),
+                        "remaining": 0,
+                        "updated_at": self.configuration_service
+                        .config[INDEX_DATETIME]
+                    }
+                )
+
+    def cancel_order(self, order):
+        self.check_pending_orders()
+        order = self.order_repository.get(order.id)
+
+        if order is not None:
+
+            if OrderStatus.OPEN.equals(order.status):
+                self.update(
+                    order.id,
+                    {
+                        "status": OrderStatus.CANCELED.value,
+                        "remaining": 0,
+                        "updated_at": self.configuration_service
+                        .config[INDEX_DATETIME]
+                    }
+                )
+
+    def has_executed(self, order, ohlcv_data_frame: pl.DataFrame):
+        """
+        Check if the order has executed based on the OHLCV data.
+
+        A buy order is executed if the low price drops below or equals the
+        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
+        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
+        goes above or equals 1000, the order is executed. This simulates the
+        situation where a seller is willing to accept a higher price for its
+        sell order.
+
+        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()
+        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):
+            # Check if the low price drops below or equals the order price
+            if (ohlcv_data_after_order['Low'] <= order_price).any():
+                return True
+        elif OrderSide.SELL.equals(order_side):
+            # Check if the high price goes above or equals the order price
+            if (ohlcv_data_after_order['High'] >= order_price).any():
+                return True
+
+        # If conditions are not met, return False
+        return False
+
+    def create_snapshot(self, portfolio_id, created_at=None):
+
+        if created_at is None:
+            created_at = self.configuration_service \
+                .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 = []