Add StrategyState

Author: sadays

investing_bot_framework/core/context/states/bot_state.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Type, List
+from typing import List
 
 from investing_bot_framework.core.context.state_validator import StateValidator
 
@@ -33,18 +33,10 @@ def start(self):
     def run(self) -> None:
         pass
 
-    @abstractmethod
-    def stop(self) -> None:
-        pass
-
     @property
     def context(self):
         return self._bot_context
 
-    @abstractmethod
-    def reconfigure(self) -> None:
-        pass
-
     def validate_state(self) -> bool:
         """
         Function that will validate the state

…re/context/states/data_provider_state.py …e/context/states/data_providing_state.pyinvesting_bot_framework/core/context/states/data_provider_state.py renamed to investing_bot_framework/core/context/states/data_providing_state.py investing_bot_framework/core/context/states/data_provider_state.py renamed to investing_bot_framework/core/context/states/data_providing_state.py

@@ -8,13 +8,39 @@
 from investing_bot_framework.core.exceptions import OperationalException
 from investing_bot_framework.core.context.states import BotState
 from investing_bot_framework.core.executors import ExecutionScheduler
+from investing_bot_framework.core.workers import Worker
 from investing_bot_framework.core.data_providers import DataProvider
-from investing_bot_framework.core.executors.data_provider_executor import DataProviderExecutor
+from investing_bot_framework.core.executors import Executor
 from investing_bot_framework.core.configuration.config_constants import DEFAULT_MAX_WORKERS, SETTINGS_MAX_WORKERS
 
 logger = logging.getLogger(__name__)
 
 
+class DataProviderExecutor(Executor):
+    """
+    Class DataProviderExecutor: is an executor for DataProvider instances.
+    """
+
+    def __init__(self, data_providers: List[DataProvider] = None, max_workers: int = DEFAULT_MAX_WORKERS):
+        super(DataProviderExecutor, self).__init__(max_workers=max_workers)
+
+        self._registered_data_providers: List[DataProvider] = []
+
+        if data_providers is not None and len(data_providers) > 0:
+            self._registered_data_providers = data_providers
+
+    def create_workers(self) -> List[Worker]:
+        return self._registered_data_providers
+
+    @property
+    def registered_data_providers(self) -> List[DataProvider]:
+        return self._registered_data_providers
+
+    @property
+    def configured(self):
+        return self._registered_data_providers is not None and len(self._registered_data_providers) > 0
+
+
 class DataProviderScheduler(ExecutionScheduler):
     """
     Data Provider scheduler that will function as a scheduler to make sure it keeps it state across multiple states,
@@ -42,7 +68,7 @@ def configured(self) -> bool:
         return self._configured
 
 
-class DataProviderState(BotState, Observer):
+class DataProvidingState(BotState, Observer):
     """
     Represent the data_providers state of a bot. This state will load all the defined data_providers providers and will
     run them.
@@ -58,19 +84,19 @@ class DataProviderState(BotState, Observer):
     data_provider_scheduler: DataProviderScheduler = None
 
     def __init__(self, context: BotContext) -> None:
-        super(DataProviderState, self).__init__(context)
+        super(DataProvidingState, self).__init__(context)
         self._updated = False
         self.data_provider_executor = None
 
     def _schedule_data_providers(self) -> List[DataProvider]:
 
-        if not DataProviderState.data_provider_scheduler:
-            DataProviderState.data_provider_scheduler = DataProviderScheduler()
+        if not DataProvidingState.data_provider_scheduler:
+            DataProvidingState.data_provider_scheduler = DataProviderScheduler()
 
-        if not DataProviderState.data_provider_scheduler.configured:
-            DataProviderState.data_provider_scheduler.configure(self.registered_data_providers)
+        if not DataProvidingState.data_provider_scheduler.configured:
+            DataProvidingState.data_provider_scheduler.configure(self.registered_data_providers)
 
-        planning = DataProviderState.data_provider_scheduler.schedule_executions()
+        planning = DataProvidingState.data_provider_scheduler.schedule_executions()
         planned_data_providers = []
 
         for data_provider in self.registered_data_providers:
@@ -113,22 +139,13 @@ def run(self) -> None:
         for data_provider in self.data_provider_executor.registered_data_providers:
             logger.info("Data provider: {} finished running".format(data_provider.get_id()))
 
-    def stop(self) -> None:
-        """
-        Stop all data_providers providers
-        """
-        pass
-
     @synchronized
     def update(self, observable, **kwargs) -> None:
         self._updated = True
 
     @staticmethod
     def register_data_providers(data_providers: List) -> None:
-        DataProviderState.registered_data_providers = data_providers
-
-    def reconfigure(self) -> None:
-        pass
+        DataProvidingState.registered_data_providers = data_providers
 
 
 

investing_bot_framework/core/context/states/setup_state.py

@@ -4,8 +4,8 @@
 
 class SetupState(BotState):
 
-    from investing_bot_framework.core.context.states.data_provider_state import DataProviderState
-    transition_state_class = DataProviderState
+    from investing_bot_framework.core.context.states.data_providing_state import DataProvidingState
+    transition_state_class = DataProvidingState
 
     def __init__(self, context):
         super(SetupState, self).__init__(context)

investing_bot_framework/core/context/states/strategy_state.py

@@ -1,21 +1,136 @@
-from typing import Type
+import logging
+import time
+from typing import List
+
 from investing_bot_framework.core.context.states import BotState
+from investing_bot_framework.core.executors import ExecutionScheduler
+from investing_bot_framework.core.exceptions import OperationalException
+from investing_bot_framework.core.workers import Worker
+from investing_bot_framework.core.executors import Executor
+from investing_bot_framework.core.events import Observer
+from investing_bot_framework.core.configuration.config_constants import DEFAULT_MAX_WORKERS, SETTINGS_MAX_WORKERS
+
+logger = logging.getLogger(__name__)
+
+
+class StrategyExecutor(Executor):
+    """
+    Class StrategyExecutor: is an executor for Strategy instances.
+    """
+
+    def __init__(self, strategies: List = None, max_workers: int = DEFAULT_MAX_WORKERS):
+        super(StrategyExecutor, self).__init__(max_workers=max_workers)
+
+        self._registered_strategies: List = []
+
+        if strategies is not None and len(strategies) > 0:
+            self._registered_strategies = strategies
+
+    def create_workers(self) -> List[Worker]:
+        return self._registered_strategies
+
+    @property
+    def registered_strategies(self) -> List:
+        return self._registered_strategies
+
+    @property
+    def configured(self):
+        return self._registered_strategies is not None and len(self._registered_strategies) > 0
+
+
+class StrategyScheduler(ExecutionScheduler):
+    """
+    Strategy scheduler that will function as a scheduler.
+    """
+
+    def __init__(self):
+        self._configured = False
+        super(StrategyScheduler, self).__init__()
+
+    def configure(self, strategies: List) -> None:
+        self._planning = {}
+
+        for strategy in strategies:
+            self.add_execution_task(
+                execution_id=strategy.get_id(),
+                time_unit=strategy.get_time_unit(),
+                interval=strategy.get_time_interval()
+            )
+
+        self._configured = True
+
+    @property
+    def configured(self) -> bool:
+        return self._configured
 
 
-class StrategyState(BotState):
+class StrategyState(BotState, Observer):
+
+    from investing_bot_framework.core.context.states.data_providing_state import DataProvidingState
+    transition_state_class = DataProvidingState
+
+    registered_strategies: List = None
+    strategy_scheduler: StrategyScheduler = None
+
+    def __init__(self, context):
+        super(StrategyState, self).__init__(context)
+        self._updated = False
+        self.strategy_executor = None
+
+    def _schedule_strategies(self) -> List:
+
+        if not StrategyState.strategy_scheduler:
+            StrategyState.strategy_scheduler = StrategyScheduler()
+
+        if not StrategyState.strategy_scheduler.configured:
+            StrategyState.strategy_scheduler.configure(self.registered_strategies)
+
+        planning = StrategyState.strategy_scheduler.schedule_executions()
+        planned_strategies = []
+
+        for strategy in self.registered_strategies:
+
+            if strategy.get_id() in planning:
+                planned_strategies.append(strategy)
+
+        return planned_strategies
+
+    def _start_strategies(self, strategies: List) -> None:
+
+        self.strategy_executor = StrategyExecutor(
+            strategies=strategies,
+            max_workers=self.context.settings.get(SETTINGS_MAX_WORKERS, DEFAULT_MAX_WORKERS)
+        )
+
+        if self.strategy_executor.configured:
+            self.strategy_executor.add_observer(self)
+            self.strategy_executor.start()
+        else:
+            # Skip the execution
+            self._updated = True
 
     def run(self) -> None:
-        pass
 
-    def stop(self) -> None:
-        pass
+        if self.registered_strategies is None:
+            raise OperationalException("Data providing state has not any data providers configured")
+
+        # Schedule the strategies providers
+        planned_strategies = self._schedule_strategies()
+
+        # Execute all the strategies providers
+        self._start_strategies(planned_strategies)
+
+        # Sleep till updated
+        while not self._updated:
+            time.sleep(1)
 
-    def reconfigure(self) -> None:
-        pass
+        # Collect all strategies from the strategies providers
+        for strategies in self.strategy_executor.registered_strategies:
+            logger.info("Data provider: {} finished running".format(strategies.get_id()))
 
     def update(self, observable, **kwargs) -> None:
-        pass
+        self._updated = True
 
-    def get_transition_state_class(self) -> Type:
-        from investing_bot_framework.core.context.states.data_provider_state import DataProviderState
-        return DataProviderState
+    @staticmethod
+    def register_strategies(strategies: List) -> None:
+        StrategyState.registered_strategies = strategies