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

investing_algorithm_framework/services/trade_order_evaluator/backtest_trade_oder_evaluator.py

@@ -0,0 +1,113 @@
+from typing import List, Dict
+
+import polars as pl
+
+from investing_algorithm_framework.domain import OrderSide, OrderStatus, \
+    Trade, Order
+from .trade_order_evaluator import TradeOrderEvaluator
+
+
+class BacktestTradeOrderEvaluator(TradeOrderEvaluator):
+
+    def evaluate(
+        self,
+        open_trades: List[Trade],
+        open_orders: List[Order],
+        ohlcv_data: Dict[str, pl.DataFrame]
+    ):
+        """
+        Evaluate trades and orders based on OHLCV data.
+
+        Args:
+            open_orders (List[Order]): List of open Order objects.
+            open_trades (List[Trade]): List of open Trade objects.
+            ohlcv_data (dict[str, pl.DataFrame]): Mapping of
+                symbol -> OHLCV Polars DataFrame.
+
+        Returns:
+            List[dict]: Updated trades with latest prices and execution status.
+        """
+        # First check pending orders
+        for open_order in open_orders:
+            data = ohlcv_data.get(open_order.symbol)
+            self._check_has_executed(open_order, data)
+
+        if len(open_trades) > 0:
+            for open_trade in open_trades:
+                data = ohlcv_data[open_trade.symbol]
+
+                if data is None or data.is_empty():
+                    continue
+
+                # Get last row of data
+                last_row = data.tail(1)
+                update_data = {
+                    "last_reported_price": last_row["Close"][0],
+                    "last_reported_price_datetime": last_row["Datetime"][0],
+                    "updated_at": last_row["Datetime"][0]
+                }
+                open_trade.update(update_data)
+
+            self.trade_service.save_all(open_trades)
+            self._check_take_profits()
+            self._check_stop_losses()
+
+    def _check_has_executed(self, order, ohlcv_df):
+        """
+        Check if the order has been executed based on OHLCV data.
+
+        BUY ORDER filled Rules:
+        - Only uses prices after the last update_at of the order.
+        - If the lowest low price of the series is below or equal
+            to the order price, e.g. if you buy asset at price 100
+            and the low price of the series is 99, then the order is filled.
+
+        SELL ORDER filled Rules:
+        - Only uses prices after the last update_at of the order.
+        - If the highest high price of the series is above or equal
+            to the order price, e.g. if you sell asset at price 100
+            and the high price of the series is 101, then the order is filled.
+
+        Args:
+            order (Order): Order.
+            ohlcv_df (pl.DataFrame): OHLCV DataFrame for the symbol.
+
+        Returns:
+            None
+        """
+
+        if ohlcv_df.is_empty():
+            return
+
+        # Extract attributes from the order object
+        updated_at = order.updated_at
+        order_side = order.order_side
+        order_price = order.price
+        ohlcv_data_after_order = ohlcv_df.filter(
+            pl.col('Datetime') >= updated_at
+        )
+
+        if ohlcv_data_after_order.is_empty():
+            return
+
+        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():
+                self.order_service.update(
+                    order.id, {
+                        'status': OrderStatus.CLOSED.value,
+                        'remaining': 0,
+                        'filled': order.amount
+                    }
+                )
+
+        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():
+                self.order_service.update(
+                    order.id, {
+                        'status': OrderStatus.CLOSED.value,
+                        'remaining': 0,
+                        'filled': order.amount
+                    }
+                )

investing_algorithm_framework/services/trade_order_evaluator/default_trade_order_evaluator.py

@@ -0,0 +1,51 @@
+from typing import List, Dict
+
+import polars as pl
+
+from investing_algorithm_framework.domain import Trade, Order, INDEX_DATETIME
+from .trade_order_evaluator import TradeOrderEvaluator
+
+
+class DefaultTradeOrderEvaluator(TradeOrderEvaluator):
+
+    def evaluate(
+        self,
+        open_trades: List[Trade],
+        open_orders: List[Order],
+        ohlcv_data: Dict[str, pl.DataFrame]
+    ):
+        """
+        Evaluate trades and orders based on OHLCV data.
+
+        Args:
+            open_orders (List[Order]): List of open Order objects.
+            open_trades (List[Trade]): List of open Trade objects.
+            ohlcv_data (dict[str, pl.DataFrame]): Mapping of
+                symbol -> OHLCV Polars DataFrame.
+
+        Returns:
+            List[dict]: Updated trades with latest prices and execution status.
+        """
+        self.order_service.check_pending_orders()
+        current_date = self.configuration_service.config[INDEX_DATETIME]
+
+        if len(open_trades) > 0:
+            for open_trade in open_trades:
+                data = ohlcv_data[open_trade.symbol]
+
+                if data is None or data.is_empty():
+                    continue
+
+                # Get last row of data
+                last_row = data.tail(1)
+                last_row_date = last_row["Datetime"][0]
+                update_data = {
+                    "last_reported_price": last_row["Close"][0],
+                    "last_reported_price_datetime": last_row_date,
+                    "updated_at": current_date
+                }
+                open_trade.update(update_data)
+
+            self.trade_service.save_all(open_trades)
+            self._check_take_profits()
+            self._check_stop_losses()

investing_algorithm_framework/services/trade_order_evaluator/trade_order_evaluator.py

@@ -0,0 +1,80 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict
+import polars as pl
+from investing_algorithm_framework.domain import Trade, Order, INDEX_DATETIME
+
+
+class TradeOrderEvaluator(ABC):
+
+    def __init__(
+        self,
+        trade_service,
+        trade_stop_loss_service,
+        trade_take_profit_service,
+        order_service,
+        configuration_service=None
+    ):
+        self.trade_service = trade_service
+        self.trade_stop_loss_service = trade_stop_loss_service
+        self.trade_take_profit_service = trade_take_profit_service
+        self.order_service = order_service
+        self.configuration_service = configuration_service
+
+    @abstractmethod
+    def evaluate(
+        self,
+        open_trades: List[Trade],
+        open_orders: List[Order],
+        ohlcv_data: Dict[str, pl.DataFrame]
+    ):
+        """
+        Evaluate trades and orders based on OHLCV data. This
+        function is responsible for updating open orders and open trades.
+        The evaluation process includes checking if orders have been executed
+        and updating the trades with the latest prices and execution status.
+        Additionally, it may trigger stop-loss and take-profit orders
+        based on the current market conditions.
+
+        Args:
+            open_trades (List[Trade]): List of open Trade objects.
+            open_orders (List[Order]): List of open Order objects.
+            ohlcv_data (dict[str, pl.DataFrame]): Mapping of
+                symbol -> OHLCV Polars DataFrame.
+
+        Returns:
+            List[dict]: Updated trades with latest prices and execution status.
+        """
+        pass
+
+    def _check_take_profits(self):
+        current_date = self.configuration_service.config[INDEX_DATETIME]
+        take_profits_orders_data = self.trade_service \
+            .get_triggered_take_profit_orders()
+
+        for take_profit_order in take_profits_orders_data:
+            take_profits = take_profit_order["take_profits"]
+            self.order_service.create(take_profit_order)
+            self.trade_take_profit_service.mark_triggered(
+                [
+                    take_profit.get("take_profit_id")
+                    for take_profit in take_profits
+                ],
+                trigger_date=current_date
+            )
+
+    def _check_stop_losses(self):
+        current_date = self.configuration_service.config[INDEX_DATETIME]
+        stop_losses_orders_data = self.trade_service \
+            .get_triggered_stop_loss_orders()
+
+        for stop_loss_order in stop_losses_orders_data:
+            stop_losses = stop_loss_order["stop_losses"]
+
+            self.order_service.create(stop_loss_order)
+            self.trade_stop_loss_service.mark_triggered(
+                [
+                    stop_loss.get("stop_loss_id") for stop_loss in
+                    stop_losses
+                ],
+                trigger_date=current_date
+            )

investing_algorithm_framework/services/trade_service/__init__.py

@@ -1,3 +1,9 @@
 from .trade_service import TradeService
+from .trade_stop_loss_service import TradeStopLossService
+from .trade_take_profit_service import TradeTakeProfitService
 
-__all__ = ["TradeService"]
+__all__ = [
+    "TradeService",
+    "TradeStopLossService",
+    "TradeTakeProfitService"
+]

investing_algorithm_framework/services/trade_service/trade_service.py

@@ -4,9 +4,9 @@ from queue import PriorityQueue
 from typing import Union
 
 from investing_algorithm_framework.domain import OrderStatus, TradeStatus, \
-    Trade, OperationalException, TradeRiskType, OrderType, \
-    OrderSide, MarketDataType, Environment, ENVIRONMENT, PeekableQueue, \
-    BACKTESTING_INDEX_DATETIME, random_number, random_string
+    Trade, OperationalException, OrderType, TradeTakeProfit, \
+    TradeStopLoss, OrderSide, Environment, ENVIRONMENT, PeekableQueue, \
+    DataType, INDEX_DATETIME, random_number, random_string
 from investing_algorithm_framework.services.repository_service import \
     RepositoryService
 
@@ -29,14 +29,12 @@ class TradeService(RepositoryService):
         trade_take_profit_repository,
         position_repository,
         portfolio_repository,
-        market_data_source_service,
         configuration_service,
         order_metadata_repository
     ):
         super(TradeService, self).__init__(trade_repository)
         self.order_repository = order_repository
         self.portfolio_repository = portfolio_repository
-        self.market_data_source_service = market_data_source_service
         self.position_repository = position_repository
         self.configuration_service = configuration_service
         self.trade_stop_loss_repository = trade_stop_loss_repository
@@ -249,7 +247,7 @@ class TradeService(RepositoryService):
 
                 if Environment.BACKTEST.equals(environment):
                     last_reported_price_date = \
-                        config[BACKTESTING_INDEX_DATETIME]
+                        config[INDEX_DATETIME]
                 else:
                     last_reported_price_date = \
                         datetime.now(tz=timezone.utc)
@@ -383,12 +381,21 @@ class TradeService(RepositoryService):
         Args:
             sell_order: Order object representing the sell order that has
                 been created
+            trades: List of Trade objects representing the trades that
+                are associated with the sell order. Default is None.
+            stop_losses: List of StopLoss objects representing the stop
+                losses that are associated with the sell order. Default
+                is None.
+            take_profits: List of TakeProfit objects representing the take
+                profits that are associated with the sell order. Default
+                is None.
 
         Returns:
             None
         """
         sell_order_id = sell_order.id
         sell_price = sell_order.price
+        sell_amount = sell_order.amount
 
         if (trades is None or len(trades) == 0) \
                 and (stop_losses is None or len(stop_losses) == 0) \
@@ -433,10 +440,11 @@ class TradeService(RepositoryService):
         position.cost -= cost
         self.position_repository.save(position)
 
-        # Update the net gain and net size of the portfolio
+        # Update the net gain, net size of the portfolio
         portfolio = self.portfolio_repository.get(position.portfolio_id)
         portfolio.total_net_gain += net_gain
         portfolio.net_size += net_gain
+        portfolio.total_revenue += sell_price * sell_amount
         self.portfolio_repository.save(portfolio)
 
     def update_trade_with_removed_sell_order(
@@ -599,7 +607,14 @@ class TradeService(RepositoryService):
         function will update all the metadata objects that where
         created by the sell order.
 
+        Args:
+            filled_difference: float representing the difference between
+                the filled amount of the sell order and the filled amount
+                of the trade
+            sell_order: Order object representing the sell order
 
+        Returns:
+            Trade object
         """
         # Update all metadata objects
         metadata_objects = self.order_metadata_repository.get_all({
@@ -702,7 +717,7 @@ class TradeService(RepositoryService):
         meta_data = market_data["metadata"]
 
         for open_trade in open_trades:
-            ohlcv_meta_data = meta_data[MarketDataType.OHLCV]
+            ohlcv_meta_data = meta_data[DataType.OHLCV]
 
             if open_trade.symbol not in ohlcv_meta_data:
                 continue
@@ -728,9 +743,10 @@ class TradeService(RepositoryService):
         self,
         trade,
         percentage: float,
-        trade_risk_type: TradeRiskType = TradeRiskType.FIXED,
+        trailing: bool = False,
         sell_percentage: float = 100,
-    ):
+        created_at: datetime = None
+    ) -> TradeStopLoss:
         """
         Function to add a stop loss to a trade.
 
@@ -751,10 +767,12 @@ class TradeService(RepositoryService):
             trade: Trade object representing the trade
             percentage: float representing the percentage of the open price
                 that the stop loss should be set at
-            trade_risk_type (TradeRiskType): The type of the stop loss, fixed
-                or trailing
+            trailing (bool): representing whether the stop loss is a
+                trailing stop loss or not. Default is False.
             sell_percentage: float representing the percentage of the trade
-                that should be sold if the stop loss is triggered
+                that should be sold if the stop loss is triggered.
+            created_at: datetime representing the creation date of the
+                stop loss. If None, the current datetime will be used.
 
         Returns:
             None
@@ -775,12 +793,14 @@ class TradeService(RepositoryService):
 
         creation_data = {
             "trade_id": trade.id,
-            "trade_risk_type": TradeRiskType.from_value(trade_risk_type).value,
+            "trailing": trailing,
             "percentage": percentage,
             "open_price": trade.open_price,
             "total_amount_trade": trade.amount,
             "sell_percentage": sell_percentage,
-            "active": True
+            "active": True,
+            "created_at": created_at if created_at is not None
+            else datetime.now(tz=timezone.utc)
         }
         return self.trade_stop_loss_repository.create(creation_data)
 
@@ -788,9 +808,10 @@ class TradeService(RepositoryService):
         self,
         trade,
         percentage: float,
-        trade_risk_type: TradeRiskType = TradeRiskType.FIXED,
+        trailing: bool = False,
         sell_percentage: float = 100,
-    ) -> None:
+        created_at: datetime = None
+    ) -> TradeTakeProfit:
         """
         Function to add a take profit to a trade. This function will add a
         take profit to the specified trade. If the take profit is triggered,
@@ -811,12 +832,16 @@ class TradeService(RepositoryService):
 
         Args:
             trade: Trade object representing the trade
-            percentage: float representing the percentage of the open price
-                that the stop loss should be set at
-            trade_risk_type (TradeRiskType): The type of the stop loss, fixed
-                or trailing
-            sell_percentage: float representing the percentage of the trade
+            percentage (float): representing the percentage of the open price
+                that the stop loss should be set at. This must be a positive
+                number, e.g. 5 for 5%, or 10 for 10%.
+            trailing (bool): representing whether the take profit is a
+                trailing take profit or not. Default is False.
+            sell_percentage (float): representing the percentage of the trade
                 that should be sold if the stop loss is triggered
+            created_at (datetime): datetime representing the creation
+                date of the take profit. If None, the current datetime
+                will be used.
 
         Returns:
             None
@@ -834,15 +859,16 @@ class TradeService(RepositoryService):
                 "Combined sell percentages of stop losses belonging "
                 "to trade exceeds 100."
             )
-
         creation_data = {
             "trade_id": trade.id,
-            "trade_risk_type": TradeRiskType.from_value(trade_risk_type).value,
+            "trailing": trailing,
             "percentage": percentage,
             "open_price": trade.open_price,
             "total_amount_trade": trade.amount,
             "sell_percentage": sell_percentage,
-            "active": True
+            "active": True,
+            "created_at": created_at if created_at is not None
+            else datetime.now(tz=timezone.utc)
         }
         return self.trade_take_profit_repository.create(creation_data)
 
@@ -854,7 +880,6 @@ class TradeService(RepositoryService):
         Returns:
             List of trade ids
         """
-        triggered_stop_losses = {}
         sell_orders_data = []
         query = {"status": TradeStatus.OPEN.value}
         open_trades = self.get_all(query)
@@ -954,9 +979,7 @@ class TradeService(RepositoryService):
 
         Returns:
             List of trade objects. A trade object is a dictionary
-
         """
-        triggered_take_profits = {}
         sell_orders_data = []
         query = {"status": TradeStatus.OPEN.value}
         open_trades = self.get_all(query)
@@ -974,7 +997,6 @@ class TradeService(RepositoryService):
                 continue
 
             for take_profit in open_trade.take_profits:
-
                 if (
                     take_profit.active and
                     take_profit.has_triggered(open_trade.last_reported_price)

investing_algorithm_framework/services/trade_service/trade_stop_loss_service.py

@@ -0,0 +1,39 @@
+import logging
+from datetime import datetime
+
+from investing_algorithm_framework.services.repository_service import \
+    RepositoryService
+
+logger = logging.getLogger(__name__)
+
+
+class TradeStopLossService(RepositoryService):
+
+    def mark_triggered(
+        self,
+        stop_loss_ids,
+        trigger_date: datetime
+    ) -> None:
+        """
+        Mark stop losses as triggered.
+
+        Args:
+            stop_loss_ids (List[str]): List of stop loss IDs to
+                mark as triggered.
+            trigger_date (datetime): The date when the stop loss
+                was triggered.
+
+        Returns:
+            None
+        """
+        update_data = {
+            "triggered": True,
+            "triggered_at": trigger_date,
+            "updated_at":  trigger_date
+        }
+
+        for id in stop_loss_ids:
+            try:
+                self.update(id, update_data)
+            except Exception as e:
+                logger.error(f"Error marking stop loss {id} as triggered: {e}")

investing_algorithm_framework/services/trade_service/trade_take_profit_service.py

@@ -0,0 +1,41 @@
+import logging
+from datetime import datetime
+
+from investing_algorithm_framework.services.repository_service import \
+    RepositoryService
+
+logger = logging.getLogger(__name__)
+
+
+class TradeTakeProfitService(RepositoryService):
+
+    def mark_triggered(
+        self,
+        take_profit_ids,
+        trigger_date: datetime
+    ) -> None:
+        """
+        Mark take profits as triggered.
+
+        Args:
+            take_profit_ids (List[str]): List of take profit IDs to
+                mark as triggered.
+            trigger_date (datetime): The date and time when the
+                take profits were triggered.
+
+        Returns:
+            None
+        """
+        update_data = {
+            "triggered": True,
+            "triggered_at": trigger_date,
+            "updated_at": trigger_date
+        }
+
+        for id in take_profit_ids:
+            try:
+                self.update(id, update_data)
+            except Exception as e:
+                logger.error(
+                    f"Error marking take profit {id} as triggered: {e}"
+                )