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

investing_algorithm_framework/services/positions/position_service.py

@@ -0,0 +1,210 @@
+import logging
+
+from investing_algorithm_framework.services.repository_service import \
+    RepositoryService
+
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class PositionService(RepositoryService):
+
+    def __init__(self, repository, portfolio_repository):
+        """
+        Initialize the PositionService.
+
+        Args:
+            repository (Repository): The repository to use for storing
+                positions.
+            portfolio_repository (Repository): The repository to use for
+                storing portfolios.
+        """
+        super().__init__(repository)
+        self.portfolio_repository = portfolio_repository
+
+    def update(self, position_id, data):
+        """
+        Function to update a position.
+
+        Args:
+            position_id (str): The id of the position to update.
+            data (dict): The data to update the position with.
+
+        Returns:
+            Position: The updated position.
+        """
+        position = self.get(position_id)
+        logger.info(
+            f"Updating position {position_id} ({position.get_symbol()}) "
+            f"with data: {data}"
+        )
+        return super().update(position_id, data)
+
+    def update_positions_with_created_buy_order(self, order):
+        """
+        Function to update positions with created order.
+        If the order is filled then also the amount of the position
+        is updated.
+
+        Args:
+            order (Order): The order that has been created.
+
+        Returns:
+            None
+        """
+        position = self.get(order.position_id)
+        portfolio = self.portfolio_repository.get(position.portfolio_id)
+        size = order.get_size()
+        filled = order.get_filled()
+
+        logger.info(
+            f"Syncing trading symbol {portfolio.get_trading_symbol()} "
+            "position with created buy "
+            f"order {order.get_id()} with size {size}"
+        )
+        trading_symbol_position = self.find(
+            {
+                "portfolio": portfolio.id,
+                "symbol": portfolio.trading_symbol
+            }
+        )
+        self.update(
+            trading_symbol_position.id,
+            {
+                "amount": trading_symbol_position.get_amount() - size
+            }
+        )
+
+        if filled > 0:
+            logger.info(
+                f"Syncing position {position.get_symbol()} with created buy "
+                f"order {order.get_id()} with filled size {order.get_filled()}"
+            )
+            self.update(
+                position.id,
+                {
+                    "amount": position.get_amount() + order.get_filled(),
+                    "cost": position.get_cost() + size,
+                }
+            )
+
+    def update_positions_with_buy_order_filled(self, order, filled_amount):
+        """
+        Function to update positions with filled order.
+
+        Args:
+            order (Order): The order that has been filled.
+            filled_amount (float): The amount that has been filled.
+
+        Returns:
+            None
+        """
+        # Calculate the filled size
+        filled_size = filled_amount * order.get_price()
+
+        if filled_amount <= 0:
+            return
+
+        logger.info(
+            f"Syncing position with filled buy "
+            f"order {order.get_id()} with filled amount "
+            f"{filled_amount}"
+        )
+
+        # Update the position
+        position = self.get(order.position_id)
+        self.update(
+            position.id,
+            {
+                "amount": position.get_amount() + filled_amount,
+                "cost":
+                    position.get_cost() + filled_size
+            }
+        )
+
+    def update_positions_with_created_sell_order(self, order):
+        """
+        Function to update positions with created order.
+        If the order is filled then also the amount of the position
+        is updated.
+
+        Args:
+            order (Order): The order that has been created.
+
+        Returns:
+            None
+        """
+        position = self.get(order.position_id)
+        portfolio = self.portfolio_repository.get(position.portfolio_id)
+        filled = order.get_filled()
+        filled_size = filled * order.get_price()
+
+        logger.info(
+            f"Syncing position {position.get_symbol()} "
+            "with created sell "
+            f"order {order.get_id()} with amount {order.get_amount()}"
+        )
+        self.update(
+            position.id,
+            {
+                "amount": position.get_amount() - order.get_amount(),
+            }
+        )
+
+        if filled > 0:
+
+            logger.info(
+                f"Syncing trading symbol {portfolio.get_trading_symbol()} "
+                "position with created sell "
+                f"order {order.get_id()} with filled size {filled_size}"
+            )
+            trading_symbol_position = self.find(
+                {
+                    "portfolio": portfolio.id,
+                    "symbol": portfolio.trading_symbol
+                }
+            )
+            self.update(
+                trading_symbol_position.id,
+                {
+                    "amount":
+                        trading_symbol_position.get_amount() + filled_size
+                }
+            )
+
+    def update_positions_with_sell_filled_order(self, order, filled_amount):
+        """
+        Function to update positions with filled order.
+
+        Args:
+            order:
+            filled_amount:
+
+        Returns:
+
+        """
+        position = self.get(order.position_id)
+        portfolio = self.portfolio_repository.get(position.portfolio_id)
+        trading_symbol_position = self.find(
+            {
+                "portfolio": portfolio.id,
+                "symbol": portfolio.trading_symbol
+            }
+        )
+        filled_size = filled_amount * order.get_price()
+
+        logger.info(
+            "Syncing trading symbol position "
+            f"{portfolio.get_trading_symbol()} "
+            f"with filled sell "
+            f"order {order.get_id()} with filled size "
+            f"{filled_size} {portfolio.get_trading_symbol()}"
+        )
+        # Update the trading symbol position
+        self.update(
+            trading_symbol_position.id,
+            {
+                "amount":
+                    trading_symbol_position.get_amount() + filled_size
+            }
+        )

investing_algorithm_framework/services/repository_service.py

@@ -3,8 +3,8 @@ class RepositoryService:
     def __init__(self, repository):
         self.repository = repository
 
-    def create(self, data):
-        return self.repository.create(data)
+    def create(self, data, save=True):
+        return self.repository.create(data, save=save)
 
     def get(self, object_id):
         return self.repository.get(object_id)
@@ -32,3 +32,9 @@ class RepositoryService:
 
     def exists(self, query_params):
         return self.repository.exists(query_params)
+
+    def save(self, object):
+        return self.repository.save(object)
+
+    def save_all(self, objects):
+        return self.repository.save_objects(objects)

investing_algorithm_framework/services/trade_order_evaluator/__init__.py

@@ -0,0 +1,9 @@
+from .trade_order_evaluator import TradeOrderEvaluator
+from .backtest_trade_oder_evaluator import BacktestTradeOrderEvaluator
+from .default_trade_order_evaluator import DefaultTradeOrderEvaluator
+
+__all__ = [
+    "TradeOrderEvaluator",
+    "BacktestTradeOrderEvaluator",
+    "DefaultTradeOrderEvaluator"
+]

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"
+]