investing-algorithm-framework 1.3.1__py3-none-any.whl → 7.25.6__py3-none-any.whl

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,13 +1,21 @@
 from .order_repository import SQLOrderRepository
-from .order_fee_repository import SQLOrderFeeRepository
-from .position_repository import SQLPositionRepository
+from .order_metadata_repository import SQLOrderMetadataRepository
 from .portfolio_repository import SQLPortfolioRepository
-from .position_cost_repository import SQLPositionCostRepository
+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__ = [
-    "SQLOrderFeeRepository",
     "SQLOrderRepository",
     "SQLPositionRepository",
+    "SQLPositionSnapshotRepository",
     "SQLPortfolioRepository",
-    "SQLPositionCostRepository"
+    "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

@@ -1,22 +1,24 @@
-from .repository import Repository
-from investing_algorithm_framework.infrastructure.models import SQLOrder, \
-    SQLPosition, SQLPortfolio
 from investing_algorithm_framework.domain import OrderStatus, OrderType, \
     OrderSide
+from investing_algorithm_framework.infrastructure.models import SQLOrder, \
+    SQLPosition, SQLPortfolio
+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
         )
         portfolio_query_param = self.get_query_param(
             "portfolio_id", query_params
         )
-        side_query_param = self.get_query_param("side", query_params)
-        type_query_param = self.get_query_param("type", query_params)
+        side_query_param = self.get_query_param("order_side", query_params)
+        type_query_param = self.get_query_param("order_type", query_params)
         status_query_param = self.get_query_param("status", query_params)
         price_query_param = self.get_query_param("price", query_params)
         amount_query_param = self.get_query_param("amount", query_params)
@@ -24,35 +26,42 @@ class SQLOrderRepository(Repository):
             "position", query_params, many=True
         )
         target_symbol_query_param = self.get_query_param(
-            "symbol", query_params
+            "target_symbol", query_params
         )
         trading_symbol_query_param = self.get_query_param(
             "trading_symbol", query_params
         )
+        order_by_created_at_asc = self.get_query_param(
+            "order_by_created_at_asc", query_params
+        )
 
-        if portfolio_query_param:
+        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(
-                identifier=portfolio_query_param
+                id=portfolio_query_param
             ).first()
 
-            if portfolio is None:
-                return query.filter_by(id=-1)
+            if portfolio:
+                positions = db.query(SQLPosition).filter_by(
+                    portfolio_id=portfolio.id
+                ).all()
+                position_ids = [p.id for p in positions]
+                query = query.filter(SQLOrder.position_id.in_(position_ids))
+            else:
+                query = query.filter_by(id=None)
 
-            positions = db.query(SQLPosition).filter_by(
-                portfolio_id=portfolio.id
-            ).all()
-            position_ids = [p.id for p in positions]
-            query = query.filter(SQLOrder.position_id.in_(position_ids))
         if external_id_query_param:
             query = query.filter_by(external_id=external_id_query_param)
 
         if side_query_param:
-            side = OrderSide.from_value(side_query_param)
-            query = query.filter_by(side=side.value)
+            order_side = OrderSide.from_value(side_query_param)
+            query = query.filter_by(order_side=order_side.value)
 
         if type_query_param:
             order_type = OrderType.from_value(type_query_param)
-            query = query.filter_by(type=order_type.value)
+            query = query.filter_by(order_type=order_type.value)
 
         if status_query_param:
             status = OrderStatus.from_value(status_query_param)
@@ -79,5 +88,9 @@ class SQLOrderRepository(Repository):
                 SQLOrder.trading_symbol == trading_symbol_query_param
             )
 
-        query = query.order_by(SQLOrder.created_at.desc())
+        if order_by_created_at_asc:
+            query = query.order_by(SQLOrder.created_at.asc())
+        else:
+            query = query.order_by(SQLOrder.created_at.desc())
+
         return query

investing_algorithm_framework/infrastructure/repositories/portfolio_repository.py

@@ -17,10 +17,10 @@ class SQLPortfolioRepository(Repository):
             query = query.filter_by(id=id_query_param)
 
         if market_query_param:
-            query = query.filter_by(market=market_query_param.lower())
+            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/portfolio_snapshot_repository.py

@@ -0,0 +1,56 @@
+from investing_algorithm_framework.infrastructure.models import \
+    SQLPortfolioSnapshot
+from .repository import Repository
+
+
+class SQLPortfolioSnapshotRepository(Repository):
+    base_class = SQLPortfolioSnapshot
+    DEFAULT_NOT_FOUND_MESSAGE = "Portfolio snapshot not found"
+
+    def _apply_query_params(self, db, query, query_params):
+        portfolio_id_query_param = self.get_query_param(
+            "portfolio_id", query_params
+        )
+        created_at_query_param = self.get_query_param(
+            "created_at", query_params
+        )
+        created_at_gt_query_param = self.get_query_param(
+            "created_at_gt", query_params
+        )
+        created_at_gte_query_param = self.get_query_param(
+            "created_at_gte", query_params
+        )
+        created_at_lt_query_param = self.get_query_param(
+            "created_at_lt", query_params
+        )
+        created_at_lte_query_param = self.get_query_param(
+            "created_at_lte", query_params
+        )
+
+        if portfolio_id_query_param is not None:
+            query = query.filter_by(portfolio_id=portfolio_id_query_param)
+
+        if created_at_query_param is not None:
+            query = query.filter_by(created_at=created_at_query_param)
+
+        if created_at_gt_query_param is not None:
+            query = query.filter(
+                SQLPortfolioSnapshot.created_at > created_at_gt_query_param
+            )
+
+        if created_at_gte_query_param is not None:
+            query = query.filter(
+                SQLPortfolioSnapshot.created_at >= created_at_gt_query_param
+            )
+
+        if created_at_lt_query_param is not None:
+            query = query.filter(
+                SQLPortfolioSnapshot.created_at < created_at_lt_query_param
+            )
+
+        if created_at_lte_query_param is not None:
+            query = query.filter(
+                SQLPortfolioSnapshot.created_at <= created_at_lte_query_param
+            )
+
+        return query

investing_algorithm_framework/infrastructure/repositories/position_repository.py

@@ -1,6 +1,7 @@
+from sqlalchemy import cast, Numeric, Float
+
+from investing_algorithm_framework.infrastructure.models import SQLPosition
 from .repository import Repository
-from investing_algorithm_framework.infrastructure.models import SQLPosition, \
-    SQLPortfolio
 
 
 class SQLPositionRepository(Repository):
@@ -8,16 +9,58 @@ 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)
+        amount_gt_query_param = self.get_query_param("amount_gt", query_params)
+        amount_gte_query_param = self.get_query_param(
+            "amount_gte", query_params
+        )
+        amount_lt_query_param = self.get_query_param("amount_lt", query_params)
+        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(SQLPosition.amount == amount_query_param)
+            query = query.filter(
+                cast(SQLPosition.amount, Float) == amount_query_param
+            )
 
         if symbol_query_param:
             query = query.filter_by(symbol=symbol_query_param)
 
-        if portfolio_query_param:
+        if portfolio_query_param is not None:
             query = query.filter_by(portfolio_id=portfolio_query_param)
+
+        if amount_gt_query_param is not None:
+            query = query.filter(
+                cast(SQLPosition.amount, Numeric) > amount_gt_query_param
+            )
+
+        if amount_gte_query_param is not None:
+            query = query.filter(
+                cast(SQLPosition.amount, Numeric) >= amount_gte_query_param
+            )
+
+        if amount_lt_query_param is not None:
+            query = query.filter(
+                cast(SQLPosition.amount, Numeric) < amount_lt_query_param
+            )
+
+        if amount_lte_query_param:
+            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

investing_algorithm_framework/infrastructure/repositories/position_snapshot_repository.py

@@ -0,0 +1,21 @@
+from investing_algorithm_framework.infrastructure.models import \
+    SQLPositionSnapshot
+from .repository import Repository
+
+
+class SQLPositionSnapshotRepository(Repository):
+    base_class = SQLPositionSnapshot
+    DEFAULT_NOT_FOUND_MESSAGE = "Position snapshot not found"
+
+    def _apply_query_params(self, db, query, query_params):
+        portfolio_snapshot_query_param = self.get_query_param(
+            "portfolio_snapshot", query_params
+        )
+
+        if portfolio_snapshot_query_param is not None:
+            query = query\
+                .filter_by(
+                    portfolio_snapshot_id=portfolio_snapshot_query_param
+                )
+
+        return query