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

investing_algorithm_framework/services/order_service/order_backtest_service.py

@@ -2,10 +2,8 @@ import logging
 
 import polars as pl
 
-from investing_algorithm_framework.domain import BACKTESTING_INDEX_DATETIME, \
-    OrderStatus, OrderSide, Order, MarketDataType
-from investing_algorithm_framework.services.market_data_source_service \
-    import BacktestMarketDataSourceService
+from investing_algorithm_framework.domain import INDEX_DATETIME, \
+    OrderStatus, OrderSide, Order, DataType
 from .order_service import OrderService
 
 logger = logging.getLogger("investing_algorithm_framework")
@@ -22,7 +20,6 @@ class OrderBacktestService(OrderService):
         portfolio_configuration_service,
         portfolio_snapshot_service,
         configuration_service,
-        market_data_source_service: BacktestMarketDataSourceService,
     ):
         super().__init__(
             configuration_service=configuration_service,
@@ -34,7 +31,6 @@ class OrderBacktestService(OrderService):
             trade_service=trade_service,
         )
         self.configuration_service = configuration_service
-        self.market_data_source_service = market_data_source_service
 
     def create(self, data, execute=True, validate=True, sync=True) -> Order:
         """
@@ -51,10 +47,9 @@ class OrderBacktestService(OrderService):
             Order: Created order object
         """
         config = self.configuration_service.get_config()
-
         # Make sure the created_at is set to the current backtest time
-        data["created_at"] = config[BACKTESTING_INDEX_DATETIME]
-        data["updated_at"] = config[BACKTESTING_INDEX_DATETIME]
+        data["created_at"] = config[INDEX_DATETIME]
+        data["updated_at"] = config[INDEX_DATETIME]
         # Call super to have standard behavior
         return super(OrderBacktestService, self)\
             .create(data, execute, validate, sync)
@@ -64,7 +59,7 @@ class OrderBacktestService(OrderService):
         order.remaining = order.get_amount()
         order.filled = 0
         order.updated_at = self.configuration_service.config[
-            BACKTESTING_INDEX_DATETIME
+            INDEX_DATETIME
         ]
         return order
 
@@ -85,7 +80,7 @@ class OrderBacktestService(OrderService):
         meta_data = market_data["metadata"]
 
         for order in pending_orders:
-            ohlcv_meta_data = meta_data[MarketDataType.OHLCV]
+            ohlcv_meta_data = meta_data[DataType.OHLCV]
 
             if order.get_symbol() not in ohlcv_meta_data:
                 continue
@@ -106,7 +101,7 @@ class OrderBacktestService(OrderService):
                         "filled": order.get_amount(),
                         "remaining": 0,
                         "updated_at": self.configuration_service
-                        .config[BACKTESTING_INDEX_DATETIME]
+                        .config[INDEX_DATETIME]
                     }
                 )
 
@@ -123,11 +118,11 @@ class OrderBacktestService(OrderService):
                         "status": OrderStatus.CANCELED.value,
                         "remaining": 0,
                         "updated_at": self.configuration_service
-                        .config[BACKTESTING_INDEX_DATETIME]
+                        .config[INDEX_DATETIME]
                     }
                 )
 
-    def has_executed(self, order, ohlcv_data_frame):
+    def has_executed(self, order, ohlcv_data_frame: pl.DataFrame):
         """
         Check if the order has executed based on the OHLCV data.
 
@@ -135,7 +130,7 @@ class OrderBacktestService(OrderService):
         order price. Example: If the order price is 1000 and the low price
         drops below or equals 1000, the order is executed. This simulates the
         situation where a buyer is willing to pay a higher price than the
-        the lowest price in the ohlcv data.
+        lowest price in the ohlcv data.
 
         A sell order is executed if the high price goes above or equals the
         order price. Example: If the order price is 1000 and the high price
@@ -143,27 +138,22 @@ class OrderBacktestService(OrderService):
         situation where a seller is willing to accept a higher price for its
         sell order.
 
-        :param order: Order object
-        :param ohlcv_data_frame: OHLCV data frame
-        :return: True if the order has executed, False otherwise
+        Args:
+            order: Order object
+            ohlcv_data_frame: OHLCV data frame
+            True if the order has executed, False otherwise
+
+        Returns:
+            bool: True if the order has executed, False otherwise
         """
 
         # Extract attributes from the order object
         created_at = order.get_created_at()
         order_side = order.get_order_side()
         order_price = order.get_price()
-        column_type = ohlcv_data_frame['Datetime'].dtype
-
-        if isinstance(column_type, pl.Datetime):
-            ohlcv_data_after_order = ohlcv_data_frame.filter(
-                pl.col('Datetime') >= created_at
-            )
-        else:
-            ohlcv_data_after_order = ohlcv_data_frame.filter(
-                pl.col('Datetime') >= created_at.strftime(
-                    self.configuration_service.config["DATETIME_FORMAT"]
-                )
-            )
+        ohlcv_data_after_order = ohlcv_data_frame.filter(
+            pl.col('Datetime') >= created_at
+        )
 
         # Check if the order execution conditions are met
         if OrderSide.BUY.equals(order_side):
@@ -182,7 +172,7 @@ class OrderBacktestService(OrderService):
 
         if created_at is None:
             created_at = self.configuration_service \
-                .config[BACKTESTING_INDEX_DATETIME]
+                .config[INDEX_DATETIME]
 
         super(OrderBacktestService, self)\
             .create_snapshot(portfolio_id, created_at=created_at)

investing_algorithm_framework/services/order_service/order_service.py

@@ -1,19 +1,14 @@
 import logging
-from datetime import datetime
-from typing import List
-
-from dateutil.tz import tzutc
 
 from investing_algorithm_framework.domain import OrderType, OrderSide, \
-    OperationalException, OrderStatus, Order, OrderExecutor, random_number, \
-    Observable, Event
+    OperationalException, OrderStatus, Order, random_number, INDEX_DATETIME
 from investing_algorithm_framework.services.repository_service \
     import RepositoryService
 
 logger = logging.getLogger("investing_algorithm_framework")
 
 
-class OrderService(RepositoryService, Observable):
+class OrderService(RepositoryService):
     """
     Service to manage orders. This service will use the provided
     order executors to execute the orders. The order service is
@@ -52,8 +47,6 @@ class OrderService(RepositoryService, Observable):
         market_credential_service=None
     ):
         super(OrderService, self).__init__(order_repository)
-        # Call the observable constructor
-        Observable.__init__(self)
         self.configuration_service = configuration_service
         self.order_repository = order_repository
         self.position_service = position_service
@@ -62,36 +55,9 @@ class OrderService(RepositoryService, Observable):
         self.portfolio_snapshot_service = portfolio_snapshot_service
         self.market_credential_service = market_credential_service
         self.trade_service = trade_service
-        self._order_executors = None
         self._order_executor_lookup = order_executor_lookup
         self._portfolio_provider_lookup = portfolio_provider_lookup
 
-    @property
-    def order_executors(self) -> List[OrderExecutor]:
-        """
-        Returns the order executors for the order service.
-        """
-        return self._order_executors
-
-    @order_executors.setter
-    def order_executors(self, value) -> None:
-        """
-        Sets the order executors for the order service.
-        """
-        self._order_executors = value
-
-    def get_order_executor(self, market) -> OrderExecutor:
-        """
-        Returns the order executor for the given market.
-
-        Args:
-            market (str): The market for which to get the order executor.
-
-        Returns:
-            OrderExecutor: The order executor for the given market.
-        """
-        return self._order_executor_lookup.get_order_executor(market)
-
     def create(self, data, execute=True, validate=True, sync=True) -> Order:
         """
         Function to create an order. The function will create the order and
@@ -189,6 +155,7 @@ class OrderService(RepositoryService, Observable):
             self.validate_order(data, portfolio)
 
         del data["portfolio_id"]
+        data["target_symbol"] = data["target_symbol"].upper()
         symbol = data["target_symbol"]
         data["id"] = self._create_order_id()
 
@@ -225,11 +192,6 @@ class OrderService(RepositoryService, Observable):
             else:
                 self._sync_portfolio_with_created_sell_order(order)
 
-        self.notify_observers(
-            Event.ORDER_CREATED,
-            {"portfolio_id": portfolio.id, "created_at": order.created_at}
-        )
-        # self.create_snapshot(portfolio.id, created_at=created_at)
         order = self.get(order_id)
         return order
 
@@ -310,7 +272,8 @@ class OrderService(RepositoryService, Observable):
             f"and price {order.get_price()}"
         )
 
-        order_executor = self.get_order_executor(portfolio.market)
+        order_executor = self._order_executor_lookup\
+            .get_order_executor(portfolio.market)
         market_credential = self.market_credential_service.get(
             portfolio.market
         )
@@ -322,7 +285,8 @@ class OrderService(RepositoryService, Observable):
         order.set_status(external_order.get_status())
         order.set_filled(external_order.get_filled())
         order.set_remaining(external_order.get_remaining())
-        order.updated_at = datetime.now(tz=tzutc())
+        config = self.configuration_service.config
+        order.updated_at = config[INDEX_DATETIME]
         return order
 
     def validate_order(self, order_data, portfolio):
@@ -544,7 +508,8 @@ class OrderService(RepositoryService, Observable):
                 market_credential = self.market_credential_service.get(
                     portfolio.market
                 )
-                order_executor = self.get_order_executor(portfolio.market)
+                order_executor = self._order_executor_lookup\
+                    .get_order_executor(portfolio.market)
                 order = order_executor\
                     .cancel_order(portfolio, order, market_credential)
                 self.update(order.id, order.to_dict())
@@ -840,33 +805,6 @@ class OrderService(RepositoryService, Observable):
 
         self.trade_service.update_trade_with_removed_sell_order(order)
 
-    # def create_snapshot(self, portfolio_id, created_at=None):
-    #
-    #     if created_at is None:
-    #         created_at = datetime.now(tz=tzutc())
-    #
-    #     portfolio = self.portfolio_repository.get(portfolio_id)
-    #     pending_orders = self.get_all(
-    #         {
-    #             "order_side": OrderSide.BUY.value,
-    #             "status": OrderStatus.OPEN.value,
-    #             "portfolio_id": portfolio.id
-    #         }
-    #     )
-    #     created_orders = self.get_all(
-    #         {
-    #             "order_side": OrderSide.BUY.value,
-    #             "status": OrderStatus.CREATED.value,
-    #             "portfolio_id": portfolio.id
-    #         }
-    #     )
-    #     return self.portfolio_snapshot_service.create_snapshot(
-    #         portfolio,
-    #         pending_orders=pending_orders,
-    #         created_orders=created_orders,
-    #         created_at=created_at
-    #     )
-
     def _create_order_id(self):
         """
         Function to create a new order id. The function will

investing_algorithm_framework/services/portfolios/portfolio_provider_lookup.py

@@ -54,9 +54,7 @@ class PortfolioProviderLookup:
             None
         """
         matches = []
-
         for portfolio_provider in self.portfolio_providers:
-
             if portfolio_provider.supports_market(market):
                 matches.append(portfolio_provider)
 

investing_algorithm_framework/services/portfolios/portfolio_service.py

@@ -2,8 +2,7 @@ import logging
 from datetime import datetime
 
 from investing_algorithm_framework.domain import OperationalException, \
-    MarketCredentialService, Portfolio, \
-    Environment, ENVIRONMENT, Observable, Event
+    MarketCredentialService, Portfolio, Environment, ENVIRONMENT
 from investing_algorithm_framework.services.configuration_service import \
     ConfigurationService
 from investing_algorithm_framework.services.repository_service \
@@ -12,7 +11,7 @@ from investing_algorithm_framework.services.repository_service \
 logger = logging.getLogger("investing_algorithm_framework")
 
 
-class PortfolioService(RepositoryService, Observable):
+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
@@ -31,8 +30,6 @@ class PortfolioService(RepositoryService, Observable):
         portfolio_provider_lookup
     ):
         super().__init__(repository=portfolio_repository)
-        # Call the observable constructor
-        Observable.__init__(self)
         self.configuration_service = configuration_service
         self.market_credential_service = market_credential_service
         self.portfolio_configuration_service = portfolio_configuration_service
@@ -79,7 +76,7 @@ class PortfolioService(RepositoryService, Observable):
                 {"identifier": identifier}
             )
             return portfolio
-
+        data["initial_balance"] = unallocated
         portfolio = super(PortfolioService, self).create(data)
         self.position_service.create(
             {
@@ -89,13 +86,6 @@ class PortfolioService(RepositoryService, Observable):
                 "cost": unallocated
             }
         )
-        self.notify_observers(
-            Event.PORTFOLIO_CREATED,
-            {
-                "portfolio_id": portfolio.id,
-                "created_at": portfolio.created_at
-            }
-        )
         return portfolio
 
     def create_portfolio_from_configuration(

investing_algorithm_framework/services/portfolios/portfolio_snapshot_service.py

@@ -1,22 +1,13 @@
-from datetime import datetime, timezone
-
-from investing_algorithm_framework.domain import Observer, Event, \
-    SNAPSHOT_INTERVAL, SnapshotInterval, OrderStatus, \
-    PortfolioSnapshot, Environment, ENVIRONMENT, BACKTESTING_INDEX_DATETIME
+from investing_algorithm_framework.domain import OrderStatus, \
+    PortfolioSnapshot
 from investing_algorithm_framework.services.repository_service import \
     RepositoryService
 
 
-class PortfolioSnapshotService(RepositoryService, Observer):
+class PortfolioSnapshotService(RepositoryService):
     """
     Service to manage portfolio snapshots. This service will create snapshots
     of the portfolio at specific intervals or based on certain events.
-
-    This service implements the Observer interface to listen for events.
-    This can be used to register this service to an observable object
-    and let it create snapshots based on the events that occur in the system.
-    For example, it can create a snapshot of the portfolio
-    at the end of each strategy iteration or when a trade is closed.
     """
 
     def __init__(
@@ -26,55 +17,24 @@ class PortfolioSnapshotService(RepositoryService, Observer):
         order_repository,
         position_repository,
         position_snapshot_service,
-        datasource_service,
-        configuration_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.configuration_service = configuration_service
-        self.datasource_service = datasource_service
+        self.data_provider_service = data_provider_service
         super(PortfolioSnapshotService, self).__init__(repository)
 
-    def notify(self, event_type: Event, payload):
-        """
-        Update the portfolio snapshot based on the event type and payload.
-
-        Args:
-            event_type: The type of event that occurred.
-            payload: The data associated with the event.
-        """
-        config = self.configuration_service.get_config()
-        snapshot_interval = config[SNAPSHOT_INTERVAL]
-
-        if Event.STRATEGY_RUN.equals(event_type) and \
-                SnapshotInterval.STRATEGY_ITERATION.equals(snapshot_interval):
-            created_at = payload.get("created_at")
-            for portfolio in self.portfolio_repository.get_all():
-                self.create_snapshot(portfolio, created_at=created_at)
-
-        elif Event.TRADE_CLOSED.equals(event_type) and \
-                SnapshotInterval.TRADE_CLOSE.equals(snapshot_interval):
-            portfolio_id = payload.get("portfolio_id")
-            created_at = payload.get("created_at")
-            portfolio = self.portfolio_repository.get(portfolio_id)
-            self.create_snapshot(portfolio=portfolio, created_at=created_at)
-
-        elif Event.PORTFOLIO_CREATED.equals(event_type):
-            portfolio_id = payload.get("portfolio_id")
-            created_at = payload.get("created_at")
-            portfolio = self.portfolio_repository.get(portfolio_id)
-            self.create_snapshot(portfolio=portfolio, created_at=created_at)
-
-        # elif Event.ORDER_CREATED.equals(event_type):
-        #     portfolio_id = payload.get("portfolio_id")
-        #     portfolio = self.portfolio_repository.get(portfolio_id)
-        #     created_at = payload.get("created_at")
-        #     self.create_snapshot(portfolio=portfolio, created_at=created_at)
-
     def create_snapshot(
-        self, portfolio, created_at=None, cash_flow=0
+        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
@@ -93,52 +53,67 @@ class PortfolioSnapshotService(RepositoryService, Observer):
                 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_orders = self.order_repository.get_all(
-            {
-                "status": OrderStatus.OPEN.value,
-                "portfolio_id": portfolio.id
-            }
-        )
-        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 pending_orders is not None:
-            for order in pending_orders:
-                pending_value += order.get_price() * order.get_remaining()
-
-        if created_at is None:
-            config = self.configuration_service.get_config()
-
-            if Environment.BACKTEST.equals(config[ENVIRONMENT]):
-                created_at = config[BACKTESTING_INDEX_DATETIME]
-            else:
-                created_at = datetime.now(tz=timezone.utc)
+        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}):
-            symbol = \
-                f"{position.get_symbol()}/{portfolio.get_trading_symbol()}"
 
             if position.get_symbol() != portfolio.get_trading_symbol():
-                ticker = self.datasource_service.get_ticker(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 = {
@@ -154,16 +129,7 @@ class PortfolioSnapshotService(RepositoryService, Observer):
             "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):

investing_algorithm_framework/services/portfolios/portfolio_sync_service.py

@@ -20,7 +20,6 @@ class PortfolioSyncService(AbstractPortfolioSyncService):
         position_repository: PositionRepository object
         portfolio_repository: PortfolioRepository object
         market_credential_service: MarketCredentialService object
-        market_service: MarketService object
         portfolio_configuration_service: PortfolioConfigurationService object
         portfolio_provider_lookup: PortfolioProviderLookup object
     """
@@ -34,7 +33,6 @@ class PortfolioSyncService(AbstractPortfolioSyncService):
         portfolio_repository,
         portfolio_configuration_service,
         market_credential_service,
-        market_service,
         portfolio_provider_lookup
     ):
         self.trade_service = trade_service
@@ -43,7 +41,6 @@ class PortfolioSyncService(AbstractPortfolioSyncService):
         self.position_repository = position_repository
         self.portfolio_repository = portfolio_repository
         self.market_credential_service = market_credential_service
-        self.market_service = market_service
         self.portfolio_configuration_service = portfolio_configuration_service
         self.portfolio_provider_lookup = portfolio_provider_lookup
 

investing_algorithm_framework/services/repository_service.py

@@ -3,8 +3,8 @@ class RepositoryService:
     def __init__(self, repository):
         self.repository = repository
 
-    def create(self, data):
-        return self.repository.create(data)
+    def create(self, data, save=True):
+        return self.repository.create(data, save=save)
 
     def get(self, object_id):
         return self.repository.get(object_id)
@@ -35,3 +35,6 @@ class RepositoryService:
 
     def save(self, object):
         return self.repository.save(object)
+
+    def save_all(self, objects):
+        return self.repository.save_objects(objects)

investing_algorithm_framework/services/trade_order_evaluator/__init__.py

@@ -0,0 +1,9 @@
+from .trade_order_evaluator import TradeOrderEvaluator
+from .backtest_trade_oder_evaluator import BacktestTradeOrderEvaluator
+from .default_trade_order_evaluator import DefaultTradeOrderEvaluator
+
+__all__ = [
+    "TradeOrderEvaluator",
+    "BacktestTradeOrderEvaluator",
+    "DefaultTradeOrderEvaluator"
+]