Refactor BotContext

Now the BotContext decides which state to run

Author: DUYN

investing_bot_framework/core/context/bot_context.py

@@ -33,37 +33,51 @@ def transition_to(self, bot_state: Type[BotState]) -> None:
 
         self._state = bot_state(context=self)
 
-    def _check_state(self) -> None:
+    def _check_state(self, raise_exception: bool = False) -> bool:
         """
         Function that wil check if the state is set
         """
 
         if self._state is None:
-            raise OperationalException(
-                "Bot context doesn't have a state, Make sure that you set the state of bot either "
-                "by initializing it or making sure that you transition to a new valid state."
-            )
 
-    def run(self) -> None:
+            if raise_exception:
+                raise OperationalException(
+                    "Bot context doesn't have a state, Make sure that you set the state of bot either "
+                    "by initializing it or making sure that you transition to a new valid state."
+                )
+            else:
+                return False
+
+        return True
+
+    def start(self) -> None:
         """
         Run the current state of the investing_bot_framework
         """
 
-        self._check_state()
+        self._check_state(raise_exception=True)
+        self._run_state()
+
+        while self._check_state():
+            self._run_state()
+
+    def _run_state(self) -> None:
         self._state.start()
+        transition_state = self._state.get_transition_state_class()
+        self.transition_to(transition_state)
 
     def stop(self) -> None:
         """
         Stop the current state of the investing_bot_framework
         """
 
-        self._check_state()
+        self._check_state(raise_exception=True)
         self._state.stop()
 
     def reconfigure(self) -> None:
         """
         Reconfigure the current state of the investing_bot_framework
         """
 
-        self._check_state()
+        self._check_state(raise_exception=True)
         self._state.reconfigure()

investing_bot_framework/core/context/states/bot_state.py

@@ -25,12 +25,10 @@ def start(self):
         while True:
             self.run()
 
-            # Will run unit state has a positive validation and can transition to next state
+            # Will run state again if validation is negative
             if self.validate_state():
                 break
 
-        self.transition()
-
     @abstractmethod
     def run(self) -> None:
         pass
@@ -64,12 +62,7 @@ def validate_state(self) -> bool:
 
         return True
 
-    def transition(self) -> None:
-        bot_state_class = self.get_transition_state_class()
-        self.context.transition_to(bot_state_class)
-        self.context.run()
-
-    def get_transition_state_class(self) -> Type:
+    def get_transition_state_class(self):
 
         assert getattr(self, 'transition_state_class', None) is not None, (
             "{} should either include a transition_state_class attribute, or override the "

investing_bot_framework/core/context/states/data_state.py

@@ -2,16 +2,48 @@
 from typing import List
 from wrapt import synchronized
 
+from investing_bot_framework.core.exceptions import ImproperlyConfigured, OperationalException
 from investing_bot_framework.core.events import Observer
 from investing_bot_framework.core.context.bot_context import BotContext
 from investing_bot_framework.core.context.states import BotState
+from investing_bot_framework.core.executors import ExecutionScheduler
 from investing_bot_framework.core.data.data_providers import DataProvider, DataProviderExecutor
-from investing_bot_framework.core.resolvers import ClassCollector
-from investing_bot_framework.core.exceptions import OperationalException
+from investing_bot_framework.core.utils import Singleton, TimeUnit
 from investing_bot_framework.core.configuration.config_constants import DEFAULT_MAX_WORKERS, SETTINGS_MAX_WORKERS, \
     SETTINGS_DATA_PROVIDER_REGISTERED_APPS
 
 
+def import_class(cl):
+    d = cl.rfind(".")
+    classname = cl[d+1:len(cl)]
+    m = __import__(cl[0:d], globals(), locals(), [classname])
+    return getattr(m, classname)
+
+
+class DataProviderScheduler(ExecutionScheduler, metaclass=Singleton):
+    """
+    Data Provider scheduler that will function as a scheduler to make sure it keeps it state across multiple states,
+    it is defined as a Singleton.
+    """
+
+    def __init__(self):
+        self._configured = False
+
+        super(DataProviderScheduler, self).__init__()
+
+    def configure(self, data_providers: List[DataProvider]) -> None:
+        self._planning = {}
+
+        for data_provider in data_providers:
+            self.add_execution_task(execution_id=data_provider.get_id(), time_unit=TimeUnit.ALWAYS)
+
+        self._configured = True
+
+    @property
+    def configured(self) -> bool:
+        return self._configured
+
+
 class DataState(BotState, Observer):
     """
     Represent the data state of a bot. This state will load all the defined data providers and will
@@ -24,7 +56,6 @@ class DataState(BotState, Observer):
     transition_state_class = StrategyState
 
     data_providers: List[DataProvider] = []
-
     _data_provider_executor: DataProviderExecutor
 
     def __init__(self, context: BotContext) -> None:
@@ -40,17 +71,17 @@ def _initialize(self) -> None:
         """
         self._clean_up()
 
-        for data_provider_app_conf in self.context.settings[SETTINGS_DATA_PROVIDER_REGISTERED_APPS]:
-            class_collector = ClassCollector(package_path=data_provider_app_conf, class_type=DataProvider)
-            self.data_providers += class_collector.instances
+        for data_provider_app_class in self.context.settings[SETTINGS_DATA_PROVIDER_REGISTERED_APPS]:
 
-        self._data_provider_executor = DataProviderExecutor(
-            data_providers=self.data_providers,
-            max_workers=self.context.settings.get(SETTINGS_MAX_WORKERS, DEFAULT_MAX_WORKERS)
-        )
+            instance = import_class(data_provider_app_class)()
+
+            if not isinstance(instance, DataProvider):
+                raise ImproperlyConfigured(
+                    "Specified data provider {} is not a instance of DataProvider".format(data_provider_app_class)
+                )
+
+            self.data_providers.append(instance)
 
-        # Adding self as an observer
-        self._data_provider_executor.add_observer(self)
         self._configured = True
 
     def _clean_up(self) -> None:
@@ -61,25 +92,52 @@ def _clean_up(self) -> None:
         self._data_provider_executor = None
         self.data_providers = []
 
+    def _schedule_data_providers(self) -> List[DataProvider]:
+        data_provider_scheduler = DataProviderScheduler()
+
+        if not data_provider_scheduler.configured:
+            data_provider_scheduler.configure(self.data_providers)
+
+        planning = data_provider_scheduler.schedule_executions()
+        planned_data_providers = []
+
+        for data_provider in self.data_providers:
+
+            if data_provider.get_id() in planning:
+                planned_data_providers.append(data_provider)
+
+        return planned_data_providers
+
+    def _start_data_providers(self, data_providers: List[DataProvider]) -> None:
+
+        self._data_provider_executor = DataProviderExecutor(
+            data_providers=data_providers,
+            max_workers=self.context.settings.get(SETTINGS_MAX_WORKERS, DEFAULT_MAX_WORKERS)
+        )
+
+        self._data_provider_executor.add_observer(self)
+        self._data_provider_executor.start()
+
     def run(self) -> None:
 
         if self._configured:
-            # Start the data providers
-            self._data_provider_executor.start()
+            # Schedule the data providers
+            planned_data_providers = self._schedule_data_providers()
+
+            # Execute all the data providers
+            self._start_data_providers(planned_data_providers)
 
             # Sleep till updated
             while not self._updated:
                 time.sleep(1)
 
             # Collect all data from the data providers
             for data_provider in self._data_provider_executor.registered_data_providers:
-                print(data_provider.get_id())
+                print("Data provider: {} finished running".format(data_provider.get_id()))
 
         else:
             raise OperationalException("Data state started without any configuration")
 
-        print('stopped running')
-
     def stop(self) -> None:
         """
         Stop all data providers

investing_bot_framework/core/executors/__init__.py

@@ -1 +1,2 @@
 from investing_bot_framework.core.executors.executor import Executor
+from investing_bot_framework.core.executors.execution_scheduler import ExecutionScheduler

investing_bot_framework/core/management/commands/runbot.py

@@ -28,7 +28,7 @@ def handle(self, *args, **options) -> Any:
         # Create an investing_bot_framework context of the investing_bot_framework and run it
         context = BotContext()
         context.initialize(SetupState)
-        context.run()
+        context.start()
 
     @staticmethod
     def validate_cycles(self, cycles: int) -> None: