investing-algorithm-framework 7.19.14__py3-none-any.whl

investing_algorithm_framework/services/portfolios/portfolio_sync_service.py

@@ -0,0 +1,182 @@
+import logging
+
+from investing_algorithm_framework.domain import OperationalException, \
+    AbstractPortfolioSyncService, ENVIRONMENT, Environment
+from investing_algorithm_framework.services.trade_service import TradeService
+
+logger = logging.getLogger(__name__)
+
+
+class PortfolioSyncService(AbstractPortfolioSyncService):
+    """
+    Service to sync the portfolio with the exchange.
+
+    This service will sync the portfolio with the exchange
+
+    Attributes:
+        trade_service: TradeService object
+        configuration_service: ConfigurationService object
+        order_service: OrderService object
+        position_repository: PositionRepository object
+        portfolio_repository: PortfolioRepository object
+        market_credential_service: MarketCredentialService object
+        portfolio_configuration_service: PortfolioConfigurationService object
+        portfolio_provider_lookup: PortfolioProviderLookup object
+    """
+
+    def __init__(
+        self,
+        trade_service: TradeService,
+        configuration_service,
+        order_service,
+        position_repository,
+        portfolio_repository,
+        portfolio_configuration_service,
+        market_credential_service,
+        portfolio_provider_lookup
+    ):
+        self.trade_service = trade_service
+        self.configuration_service = configuration_service
+        self.order_service = order_service
+        self.position_repository = position_repository
+        self.portfolio_repository = portfolio_repository
+        self.market_credential_service = market_credential_service
+        self.portfolio_configuration_service = portfolio_configuration_service
+        self.portfolio_provider_lookup = portfolio_provider_lookup
+
+    def sync_unallocated(self, portfolio):
+        """
+        Method to sync the unallocated balance of the portfolio with the
+        available balance on the exchange. This method will retrieve the
+        available balance of the portfolio from the exchange and update the
+        unallocated balance of the portfolio accordingly.
+
+        If the portfolio already exists (exists in the database),
+        then a check is done if the exchange has the available
+        balance of the portfolio unallocated balance. If the exchange
+        does not have the available balance of the portfolio,
+        an OperationalException will be raised.
+
+        If the portfolio does not exist, the portfolio will be created with
+        the unallocated balance of the portfolio set to the available
+        balance on the exchange. If also a initial balance is set in
+        the portfolio configuration, the unallocated balance will be set
+        to the initial balance (given the balance is available on
+        the exchange). If the initial balance is not set, the
+        unallocated balance will be set to the available balance
+        on the exchange.
+
+        Args:
+            portfolio: Portfolio object
+
+        Returns:
+            Portfolio object
+        """
+        market_credential = self.market_credential_service.get(
+            portfolio.market
+        )
+
+        if market_credential is None:
+            raise OperationalException(
+                f"No market credential found for market "
+                f"{portfolio.market}. Cannot sync unallocated amount."
+            )
+
+        portfolio_provider = self.portfolio_provider_lookup\
+            .get_portfolio_provider(portfolio.market)
+        position = portfolio_provider.get_position(
+            portfolio, portfolio.trading_symbol, market_credential
+        )
+
+        if not portfolio.initialized:
+            # Check if the portfolio has an initial balance set
+            if portfolio.initial_balance is not None:
+                available = position.amount
+
+                if portfolio.initial_balance > available:
+                    raise OperationalException(
+                        "The initial balance of the " +
+                        "portfolio configuration " +
+                        f"({portfolio.initial_balance} "
+                        f"{portfolio.trading_symbol}) is more " +
+                        "than the available balance on the exchange. " +
+                        "Please make sure that the initial balance of " +
+                        "the portfolio configuration is less " +
+                        "than the available balance on the " +
+                        f"exchange {available} {portfolio.trading_symbol}."
+                    )
+                else:
+                    unallocated = portfolio.initial_balance
+            else:
+                # If the portfolio does not have an initial balance
+                # set, get the available balance on the exchange
+                if position is None:
+                    raise OperationalException(
+                        f"There is no available balance on the exchange for "
+                        f"{portfolio.trading_symbol.upper()} on market "
+                        f"{portfolio.market}. Please make sure that you have "
+                        f"an available balance on the exchange for "
+                        f"{portfolio.trading_symbol.upper()} on market "
+                        f"{portfolio.market}."
+                    )
+                else:
+                    unallocated = position.amount
+
+            update_data = {
+                "unallocated": unallocated,
+                "net_size": unallocated,
+                "initialized": True
+            }
+            portfolio = self.portfolio_repository.update(
+                portfolio.id, update_data
+            )
+
+            # Update also a trading symbol position
+            trading_symbol_position = self.position_repository.find(
+                {
+                    "symbol": portfolio.trading_symbol,
+                    "portfolio_id": portfolio.id
+                }
+            )
+            self.position_repository.update(
+                trading_symbol_position.id, {"amount": unallocated}
+            )
+
+        else:
+            # Check if the portfolio unallocated balance is
+            # available on the exchange
+            if portfolio.unallocated > 0:
+                if position is None or portfolio.unallocated > position.amount:
+                    raise OperationalException(
+                        f"Out of sync: the unallocated balance"
+                        " of the exiting portfolio is more than the available"
+                        " balance on the exchange. Please make sure"
+                        " that you have at least "
+                        f"{portfolio.unallocated}"
+                        f" {portfolio.trading_symbol.upper()} available"
+                        " on the exchange."
+                    )
+
+        return portfolio
+
+    def sync_orders(self, portfolio):
+        """
+        Function to sync all local orders with the orders on the exchange.
+        This method will go over all local open orders and check if they are
+        changed on the exchange. If they are, the local order will be
+        updated to match the status on the exchange.
+
+        Args:
+            portfolio: Portfolio object
+
+        Returns:
+            None
+        """
+
+        config = self.configuration_service.get_config()
+
+        if ENVIRONMENT in config \
+                and Environment.BACKTEST.equals(config[ENVIRONMENT]):
+            return
+
+        self.order_service.check_pending_orders(portfolio)

investing_algorithm_framework/services/positions/__init__.py

@@ -0,0 +1,7 @@
+from .position_service import PositionService
+from .position_snapshot_service import PositionSnapshotService
+
+__all__ = [
+    "PositionService",
+    "PositionSnapshotService"
+]

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/positions/position_snapshot_service.py

@@ -0,0 +1,18 @@
+from investing_algorithm_framework.services.repository_service \
+    import RepositoryService
+
+
+class PositionSnapshotService(RepositoryService):
+
+    def create_snapshot(self, portfolio_snapshot_id, position):
+        self.create(
+            {
+                "portfolio_snapshot_id": portfolio_snapshot_id,
+                "symbol": position.symbol,
+                "amount": position.amount,
+                "cost": position.cost,
+            }
+        )
+
+    def get_snapshots(self, portfolio_snapshot_id):
+        pass

investing_algorithm_framework/services/repository_service.py

@@ -0,0 +1,40 @@
+class RepositoryService:
+
+    def __init__(self, repository):
+        self.repository = repository
+
+    def create(self, data, save=True):
+        return self.repository.create(data, save=save)
+
+    def get(self, object_id):
+        return self.repository.get(object_id)
+
+    def get_all(self, query_params=None):
+        return self.repository.get_all(query_params)
+
+    def update(self, object_id, data):
+        return self.repository.update(object_id, data)
+
+    def update_all(self, query_params, data):
+        return self.repository.update_all(query_params, data)
+
+    def delete(self, object_id):
+        return self.repository.delete(object_id)
+
+    def delete_all(self, query_params):
+        return self.repository.delete_all(query_params)
+
+    def find(self, query_params):
+        return self.repository.find(query_params)
+
+    def count(self, query_params=None):
+        return self.repository.count(query_params)
+
+    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,132 @@
+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 __init__(
+        self,
+        trade_service,
+        order_service
+    ):
+        super().__init__(trade_service, order_service)
+
+    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)
+
+        # self.order_service.save_all(orders)
+        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)
+
+            stop_losses_orders_data = self.trade_service \
+                .get_triggered_stop_loss_orders()
+
+            for stop_loss_order in stop_losses_orders_data:
+                self.order_service.create(stop_loss_order)
+
+            take_profits_orders_data = self.trade_service \
+                .get_triggered_take_profit_orders()
+
+            for take_profit_order in take_profits_orders_data:
+                self.order_service.create(take_profit_order)
+
+    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,66 @@
+from typing import List, Dict
+
+import polars as pl
+
+from investing_algorithm_framework.domain import Trade, Order
+from .trade_order_evaluator import TradeOrderEvaluator
+
+
+class DefaultTradeOrderEvaluator(TradeOrderEvaluator):
+
+    def __init__(
+        self,
+        trade_service,
+        order_service
+    ):
+        super().__init__(trade_service, order_service)
+
+    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()
+
+        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)
+
+            stop_losses_orders_data = self.trade_service \
+                .get_triggered_stop_loss_orders()
+
+            for stop_loss_order in stop_losses_orders_data:
+                self.order_service.create(stop_loss_order)
+
+            take_profits_orders_data = self.trade_service \
+                .get_triggered_take_profit_orders()
+
+            for take_profit_order in take_profits_orders_data:
+                self.order_service.create(take_profit_order)