Merge pull request #6 from investingbots/feature_base_strategy

Feature base strategy

Author: investingbots

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

bot/data/data_provider/data_provider.py

@@ -1,5 +1,5 @@
 import logging
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from pandas import DataFrame
 
 from bot.events.observable import Observable
@@ -18,7 +18,7 @@ def __init__(self, message: str) -> None:
         super().__init__(self)
         self.message = message
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.message
 
     def __json__(self):
@@ -29,11 +29,11 @@ def __json__(self):
 
 class DataProvider(Observable):
 
-    def __init__(self):
+    def __init__(self) -> None:
         super(DataProvider, self).__init__()
         self._data: DataFrame = None
 
-    def start(self):
+    def start(self) -> None:
         self._data = self.provide_data()
         self.notify_observers()
 
@@ -48,16 +48,17 @@ def provide_data(self) -> DataFrame:
         pass
 
     @property
-    def data(self):
+    def data(self) -> DataFrame:
 
         if self._data is None:
-
-            raise DataProviderException("Could not provide data")
-
+            raise DataProviderException("Could not provide data, data is not set")
         else:
-            return self._data
+            data = self._data
+            self.clean_up()
+            return data
 
-    def clear(self):
+    @abstractmethod
+    def clean_up(self) -> None:
         self._data = None
 
     @abstractmethod

bot/data/data_provider_executor.py

@@ -1,10 +1,10 @@
 import logging
-from typing import List, Dict, Tuple
+from typing import List, Tuple
 
 from bot.utils import StoppableThread
 from bot.executors import WorkerExecutor
 from bot.events.observable import Observable
-from bot.data.data_provider.data_provider import DataProvider, DataProviderException
+from bot.data.data_provider.data_provider import DataProvider
 
 logger = logging.getLogger(__name__)
 
@@ -31,31 +31,9 @@ def create_jobs(self) -> List[Tuple[Observable, StoppableThread]]:
 
         return jobs
 
+    def start(self) -> None:
+        super(DataProviderExecutor, self).start()
+
     @property
     def registered_data_providers(self) -> List[DataProvider]:
         return self._registered_data_providers
-
-
-class ConfigDataProviderExecutor(DataProviderExecutor):
-
-    def __init__(self, config: Dict[str, any], data_providers: List[DataProvider] = None):
-
-        data_providers: List[DataProvider] = []
-
-        # Enable fmp data provider
-        if config.get('data_provider', {}).get('fmp', {}).get('enabled', False):
-            logger.info('Enabling data_provider.fmp ...')
-
-            try:
-                logging.info("Initializing FMP data provider")
-                from bot.data.data_provider.template.fmp_data_provider import FMPDataProvider
-                data_providers.append(FMPDataProvider())
-            except Exception as e:
-                raise DataProviderException(str(e))
-
-        if data_providers is not None:
-
-            for data_provider in data_providers:
-                data_providers.append(data_provider)
-
-        super(ConfigDataProviderExecutor, self).__init__(data_providers)

bot/executors/executor.py

@@ -0,0 +1,13 @@
+from abc import abstractmethod
+
+from bot.events.observable import Observable
+
+
+class Executor(Observable):
+    """
+    Executor class: functions as an interface that will handle the executions of functions.
+    """
+
+    @abstractmethod
+    def start(self) -> None:
+        pass

bot/executors/single_worker_executor.py

@@ -0,0 +1,20 @@
+from abc import abstractmethod
+
+from bot.executors.executor import Executor
+
+
+class SingleExecutor(Executor):
+    """
+    SingleExecutor class: functions as an abstract class that will handle the executions of a single function.
+    """
+
+    def __init__(self) -> None:
+        super(SingleExecutor, self).__init__()
+
+    def start(self) -> None:
+        self.run_job()
+        self.notify_observers()
+
+    @abstractmethod
+    def run_job(self) -> None:
+        pass

bot/executors/worker_executor.py

@@ -1,18 +1,23 @@
+import logging
 from queue import Queue
 from abc import abstractmethod
 from wrapt import synchronized
-from typing import Dict, List, Tuple, Any
+from typing import Dict, List, Tuple
 
 from bot import OperationalException
 from bot.utils import StoppableThread
 from bot.events.observer import Observer
+from bot.executors.executor import Executor
 from bot.events.observable import Observable
 from bot.constants import DEFAULT_MAX_WORKERS
 
 
-class WorkerExecutor(Observable, Observer):
+logger = logging.getLogger(__name__)
+
+
+class WorkerExecutor(Executor, Observer):
     """
-    WorkerExecutor class: Abstract class that will schedule, execute and manage workers.
+    WorkerExecutor class: functions as an abstract class that will schedule, execute and manage workers.
     """
 
     def __init__(self, max_workers: int = DEFAULT_MAX_WORKERS) -> None:

bot/remote_loaders/data_provider_remote_loader.py

@@ -22,12 +22,12 @@ def load_data_provider(self, data_provider_class_name: str) -> DataProvider:
         modules = self.locate_python_modules(data_providers_dir)
         location = self.locate_class(modules, data_provider_class_name)
         generator = self.create_class_generators(location, data_provider_class_name, DataProvider)
-        data_provider: DataProvider = next(generator, None)
+        instance: DataProvider = next(generator, None)()
 
-        if data_provider and issubclass(data_provider, DataProvider):
-            return data_provider
+        if instance and isinstance(instance, DataProvider):
+            return instance
 
         raise OperationalException(
-            f"Impossible to load Strategy '{data_provider_class_name}'. This strategy does not exist "
+            f"Impossible to load Strategy '{data_provider_class_name}'. This data provider does not exist "
             "or contains Python code errors."
         )

bot/remote_loaders/strategy_remote_loader.py

@@ -22,9 +22,9 @@ def load_strategy(self, strategy_class_name: str) -> Strategy:
         modules = self.locate_python_modules(strategies_dir)
         location = self.locate_class(modules, strategy_class_name)
         generator = self.create_class_generators(location, strategy_class_name, Strategy)
-        strategy: Strategy = next(generator, None)
+        strategy: Strategy = next(generator, None)()
 
-        if strategy and issubclass(strategy, Strategy):
+        if strategy and isinstance(strategy, Strategy):
             return strategy
 
         raise OperationalException(