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

investing_algorithm_framework/infrastructure/models/trades/trade.py

@@ -0,0 +1,130 @@
+from sqlalchemy import Column, Integer, String, DateTime, Float
+from sqlalchemy.orm import relationship
+
+from investing_algorithm_framework.domain import Trade, TradeStatus
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+from investing_algorithm_framework.infrastructure.models\
+    .order_trade_association import order_trade_association
+
+
+class SQLTrade(Trade, SQLBaseModel, SQLAlchemyModelExtension):
+    """
+    SQL Trade model
+
+    A trade is a combination of a buy and sell order that has been opened or
+    closed.
+
+    A trade is considered opened when a buy order is executed and there is
+    no corresponding sell order. A trade is considered closed when a sell
+    order is executed and the amount of the sell order is equal or larger
+    to the amount of the buy order.
+
+    A single sell order can close multiple buy orders. Also, a single
+    buy order can be closed by multiple sell orders.
+
+    Attributes:
+    orders: str, the id of the buy order
+        target_symbol: str, the target symbol of the trade
+        trading_symbol: str, the trading symbol of the trade
+        closed_at: datetime, the datetime when the trade was closed
+        amount: float, the amount of the trade
+        available_amount: float, the available amount of the trade
+        remaining: float, the remaining amount that is not filled by the
+            buy order that opened the trade.
+        filled_amount: float, the filled amount of the trade by the buy
+            order that opened the trade.
+        net_gain: float, the net gain of the trade
+        last_reported_price: float, the last reported price of the trade
+        last_reported_price_datetime: datetime, the datetime when the last
+            reported price was reported
+        created_at: datetime, the datetime when the trade was created
+        updated_at: datetime, the datetime when the trade was last updated
+        status: str, the status of the trade
+    """
+
+    __tablename__ = "trades"
+    id = Column(Integer, primary_key=True, unique=True)
+    orders = relationship(
+        'SQLOrder',
+        secondary=order_trade_association,
+        back_populates='trades',
+        lazy='joined'
+    )
+    target_symbol = Column(String)
+    trading_symbol = Column(String)
+    closed_at = Column(DateTime, default=None)
+    opened_at = Column(DateTime, default=None)
+    open_price = Column(Float, default=None)
+    amount = Column(Float, default=None)
+    available_amount = Column(Float, default=None)
+    filled_amount = Column(Float, default=None)
+    remaining = Column(Float, default=None)
+    net_gain = Column(Float, default=0)
+    cost = Column(Float, default=0)
+    last_reported_price = Column(Float, default=None)
+    last_reported_price_datetime = Column(DateTime, default=None)
+    high_water_mark = Column(Float, default=None)
+    high_water_mark_datetime = Column(DateTime, default=None)
+    updated_at = Column(DateTime, default=None)
+    status = Column(String, default=TradeStatus.CREATED.value)
+    # Stop losses should be actively loaded
+    stop_losses = relationship(
+        'SQLTradeStopLoss',
+        back_populates='trade',
+        lazy='joined'
+    )
+    # Take profits should be actively loaded
+    take_profits = relationship(
+        'SQLTradeTakeProfit',
+        back_populates='trade',
+        lazy='joined'
+    )
+
+    def __init__(
+        self,
+        buy_order,
+        target_symbol,
+        trading_symbol,
+        opened_at,
+        amount,
+        available_amount,
+        filled_amount,
+        remaining,
+        status=TradeStatus.CREATED.value,
+        closed_at=None,
+        updated_at=None,
+        net_gain=0,
+        cost=0,
+        last_reported_price=None,
+        last_reported_price_datetime=None,
+        high_water_mark=None,
+        high_water_mark_datetime=None,
+        sell_orders=[],
+        stop_losses=[],
+        take_profits=[],
+    ):
+        self.orders = [buy_order]
+        self.open_price = buy_order.price
+        self.target_symbol = target_symbol
+        self.trading_symbol = trading_symbol
+        self.closed_at = closed_at
+        self.amount = amount
+        self.available_amount = available_amount
+        self.filled_amount = filled_amount
+        self.remaining = remaining
+        self.net_gain = net_gain
+        self.cost = cost
+        self.last_reported_price = last_reported_price
+        self.last_reported_price_datetime = last_reported_price_datetime
+        self.high_water_mark = high_water_mark
+        self.high_water_mark_datetime = high_water_mark_datetime
+        self.opened_at = opened_at
+        self.updated_at = updated_at
+        self.status = status
+        self.stop_losses = stop_losses
+        self.take_profits = take_profits
+
+        if sell_orders is not None:
+            self.orders.extend(sell_orders)

investing_algorithm_framework/infrastructure/models/trades/trade_stop_loss.py

@@ -0,0 +1,40 @@
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, Boolean
+from sqlalchemy.orm import relationship
+
+from investing_algorithm_framework.domain import TradeStopLoss
+from investing_algorithm_framework.infrastructure.database import SQLBaseModel
+from investing_algorithm_framework.infrastructure.models.model_extension \
+    import SQLAlchemyModelExtension
+
+
+class SQLTradeStopLoss(TradeStopLoss, SQLBaseModel, SQLAlchemyModelExtension):
+    """
+    SQLTradeStopLoss model
+
+    A trade stop loss is a stop loss strategy for a trade.
+
+    Attributes:
+    * trade: Trade - the trade that the take profit is for
+    * take_profit: float - the take profit percentage
+    * trade_risk_type: TradeRiskType - the type of trade risk, either
+        trailing or fixed
+    * sell_percentage: float - the percentage of the trade to sell when the
+
+    """
+
+    __tablename__ = "trade_stop_losses"
+    id = Column(Integer, primary_key=True, unique=True)
+    trade_id = Column(Integer, ForeignKey('trades.id'))
+    trade = relationship('SQLTrade', back_populates='stop_losses')
+    trade_risk_type = Column(String)
+    percentage = Column(Float)
+    sell_percentage = Column(Float)
+    open_price = Column(Float)
+    high_water_mark = Column(Float)
+    high_water_mark_date = Column(String)
+    stop_loss_price = Column(Float)
+    sell_prices = Column(String)
+    sell_dates = Column(String)
+    sell_amount = Column(Float)
+    sold_amount = Column(Float)
+    active = Column(Boolean)

investing_algorithm_framework/infrastructure/models/trades/trade_take_profit.py

@@ -0,0 +1,41 @@
+from sqlalchemy import Column, Integer, String, Float, ForeignKey, Boolean
+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
+    * take_profit: float - the take profit percentage
+    * trade_risk_type: TradeRiskType - the type of trade risk, either
+        trailing or fixed
+    * sell_percentage: float - the percentage of the trade to sell when the
+    """
+
+    __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')
+    trade_risk_type = Column(String)
+    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)

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())