Refactor

Author: dmptrluke

cloudbot/__init__.py

@@ -2,7 +2,7 @@
 
 # check python version
 if sys.version_info < (3, 4, 0):
-    print("CloudBot3 requires Python 3.4 or newer.")
+    print("CloudBot requires Python 3.4 or newer.")
     sys.exit(1)
 
 import json
@@ -12,33 +12,25 @@
 
 __version__ = "0.1.1.dev0"
 
-__all__ = ["util", "bot", "connection", "config", "permissions", "plugin", "event", "hook", "dev_mode", "log_dir"]
+__all__ = ["util", "bot", "connection", "config", "permissions", "plugin", "event", "hook", "log_dir"]
 
 
 def _setup():
-    default_developer_mode = {"plugin_reloading": False, "config_reloading": True,
-                              "console_debug": False, "file_debug": True}
     if os.path.exists(os.path.abspath("config.json")):
         with open(os.path.abspath("config.json")) as config_file:
             json_conf = json.load(config_file)
-        developer_mode = json_conf.get("developer_mode", default_developer_mode)
+        logging_config = json_conf.get("logging", {})
     else:
-        developer_mode = default_developer_mode
+        logging_config = {}
 
-    if "config_reloading" not in developer_mode:
-        developer_mode["config_reloading"] = default_developer_mode["config_reloading"]
-    if "plugin_reloading" not in developer_mode:
-        developer_mode["plugin_reloading"] = default_developer_mode["plugin_reloading"]
-    if "console_debug" not in developer_mode:
-        developer_mode["console_debug"] = default_developer_mode["console_debug"]
-    if "file_debug" not in developer_mode:
-        developer_mode["file_debug"] = default_developer_mode["file_debug"]
+    console_debug = logging_config.get("console_debug", False)
+    file_debug = logging_config.get("file_debug", True)
 
-    global log_dir
-    log_dir = os.path.join(os.path.abspath(os.path.curdir), "logs")
+    global logging_dir
+    logging_dir = os.path.join(os.path.abspath(os.path.curdir), "logs")
 
-    if not os.path.exists(log_dir):
-        os.makedirs(log_dir)
+    if not os.path.exists(logging_dir):
+        os.makedirs(logging_dir)
 
     dict_config = {
         "version": 1,
@@ -66,7 +58,7 @@ def _setup():
                 "formatter": "full",
                 "level": "INFO",
                 "encoding": "utf-8",
-                "filename": os.path.join(log_dir, "bot.log")
+                "filename": os.path.join(logging_dir, "bot.log")
             }
         },
         "loggers": {
@@ -77,24 +69,21 @@ def _setup():
         }
     }
 
-    if developer_mode["console_debug"]:
+    if console_debug:
         dict_config["handlers"]["console"]["level"] = "DEBUG"
 
-    if developer_mode["file_debug"]:
+    if file_debug:
         dict_config["handlers"]["debug_file"] = {
             "class": "logging.handlers.RotatingFileHandler",
             "maxBytes": 1000000,
             "backupCount": 5,
             "formatter": "full",
             "encoding": "utf-8",
             "level": "DEBUG",
-            "filename": os.path.join(log_dir, "debug.log")
+            "filename": os.path.join(logging_dir, "debug.log")
         }
         dict_config["loggers"]["cloudbot"]["handlers"].append("debug_file")
 
     logging.config.dictConfig(dict_config)
 
-    return developer_mode
-
-
-dev_mode = _setup()
+_setup()

cloudbot/__main__.py

@@ -5,21 +5,16 @@
 import time
 import signal
 
-print('CloudBot3 <http://git.io/refresh>')
+# store the original working directory, for use when restarting
+original_wd = os.path.realpath(".")
 
-# set up environment
-
-# we need to make sure we are in the install directory
+# set up environment - we need to make sure we are in the install directory
 path0 = os.path.realpath(sys.path[0] or '.')
-cloudbot_dir = os.path.realpath(os.path.dirname(__file__))
-if path0 == cloudbot_dir:
-    sys.path[0] = path0 = os.path.dirname(cloudbot_dir)
+install_dir = os.path.realpath(os.path.dirname(__file__))
+if path0 == install_dir:
+    sys.path[0] = path0 = os.path.dirname(install_dir)
 os.chdir(path0)
 
-# add 'lib' to path for libraries (currently unused)
-if os.path.exists(os.path.abspath('lib')):
-    sys.path += ['lib']
-
 # import bot
 from cloudbot.bot import CloudBot
 
@@ -31,12 +26,10 @@ def main():
     logging.logProcesses = 0
 
     logger = logging.getLogger("cloudbot")
-
-    # store the original working directory, for use when restarting
-    original_wd = os.path.realpath(".")
+    logger.info("Starting CloudBot.")
 
     # create the bot
-    cloudbot = CloudBot()
+    bot = CloudBot()
 
     # whether we are killed while restarting
     stopped_while_restarting = False
@@ -47,11 +40,11 @@ def main():
     # define closure for signal handling
     def exit_gracefully(signum, frame):
         nonlocal stopped_while_restarting
-        if not cloudbot:
+        if not bot:
             # we are currently in the process of restarting
             stopped_while_restarting = True
         else:
-            cloudbot.loop.call_soon_threadsafe(lambda: asyncio.async(cloudbot.stop("Killed"), loop=cloudbot.loop))
+            bot.loop.call_soon_threadsafe(lambda: asyncio.async(bot.stop("Killed"), loop=bot.loop))
 
         # restore the original handler so if they do it again it triggers
         signal.signal(signal.SIGINT, original_sigint)
@@ -61,12 +54,12 @@ def exit_gracefully(signum, frame):
     # start the bot master
 
     # CloudBot.run() will return True if it should restart, False otherwise
-    restart = cloudbot.run()
+    restart = bot.run()
 
     # the bot has stopped, do we want to restart?
     if restart:
         # remove reference to cloudbot, so exit_gracefully won't try to stop it
-        cloudbot = None
+        bot = None
         # sleep one second for timeouts
         time.sleep(1)
         if stopped_while_restarting:
@@ -75,8 +68,8 @@ def exit_gracefully(signum, frame):
             # actually restart
             os.chdir(original_wd)
             args = sys.argv
-            logger.info("Restarting CloudBot")
-            logger.debug("Restarting - arguments {}".format(args))
+            logger.info("Restarting Bot")
+            logger.debug("Restart arguments: {}".format(args))
             for f in [sys.stdout, sys.stderr]:
                 f.flush()
             # close logging, and exit the program.

cloudbot/bot.py

@@ -71,15 +71,9 @@ def __init__(self, loop=asyncio.get_event_loop()):
         self.config = Config(self)
         logger.debug("Config system initialised.")
 
-        # log developer mode
-        if cloudbot.dev_mode.get("plugin_reloading"):
-            logger.info("Enabling developer option: plugin reloading.")
-        if cloudbot.dev_mode.get("config_reloading"):
-            logger.info("Enabling developer option: config reloading.")
-        if cloudbot.dev_mode.get("console_debug"):
-            logger.info("Enabling developer option: console debug.")
-        if cloudbot.dev_mode.get("file_debug"):
-            logger.info("Enabling developer option: file debug")
+        # set values for reloading
+        self.plugin_reloading_enabled = self.config.get("reloading", {}).get("plugin_reloading", False)
+        self.config_reloading_enabled = self.config.get("reloading", {}).get("config_reloading", True)
 
         # this doesn't REALLY need to be here but it's nice
         self.user_agent = self.config.get('user_agent', 'CloudBot/3.0 - CloudBot Refresh '
@@ -91,6 +85,7 @@ def __init__(self, loop=asyncio.get_event_loop()):
         self.db_factory = sessionmaker(bind=self.db_engine)
         self.db_session = scoped_session(self.db_factory)
         self.db_metadata = MetaData()
+
         # set botvars.metadata so plugins can access when loading
         botvars.metadata = self.db_metadata
         logger.debug("Database system initialised.")
@@ -101,7 +96,7 @@ def __init__(self, loop=asyncio.get_event_loop()):
         # create bot connections
         self.create_connections()
 
-        if cloudbot.dev_mode.get("plugin_reloading"):
+        if self.plugin_reloading_enabled:
             self.reloader = PluginReloader(self)
 
         self.plugin_manager = PluginManager(self)
@@ -143,11 +138,11 @@ def stop(self, reason=None, *, restart=False):
         """quits all networks and shuts the bot down"""
         logger.info("Stopping bot.")
 
-        if cloudbot.dev_mode.get("config_reloading"):
+        if self.config_reloading_enabled:
             logger.debug("Stopping config reloader.")
             self.config.stop()
 
-        if cloudbot.dev_mode.get("plugin_reloading"):
+        if self.plugin_reloading_enabled:
             logger.debug("Stopping plugin reloader.")
             self.reloader.stop()
 
@@ -186,7 +181,7 @@ def _init_routine(self):
             logger.info("Killed while loading, exiting")
             return
 
-        if cloudbot.dev_mode.get("plugin_reloading"):
+        if self.plugin_reloading_enabled:
             # start plugin reloader
             self.reloader.start(os.path.abspath("plugins"))
 

cloudbot/config.py

@@ -35,8 +35,9 @@ def __init__(self, bot, *args, **kwargs):
 
         # populate self with config data
         self.load_config()
+        self.reloading_enabled = self.get("reloading", {}).get("config_reloading", True)
 
-        if cloudbot.dev_mode["config_reloading"]:
+        if self.reloading_enabled:
             # start watcher
             self.observer = Observer()
 
@@ -48,7 +49,7 @@ def __init__(self, bot, *args, **kwargs):
 
     def stop(self):
         """shuts down the config reloader"""
-        if cloudbot.dev_mode["config_reloading"]:
+        if self.reloading_enabled:
             self.observer.stop()
 
     def load_config(self):

cloudbot/util/dictionaries.py

@@ -0,0 +1,43 @@
+class CaseInsensitiveDict(dict):
+    """
+    dict() -> new empty dictionary
+    dict(mapping) -> new dictionary initialized from a mapping object's
+        (key, value) pairs
+    dict(iterable) -> new dictionary initialized as if via:
+        d = {}
+        for k, v in iterable:
+            d[k] = v
+    dict(**kwargs) -> new dictionary initialized with the name=value pairs
+        in the keyword argument list.  For example:  dict(one=1, two=2)
+    """
+
+    def get(self, k, d=None):  # real signature unknown; restored from __doc__
+        """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
+        return super().get(k.lower() if k is not None else k, d)
+
+    def pop(self, k, d=None):  # real signature unknown; restored from __doc__
+        """
+        D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+        If key is not found, d is returned if given, otherwise KeyError is raised
+        """
+        return super().pop(k.lower() if k is not None else k, d)
+
+    def setdefault(self, k, d=None):  # real signature unknown; restored from __doc__
+        """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
+        return super().setdefault(k.lower() if k is not None else k, d)
+
+    def __contains__(self, k):  # real signature unknown
+        """ True if D has a key k, else False. """
+        return super().__contains__(k.lower() if k is not None else k)
+
+    def __delitem__(self, k):  # real signature unknown
+        """ Delete self[key]. """
+        return super().__delitem__(k.lower() if k is not None else k)
+
+    def __getitem__(self, k):  # real signature unknown; restored from __doc__
+        """ x.__getitem__(y) <==> x[y] """
+        return super().__getitem__(k.lower() if k is not None else k)
+
+    def __setitem__(self, k, v):  # real signature unknown
+        """ Set self[key] to value. """
+        return super().__setitem__(k.lower() if k is not None else k, v)

config.default.json

@@ -89,13 +89,13 @@
         ],
         "whitelist": []
     },
-    "developer_mode": {
+    "reloading": {
         "config_reloading": true,
-        "plugin_reloading": false,
-        "console_debug": false,
-        "file_debug": true
+        "plugin_reloading": false
     },
     "logging": {
+        "console_debug": false,
+        "file_debug": true,
         "show_plugin_loading": true,
         "show_motd": true,
         "show_server_info": true,