Fix logging

Author: MDUYN

investing_algorithm_framework/templates/states/data_providing_state.py

@@ -6,7 +6,9 @@
 from investing_algorithm_framework.core.workers import Worker
 from investing_algorithm_framework.core.executors import Executor
 from investing_algorithm_framework.configuration.config_constants \
-    import DEFAULT_MAX_WORKERS, SETTINGS_MAX_WORKERS
+    import SETTINGS_MAX_CONCURRENT_WORKERS, DEFAULT_MAX_WORKERS
+from investing_algorithm_framework.templates.data_providers.data_provider \
+    import DataProviderInterface
 
 
 class DataProvidingState(State):
@@ -40,12 +42,25 @@ def run(self) -> None:
         # Execute all the data providers
         executor = Executor(
             workers=self.registered_data_providers,
-            max_concurrent_workers=self.context.settings.get(
-                SETTINGS_MAX_WORKERS, DEFAULT_MAX_WORKERS
+            max_concurrent_workers=self.context.config.get(
+                SETTINGS_MAX_CONCURRENT_WORKERS, DEFAULT_MAX_WORKERS
             )
         )
         executor.start()
 
     @staticmethod
-    def register_data_providers(data_providers: List[Worker]) -> None:
+    def register_data_providers(data_providers: List) -> None:
+
+        for data_provider in data_providers:
+
+            assert isinstance(data_provider, Worker), (
+                'Data provider {} must be of type '
+                'Worker'.format(data_provider.__class__)
+            )
+
+            assert isinstance(data_provider, DataProviderInterface), (
+                'Data provider {} must be of type '
+                'DataProviderInterface'.format(data_provider.__class__)
+            )
+
         DataProvidingState.registered_data_providers = data_providers

investing_algorithm_framework/templates/states/ordering_state.py

@@ -1,9 +1,14 @@
 from typing import List
+import logging
 
+from investing_algorithm_framework.core.executors import Executor
 from investing_algorithm_framework.core.state import State
 from investing_algorithm_framework.core.exceptions import OperationalException
-from investing_algorithm_framework.templates.order_executors \
-    import OrderExecutor
+from investing_algorithm_framework.core.workers import Worker
+from investing_algorithm_framework.configuration.config_constants import \
+    SETTINGS_MAX_CONCURRENT_WORKERS, DEFAULT_MAX_WORKERS
+from investing_algorithm_framework.templates.order_executors.order_executor \
+    import OrderExecutorInterface
 
 
 class OrderingState(State):
@@ -12,21 +17,40 @@ class OrderingState(State):
         import DataProvidingState
     transition_state_class = DataProvidingState
 
-    order_executors: List[OrderExecutor] = None
+    registered_order_executors: List[Worker] = None
 
     def __init__(self, context) -> None:
         super(OrderingState, self).__init__(context)
 
-        if self.order_executors is None or len(self.order_executors) < 1:
+        if self.registered_order_executors is None \
+                or len(self.registered_order_executors) < 1:
             raise OperationalException(
                 "OrderingState state has not any order executors configured"
             )
 
     def run(self) -> None:
 
-        for order_executor in OrderingState.order_executors:
-            order_executor.execute_orders()
+        # Execute all the order executors
+        executor = Executor(
+            workers=self.registered_order_executors,
+            max_concurrent_workers=self.context.config.get(
+                SETTINGS_MAX_CONCURRENT_WORKERS, DEFAULT_MAX_WORKERS
+            )
+        )
+        executor.start()
 
     @staticmethod
-    def register_order_executors(order_executors: List[OrderExecutor]) -> None:
-        OrderingState.order_executors = order_executors
+    def register_order_executors(order_executors: List) -> None:
+
+        for order_executor in order_executors:
+            assert isinstance(order_executor, Worker), (
+                'Order executor {} must be of type '
+                'Worker'.format(order_executor.__class__)
+            )
+
+            assert isinstance(order_executor, OrderExecutorInterface), (
+                'Order executor {} must be of type '
+                'OrderExecutorInterface'.format(order_executor.__class__)
+            )
+
+        OrderingState.registered_order_executors = order_executors

investing_algorithm_framework/templates/states/setup_state.py

@@ -21,7 +21,7 @@ def run(self) -> None:
         """
 
         # Load the settings
-        if not self.context.settings.configured:
+        if not self.context.config.configured:
             raise ImproperlyConfigured(
                 "Settings module is not specified, make sure you have setup "
                 "a investing_algorithm_framework project and the "

investing_algorithm_framework/templates/states/strategy_state.py

@@ -4,8 +4,10 @@
 from investing_algorithm_framework.core.exceptions import OperationalException
 from investing_algorithm_framework.core.executors import Executor
 from investing_algorithm_framework.configuration.config_constants \
-    import DEFAULT_MAX_WORKERS, SETTINGS_MAX_WORKERS
+    import DEFAULT_MAX_WORKERS, SETTINGS_MAX_CONCURRENT_WORKERS
 from investing_algorithm_framework.core.workers import Worker
+from investing_algorithm_framework.templates.strategies.strategy \
+    import StrategyInterface
 
 
 class StrategyState(State):
@@ -33,14 +35,27 @@ def run(self) -> None:
         # Execute all the strategies
         executor = Executor(
             workers=self.registered_strategies,
-            max_concurrent_workers=self.context.settings.get(
-                SETTINGS_MAX_WORKERS, DEFAULT_MAX_WORKERS
+            max_concurrent_workers=self.context.config.get(
+                SETTINGS_MAX_CONCURRENT_WORKERS, DEFAULT_MAX_WORKERS
             )
         )
         executor.start()
 
     @staticmethod
     def register_strategies(strategies: List) -> None:
+
+        for strategy in strategies:
+
+            assert isinstance(strategy, Worker), (
+                'Strategy {} must be of type '
+                'Worker'.format(strategy.__class__)
+            )
+
+            assert isinstance(strategy, StrategyInterface), (
+                'Strategy {} must be of type '
+                'StrategyInterface'.format(strategy.__class__)
+            )
+
         StrategyState.registered_strategies = strategies
 
     def get_transition_state_class(self):