Fix app hook registration

Author: MDUYN

investing_algorithm_framework/app/app.py

@@ -34,13 +34,51 @@
 
 
 class AppHook:
+    """
+    Abstract class for app hooks. App hooks are used to run code before
+    actions of the framework are executed. This is useful for running code
+    that needs to be run before the following events:
+    - App initialization
+    - Strategy run
+    """
 
     @abstractmethod
-    def on_run(self, app, algorithm: Algorithm):
+    def on_run(self, context) -> None:
+        """
+        Method to run the app hook. This method should be implemented
+        by the user. This method will be called when the app is performing
+        a specific action.
+
+        Args:
+            context: The context of the app. This can be used to get the
+                current state of the trading bot, such as portfolios,
+                orders, positions, etc.
+
+        Returns:
+            None
+        """
         raise NotImplementedError()
 
 
 class App:
+    """
+    Class to represent the app. This class is used to initialize the
+    application and run your trading bot.
+
+    Attributes:
+        - container: The dependency container for the app. This is used
+            to store all the services and repositories for the app.
+        - algorithm: The algorithm to run. This is used to run the
+            trading bot.
+        - flask_app: The flask app instance. This is used to run the
+            web app.
+        - state_handler: The state handler for the app. This is used
+            to save and load the state of the app.
+        - name: The name of the app. This is used to identify the app
+            in logs and other places.
+        - started: A boolean value that indicates if the app has been
+            started or not.
+    """
 
     def __init__(self, state_handler=None, name=None):
         self._flask_app: Optional[Flask] = None
@@ -54,6 +92,7 @@ def __init__(self, state_handler=None, name=None):
         self._market_credential_service: \
             Optional[MarketCredentialService] = None
         self._on_initialize_hooks = []
+        self._on_strategy_run_hooks = []
         self._on_after_initialize_hooks = []
         self._state_handler = state_handler
         self._name = name
@@ -114,13 +153,25 @@ def set_config_with_dict(self, dictionary) -> None:
         configuration_service.add_dict(dictionary)
 
     def initialize_services(self) -> None:
-        self._configuration_service = self.container.configuration_service()
-        self._configuration_service.initialize()
+        """
+        Method to initialize the services for the app. This method should
+        be called before running the application. This method initializes
+        all services so that they are ready to be used.
+
+        Returns:
+            None
+        """
         self._market_data_source_service = \
             self.container.market_data_source_service()
         self._market_credential_service = \
             self.container.market_credential_service()
 
+        strategy_orchestrator_service = \
+            self.container.strategy_orchestrator_service()
+
+        for app_hook in self._on_strategy_run_hooks:
+            strategy_orchestrator_service.add_app_hook(app_hook)
+
     @algorithm.setter
     def algorithm(self, algorithm: Algorithm) -> None:
         self._algorithm = algorithm
@@ -212,6 +263,7 @@ def initialize(self):
             None
         """
         logger.info("Initializing app")
+        self.initialize_services()
         self._initialize_default_order_executors()
         self._initialize_default_portfolio_providers()
 
@@ -418,7 +470,7 @@ def run(
 
             # Run all on_initialize hooks
             for hook in self._on_initialize_hooks:
-                hook.on_run(self, self.algorithm)
+                hook.on_run(self.context)
 
             configuration_service = self.container.configuration_service()
             config = configuration_service.get_config()
@@ -580,7 +632,28 @@ def get_portfolio_configurations(self):
             .portfolio_configuration_service()
         return portfolio_configuration_service.get_all()
 
-    def get_market_credentials(self):
+    def get_market_credential(self, market: str) -> MarketCredential:
+        """
+        Function to get a market credential from the app. This method
+        should be called when you want to get a market credential.
+
+        Args:
+            market (str): The market to get the credential for
+
+        Returns:
+            MarketCredential: Instance of MarketCredential
+        """
+
+        market_credential_service = self.container \
+            .market_credential_service()
+        market_credential = market_credential_service.get(market)
+        if market_credential is None:
+            raise OperationalException(
+                f"Market credential for {market} not found"
+            )
+        return market_credential
+
+    def get_market_credentials(self) -> List[MarketCredential]:
         """
         Function to get all market credentials from the app. This method
         should be called when you want to get all market credentials.
@@ -852,17 +925,40 @@ def add_market_credential(self, market_credential: MarketCredential):
         market_credential.market = market_credential.market.upper()
         self._market_credential_service.add(market_credential)
 
-    def on_initialize(self, app_hook: AppHook):
+    def on_initialize(self, app_hook):
         """
         Function to add a hook that runs when the app is initialized. The hook
         should be an instance of AppHook.
         """
 
+        # Check if the app_hook inherits from AppHook
+        if not issubclass(app_hook, AppHook):
+            raise OperationalException(
+                "App hook should be an instance of AppHook"
+            )
+
         if inspect.isclass(app_hook):
             app_hook = app_hook()
 
         self._on_initialize_hooks.append(app_hook)
 
+    def on_strategy_run(self, app_hook):
+        """
+        Function to add a hook that runs when a strategy is run. The hook
+        should be an instance of AppHook.
+        """
+
+        # Check if the app_hook inherits from AppHook
+        if not issubclass(app_hook, AppHook):
+            raise OperationalException(
+                "App hook should be an instance of AppHook"
+            )
+
+        if inspect.isclass(app_hook):
+            app_hook = app_hook()
+
+        self._on_strategy_run_hooks.append(app_hook)
+
     def after_initialize(self, app_hook: AppHook):
         """
         Function to add a hook that runs after the app is initialized.

investing_algorithm_framework/dependency_container.py

@@ -132,7 +132,7 @@ class DependencyContainer(containers.DeclarativeContainer):
         market_service=market_service,
         portfolio_provider_lookup=portfolio_provider_lookup,
     )
-    strategy_orchestrator_service = providers.Factory(
+    strategy_orchestrator_service = providers.ThreadSafeSingleton(
         StrategyOrchestratorService,
         market_data_source_service=market_data_source_service,
         configuration_service=configuration_service,

investing_algorithm_framework/domain/models/market/market_credential.py

@@ -51,14 +51,6 @@ def initialize(self):
             environment_variable = f"{self.market.upper()}_SECRET_KEY"
             self._secret_key = os.getenv(environment_variable)
 
-            if self.secret_key is None:
-                raise OperationalException(
-                    f"Market credential for market {self.market}"
-                    " requires a secret key, either"
-                    " as an argument or as an environment variable"
-                    f" named as {self._market.upper()}_SECRET_KEY"
-                )
-
     def get_api_key(self):
         return self.api_key
 

investing_algorithm_framework/infrastructure/order_executors/ccxt_order_executor.py

@@ -3,7 +3,8 @@
 import ccxt
 
 from investing_algorithm_framework.domain import OrderExecutor, \
-    OperationalException, Order, OrderStatus, OrderSide, OrderType
+    OperationalException, Order, OrderStatus, OrderSide, OrderType, \
+    MarketCredential
 
 logger = getLogger("investing_algorithm_framework")
 
@@ -136,12 +137,55 @@ def initialize_exchange(market, market_credential):
                 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

investing_algorithm_framework/infrastructure/portfolio_providers/ccxt_portfolio_provider.py

@@ -3,7 +3,7 @@
 from typing import Union
 
 from investing_algorithm_framework.domain import PortfolioProvider, \
-    OperationalException, Order, Position
+    OperationalException, Order, Position, MarketCredential
 
 
 logger = getLogger("investing_algorithm_framework")
@@ -110,6 +110,17 @@ def get_position(
 
     @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):
@@ -124,12 +135,56 @@ def initialize_exchange(market, market_credential):
                 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

investing_algorithm_framework/services/strategy_orchestrator_service.py

@@ -36,8 +36,9 @@ class StrategyOrchestratorService:
     def __init__(
         self,
         market_data_source_service: MarketDataSourceService,
-        configuration_service
+        configuration_service,
     ):
+        self._app_hooks = []
         self.history = {}
         self._strategies = []
         self._tasks = []
@@ -49,6 +50,18 @@ def __init__(
             = market_data_source_service
         self.configuration_service = configuration_service
 
+    def add_app_hook(self, app_hook):
+        """
+        Add an app hook to the list of app hooks
+
+        Args:
+            app_hook (AppHook): The app hook to add
+
+        Returns:
+            None
+        """
+        self._app_hooks.append(app_hook)
+
     def cleanup_threads(self):
 
         for stoppable in self.threads:
@@ -73,6 +86,10 @@ def run_strategy(self, strategy, context, sync=False):
 
         logger.info(f"Running strategy {strategy.worker_id}")
 
+        # Run the app hooks
+        for app_hook in self._app_hooks:
+            app_hook.on_run(context=context)
+
         if sync:
             strategy.run_strategy(
                 market_data=market_data,