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

investing_algorithm_framework/infrastructure/models/trades/trade_take_profit.py

@@ -0,0 +1,55 @@
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, Boolean, \
+    DateTime
+from sqlalchemy.orm import relationship
+
+from investing_algorithm_framework.domain import TradeTakeProfit
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+
+
+class SQLTradeTakeProfit(
+    TradeTakeProfit, SQLBaseModel, SQLAlchemyModelExtension
+):
+    """
+    SQLTradeTakeProfit model
+
+    A trade take profit is a take profit strategy for a trade.
+
+    Attributes:
+    - trade (Trade): the trade that the take profit is for
+    - percentage (float): the take profit percentage
+    - trailing (bool): indicates whether the take profit is trailing
+    - sell_percentage (float) the percentage of the trade to sell
+         when the take profit is triggered.
+    - target_price (float): the target price at which to take profit.
+    - sell_prices (String): a serialized list of prices at which
+            take profits were executed.
+    - sell_dates (String): a serialized list of dates when
+            take profits were executed.
+    - sell_amount (float): the total amount sold due to take profits.
+    - sold_amount (float): the total amount that has been sold due
+        to take profits.
+    - active (bool): indicates whether the take profit is currently active.
+    """
+
+    __tablename__ = "trade_take_profits"
+    id = Column(Integer, primary_key=True, unique=True)
+    trade_id = Column(Integer, ForeignKey('trades.id'))
+    trade = relationship('SQLTrade', back_populates='take_profits')
+    trailing = Column(Boolean)
+    percentage = Column(Float)
+    sell_percentage = Column(Float)
+    open_price = Column(Float)
+    high_water_mark = Column(Float)
+    high_water_mark_date = Column(String)
+    sell_prices = Column(String)
+    take_profit_price = Column(Float)
+    sell_amount = Column(Float)
+    sell_dates = Column(String)
+    sold_amount = Column(Float)
+    active = Column(Boolean)
+    triggered = Column(Boolean, default=False)
+    triggered_at = Column(DateTime, default=None)
+    created_at = Column(DateTime)
+    updated_at = Column(DateTime, default=None)

investing_algorithm_framework/infrastructure/order_executors/__init__.py

@@ -0,0 +1,21 @@
+from .ccxt_order_executor import CCXTOrderExecutor
+from .backtest_oder_executor import BacktestOrderExecutor
+
+
+def get_default_order_executors():
+    """
+    Function to get the default order executors.
+
+    Returns:
+        list: List of default order executors.
+    """
+    return [
+        CCXTOrderExecutor(),
+    ]
+
+
+__all__ = [
+    'CCXTOrderExecutor',
+    'BacktestOrderExecutor',
+    'get_default_order_executors',
+]

investing_algorithm_framework/infrastructure/order_executors/backtest_oder_executor.py

@@ -0,0 +1,28 @@
+from investing_algorithm_framework.domain import OrderExecutor, OrderStatus, \
+    INDEX_DATETIME, Order
+
+
+class BacktestOrderExecutor(OrderExecutor):
+    """
+    Backtest implementation of order executor. This executor is used to
+    simulate order execution in a backtesting environment.
+
+    !Important: This executor does not actually execute orders on any market.
+        It should be used only for backtesting purposes.
+    """
+
+    def execute_order(self, portfolio, order, market_credential) -> Order:
+        order.status = OrderStatus.OPEN.value
+        order.remaining = order.get_amount()
+        order.filled = 0
+        order.updated_at = self.config[INDEX_DATETIME]
+        return order
+
+    def cancel_order(self, portfolio, order, market_credential) -> Order:
+        order.status = OrderStatus.CANCELED.value
+        order.remaining = 0
+        order.updated_at = self.config[INDEX_DATETIME]
+        return order
+
+    def supports_market(self, market):
+        return True

investing_algorithm_framework/infrastructure/order_executors/ccxt_order_executor.py

@@ -0,0 +1,200 @@
+from logging import getLogger
+
+import ccxt
+
+from investing_algorithm_framework.domain import OrderExecutor, \
+    OperationalException, Order, OrderStatus, OrderSide, OrderType, \
+    MarketCredential
+
+logger = getLogger("investing_algorithm_framework")
+
+
+class CCXTOrderExecutor(OrderExecutor):
+    """
+    CCXTOrderExecutor is a class that implements the OrderExecutor
+    interface for executing orders using the CCXT library.
+    """
+
+    def execute_order(self, portfolio, order, market_credential) -> Order:
+        """
+        Executes an order for a given portfolio on a CCXT exchange.
+
+        Args:
+            order: The order to be executed
+            portfolio: The portfolio in which the order will be executed
+            market_credential: The market credential to use for the order
+
+        Returns:
+            Order: Instance of the executed order. The order instance
+            should copy the id of the order that has been provided as a
+        """
+        market = portfolio.market
+        exchange = self.initialize_exchange(market, market_credential)
+        symbol = order.get_symbol()
+        amount = order.get_amount()
+        price = order.get_price()
+        order_type = order.get_order_type()
+        order_side = order.get_order_side()
+
+        try:
+            if OrderType.LIMIT.equals(order_type):
+                if OrderSide.BUY.equals(order_side):
+
+                    # Check if the exchange supports the
+                    # createLimitBuyOrder method
+                    if not hasattr(exchange, "createLimitBuyOrder"):
+                        raise OperationalException(
+                            f"Exchange {market} does not support "
+                            f"functionality createLimitBuyOrder"
+                        )
+
+                    # Create a limit buy order
+                    external_order = exchange.createLimitBuyOrder(
+                        symbol, amount, price,
+                    )
+                else:
+                    # Check if the exchange supports
+                    # the createLimitSellOrder method
+                    if not hasattr(exchange, "createLimitSellOrder"):
+                        raise OperationalException(
+                            f"Exchange {market} does not support "
+                            f"functionality createLimitSellOrder"
+                        )
+
+                    # Create a limit sell order
+                    external_order = exchange.createLimitSellOrder(
+                        symbol, amount, price,
+                    )
+            else:
+                raise OperationalException(
+                    f"Order type {order_type} not supported "
+                    f"by CCXT OrderExecutor"
+                )
+
+            external_order = Order.from_ccxt_order(external_order)
+            external_order.id = order.id
+            return external_order
+        except Exception as e:
+            logger.exception(e)
+            raise OperationalException("Could not create limit buy order")
+
+    def cancel_order(self, portfolio, order, market_credential) -> Order:
+        """
+        Cancels an order for a given portfolio on a CCXT exchange.
+
+        Args:
+            order: The order to be canceled
+            portfolio: The portfolio in which the order was executed
+            market_credential: The market credential to use for the order
+
+        Returns:
+            Order: Instance of the canceled order.
+        """
+        market = portfolio.market
+        exchange = self.initialize_exchange(market, market_credential)
+
+        if not exchange.has['cancelOrder']:
+            raise OperationalException(
+                f"Exchange {market} does not support "
+                f"functionality cancelOrder"
+            )
+
+        try:
+            exchange.cancelOrder(
+                order.get_external_id(),
+                f"{order.get_target_symbol()}/{order.get_trading_symbol()}"
+            )
+            order.status = OrderStatus.CANCELED.value
+            return order
+        except Exception as e:
+            logger.exception(e)
+            raise OperationalException("Could not cancel order")
+
+    @staticmethod
+    def initialize_exchange(market, market_credential):
+        """
+        Function to initialize the exchange for the market.
+
+        Args:
+            market (str): The market to initialize the exchange for
+            market_credential (MarketCredential): The market credential to use
+                for the exchange
+
+        Returns:
+
+        """
+        market = market.lower()
+
+        if not hasattr(ccxt, market):
+            raise OperationalException(
+                f"No ccxt exchange for market id {market}"
+            )
+
+        exchange_class = getattr(ccxt, market)
+
+        if exchange_class is None:
+            raise OperationalException(
+                f"No market service found for market id {market}"
+            )
+
+        # Check the credentials for the exchange
+        CCXTOrderExecutor.check_credentials(exchange_class, market_credential)
+        exchange = exchange_class({
+            'apiKey': market_credential.api_key,
+            'secret': market_credential.secret_key,
+        })
+        return exchange
+
+    @staticmethod
+    def check_credentials(
+        exchange_class, market_credential: MarketCredential
+    ):
+        """
+        Function to check if the credentials are valid for the exchange.
+
+        Args:
+            exchange_class: The exchange class to check the credentials for
+            market_credential: The market credential to use for the exchange
+
+        Raises:
+            OperationalException: If the credentials are not valid
+
+        Returns:
+            None
+        """
+        exchange = exchange_class()
+        credentials_info = exchange.requiredCredentials
+        market = market_credential.get_market()
+
+        if ('apiKey' in credentials_info
+                and credentials_info["apiKey"]
+                and market_credential.get_api_key() is None):
+            raise OperationalException(
+                f"Market credential for market {market}"
+                " requires an api key, either"
+                " as an argument or as an environment variable"
+                f" named as {market.upper()}_API_KEY"
+            )
+
+        if ('secret' in credentials_info
+                and credentials_info["secret"]
+                and market_credential.get_secret_key() is None):
+            raise OperationalException(
+                f"Market credential for market {market}"
+                " requires a secret key, either"
+                " as an argument or as an environment variable"
+                f" named as {market.upper()}_SECRET_KEY"
+            )
+
+    def supports_market(self, market):
+        """
+        Function to check if the market is supported by the portfolio
+        provider.
+
+        Args:
+            market: Market object
+
+        Returns:
+            bool: True if the market is supported, False otherwise
+        """
+        return hasattr(ccxt, market.lower())

investing_algorithm_framework/infrastructure/portfolio_providers/__init__.py

@@ -0,0 +1,19 @@
+from .ccxt_portfolio_provider import CCXTPortfolioProvider
+
+
+def get_default_portfolio_providers():
+    """
+    Function to get the default portfolio providers.
+
+    Returns:
+        list: List of default portfolio providers.
+    """
+    return [
+        CCXTPortfolioProvider(),
+    ]
+
+
+__all__ = [
+    "CCXTPortfolioProvider",
+    "get_default_portfolio_providers",
+]

investing_algorithm_framework/infrastructure/portfolio_providers/ccxt_portfolio_provider.py

@@ -0,0 +1,199 @@
+import ccxt
+from logging import getLogger
+from typing import Union
+
+from investing_algorithm_framework.domain import PortfolioProvider, \
+    OperationalException, Order, Position, MarketCredential
+
+
+logger = getLogger("investing_algorithm_framework")
+
+
+class CCXTPortfolioProvider(PortfolioProvider):
+    """
+    Implementation of Portfolio Provider for CCXT.
+    """
+
+    def get_order(
+        self, portfolio, order, market_credential
+    ) -> Union[Order, None]:
+        """
+        Method to check if there are any pending orders for the portfolio.
+        This method will retrieve the open orders from the exchange and
+        check if there are any pending orders for the portfolio.
+
+        !IMPORTANT: This function should return None if the order is
+        not found or if the order is not available on the
+        exchange or broker. Please do not throw an exception if the
+        order is not found.
+
+        Args:
+            portfolio: Portfolio object
+            order: Order object from the database
+            market_credential: Market credential object
+
+        Returns:
+            None
+        """
+        exchange = self.initialize_exchange(
+            portfolio.market, market_credential
+        )
+
+        if not exchange.has['fetchOrder']:
+            raise OperationalException(
+                f"Market service {portfolio.market} does not support "
+                f"functionality get_order"
+            )
+
+        symbol = order.get_symbol()
+
+        try:
+            external_order = exchange.fetchOrder(order.external_id, symbol)
+            external_order = Order.from_ccxt_order(external_order)
+            external_order.id = order.id
+            return external_order
+        except Exception as e:
+            logger.exception(e)
+            raise OperationalException("Could not retrieve order")
+
+    def get_position(
+        self, portfolio, symbol, market_credential
+    ) -> Union[Position, None]:
+        """
+        Function to get the position for a given symbol in the portfolio.
+        The returned position should be an object that reflects the current
+        state of the position on the exchange or broker.
+
+        !IMPORTANT: This function should return None if the position is
+        not found or if the position is not available on the
+        exchange or broker. Please do not throw an exception if the
+        position is not found.
+
+        Args:
+            portfolio (Portfolio): Portfolio object
+            symbol (str): Symbol object
+            market_credential (MarketCredential): MarketCredential object
+
+        Returns:
+            Position: Position for the given symbol in the portfolio
+        """
+
+        exchange = self.initialize_exchange(
+            portfolio.market, market_credential
+        )
+
+        if not exchange.has['fetchBalance']:
+            raise OperationalException(
+                f"Market service {portfolio.market} does not support "
+                f"functionality get_balance"
+            )
+
+        try:
+            amount = exchange.fetchBalance()["free"]
+
+            if symbol not in amount:
+                return None
+
+            return Position(
+                symbol=symbol,
+                amount=amount[symbol],
+                cost=0,
+                portfolio_id=portfolio.id
+            )
+        except Exception as e:
+            logger.exception(e)
+            raise OperationalException(
+                f"Please make sure you have "
+                f"registered a valid market credential "
+                f"object to the app: {str(e)}"
+            )
+
+    @staticmethod
+    def initialize_exchange(market, market_credential):
+        """
+        Function to initialize the exchange for the market.
+
+        Args:
+            market (str): The market to initialize the exchange for
+            market_credential (MarketCredential): The market credential to use
+                for the exchange
+
+        Returns:
+
+        """
+        market = market.lower()
+
+        if not hasattr(ccxt, market):
+            raise OperationalException(
+                f"No ccxt exchange for market id {market}"
+            )
+
+        exchange_class = getattr(ccxt, market)
+
+        if exchange_class is None:
+            raise OperationalException(
+                f"No market service found for market id {market}"
+            )
+
+        # Check the credentials for the exchange
+        (CCXTPortfolioProvider
+         .check_credentials(exchange_class, market_credential))
+        exchange = exchange_class({
+            'apiKey': market_credential.api_key,
+            'secret': market_credential.secret_key,
+        })
+        return exchange
+
+    @staticmethod
+    def check_credentials(
+        exchange_class, market_credential: MarketCredential
+    ):
+        """
+        Function to check if the credentials are valid for the exchange.
+
+        Args:
+            exchange_class: The exchange class to check the credentials for
+            market_credential: The market credential to use for the exchange
+
+        Raises:
+            OperationalException: If the credentials are not valid
+
+        Returns:
+            None
+        """
+        exchange = exchange_class()
+        credentials_info = exchange.requiredCredentials
+        market = market_credential.get_market()
+
+        if ('apiKey' in credentials_info
+                and credentials_info["apiKey"]
+                and market_credential.get_api_key() is None):
+            raise OperationalException(
+                f"Market credential for market {market}"
+                " requires an api key, either"
+                " as an argument or as an environment variable"
+                f" named as {market.upper()}_API_KEY"
+            )
+
+        if ('secret' in credentials_info
+                and credentials_info["secret"]
+                and market_credential.get_secret_key() is None):
+            raise OperationalException(
+                f"Market credential for market {market}"
+                " requires a secret key, either"
+                " as an argument or as an environment variable"
+                f" named as {market.upper()}_SECRET_KEY"
+            )
+
+    def supports_market(self, market):
+        """
+        Function to check if the market is supported by the portfolio
+        provider.
+
+        Args:
+            market: Market object
+
+        Returns:
+            bool: True if the market is supported, False otherwise
+        """
+        return hasattr(ccxt, market.lower())

investing_algorithm_framework/infrastructure/repositories/__init__.py

@@ -1,8 +1,12 @@
 from .order_repository import SQLOrderRepository
+from .order_metadata_repository import SQLOrderMetadataRepository
 from .portfolio_repository import SQLPortfolioRepository
 from .portfolio_snapshot_repository import SQLPortfolioSnapshotRepository
 from .position_repository import SQLPositionRepository
 from .position_snapshot_repository import SQLPositionSnapshotRepository
+from .trade_repository import SQLTradeRepository
+from .trade_stop_loss_repository import SQLTradeStopLossRepository
+from .trade_take_profit_repository import SQLTradeTakeProfitRepository
 
 __all__ = [
     "SQLOrderRepository",
@@ -10,4 +14,8 @@ __all__ = [
     "SQLPositionSnapshotRepository",
     "SQLPortfolioRepository",
     "SQLPortfolioSnapshotRepository",
+    "SQLTradeRepository",
+    "SQLTradeTakeProfitRepository",
+    "SQLTradeStopLossRepository",
+    "SQLOrderMetadataRepository"
 ]

investing_algorithm_framework/infrastructure/repositories/order_metadata_repository.py

@@ -0,0 +1,17 @@
+from investing_algorithm_framework.infrastructure.models import \
+    SQLOrderMetadata
+from .repository import Repository
+
+
+class SQLOrderMetadataRepository(Repository):
+    base_class = SQLOrderMetadata
+    DEFAULT_NOT_FOUND_MESSAGE = "The requested order metadata was not found"
+
+    def _apply_query_params(self, db, query, query_params):
+
+        if "order_id" in query_params:
+            query = query.filter(
+               SQLOrderMetadata.order_id == query_params["order_id"]
+            )
+
+        return query

investing_algorithm_framework/infrastructure/repositories/order_repository.py

@@ -7,8 +7,10 @@ from .repository import Repository
 
 class SQLOrderRepository(Repository):
     base_class = SQLOrder
+    DEFAULT_NOT_FOUND_MESSAGE = "The requested order was not found"
 
     def _apply_query_params(self, db, query, query_params):
+        id_query_param = self.get_query_param("id", query_params)
         external_id_query_param = self.get_query_param(
             "external_id", query_params
         )
@@ -33,6 +35,9 @@ class SQLOrderRepository(Repository):
             "order_by_created_at_asc", query_params
         )
 
+        if id_query_param:
+            query = query.filter_by(id=id_query_param)
+
         if portfolio_query_param is not None:
             portfolio = db.query(SQLPortfolio).filter_by(
                 id=portfolio_query_param

investing_algorithm_framework/infrastructure/repositories/portfolio_repository.py

@@ -20,7 +20,7 @@ class SQLPortfolioRepository(Repository):
             query = query.filter_by(market=market_query_param.upper())
 
         if identifier_query_param:
-            query = query.filter_by(identifier=identifier_query_param.lower())
+            query = query.filter_by(identifier=identifier_query_param.upper())
 
         if position_query_param:
             position = db.query(SQLPosition)\

investing_algorithm_framework/infrastructure/repositories/position_repository.py

@@ -9,6 +9,7 @@ class SQLPositionRepository(Repository):
     DEFAULT_NOT_FOUND_MESSAGE = "Position not found"
 
     def _apply_query_params(self, db, query, query_params):
+        id_query_param = self.get_query_param("id", query_params)
         amount_query_param = self.get_query_param("amount", query_params)
         symbol_query_param = self.get_query_param("symbol", query_params)
         portfolio_query_param = self.get_query_param("portfolio", query_params)
@@ -20,6 +21,10 @@ class SQLPositionRepository(Repository):
         amount_lte_query_param = self.get_query_param(
             "amount_lte", query_params
         )
+        order_id_query_param = self.get_query_param("order_id", query_params)
+
+        if id_query_param:
+            query = query.filter_by(id=id_query_param)
 
         if amount_query_param:
             query = query.filter(
@@ -51,5 +56,11 @@ class SQLPositionRepository(Repository):
             query = query.filter(
                 cast(SQLPosition.amount, Numeric) <= amount_lte_query_param
             )
+        # Filter by order_id, orders is a one-to-many relationship
+        # with 3 position
+        if order_id_query_param:
+            query = query.filter(
+                SQLPosition.orders.any(id=order_id_query_param)
+            )
 
         return query