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

investing_algorithm_framework/services/portfolios/__init__.py

@@ -0,0 +1,16 @@
+from .backtest_portfolio_service import BacktestPortfolioService
+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",
+    "PortfolioSyncService",
+    "PortfolioSnapshotService",
+    "PortfolioService",
+    "PortfolioSnapshotService",
+    "BacktestPortfolioService",
+    "PortfolioProviderLookup"
+]

investing_algorithm_framework/services/portfolios/backtest_portfolio_service.py

@@ -0,0 +1,54 @@
+from datetime import datetime
+
+from investing_algorithm_framework.domain import PortfolioConfiguration, \
+    OperationalException
+from .portfolio_service import PortfolioService
+
+
+class BacktestPortfolioService(PortfolioService):
+    """
+    BacktestPortfolioService is a subclass of PortfolioService.
+    It is used to create a portfolio for backtesting. This class does
+    not check if the initial balance is present on the exchange or broker.
+    """
+    def create_portfolio_from_configuration(
+        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": amount,
+            "initialized": True,
+            "created_at": created_at
+        }
+        return self.create(data)

investing_algorithm_framework/services/portfolios/portfolio_configuration_service.py

@@ -0,0 +1,75 @@
+import logging
+
+from investing_algorithm_framework.domain import ApiException
+
+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
+        self.position_repository = position_repository
+        self.portfolio_configurations = []
+
+    def add(self, portfolio_configuration):
+        self.portfolio_configurations.append(portfolio_configuration)
+
+    def get(self, identifier):
+        portfolio_configuration = next(
+            (
+                portfolio_configuration for portfolio_configuration in
+                self.portfolio_configurations
+                if portfolio_configuration.identifier.upper() ==
+                identifier.upper()),
+            None
+        )
+
+        # 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
+
+    def find(self, query_params):
+        market = query_params.get("market", None)
+        identifier = query_params.get("market", None)
+
+        if market is not None:
+            return next(
+                (portfolio_configuration for portfolio_configuration in
+                 self.portfolio_configurations if
+                 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.upper()
+                    == identifier.upper()),
+                None
+            )
+        elif market is None and identifier is None:
+            return self.portfolio_configurations[0]
+        else:
+            raise ApiException('Portfolio configuration not found', 404)
+
+    def get_all(self):
+        return self.portfolio_configurations
+
+    def count(self):
+        return len(self.portfolio_configurations)
+
+    def clear(self):
+        self.portfolio_configurations = []

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

@@ -0,0 +1,188 @@
+import logging
+from datetime import datetime
+
+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 \
+    import RepositoryService
+
+logger = logging.getLogger("investing_algorithm_framework")
+
+
+class PortfolioService(RepositoryService):
+    """
+    Service to manage portfolios. This service will sync the portfolios with
+    the exchange balances and orders. It will also create portfolios based on
+    the portfolio configurations registered by the user
+    """
+
+    def __init__(
+        self,
+        configuration_service: ConfigurationService,
+        market_credential_service: MarketCredentialService,
+        order_service,
+        portfolio_configuration_service,
+        portfolio_snapshot_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.portfolio_configuration_service = portfolio_configuration_service
+        self.order_service = order_service
+        self.portfolio_snapshot_service = portfolio_snapshot_service
+        self.position_service = position_service
+        self.portfolio_provider_lookup = portfolio_provider_lookup
+
+    def find(self, query_params):
+        portfolio = self.repository.find(query_params)
+        portfolio_configuration = self.portfolio_configuration_service\
+            .get(portfolio.identifier)
+        portfolio.configuration = portfolio_configuration
+        return portfolio
+
+    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(
+            {
+                "symbol": portfolio.get_trading_symbol(),
+                "amount": unallocated,
+                "portfolio_id": portfolio.id,
+                "cost": unallocated
+            }
+        )
+        return portfolio
+
+    def create_portfolio_from_configuration(
+        self,
+        portfolio_configuration,
+        initial_amount=None,
+        created_at: datetime = None
+    ) -> Portfolio:
+        """
+        Method to create a portfolio based on a portfolio configuration.
+        This method will create a portfolio based on the configuration
+        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")
+
+        # Check if there is a market credential for the portfolio configuration
+        market_credential = self.market_credential_service.get(
+            portfolio_configuration.market
+        )
+
+        if market_credential is None:
+            raise OperationalException(
+                f"No market credential found for market "
+                f"{portfolio_configuration.market}. Cannot "
+                f"initialize portfolio configuration."
+            )
+
+        # 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 self.repository.exists(
+            {"identifier": portfolio_configuration.identifier}
+        ):
+            portfolio = self.repository.find(
+                {"identifier": portfolio_configuration.identifier}
+            )
+            return portfolio
+        else:
+            # Create a new portfolio
+            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

@@ -0,0 +1,136 @@
+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,
+        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,
+        created_at,
+        cash_flow=0,
+        created_orders=None,
+        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 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
+
+        for position in \
+                self.position_repository.get_all({"portfolio": portfolio.id}):
+
+            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, save=save)
+        return snapshot
+
+    def get_latest_snapshot(self, portfolio_id):
+        pass