Merge pull request #5 from investingbots/feature_base_strategy

Feature base strategy

Author: investingbots

.gitignore

@@ -129,4 +129,9 @@ config.json
 bot_configuration.db
 *.db
 .idea
-*log*
+*log*
+
+!plugins/strategies/
+plugins/strategies/*.py
+!plugins/data_providers/
+plugins/data_providers/*.py

LICENSE

@@ -1,2 +1,3 @@
 from bot.configuration.configuration import Configuration
 from bot.configuration.arguments import Arguments
+

bot/bot.py

@@ -3,71 +3,79 @@
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from bot.configuration.cli_options import AVAILABLE_CLI_OPTIONS
+from bot import __version__
 from bot import constants
 from bot import DependencyException
+from bot.configuration.bot_configuration import initialize
 
 logger = logging.getLogger(__name__)
 
 
-ARGS_COMMON = ["version", "config"]
+class Argument:
+
+    def __init__(self, *args, **kwargs):
+        self.cli = args
+        self.kwargs = kwargs
+
+
+# Declarations of the command line interface commands
+CLI_COMMANDS = {
+    "version": Argument(
+        '-V', '--version',
+        action='version',
+        version=f'%(prog)s {__version__}',
+    ),
+    "config": Argument(
+        '-c', '--config',
+        help="Specify configuration file (default: {}".format(constants.DEFAULT_CONFIG),
+        action='append',
+        metavar='PATH',
+    ),
+}
 
 
 class Arguments:
     """
-    Arguments Class. Manage the arguments received by the cli
+    Arguments Class. Functions as a utilities class to manage the arguments received by the command line interface,
     """
 
     def __init__(self, args: Optional[List[str]]) -> None:
-
-        # Map the args
         self.args = args
-        self._parsed_arg: Optional[argparse.Namespace] = None
+        self._parsed_args: Optional[argparse.Namespace] = None
+        self.parser = argparse.ArgumentParser()
 
-    def get_parsed_arg(self) -> Dict[str, Any]:
+    @property
+    def parsed_args(self) -> Dict[str, Any]:
         """
         Return the list of arguments
         :return: List[str] List of arguments
         """
 
-        if self._parsed_arg is None:
-            self._build_sub_commands()
-            self._parsed_arg = self._parse_args()
+        if self._parsed_args is None:
+            self.build_args()
+            self._parsed_args = self._parse_args()
 
-        return vars(self._parsed_arg)
+        return vars(self._parsed_args)
 
     def _parse_args(self) -> argparse.Namespace:
         """
         Parses given arguments and returns an argparse Namespace instance.
         """
         parsed_arg = self.parser.parse_args(self.args)
 
-        # Workaround issue in argparse with action='append' and default value
-        # (see https://bugs.python.org/issue16399)
-        # Allow no-config for certain commands (like downloading / plotting)
-
-        if 'config' in parsed_arg and parsed_arg.config is None and (Path.cwd() / constants.DEFAULT_CONFIG).is_file():
-            parsed_arg.config = [constants.DEFAULT_CONFIG]
+        if 'config' in parsed_arg and parsed_arg.config is None or (Path.cwd() / constants.DEFAULT_CONFIG).is_file():
+            parsed_arg.config = constants.DEFAULT_CONFIG
         else:
             raise DependencyException("config.json file is not specified, "
                                       "please see the configuration section in the docs")
 
         return parsed_arg
 
-    @staticmethod
-    def _build_args(option_list, parser):
-
-        for val in option_list:
-            opt = AVAILABLE_CLI_OPTIONS[val]
-            parser.add_argument(*opt.cli, dest=val, **opt.kwargs)
+    def build_args(self):
 
-    def _build_sub_commands(self) -> None:
-        """
-        Builds and attaches all sub commands.
-        :return: None
-        """
+        for command in CLI_COMMANDS:
+            argument = CLI_COMMANDS[command]
+            self.parser.add_argument(*argument.cli, dest=command, **argument.kwargs)
 
-        # Build main command
-        self.parser = argparse.ArgumentParser(description="Trading bot based on value principles")
-        self._build_args(option_list=ARGS_COMMON, parser=self.parser)
+        self.parser.set_defaults(func=initialize)
 

bot/configuration/__init__.py

@@ -0,0 +1,30 @@
+import logging
+from typing import Dict, Any
+
+from bot.configuration.configuration import Configuration
+from bot.context.bot_context import BotContext
+from bot.context.setup_state import SetupState
+
+
+logger = logging.getLogger(__name__)
+
+
+def initialize(args: Dict[str, Any]) -> int:
+    logger.info("Initializing bot ...")
+
+    # Create the configuration
+    config = Configuration.create_config(args)
+
+    context = BotContext()
+    context.config = config.config
+
+    # Initialize context with SetupState
+    context.initialize(SetupState)
+
+    try:
+        context.run()
+    except KeyboardInterrupt:
+        logger.info('SIGINT received, aborting ...')
+
+    return 0
+

bot/configuration/arguments.py

@@ -1,50 +1,51 @@
+import os
 import logging
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
+from bot import OperationalException
 from bot.configuration.load_config import load_config_file
+
 logger = logging.getLogger(__name__)
 
 
 class Configuration:
     """
-    Class to read and init the bot configuration
+    Class to read and initialize the bot configuration
     """
 
-    def __init__(self, args: Dict[str, Any]) -> None:
-        self.args = args
-        self.config: Optional[Dict[str, Any]] = None
+    def __init__(self, args: Dict[str, Any], direct=True) -> None:
+        if direct:
+            raise OperationalException("Direct creation of Configuration is not allowed")
 
-    def get_config(self) -> Dict[str, Any]:
-        """
-        Return the config. Use this method to get the bot config
-        :return: Dict: Bot config
-        """
-        if self.config is None:
-            self.config = self.load_config()
+        self._config: Optional[Dict[str, Any]] = None
 
-        return self.config
+        self._initialize(args)
 
-    @staticmethod
-    def load_from_files(files: List[str]) -> Dict[str, Any]:
+    def _initialize(self, args):
+        self._config = load_config_file(args.get('config'))
 
-        config = {}
+    @classmethod
+    def create_config(cls, args: Dict[str, Any]):
 
-        # We expect here a list of config filenames
-        for path in files:
-            logger.info(f'Using config: {path} ...')
+        # Check if all dependencies are met
+        if not args['config']:
+            raise OperationalException("Config file is not specified")
 
-            # Merge config options, overwriting old values
-            config = load_config_file(path)
+        config_file = args['config']
 
-        return config
+        if not os.path.isfile(config_file):
+            raise OperationalException("Specified config location is not a file")
 
-    def load_config(self) -> Dict[str, Any]:
+        if not config_file.endswith('.json'):
+            raise OperationalException("Specified config file is not a JSON file")
+
+        logger.info("Using configuration file: {}".format(config_file))
+        return Configuration(args, direct=False)
+
+    @property
+    def config(self) -> Dict[str, Any]:
         """
-        Extract information for sys.argv and load the bot configuration
-        :return: Configuration dictionary
+        Return the config.
         """
-        # Load all configs
-        config: Dict[str, Any] = self.load_from_files(self.args.get("config", []))
-
-        return config
+        return self._config