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

investing_algorithm_framework/services/portfolios/__init__.py

@@ -3,6 +3,7 @@ from .portfolio_configuration_service import PortfolioConfigurationService
 from .portfolio_service import PortfolioService
 from .portfolio_snapshot_service import PortfolioSnapshotService
 from .portfolio_sync_service import PortfolioSyncService
+from .portfolio_provider_lookup import PortfolioProviderLookup
 
 __all__ = [
     "PortfolioConfigurationService",
@@ -10,5 +11,6 @@ __all__ = [
     "PortfolioSnapshotService",
     "PortfolioService",
     "PortfolioSnapshotService",
-    "BacktestPortfolioService"
+    "BacktestPortfolioService",
+    "PortfolioProviderLookup"
 ]

investing_algorithm_framework/services/portfolios/backtest_portfolio_service.py

@@ -1,4 +1,7 @@
-from investing_algorithm_framework.domain import PortfolioConfiguration
+from datetime import datetime
+
+from investing_algorithm_framework.domain import PortfolioConfiguration, \
+    OperationalException
 from .portfolio_service import PortfolioService
 
 
@@ -9,12 +12,43 @@ class BacktestPortfolioService(PortfolioService):
     not check if the initial balance is present on the exchange or broker.
     """
     def create_portfolio_from_configuration(
-        self, portfolio_configuration: PortfolioConfiguration
+        self,
+        portfolio_configuration: PortfolioConfiguration,
+        initial_amount=None,
+        created_at: datetime = None
     ):
+        """
+        Wil create a portfolio from a portfolio configuration for backtesting.
+
+        Args:
+            portfolio_configuration (PortfolioConfiguration):
+                Portfolio configuration to create the portfolio from
+            initial_amount (Decimal): Initial balance for the portfolio
+            created_at (datetime): The date and time when the portfolio
+                is created. If not provided, the current date and time
+                will be used.
+
+        Returns:
+            Portfolio: The created portfolio
+        """
+        amount = portfolio_configuration.initial_balance
+
+        if initial_amount is not None:
+            amount = initial_amount
+
+        if amount is None:
+            raise OperationalException(
+                "Initial amount is required as a parameter or the " +
+                "'initial_balance' attribute needs to be set on the "
+                "portfolio configuration before running the backtest."
+            )
+
         data = {
             "identifier": portfolio_configuration.identifier,
             "market": portfolio_configuration.market,
             "trading_symbol": portfolio_configuration.trading_symbol,
-            "unallocated": portfolio_configuration.initial_balance,
+            "unallocated": amount,
+            "initialized": True,
+            "created_at": created_at
         }
         return self.create(data)

investing_algorithm_framework/services/portfolios/portfolio_configuration_service.py

@@ -6,6 +6,11 @@ logger = logging.getLogger(__name__)
 
 
 class PortfolioConfigurationService:
+    """
+    Service to manage portfolio configurations. This service will
+    manage the portfolio configurations that the user has
+    registered in the app.
+    """
 
     def __init__(self, portfolio_repository, position_repository):
         self.portfolio_repository = portfolio_repository
@@ -17,14 +22,22 @@ class PortfolioConfigurationService:
 
     def get(self, identifier):
         portfolio_configuration = next(
-            (portfolio_configuration for portfolio_configuration in
-                self.portfolio_configurations if
-                portfolio_configuration.identifier == identifier.lower()),
+            (
+                portfolio_configuration for portfolio_configuration in
+                self.portfolio_configurations
+                if portfolio_configuration.identifier.upper() ==
+                identifier.upper()),
             None
         )
 
-        if portfolio_configuration is None:
-            raise ApiException('Portfolio configuration not found', 404)
+        # if portfolio_configuration is None:
+        #     raise ApiException(
+        #         f'Portfolio configuration not '
+        #         f'found for {identifier}'
+        #         " Please make sure that you have registered a portfolio "
+        #         "configuration for the portfolio you are trying to use",
+        #         404
+        #     )
 
         return portfolio_configuration
 
@@ -36,14 +49,15 @@ class PortfolioConfigurationService:
             return next(
                 (portfolio_configuration for portfolio_configuration in
                  self.portfolio_configurations if
-                 portfolio_configuration.market == market.lower()),
+                 portfolio_configuration.market.upper() == market.upper()),
                 None
             )
         elif identifier is not None:
             return next(
                 (portfolio_configuration for portfolio_configuration in
-                 self.portfolio_configurations if
-                 portfolio_configuration.identifier == identifier.lower()),
+                    self.portfolio_configurations if
+                    portfolio_configuration.identifier.upper()
+                    == identifier.upper()),
                 None
             )
         elif market is None and identifier is None:

investing_algorithm_framework/services/portfolios/portfolio_provider_lookup.py

@@ -0,0 +1,106 @@
+import logging
+from collections import defaultdict
+from typing import List, Union
+
+from investing_algorithm_framework.domain import ImproperlyConfigured, \
+    PortfolioProvider
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class PortfolioProviderLookup:
+    """
+    Efficient lookup for portfolio providers based on market in O(1) time.
+    """
+    def __init__(self):
+        self.portfolio_providers = []
+
+        # These will be our lookup tables
+        self.portfolio_provider_lookup = defaultdict()
+
+    def add_portfolio_provider(self, portfolio_provider: PortfolioProvider):
+        """
+        Add a portfolio provider to the lookup table.
+
+        Args:
+            portfolio_provider (PortfolioProvider): The portfolio provider
+                to be added.
+
+        Returns:
+            None
+        """
+        self.portfolio_providers.append(portfolio_provider)
+
+    def register_portfolio_provider_for_market(self, market) -> None:
+        """
+        Register a portfolio provider for a specific market.
+        This method will create a lookup table for efficient access to
+        portfolio providers based on market. It will use the
+        portfolio providers that are currently registered in the
+        portfolio_providers list. The lookup table will be a dictionary
+        where the key is the market and the value is the portfolio provider.
+
+        This method will also check if the portfolio provider supports
+        the market. If no portfolio provider is found for the market,
+        it will raise an ImproperlyConfigured exception.
+
+        If multiple portfolio providers are found for the market,
+        it will sort them by priority and pick the best one.
+
+        Args:
+            market:
+
+        Returns:
+            None
+        """
+        matches = []
+        for portfolio_provider in self.portfolio_providers:
+            if portfolio_provider.supports_market(market):
+                matches.append(portfolio_provider)
+
+        if len(matches) == 0:
+            raise ImproperlyConfigured(
+                f"No portfolio provider found for market "
+                f"{market}. Cannot configure portfolio."
+                f" Please make sure that you have registered a portfolio "
+                f"provider for the market you are trying to use"
+            )
+
+        # Sort by priority and pick the best one
+        best_provider = sorted(matches, key=lambda x: x.priority)[0]
+        self.portfolio_provider_lookup[market] = best_provider
+
+    def get_portfolio_provider(self, market) -> Union[PortfolioProvider, None]:
+        """
+        Get the portfolio provider for a specific market.
+        This method will return the portfolio provider for the given market.
+        If no portfolio provider is found, it will return None.
+
+        Args:
+            market:
+
+        Returns:
+            PortfolioProvider: The portfolio provider for the given market.
+        """
+        return self.portfolio_provider_lookup.get(market, None)
+
+    def get_all(self) -> List[PortfolioProvider]:
+        """
+        Get all portfolio providers.
+        This method will return all portfolio providers that are currently
+        registered in the portfolio_providers list.
+
+        Returns:
+            List[PortfolioProvider]: A list of all portfolio providers.
+        """
+        return self.portfolio_providers
+
+    def reset(self):
+        """
+        Function to reset the order executor lookup table
+
+        Returns:
+            None
+        """
+        self.portfolio_provider_lookup = defaultdict()
+        self.portfolio_providers = []

investing_algorithm_framework/services/portfolios/portfolio_service.py

@@ -1,8 +1,8 @@
 import logging
 from datetime import datetime
 
-from investing_algorithm_framework.domain import OrderSide, OrderStatus, \
-    OperationalException, MarketService, MarketCredentialService, Portfolio
+from investing_algorithm_framework.domain import OperationalException, \
+    MarketCredentialService, Portfolio, Environment, ENVIRONMENT
 from investing_algorithm_framework.services.configuration_service import \
     ConfigurationService
 from investing_algorithm_framework.services.repository_service \
@@ -21,22 +21,22 @@ class PortfolioService(RepositoryService):
     def __init__(
         self,
         configuration_service: ConfigurationService,
-        market_service: MarketService,
         market_credential_service: MarketCredentialService,
         order_service,
-        portfolio_repository,
         portfolio_configuration_service,
         portfolio_snapshot_service,
-        position_service
+        position_service,
+        portfolio_repository,
+        portfolio_provider_lookup
     ):
+        super().__init__(repository=portfolio_repository)
         self.configuration_service = configuration_service
         self.market_credential_service = market_credential_service
-        self.market_service = market_service
         self.portfolio_configuration_service = portfolio_configuration_service
         self.order_service = order_service
         self.portfolio_snapshot_service = portfolio_snapshot_service
         self.position_service = position_service
-        super(PortfolioService, self).__init__(portfolio_repository)
+        self.portfolio_provider_lookup = portfolio_provider_lookup
 
     def find(self, query_params):
         portfolio = self.repository.find(query_params)
@@ -47,6 +47,36 @@ class PortfolioService(RepositoryService):
 
     def create(self, data):
         unallocated = data.get("unallocated", 0)
+        market = data.get("market")
+
+        # Check if the app is in backtest mode
+        config = self.configuration_service.get_config()
+        environment = config[ENVIRONMENT]
+
+        if not Environment.BACKTEST.equals(environment):
+            # Check if there is a market credential
+            # for the portfolio configuration
+            market_credential = self.market_credential_service.get(market)
+
+            if market_credential is None:
+                raise OperationalException(
+                    f"No market credential found for market "
+                    f"{market}. Cannot "
+                    f"initialize portfolio configuration."
+                )
+
+        identifier = data.get("identifier")
+        # Check if the portfolio already exists
+        # If the portfolio already exists, return the portfolio after checking
+        # the unallocated balance of the portfolio on the exchange
+        if identifier is not None and self.repository.exists(
+            {"identifier": identifier}
+        ):
+            portfolio = self.repository.find(
+                {"identifier": identifier}
+            )
+            return portfolio
+        data["initial_balance"] = unallocated
         portfolio = super(PortfolioService, self).create(data)
         self.position_service.create(
             {
@@ -56,30 +86,13 @@ class PortfolioService(RepositoryService):
                 "cost": unallocated
             }
         )
-        self.create_snapshot(portfolio.id, created_at=portfolio.created_at)
         return portfolio
 
-    def create_snapshot(self, portfolio_id, created_at=None):
-
-        if created_at is None:
-            created_at = datetime.utcnow()
-
-        portfolio = self.get(portfolio_id)
-        pending_orders = self.order_service.get_all(
-            {
-                "order_side": OrderSide.BUY.value,
-                "status": OrderStatus.OPEN.value,
-                "portfolio_id": portfolio.id
-            }
-        )
-        return self.portfolio_snapshot_service.create_snapshot(
-            portfolio,
-            pending_orders=pending_orders,
-            created_at=created_at
-        )
-
     def create_portfolio_from_configuration(
-        self, portfolio_configuration
+        self,
+        portfolio_configuration,
+        initial_amount=None,
+        created_at: datetime = None
     ) -> Portfolio:
         """
         Method to create a portfolio based on a portfolio configuration.
@@ -87,6 +100,17 @@ class PortfolioService(RepositoryService):
         provided. If the portfolio already exists, it will be returned.
 
         If the portfolio does not exist, it will be created.
+
+        Args:
+            portfolio_configuration (PortfolioConfiguration)
+                Portfolio configuration to create the portfolio from
+            initial_amount (Decimal): Initial balance for the portfolio
+            created_at (datetime): The date and time when the portfolio
+                is created. If not provided, the current date and time
+                will be used.
+
+        Returns:
+            Portfolio: Portfolio created from the configuration
         """
         logger.info("Creating portfolios")
 
@@ -117,4 +141,48 @@ class PortfolioService(RepositoryService):
             portfolio = Portfolio.from_portfolio_configuration(
                 portfolio_configuration
             )
+            data = portfolio.to_dict()
+
+            if created_at is not None:
+                data["created_at"] = created_at
+
+            if initial_amount is not None:
+                data["unallocated"] = initial_amount
+
+            self.create(data)
+
         return portfolio
+
+    def update_portfolio_with_filled_order(self, order, filled_amount) -> None:
+        """
+        Function to update the portfolio with filled order.
+
+        Args:
+            order: Order object
+            filled_amount: float
+
+        Returns:
+            None
+        """
+        filled_size = filled_amount * order.get_price()
+
+        if filled_size <= 0:
+            return
+
+        logger.info(
+            f"Syncing portfolio with filled sell "
+            f"order {order.get_id()} with filled amount "
+            f"{filled_amount}"
+        )
+
+        position = self.position_service.get(order.position_id)
+        portfolio = self.get(position.portfolio_id)
+
+        self.update(
+            portfolio.id,
+            {
+                "unallocated": portfolio.get_unallocated() + filled_size,
+                "total_trade_volume":
+                    portfolio.get_total_trade_volume() + filled_size,
+            }
+        )

investing_algorithm_framework/services/portfolios/portfolio_snapshot_service.py

@@ -1,67 +1,136 @@
-from datetime import datetime
-
+from investing_algorithm_framework.domain import OrderStatus, \
+    PortfolioSnapshot
 from investing_algorithm_framework.services.repository_service import \
     RepositoryService
 
 
 class PortfolioSnapshotService(RepositoryService):
+    """
+    Service to manage portfolio snapshots. This service will create snapshots
+    of the portfolio at specific intervals or based on certain events.
+    """
 
     def __init__(
         self,
         repository,
+        portfolio_repository,
+        order_repository,
         position_repository,
-        position_snapshot_service
+        position_snapshot_service,
+        data_provider_service,
     ):
+        self.order_repository = order_repository
         self.position_snapshot_service = position_snapshot_service
+        self.portfolio_repository = portfolio_repository
         self.position_repository = position_repository
+        self.data_provider_service = data_provider_service
         super(PortfolioSnapshotService, self).__init__(repository)
 
     def create_snapshot(
         self,
         portfolio,
-        pending_orders=None,
+        created_at,
+        cash_flow=0,
         created_orders=None,
-        created_at=None,
-        cash_flow=0
-    ):
+        open_orders=None,
+        positions=None,
+        save=True
+    ) -> PortfolioSnapshot:
+        """
+        Function to create a snapshot of the portfolio. During
+        creation, it will calculate the pending value of the
+        portfolio based on the pending orders and created orders. Also,
+        it will calculate the total value of the portfolio based on the
+        current positions and the unallocated cash. It will do this by
+        fetching the current ticker prices for each position in the portfolio.
+        This function will also create position snapshots for each position
+        in the portfolio and associate them with the snapshot.
+
+        Args:
+            portfolio (Portfolio): The portfolio to create a snapshot for.
+            created_at (datetime, optional): The date and time when the
+                snapshot was created. If not provided, the current date
+                and time will be used.
+            cash_flow (float, optional): The cash flow to include
+                in the snapshot.
+            created_orders (list, optional): A list of created orders
+                to consider when calculating the pending value.
+            open_orders (list, optional): A list of open orders
+                to consider when calculating the pending value.
+            positions (list, optional): A list of positions to consider
+                when calculating the total value of the portfolio.
+            save (bool, optional): Whether to save the snapshot to
+                the database.
+
+        Returns:
+            PortfolioSnapshot: The created snapshot of the portfolio.
+        """
         pending_value = 0
+        pending_symbols = set()
+        allocated = 0
+
+        if open_orders is None:
+            open_orders = self.order_repository.get_all(
+                {
+                    "status": OrderStatus.OPEN.value,
+                    "portfolio_id": portfolio.id
+                }
+            )
+
+        if created_orders is None:
+            created_orders = self.order_repository.get_all(
+                {
+                    "status": OrderStatus.CREATED.value,
+                    "portfolio_id": portfolio.id
+                }
+            )
 
-        if created_orders is not None:
-            for order in created_orders:
-                pending_value += order.get_price() * order.get_amount()
+        if positions is None:
+            positions = self.position_repository.get_all(
+                {"portfolio": portfolio.id}
+            )
+
+        for order in created_orders:
+            pending_value += order.get_price() * order.get_amount()
+            pending_symbols.add(order.get_symbol())
+
+        for order in open_orders:
+            pending_value += order.get_price() * order.get_remaining()
+            pending_symbols.add(order.get_symbol())
+
+        total_value = portfolio.get_unallocated() + pending_value
 
-        if pending_orders is not None:
-            for order in pending_orders:
-                pending_value += order.get_price() * order.get_remaining()
+        for position in \
+                self.position_repository.get_all({"portfolio": portfolio.id}):
 
-        if created_at is None:
-            created_at = datetime.now()
+            if position.get_symbol() != portfolio.get_trading_symbol():
+                symbol_pair = f"{position.get_symbol()}/" \
+                    f"{portfolio.get_trading_symbol()}"
+                ticker = self.data_provider_service.get_ticker_data(
+                    symbol=symbol_pair,
+                    market=portfolio.market,
+                    date=created_at
+                )
+                # Calculate the position worth
+                position_worth = position.get_amount() * ticker["bid"]
+                allocated += position_worth
+                total_value += position_worth
 
         data = {
             "portfolio_id": portfolio.id,
             "trading_symbol": portfolio.trading_symbol,
             "pending_value": pending_value,
             "unallocated": portfolio.unallocated,
+            "net_size": portfolio.net_size,
             "total_net_gain": portfolio.total_net_gain,
             "total_revenue": portfolio.total_revenue,
             "total_cost": portfolio.total_cost,
             "cash_flow": cash_flow,
             "created_at": created_at,
+            "total_value": total_value,
         }
-        snapshot = self.create(data)
-        positions = self.position_repository.get_all(
-            {"portfolio": portfolio.id}
-        )
-
-        for position in positions:
-            self.position_snapshot_service.create_snapshot(
-                snapshot.id, position
-            )
-
+        snapshot = self.create(data, save=save)
         return snapshot
 
     def get_latest_snapshot(self, portfolio_id):
         pass
-
-    def get_snapshots(self, portfolio_id, start_date=None, end_date=None):
-        pass