Setup States

Author: DUYN

bot/context/analyzing_state.py

@@ -1,13 +1,26 @@
+import logging
+
 from bot.context.bot_state import BotState
+from bot.context.bot_context import BotContext
+
+logger = logging.getLogger(__name__)
 
 
 class AnalyzingState(BotState):
 
-    def run(self):
-        pass
+    def __init__(self):
+        logger.info("Initializing analyzing state ...")
+
+    def run(self) -> None:
+        logger.info("Analyzing state started ...")
+
+        from bot.context.data_providing_state import DataProvidingState
+        context = BotContext()
+        context.transition_to(DataProvidingState)
+        context.run()
 
-    def stop(self):
+    def stop(self) -> None:
         pass
 
-    def reconfigure(self):
+    def reconfigure(self) -> None:
         pass

bot/context/bot_context.py

@@ -1,12 +1,13 @@
 import logging
-from typing import Dict, Type, Any
 from pandas import DataFrame
+from typing import Dict, Type, Any, List
 
-from bot.utils import Singleton
 from bot import OperationalException
 from bot.data import DataProviderExecutor
 from bot.context.bot_state import BotState
 from bot.strategies import StrategyExecutor
+from bot.utils import Singleton, DataSource
+
 
 logger = logging.getLogger(__name__)
 
@@ -23,8 +24,17 @@ class BotContext(metaclass=Singleton):
     """
     _state: BotState = None
 
+    """
+    List of all the buying and selling orders.
+    """
+    _buy_orders: DataFrame = None
+    _sell_orders: DataFrame = None
+
+    """
+    The data sources for the bot
+    """
     _analyzed_data: DataFrame = None
-    _raw_data_sources: Dict[str, DataFrame] = None
+    _data_sources: List[DataSource] = None
 
     _strategy_executor = None
     _data_provider_executor: DataProviderExecutor = None
@@ -68,12 +78,12 @@ def analyzed_data(self, data_frame: DataFrame) -> None:
         self._analyzed_data = data_frame
 
     @property
-    def raw_data(self) -> Dict[str, DataFrame]:
-        return self._raw_data_sources
+    def data_sources(self) -> List[DataSource]:
+        return self._data_sources
 
-    @raw_data.setter
-    def raw_data(self, raw_data_sources: Dict[str, DataFrame]) -> None:
-        self._raw_data_sources = raw_data_sources
+    @data_sources.setter
+    def data_sources(self, data_sources: List[DataSource]) -> None:
+        self._data_sources = data_sources
 
     @property
     def data_provider_executor(self) -> DataProviderExecutor:

bot/context/data_providing_state.py

@@ -1,69 +1,74 @@
 import logging
 from time import sleep
+from typing import List
 from wrapt import synchronized
 
+from bot.utils import DataSource
 from bot import OperationalException
 from bot.events.observer import Observer
 from bot.context.bot_state import BotState
 from bot.context.bot_context import BotContext
-from bot.context.analyzing_state import AnalyzingState
 from bot.data.data_provider_executor import DataProviderExecutor
 
 logger = logging.getLogger(__name__)
 
 
 class DataProvidingState(BotState, Observer):
 
-    def __init__(self):
+    def __init__(self) -> None:
         super(DataProvidingState, self).__init__()
 
         logger.info("Initializing data providing state ...")
 
         # Initialize the manager
         context = BotContext()
 
-        self._executor: DataProviderExecutor = context.data_provider_executor
-        self._executor.add_observer(self)
+        self._data_provider_executor: DataProviderExecutor = context.data_provider_executor
+        self._data_provider_executor.add_observer(self)
 
         self._updated = False
         self._started = False
 
-    def _clean_up(self):
+    def _clean_up(self) -> None:
 
-        if self._executor.processing:
-            self._executor.stop()
+        if self._data_provider_executor.processing:
+            self._data_provider_executor.stop()
 
         self._updated = False
         self._started = False
 
-    def run(self):
+    def run(self) -> None:
         logger.info("Data providing state started ...")
 
-        # if not self._started:
-        #     self._executor.start()
-        #
-        # # Sleep till updated
-        # while not self._updated:
-        #     sleep(1)
-        #
-        # if self._updated:
-        #
-        #     # Collect all data from the data providers
-        #     data_entries = {}
-        #
-        #     for data_provider in self._executor.registered_data_providers:
-        #         data_entries[data_provider.get_id()] = data_provider.data
-        #
-        #     context = BotContext()
-        #     context.raw_data = data_entries
-        #     context.transition_to(AnalyzingState)
-        # else:
-        #     raise OperationalException("Abruptly ended out of run state")
-
-    def stop(self):
+        data_sources: List[DataSource] = []
+
+        if not self._started:
+            self._data_provider_executor.start()
+
+        # Sleep till updated
+        while not self._updated:
+            sleep(1)
+
+        if self._updated:
+
+            # Collect all data from the data providers
+            for data_provider in self._data_provider_executor.registered_data_providers:
+                data_sources.append(DataSource(data_provider.get_id(), data_provider.data))
+
+            context = BotContext()
+            context.data_sources = data_sources
+
+            # Transitioning to another state
+            from bot.context.analyzing_state import AnalyzingState
+            context.transition_to(AnalyzingState)
+            context.run()
+        else:
+            raise OperationalException("Abruptly ended out of run state")
+
+    def stop(self) -> None:
         pass
 
-    def reconfigure(self):
+    def reconfigure(self) -> None:
         self._clean_up()
 
     @synchronized