diff --git a/sopel_modules/SpiceBot/Channels.py b/sopel_modules/SpiceBot/Channels.py
index 433b984..a403875 100644
--- a/sopel_modules/SpiceBot/Channels.py
+++ b/sopel_modules/SpiceBot/Channels.py
@@ -24,15 +24,15 @@ class BotChannels():
 
     def channel_list_recieve_input(self, trigger):
         channel, _, topic = trigger.args[1:]
-        if channel.lower() not in self.SpiceBot_Channels['list'].keys():
-            self.SpiceBot_Channels['list'][channel.lower()] = dict()
-        self.SpiceBot_Channels['list'][channel.lower()]['name'] = channel
-        self.SpiceBot_Channels['list'][channel.lower()]['topic'] = self.topic_compile(topic)
+        if channel.lower() not in self.dict['list'].keys():
+            self.dict['list'][channel.lower()] = dict()
+        self.dict['list'][channel.lower()]['name'] = channel
+        self.dict['list'][channel.lower()]['topic'] = self.topic_compile(topic)
         self.channel_lock = True
 
     def channel_list_recieve_finish(self):
-        if not self.SpiceBot_Channels['InitialProcess']:
-            self.SpiceBot_Channels['InitialProcess'] = True
+        if not self.dict['InitialProcess']:
+            self.dict['InitialProcess'] = True
         self.channel_lock = False
 
     def topic_compile(self, topic):
@@ -48,17 +48,17 @@ class BotChannels():
         for channel in bot.channels.keys():
             if len(bot.channels[channel].privileges.keys()) == 1 and channel not in ignorepartlist and channel.startswith("#"):
                 bot.part(channel, "Leaving Empty Channel")
-                if channel.lower() in self.SpiceBot_Channels['list']:
-                    del self.SpiceBot_Channels['list'][channel.lower()]
+                if channel.lower() in self.dict['list']:
+                    del self.dict['list'][channel.lower()]
 
     def join_all_channels(self, bot):
         if bot.config.SpiceBot_Channels.joinall:
-            for channel in self.SpiceBot_Channels['list'].keys():
+            for channel in self.dict['list'].keys():
                 if channel.startswith("#"):
                     if channel not in bot.channels.keys() and channel not in bot.config.SpiceBot_Channels.chanignore:
-                        bot.write(('JOIN', bot.nick, self.SpiceBot_Channels['list'][channel]['name']))
+                        bot.write(('JOIN', bot.nick, self.dict['list'][channel]['name']))
                         if channel not in bot.channels.keys() and bot.config.SpiceBot_Channels.operadmin:
-                            bot.write(('SAJOIN', bot.nick, self.SpiceBot_Channels['list'][channel]['name']))
+                            bot.write(('SAJOIN', bot.nick, self.dict['list'][channel]['name']))
 
     def chanadmin_all_channels(self, bot):
         # Chan ADMIN +a
@@ -72,4 +72,4 @@ class BotChannels():
                     bot.part(channel)
 
 
-botchannels = BotChannels()
+channels = BotChannels()
diff --git a/sopel_modules/SpiceBot/Commands.py b/sopel_modules/SpiceBot/Commands.py
index 5a4eb99..67edcca 100644
--- a/sopel_modules/SpiceBot/Commands.py
+++ b/sopel_modules/SpiceBot/Commands.py
@@ -27,9 +27,9 @@ class BotCommands():
         if not isinstance(validcoms, list):
             validcoms = [validcoms]
 
-        if command_type not in self.SpiceBot_Commands['commands'].keys():
-            self.SpiceBot_Commands['commands'][command_type] = dict()
-        self.SpiceBot_Commands['counts'] += 1
+        if command_type not in self.dict['commands'].keys():
+            self.dict['commands'][command_type] = dict()
+        self.dict['counts'] += 1
 
         dict_from_file = dict()
 
@@ -44,13 +44,13 @@ class BotCommands():
                 comaliases = spicemanip.main(dict_from_file["validcoms"], '2+', 'list')
             else:
                 comaliases = []
-            self.SpiceBot_Commands['commands'][command_type][maincom] = dict_from_file
+            self.dict['commands'][command_type][maincom] = dict_from_file
         else:
             comaliases = validcoms
 
         for comalias in comaliases:
-            if comalias not in self.SpiceBot_Commands['commands'][command_type].keys():
-                self.SpiceBot_Commands['commands'][command_type][comalias] = {"aliasfor": aliasfor}
+            if comalias not in self.dict['commands'][command_type].keys():
+                self.dict['commands'][command_type][comalias] = {"aliasfor": aliasfor}
 
 
-botcommands = BotCommands()
+commands = BotCommands()
diff --git a/sopel_modules/SpiceBot/Database.py b/sopel_modules/SpiceBot/Database.py
index a4aa3c7..e8822d0 100644
--- a/sopel_modules/SpiceBot/Database.py
+++ b/sopel_modules/SpiceBot/Database.py
@@ -28,18 +28,18 @@ class BotDatabase():
         nick = Identifier(nick)
         nick_id = bot.db.get_nick_id(nick, create=True)
 
-        if nick_id not in self.SpiceBot_Database["nicks"].keys():
-            self.SpiceBot_Database["nicks"][nick_id] = {}
+        if nick_id not in self.dict["nicks"].keys():
+            self.dict["nicks"][nick_id] = {}
 
-        if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys():
-            self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
+        if sorting_key not in self.dict["nicks"][nick_id].keys():
+            self.dict["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
 
         self.lock.release()
 
-        if key not in self.SpiceBot_Database["nicks"][nick_id][sorting_key].keys():
+        if key not in self.dict["nicks"][nick_id][sorting_key].keys():
             return None
         else:
-            return self.SpiceBot_Database["nicks"][nick_id][sorting_key][key]
+            return self.dict["nicks"][nick_id][sorting_key][key]
 
     def set_nick_value(self, bot, nick, key, value, sorting_key='unsorted'):
 
@@ -48,15 +48,15 @@ class BotDatabase():
         nick = Identifier(nick)
         nick_id = bot.db.get_nick_id(nick, create=True)
 
-        if nick_id not in self.SpiceBot_Database["nicks"].keys():
-            self.SpiceBot_Database["nicks"][nick_id] = {}
+        if nick_id not in self.dict["nicks"].keys():
+            self.dict["nicks"][nick_id] = {}
 
-        if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys():
-            self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
+        if sorting_key not in self.dict["nicks"][nick_id].keys():
+            self.dict["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
 
-        self.SpiceBot_Database["nicks"][nick_id][sorting_key][key] = value
+        self.dict["nicks"][nick_id][sorting_key][key] = value
 
-        bot.db.set_nick_value(nick, sorting_key, self.SpiceBot_Database["nicks"][nick_id][sorting_key])
+        bot.db.set_nick_value(nick, sorting_key, self.dict["nicks"][nick_id][sorting_key])
 
         self.lock.release()
 
@@ -67,14 +67,14 @@ class BotDatabase():
         nick = Identifier(nick)
         nick_id = bot.db.get_nick_id(nick, create=True)
 
-        if nick_id not in self.SpiceBot_Database["nicks"].keys():
-            self.SpiceBot_Database["nicks"][nick_id] = {}
+        if nick_id not in self.dict["nicks"].keys():
+            self.dict["nicks"][nick_id] = {}
 
-        if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys():
-            self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
+        if sorting_key not in self.dict["nicks"][nick_id].keys():
+            self.dict["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
 
-        del self.SpiceBot_Database["nicks"][nick_id][sorting_key][key]
-        bot.db.set_nick_value(nick, sorting_key, self.SpiceBot_Database["nicks"][nick_id][sorting_key])
+        del self.dict["nicks"][nick_id][sorting_key][key]
+        bot.db.set_nick_value(nick, sorting_key, self.dict["nicks"][nick_id][sorting_key])
 
         self.lock.release()
 
@@ -85,22 +85,22 @@ class BotDatabase():
         nick = Identifier(nick)
         nick_id = bot.db.get_nick_id(nick, create=True)
 
-        if nick_id not in self.SpiceBot_Database["nicks"].keys():
-            self.SpiceBot_Database["nicks"][nick_id] = {}
+        if nick_id not in self.dict["nicks"].keys():
+            self.dict["nicks"][nick_id] = {}
 
-        if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys():
-            self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
+        if sorting_key not in self.dict["nicks"][nick_id].keys():
+            self.dict["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
 
-        if key not in self.SpiceBot_Database["nicks"][nick_id][sorting_key].keys():
+        if key not in self.dict["nicks"][nick_id][sorting_key].keys():
             oldvalue = []
         else:
-            oldvalue = self.SpiceBot_Database["nicks"][nick_id][sorting_key][key]
+            oldvalue = self.dict["nicks"][nick_id][sorting_key][key]
 
         if not oldvalue:
-            self.SpiceBot_Database["nicks"][nick_id][sorting_key][key] = value
+            self.dict["nicks"][nick_id][sorting_key][key] = value
         else:
-            self.SpiceBot_Database["nicks"][nick_id][sorting_key][key] = oldvalue + value
-        bot.db.set_nick_value(nick, sorting_key, self.SpiceBot_Database["nicks"][nick_id][sorting_key])
+            self.dict["nicks"][nick_id][sorting_key][key] = oldvalue + value
+        bot.db.set_nick_value(nick, sorting_key, self.dict["nicks"][nick_id][sorting_key])
 
         self.lock.release()
 
@@ -114,24 +114,24 @@ class BotDatabase():
         nick = Identifier(nick)
         nick_id = bot.db.get_nick_id(nick, create=True)
 
-        if nick_id not in self.SpiceBot_Database["nicks"].keys():
-            self.SpiceBot_Database["nicks"][nick_id] = {}
+        if nick_id not in self.dict["nicks"].keys():
+            self.dict["nicks"][nick_id] = {}
 
-        if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys():
-            self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
+        if sorting_key not in self.dict["nicks"][nick_id].keys():
+            self.dict["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
 
-        if key not in self.SpiceBot_Database["nicks"][nick_id][sorting_key].keys():
-            self.SpiceBot_Database["nicks"][nick_id][sorting_key][key] = []
+        if key not in self.dict["nicks"][nick_id][sorting_key].keys():
+            self.dict["nicks"][nick_id][sorting_key][key] = []
 
         if adjustmentdirection == 'add':
             for entry in entries:
-                if entry not in self.SpiceBot_Database["nicks"][nick_id][sorting_key][key]:
-                    self.SpiceBot_Database["nicks"][nick_id][sorting_key][key].append(entry)
+                if entry not in self.dict["nicks"][nick_id][sorting_key][key]:
+                    self.dict["nicks"][nick_id][sorting_key][key].append(entry)
         elif adjustmentdirection == 'del':
             for entry in entries:
-                while entry in self.SpiceBot_Database["nicks"][nick_id][sorting_key][key]:
-                    self.SpiceBot_Database["nicks"][nick_id][sorting_key][key].remove(entry)
-        bot.db.set_nick_value(nick, sorting_key, self.SpiceBot_Database["nicks"][nick_id][sorting_key])
+                while entry in self.dict["nicks"][nick_id][sorting_key][key]:
+                    self.dict["nicks"][nick_id][sorting_key][key].remove(entry)
+        bot.db.set_nick_value(nick, sorting_key, self.dict["nicks"][nick_id][sorting_key])
 
         self.lock.release()
 
@@ -143,18 +143,18 @@ class BotDatabase():
 
         channel = Identifier(channel)
 
-        if channel not in self.SpiceBot_Database["channels"].keys():
-            self.SpiceBot_Database["channels"][channel] = {}
+        if channel not in self.dict["channels"].keys():
+            self.dict["channels"][channel] = {}
 
-        if sorting_key not in self.SpiceBot_Database["channels"][channel].keys():
-            self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
+        if sorting_key not in self.dict["channels"][channel].keys():
+            self.dict["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
 
         self.lock.release()
 
-        if key not in self.SpiceBot_Database["channels"][channel][sorting_key].keys():
+        if key not in self.dict["channels"][channel][sorting_key].keys():
             return None
         else:
-            return self.SpiceBot_Database["channels"][channel][sorting_key][key]
+            return self.dict["channels"][channel][sorting_key][key]
 
     def set_channel_value(self, bot, channel, key, value, sorting_key='unsorted'):
 
@@ -162,14 +162,14 @@ class BotDatabase():
 
         channel = Identifier(channel)
 
-        if channel not in self.SpiceBot_Database["channels"].keys():
-            self.SpiceBot_Database["channels"][channel] = {}
+        if channel not in self.dict["channels"].keys():
+            self.dict["channels"][channel] = {}
 
-        if sorting_key not in self.SpiceBot_Database["channels"][channel].keys():
-            self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
+        if sorting_key not in self.dict["channels"][channel].keys():
+            self.dict["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
 
-        self.SpiceBot_Database["channels"][channel][sorting_key][key] = value
-        bot.db.set_channel_value(channel, sorting_key, self.SpiceBot_Database["channels"][channel][sorting_key])
+        self.dict["channels"][channel][sorting_key][key] = value
+        bot.db.set_channel_value(channel, sorting_key, self.dict["channels"][channel][sorting_key])
 
         self.lock.release()
 
@@ -179,14 +179,14 @@ class BotDatabase():
 
         channel = Identifier(channel)
 
-        if channel not in self.SpiceBot_Database["channels"].keys():
-            self.SpiceBot_Database["channels"][channel] = {}
+        if channel not in self.dict["channels"].keys():
+            self.dict["channels"][channel] = {}
 
-        if sorting_key not in self.SpiceBot_Database["channels"][channel].keys():
-            self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
+        if sorting_key not in self.dict["channels"][channel].keys():
+            self.dict["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
 
-        del self.SpiceBot_Database["channels"][channel][sorting_key][key]
-        bot.db.set_channel_value(channel, sorting_key, self.SpiceBot_Database["channels"][channel][sorting_key])
+        del self.dict["channels"][channel][sorting_key][key]
+        bot.db.set_channel_value(channel, sorting_key, self.dict["channels"][channel][sorting_key])
 
         self.lock.release()
 
@@ -196,22 +196,22 @@ class BotDatabase():
 
         channel = Identifier(channel)
 
-        if channel not in self.SpiceBot_Database["channels"].keys():
-            self.SpiceBot_Database["channels"][channel] = {}
+        if channel not in self.dict["channels"].keys():
+            self.dict["channels"][channel] = {}
 
-        if sorting_key not in self.SpiceBot_Database["channels"][channel].keys():
-            self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
+        if sorting_key not in self.dict["channels"][channel].keys():
+            self.dict["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
 
-        if key not in self.SpiceBot_Database["channels"][channel][sorting_key].keys():
+        if key not in self.dict["channels"][channel][sorting_key].keys():
             oldvalue = None
         else:
-            oldvalue = self.SpiceBot_Database["channels"][channel][sorting_key][key]
+            oldvalue = self.dict["channels"][channel][sorting_key][key]
 
         if not oldvalue:
-            self.SpiceBot_Database["channels"][channel][sorting_key][key] = value
+            self.dict["channels"][channel][sorting_key][key] = value
         else:
-            self.SpiceBot_Database["channels"][channel][sorting_key][key] = oldvalue + value
-        bot.db.set_channel_value(channel, sorting_key, self.SpiceBot_Database["channels"][channel][sorting_key])
+            self.dict["channels"][channel][sorting_key][key] = oldvalue + value
+        bot.db.set_channel_value(channel, sorting_key, self.dict["channels"][channel][sorting_key])
 
         self.lock.release()
 
@@ -224,26 +224,26 @@ class BotDatabase():
 
         channel = Identifier(channel)
 
-        if channel not in self.SpiceBot_Database["channels"].keys():
-            self.SpiceBot_Database["channels"][channel] = {}
+        if channel not in self.dict["channels"].keys():
+            self.dict["channels"][channel] = {}
 
-        if sorting_key not in self.SpiceBot_Database["channels"][channel].keys():
-            self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
+        if sorting_key not in self.dict["channels"][channel].keys():
+            self.dict["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
 
-        if key not in self.SpiceBot_Database["channels"][channel][sorting_key].keys():
-            self.SpiceBot_Database["channels"][channel][sorting_key][key] = []
+        if key not in self.dict["channels"][channel][sorting_key].keys():
+            self.dict["channels"][channel][sorting_key][key] = []
 
         if adjustmentdirection == 'add':
             for entry in entries:
-                if entry not in self.SpiceBot_Database["channels"][channel][sorting_key][key]:
-                    self.SpiceBot_Database["channels"][channel][sorting_key][key].append(entry)
+                if entry not in self.dict["channels"][channel][sorting_key][key]:
+                    self.dict["channels"][channel][sorting_key][key].append(entry)
         elif adjustmentdirection == 'del':
             for entry in entries:
-                while entry in self.SpiceBot_Database["channels"][channel][sorting_key][key]:
-                    self.SpiceBot_Database["channels"][channel][sorting_key][key].remove(entry)
-        bot.db.set_channel_value(channel, sorting_key, self.SpiceBot_Database["channels"][channel][sorting_key])
+                while entry in self.dict["channels"][channel][sorting_key][key]:
+                    self.dict["channels"][channel][sorting_key][key].remove(entry)
+        bot.db.set_channel_value(channel, sorting_key, self.dict["channels"][channel][sorting_key])
 
         self.lock.release()
 
 
-botdb = BotDatabase()
+db = BotDatabase()
diff --git a/sopel_modules/SpiceBot/Events.py b/sopel_modules/SpiceBot/Events.py
index 34dfc54..46d9068 100644
--- a/sopel_modules/SpiceBot/Events.py
+++ b/sopel_modules/SpiceBot/Events.py
@@ -17,7 +17,7 @@ class BotEvents(object):
 
     Events will be assigned a 4-digit number above 1000.
 
-    This allows you to do, ``@module.event(botevents.BOT_WELCOME)````
+    This allows you to do, ``@module.event(events.BOT_WELCOME)````
 
     Triggers handled by this module will be processed immediately.
     Others will be placed into a queue.
@@ -43,8 +43,8 @@ class BotEvents(object):
 
     def __getattr__(self, name):
         ''' will only get called for undefined attributes '''
-        eventnumber = max(list(self.SpiceBot_Events["assigned_IDs"].keys())) + 1
-        self.SpiceBot_Events["assigned_IDs"][eventnumber] = str(name)
+        eventnumber = max(list(self.dict["assigned_IDs"].keys())) + 1
+        self.dict["assigned_IDs"][eventnumber] = str(name)
         setattr(self, name, str(eventnumber))
         return str(eventnumber)
 
@@ -53,7 +53,7 @@ class BotEvents(object):
         if number in self.defaultevents:
             self.dispatch(bot, pretriggerdict)
         else:
-            self.SpiceBot_Events["trigger_queue"].append(pretriggerdict)
+            self.dict["trigger_queue"].append(pretriggerdict)
 
     def dispatch(self, bot, pretriggerdict):
         number = pretriggerdict["number"]
@@ -72,37 +72,37 @@ class BotEvents(object):
         else:
             eventnumber = str(trigger.event)
             message = trigger.args[1]
-        if eventnumber not in self.SpiceBot_Events["triggers_recieved"]:
-            self.SpiceBot_Events["triggers_recieved"][eventnumber] = []
-        self.SpiceBot_Events["triggers_recieved"][eventnumber].append(message)
+        if eventnumber not in self.dict["triggers_recieved"]:
+            self.dict["triggers_recieved"][eventnumber] = []
+        self.dict["triggers_recieved"][eventnumber].append(message)
 
     def check(self, checklist):
         if not isinstance(checklist, list):
             checklist = [str(checklist)]
         for number in checklist:
-            if str(number) not in self.SpiceBot_Events["triggers_recieved"].keys():
+            if str(number) not in self.dict["triggers_recieved"].keys():
                 return False
         return True
 
     def startup_add(self, startlist):
         if not isinstance(startlist, list):
             startlist = [str(startlist)]
-        self.SpiceBot_Events["startup_required"].extend(startlist)
+        self.dict["startup_required"].extend(startlist)
 
     def startup_check(self):
-        for number in self.SpiceBot_Events["startup_required"]:
-            if str(number) not in self.SpiceBot_Events["triggers_recieved"].keys():
+        for number in self.dict["startup_required"]:
+            if str(number) not in self.dict["triggers_recieved"].keys():
                 return False
         return True
 
     def startup_debug(self):
         not_done = []
-        for number in self.SpiceBot_Events["startup_required"]:
-            if str(number) not in self.SpiceBot_Events["triggers_recieved"].keys():
+        for number in self.dict["startup_required"]:
+            if str(number) not in self.dict["triggers_recieved"].keys():
                 not_done.append(int(number))
         reference_not_done = []
         for item in not_done:
-            reference_not_done.append(str(self.SpiceBot_Events["assigned_IDs"][item]))
+            reference_not_done.append(str(self.dict["assigned_IDs"][item]))
         return reference_not_done
 
     def check_ready(self, checklist):
@@ -126,4 +126,4 @@ class BotEvents(object):
         return actual_decorator
 
 
-botevents = BotEvents()
+events = BotEvents()
diff --git a/sopel_modules/SpiceBot/Logs.py b/sopel_modules/SpiceBot/Logs.py
index 2308c30..6937137 100644
--- a/sopel_modules/SpiceBot/Logs.py
+++ b/sopel_modules/SpiceBot/Logs.py
@@ -28,14 +28,14 @@ class BotLogs():
         logmessage = logtitle + "    " + logentry
 
         if self.sopel_config["logging_channel"]:
-            self.SpiceBot_Logs["queue"].append(logmessage)
+            self.dict["queue"].append(logmessage)
 
         if stdio:
             sopel.tools.stderr(logmessage)
 
-        if logtype not in self.SpiceBot_Logs["list"].keys():
-            self.SpiceBot_Logs["list"][logtype] = []
-        self.SpiceBot_Logs["list"][logtype].append(logentry)
+        if logtype not in self.dict["list"].keys():
+            self.dict["list"][logtype] = []
+        self.dict["list"][logtype].append(logentry)
 
     def get_logs(self):
         return []
@@ -43,7 +43,7 @@ class BotLogs():
     def stdio_logs_fetch(self, bot):
 
         stdio_ignore = []
-        for logtype in self.SpiceBot_Logs["list"].keys():
+        for logtype in self.dict["list"].keys():
             stdio_ignore.append("[" + logtype + "]")
 
         logfile = os.path.os.path.join(bot.config.core.logdir, 'stdio.log')
@@ -103,4 +103,4 @@ class BotLogs():
         return pidnum
 
 
-botlogs = BotLogs()
+logs = BotLogs()
diff --git a/sopel_modules/SpiceBot/Tools.py b/sopel_modules/SpiceBot/Tools.py
index 05ffc21..c25823b 100644
--- a/sopel_modules/SpiceBot/Tools.py
+++ b/sopel_modules/SpiceBot/Tools.py
@@ -19,7 +19,7 @@ from pygit2 import clone_repository
 
 import spicemanip
 
-from .Logs import botlogs
+from .Logs import logs
 
 
 """Variable References"""
@@ -298,7 +298,7 @@ def spicebot_update(bot, deps=False):
     if not os.path.exists(clonepath) or not os.path.isdir(clonepath):
         os.system(clonepath)
 
-    botlogs.log('SpiceBot_Update', "Cloning  to " + clonepath, True)
+    logs.log('SpiceBot_Update', "Cloning  to " + clonepath, True)
 
     clone_repository(str(bot.config.SpiceBot_Update.gitrepo + ".git"), clonepath, checkout_branch=bot.config.SpiceBot_Update.gitbranch)
 
@@ -309,12 +309,12 @@ def spicebot_update(bot, deps=False):
     # pipcommand += " git+" + str(bot.config.SpiceBot_Update.gitrepo) + "@" + str(bot.config.SpiceBot_Update.gitbranch)
     pipcommand += " /tmp/SpiceBot/"
 
-    botlogs.log('SpiceBot_Update', "Running `" + pipcommand + "`", True)
+    logs.log('SpiceBot_Update', "Running `" + pipcommand + "`", True)
     # for line in os.popen(pipcommand).read().split('\n'):
-    #    botlogs.log('SpiceBot_Update', "    " + line)
+    #    logs.log('SpiceBot_Update', "    " + line)
     os.system(pipcommand)
 
-    botlogs.log('SpiceBot_Update', "Deleting " + clonepath, True)
+    logs.log('SpiceBot_Update', "Deleting " + clonepath, True)
 
     os.system("sudo rm -r /tmp/SpiceBot")
 
@@ -330,10 +330,10 @@ def service_manip(bot, servicename, dowhat, log_from='service_manip'):
     if str(dowhat) not in ["start", "stop", "restart"]:
         return
     try:
-        botlogs.log(log_from, str(dowhat).title() + "ing " + str(servicename) + ".service.")
+        logs.log(log_from, str(dowhat).title() + "ing " + str(servicename) + ".service.")
         os.system("sudo service " + str(servicename) + " " + str(dowhat))
     except Exception as e:
-        botlogs.log(log_from, str(dowhat).title() + "ing " + str(servicename) + ".service Failed: " + str(e))
+        logs.log(log_from, str(dowhat).title() + "ing " + str(servicename) + ".service Failed: " + str(e))
 
 
 """Config Reading Functions"""
@@ -365,7 +365,7 @@ def read_directory_json_to_dict(bot, directories, configtypename="Config File",
         except Exception as e:
             filereadgood = False
             if bot:
-                botlogs.log(log_from, "Error loading %s: %s (%s)" % (configtypename, e, filepath))
+                logs.log(log_from, "Error loading %s: %s (%s)" % (configtypename, e, filepath))
             dict_from_file = dict()
         # Close File
         inf.close()
@@ -380,10 +380,10 @@ def read_directory_json_to_dict(bot, directories, configtypename="Config File",
 
     if filecount:
         if bot:
-            botlogs.log(log_from, 'Registered %d %s dict files,' % (filecount, configtypename))
-            botlogs.log(log_from, '%d %s dict files failed to load' % (fileopenfail, configtypename), True)
+            logs.log(log_from, 'Registered %d %s dict files,' % (filecount, configtypename))
+            logs.log(log_from, '%d %s dict files failed to load' % (fileopenfail, configtypename), True)
     else:
         if bot:
-            botlogs.log(log_from, "Warning: Couldn't load any %s dict files" % (configtypename))
+            logs.log(log_from, "Warning: Couldn't load any %s dict files" % (configtypename))
 
     return configs_dict
diff --git a/sopel_modules/SpiceBot_AI/AI.py b/sopel_modules/SpiceBot_AI/AI.py
index 5ca12ab..593b8c9 100644
--- a/sopel_modules/SpiceBot_AI/AI.py
+++ b/sopel_modules/SpiceBot_AI/AI.py
@@ -9,7 +9,7 @@ import spicemanip
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_LOADED, SpiceBot.botevents.BOT_COMMANDSQUERY])
+@SpiceBot.events.check_ready([SpiceBot.events.BOT_LOADED, SpiceBot.events.BOT_COMMANDSQUERY])
 @sopel.module.nickname_commands('(.*)')
 def bot_command_nick(bot, trigger):
 
@@ -21,13 +21,13 @@ def bot_command_nick(bot, trigger):
     if triggercommand[0] == "?":
         return
 
-    if triggercommand in SpiceBot.botcommands.SpiceBot_Commands['commands']["nickname"].keys():
+    if triggercommand in SpiceBot.commands.dict['commands']["nickname"].keys():
         return
     triggerargs.insert(0, triggercommand)
 
     fulltrigger = spicemanip.main(triggerargs, 0).lower()
 
-    if fulltrigger in SpiceBot.botcommands.SpiceBot_Commands['nickrules']:
+    if fulltrigger in SpiceBot.commands.dict['nickrules']:
         return
 
     if fulltrigger.lower().startswith("what is"):
@@ -154,7 +154,7 @@ def bot_command_nick(bot, trigger):
 
     else:
 
-        closestmatches = SpiceBot.similar_list(bot, triggercommand, SpiceBot.botcommands.SpiceBot_Commands['commands']["nickname"].keys(), 3, 'reverse')
+        closestmatches = SpiceBot.similar_list(bot, triggercommand, SpiceBot.commands.dict['commands']["nickname"].keys(), 3, 'reverse')
 
         if len(closestmatches):
             closestmatches = spicemanip.main(closestmatches, "andlist")
diff --git a/sopel_modules/SpiceBot_Channels_Command/Channels_Command.py b/sopel_modules/SpiceBot_Channels_Command/Channels_Command.py
index 1599bc3..eafdda9 100644
--- a/sopel_modules/SpiceBot_Channels_Command/Channels_Command.py
+++ b/sopel_modules/SpiceBot_Channels_Command/Channels_Command.py
@@ -9,7 +9,7 @@ import spicemanip
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_LOADED])
+@SpiceBot.events.check_ready([SpiceBot.events.BOT_LOADED])
 @sopel.module.nickname_commands('channels', 'channel')
 def nickname_comand_channels(bot, trigger):
 
@@ -29,14 +29,14 @@ def nickname_comand_channels(bot, trigger):
 
     elif commandused == 'total':
         botcount = len(bot.channels.keys())
-        servercount = len(SpiceBot.botchannels.SpiceBot_Channels['list'].keys())
+        servercount = len(SpiceBot.channels.dict['list'].keys())
         bot.osd("I am in " + str(botcount) + " of " + str(servercount) + " channel(s) available on this server.")
         return
 
     elif commandused == 'random':
-        channel = spicemanip.main(SpiceBot.botchannels.SpiceBot_Channels['list'], 'random')
-        topic = SpiceBot.botchannels.SpiceBot_Channels['list'][channel]['topic']
-        msg = ["Random channel for you: {}.".format(SpiceBot.botchannels.SpiceBot_Channels['list'][channel]['name'])]
+        channel = spicemanip.main(SpiceBot.channels.dict['list'], 'random')
+        topic = SpiceBot.channels.dict['list'][channel]['topic']
+        msg = ["Random channel for you: {}.".format(SpiceBot.channels.dict['list'][channel]['name'])]
         if topic and not topic.isspace():
             msg.append("The topic is: {}".format(topic))
         else:
@@ -48,15 +48,15 @@ def nickname_comand_channels(bot, trigger):
         if not trigger.admin:
             bot.osd("You do not have permission to update the channel listing.")
             return
-        SpiceBot.botchannels.bot_part_empty(bot)
-        SpiceBot.botchannels.channel_list_request(bot)
+        SpiceBot.channels.bot_part_empty(bot)
+        SpiceBot.channels.channel_list_request(bot)
         bot.osd(["[SpiceBot_Channels]", "I am now updating the channel listing for this server."])
-        while SpiceBot.botchannels.channel_lock:
+        while SpiceBot.channels.channel_lock:
             pass
-        SpiceBot.botchannels.join_all_channels(bot)
-        foundchannelcount = len(SpiceBot.botchannels.SpiceBot_Channels['list'].keys())
+        SpiceBot.channels.join_all_channels(bot)
+        foundchannelcount = len(SpiceBot.channels.dict['list'].keys())
         bot.osd("[SpiceBot_Channels]", "Channel listing finished!", str(foundchannelcount) + " channel(s) found.")
-        SpiceBot.botchannels.bot_part_empty(bot)
+        SpiceBot.channels.bot_part_empty(bot)
         return
 
     elif commandused == 'topic':
@@ -64,11 +64,11 @@ def nickname_comand_channels(bot, trigger):
             bot.osd("Channel name input missing.")
             return
         channel = spicemanip.main(triggerargs, 1)
-        if not SpiceBot.inlist(channel.lower(), SpiceBot.botchannels.SpiceBot_Channels['list'].keys()):
+        if not SpiceBot.inlist(channel.lower(), SpiceBot.channels.dict['list'].keys()):
             bot.osd("Channel name {} not valid.".format(channel))
             return
-        topic = SpiceBot.botchannels.SpiceBot_Channels['list'][channel.lower()]['topic']
-        channel = SpiceBot.botchannels.SpiceBot_Channels['list'][channel.lower()]['name']
+        topic = SpiceBot.channels.dict['list'][channel.lower()]['topic']
+        channel = SpiceBot.channels.dict['list'][channel.lower()]['name']
         bot.osd("Topic for {}: {}".format(channel, topic))
         return
 
@@ -81,7 +81,7 @@ def nickname_comand_channels(bot, trigger):
                 channel = trigger.sender
         else:
             channel = spicemanip.main(triggerargs, 1)
-            if not SpiceBot.inlist(channel.lower(), SpiceBot.botchannels.SpiceBot_Channels['list'].keys()):
+            if not SpiceBot.inlist(channel.lower(), SpiceBot.channels.dict['list'].keys()):
                 bot.osd("Channel name {} not valid.".format(channel))
                 return
             if not SpiceBot.inlist(channel.lower(), bot.channels.keys()):
@@ -101,7 +101,7 @@ def nickname_comand_channels(bot, trigger):
     # Users List
     if commandused == 'users':
         channel = spicemanip.main(triggerargs, 1)
-        if not SpiceBot.inlist(channel.lower(), SpiceBot.botchannels.SpiceBot_Channels['list'].keys()):
+        if not SpiceBot.inlist(channel.lower(), SpiceBot.channels.dict['list'].keys()):
             bot.osd("Channel name {} not valid.".format(channel))
             return
         if not SpiceBot.inlist(channel.lower(), bot.channels.keys()):
diff --git a/sopel_modules/SpiceBot_Channels_Parsing/Channels_Parsing.py b/sopel_modules/SpiceBot_Channels_Parsing/Channels_Parsing.py
index 8951ed5..a9002e7 100644
--- a/sopel_modules/SpiceBot_Channels_Parsing/Channels_Parsing.py
+++ b/sopel_modules/SpiceBot_Channels_Parsing/Channels_Parsing.py
@@ -29,91 +29,91 @@ def configure(config):
 
 
 def setup(bot):
-    SpiceBot.botlogs.log('SpiceBot_Channels', "Starting setup procedure")
-    SpiceBot.botevents.startup_add([SpiceBot.botevents.BOT_CHANNELS])
+    SpiceBot.logs.log('SpiceBot_Channels', "Starting setup procedure")
+    SpiceBot.events.startup_add([SpiceBot.events.BOT_CHANNELS])
     bot.config.define_section("SpiceBot_Channels", SpiceBot_Channels_MainSection, validate=False)
 
 
-@sopel.module.event(SpiceBot.botevents.RPL_WELCOME)
+@sopel.module.event(SpiceBot.events.RPL_WELCOME)
 @sopel.module.rule('.*')
 def unkickable_bot(bot, trigger):
     if bot.config.SpiceBot_Channels.operadmin:
         bot.write(('SAMODE', bot.nick, '+q'))
 
 
-@sopel.module.event(SpiceBot.botevents.RPL_WELCOME)
+@sopel.module.event(SpiceBot.events.RPL_WELCOME)
 @sopel.module.rule('.*')
 def request_channels_list_initial(bot, trigger):
 
-    SpiceBot.botchannels.bot_part_empty(bot)
+    SpiceBot.channels.bot_part_empty(bot)
 
-    SpiceBot.botlogs.log('SpiceBot_Channels', "Sending Request for all server channels")
-    SpiceBot.botchannels.channel_list_request(bot)
+    SpiceBot.logs.log('SpiceBot_Channels', "Sending Request for all server channels")
+    SpiceBot.channels.channel_list_request(bot)
 
     starttime = time.time()
 
     # wait 60 seconds for initial population of information
-    while not SpiceBot.botchannels.SpiceBot_Channels['InitialProcess']:
+    while not SpiceBot.channels.dict['InitialProcess']:
         if time.time() - starttime >= 60:
-            SpiceBot.botlogs.log('SpiceBot_Channels', "Initial Channel list populating Timed Out")
-            SpiceBot.botchannels.SpiceBot_Channels['InitialProcess'] = True
+            SpiceBot.logs.log('SpiceBot_Channels', "Initial Channel list populating Timed Out")
+            SpiceBot.channels.dict['InitialProcess'] = True
         else:
             pass
 
-    foundchannelcount = len(SpiceBot.botchannels.SpiceBot_Channels['list'].keys())
-    SpiceBot.botlogs.log('SpiceBot_Channels', "Channel listing finished! " + str(foundchannelcount) + " channel(s) found.")
+    foundchannelcount = len(SpiceBot.channels.dict['list'].keys())
+    SpiceBot.logs.log('SpiceBot_Channels', "Channel listing finished! " + str(foundchannelcount) + " channel(s) found.")
 
-    SpiceBot.botchannels.join_all_channels(bot)
-    SpiceBot.botchannels.chanadmin_all_channels(bot)
+    SpiceBot.channels.join_all_channels(bot)
+    SpiceBot.channels.chanadmin_all_channels(bot)
 
-    if "*" in SpiceBot.botchannels.SpiceBot_Channels['list'].keys():
-        del SpiceBot.botchannels.SpiceBot_Channels['list']["*"]
+    if "*" in SpiceBot.channels.dict['list'].keys():
+        del SpiceBot.channels.dict['list']["*"]
 
-    SpiceBot.botchannels.bot_part_empty(bot)
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_CHANNELS, "SpiceBot_Channels")
+    SpiceBot.channels.bot_part_empty(bot)
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_CHANNELS, "SpiceBot_Channels")
 
 
 @sopel.module.event('321')
 @sopel.module.rule('.*')
 def watch_chanlist_start(bot, trigger):
-    SpiceBot.botchannels.channel_list_recieve_start()
+    SpiceBot.channels.channel_list_recieve_start()
 
 
 @sopel.module.event('322')
 @sopel.module.rule('.*')
 def watch_chanlist_populate(bot, trigger):
-    SpiceBot.botchannels.channel_list_recieve_input(trigger)
+    SpiceBot.channels.channel_list_recieve_input(trigger)
 
 
 @sopel.module.event('323')
 @sopel.module.rule('.*')
 def watch_chanlist_complete(bot, trigger):
-    SpiceBot.botchannels.channel_list_recieve_finish()
+    SpiceBot.channels.channel_list_recieve_finish()
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_CHANNELS)
+@sopel.module.event(SpiceBot.events.BOT_CHANNELS)
 @sopel.module.rule('.*')
 def trigger_channel_list_recurring(bot, trigger):
     while True:
         time.sleep(1800)
-        SpiceBot.botchannels.bot_part_empty(bot)
+        SpiceBot.channels.bot_part_empty(bot)
 
-        oldlist = list(SpiceBot.botchannels.SpiceBot_Channels['list'].keys())
-        SpiceBot.botchannels.channel_list_request(bot)
+        oldlist = list(SpiceBot.channels.dict['list'].keys())
+        SpiceBot.channels.channel_list_request(bot)
 
-        while SpiceBot.botchannels.channel_lock:
+        while SpiceBot.channels.channel_lock:
             pass
 
-        newlist = [item.lower() for item in oldlist if item.lower() not in list(SpiceBot.botchannels.SpiceBot_Channels['list'].keys())]
+        newlist = [item.lower() for item in oldlist if item.lower() not in list(SpiceBot.channels.dict['list'].keys())]
         if "*" in newlist:
             newlist.remove("*")
         if len(newlist) and bot.config.SpiceBot_Channels.announcenew:
             bot.osd(["The Following channel(s) are new:", spicemanip.main(newlist, 'andlist')], bot.channels.keys())
 
-        SpiceBot.botchannels.join_all_channels(bot)
+        SpiceBot.channels.join_all_channels(bot)
 
-        SpiceBot.botchannels.chanadmin_all_channels(bot)
+        SpiceBot.channels.chanadmin_all_channels(bot)
 
-        if "*" in SpiceBot.botchannels.SpiceBot_Channels['list'].keys():
-            del SpiceBot.botchannels.SpiceBot_Channels['list']["*"]
-        SpiceBot.botchannels.bot_part_empty(bot)
+        if "*" in SpiceBot.channels.dict['list'].keys():
+            del SpiceBot.channels.dict['list']["*"]
+        SpiceBot.channels.bot_part_empty(bot)
diff --git a/sopel_modules/SpiceBot_CommandsQuery/NickQueryCommand.py b/sopel_modules/SpiceBot_CommandsQuery/NickQueryCommand.py
index 3c37745..6e3df6c 100644
--- a/sopel_modules/SpiceBot_CommandsQuery/NickQueryCommand.py
+++ b/sopel_modules/SpiceBot_CommandsQuery/NickQueryCommand.py
@@ -10,7 +10,7 @@ import sopel_modules.SpiceBot as SpiceBot
 import spicemanip
 
 
-@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_COMMANDSQUERY])
+@SpiceBot.events.check_ready([SpiceBot.events.BOT_COMMANDSQUERY])
 @sopel.module.nickname_commands('(.*)')
 def query_detection_nick(bot, trigger):
 
@@ -28,9 +28,9 @@ def query_detection_nick(bot, trigger):
         return
 
     commands_list = dict()
-    for com in SpiceBot.botcommands.SpiceBot_Commands['commands']['nickname'].keys():
+    for com in SpiceBot.commands.dict['commands']['nickname'].keys():
         if com not in commands_list.keys():
-            commands_list[com] = SpiceBot.botcommands.SpiceBot_Commands['commands']['nickname'][com]
+            commands_list[com] = SpiceBot.commands.dict['commands']['nickname'][com]
 
     if triggercommand.endswith("+"):
 
diff --git a/sopel_modules/SpiceBot_CommandsQuery/QueryCommand.py b/sopel_modules/SpiceBot_CommandsQuery/QueryCommand.py
index 1711cb7..d4629d3 100644
--- a/sopel_modules/SpiceBot_CommandsQuery/QueryCommand.py
+++ b/sopel_modules/SpiceBot_CommandsQuery/QueryCommand.py
@@ -10,7 +10,7 @@ import sopel_modules.SpiceBot as SpiceBot
 import spicemanip
 
 
-@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_COMMANDSQUERY])
+@SpiceBot.events.check_ready([SpiceBot.events.BOT_COMMANDSQUERY])
 @sopel.module.rule('^\?(.*)')
 def query_detection(bot, trigger):
 
@@ -24,11 +24,11 @@ def query_detection(bot, trigger):
         return
 
     commands_list = dict()
-    for commandstype in SpiceBot.botcommands.SpiceBot_Commands['commands'].keys():
+    for commandstype in SpiceBot.commands.dict['commands'].keys():
         if commandstype not in ['rule', 'nickname']:
-            for com in SpiceBot.botcommands.SpiceBot_Commands['commands'][commandstype].keys():
+            for com in SpiceBot.commands.dict['commands'][commandstype].keys():
                 if com not in commands_list.keys():
-                    commands_list[com] = SpiceBot.botcommands.SpiceBot_Commands['commands'][commandstype][com]
+                    commands_list[com] = SpiceBot.commands.dict['commands'][commandstype][com]
 
     if triggercommand[:-1] == "+":
 
diff --git a/sopel_modules/SpiceBot_Database_Addons/Databaseaddons.py b/sopel_modules/SpiceBot_Database_Addons/Databaseaddons.py
index 99dbc39..fe360d3 100644
--- a/sopel_modules/SpiceBot_Database_Addons/Databaseaddons.py
+++ b/sopel_modules/SpiceBot_Database_Addons/Databaseaddons.py
@@ -16,7 +16,7 @@ import sopel_modules.SpiceBot as SpiceBot
 def setup(bot):
 
     # Inject Database Functions
-    SpiceBot.botlogs.log('SpiceBot_Databaseaddons', "Implanting Database functions into bot")
+    SpiceBot.logs.log('SpiceBot_Databaseaddons', "Implanting Database functions into bot")
     SopelDB.delete_nick_value = SopelDBCache.delete_nick_value
     SopelDB.adjust_nick_value = SopelDBCache.adjust_nick_value
     SopelDB.delete_channel_value = SopelDBCache.delete_channel_value
diff --git a/sopel_modules/SpiceBot_Events/Connected.py b/sopel_modules/SpiceBot_Events/Connected.py
index be399d2..ecf81ac 100644
--- a/sopel_modules/SpiceBot_Events/Connected.py
+++ b/sopel_modules/SpiceBot_Events/Connected.py
@@ -7,10 +7,10 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_WELCOME)
+@sopel.module.event(SpiceBot.events.BOT_WELCOME)
 @sopel.module.rule('.*')
 def bot_events_Connected(bot, trigger):
     """Here, we wait until we are in at least one channel"""
     while not len(bot.channels.keys()) > 0:
         pass
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_CONNECTED, "Bot Connected to IRC")
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_CONNECTED, "Bot Connected to IRC")
diff --git a/sopel_modules/SpiceBot_Events/Connection_Count.py b/sopel_modules/SpiceBot_Events/Connection_Count.py
index dfa4887..461ed8d 100644
--- a/sopel_modules/SpiceBot_Events/Connection_Count.py
+++ b/sopel_modules/SpiceBot_Events/Connection_Count.py
@@ -7,9 +7,9 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.RPL_WELCOME)
+@sopel.module.event(SpiceBot.events.RPL_WELCOME)
 @sopel.module.rule('.*')
 def bot_startup_welcome(bot, trigger):
-   SpiceBot.botevents.SpiceBot_Events["RPL_WELCOME_Count"] += 1
-   if SpiceBot.botevents.SpiceBot_Events["RPL_WELCOME_Count"] > 1:
-       SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_RECONNECTED, "Bot ReConnected to IRC")
+   SpiceBot.events.dict["RPL_WELCOME_Count"] += 1
+   if SpiceBot.events.dict["RPL_WELCOME_Count"] > 1:
+       SpiceBot.events.trigger(bot, SpiceBot.events.BOT_RECONNECTED, "Bot ReConnected to IRC")
diff --git a/sopel_modules/SpiceBot_Events/Loaded.py b/sopel_modules/SpiceBot_Events/Loaded.py
index e1e5c12..820c3b2 100644
--- a/sopel_modules/SpiceBot_Events/Loaded.py
+++ b/sopel_modules/SpiceBot_Events/Loaded.py
@@ -7,9 +7,9 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@SpiceBot.botevents.startup_check_ready()
-@sopel.module.event(SpiceBot.botevents.BOT_READY)
+@SpiceBot.events.startup_check_ready()
+@sopel.module.event(SpiceBot.events.BOT_READY)
 @sopel.module.rule('.*')
 def bot_events_startup_complete(bot, trigger):
     """All events registered as required for startup have completed"""
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_LOADED, "All registered modules setup procedures have completed")
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_LOADED, "All registered modules setup procedures have completed")
diff --git a/sopel_modules/SpiceBot_Events/Logging.py b/sopel_modules/SpiceBot_Events/Logging.py
index fb111db..77c1fb8 100644
--- a/sopel_modules/SpiceBot_Events/Logging.py
+++ b/sopel_modules/SpiceBot_Events/Logging.py
@@ -7,8 +7,8 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_WELCOME, SpiceBot.botevents.BOT_READY, SpiceBot.botevents.BOT_CONNECTED, SpiceBot.botevents.BOT_LOADED)
+@sopel.module.event(SpiceBot.events.BOT_WELCOME, SpiceBot.events.BOT_READY, SpiceBot.events.BOT_CONNECTED, SpiceBot.events.BOT_LOADED)
 @sopel.module.rule('.*')
 def bot_events_complete(bot, trigger):
     """This is here simply to log to stderr that this was recieved."""
-    SpiceBot.botlogs.log('SpiceBot_Events', trigger.args[1], True)
+    SpiceBot.logs.log('SpiceBot_Events', trigger.args[1], True)
diff --git a/sopel_modules/SpiceBot_Events/Queue.py b/sopel_modules/SpiceBot_Events/Queue.py
index 778642c..68905c0 100644
--- a/sopel_modules/SpiceBot_Events/Queue.py
+++ b/sopel_modules/SpiceBot_Events/Queue.py
@@ -7,12 +7,12 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_WELCOME)
+@sopel.module.event(SpiceBot.events.BOT_WELCOME)
 @sopel.module.rule('.*')
 def bot_events_connected(bot, trigger):
     """For items tossed in a queue, this will trigger them accordingly"""
     while True:
-        if len(SpiceBot.botevents.SpiceBot_Events["trigger_queue"]):
-            pretriggerdict = SpiceBot.botevents.SpiceBot_Events["trigger_queue"][0]
-            SpiceBot.botevents.dispatch(bot, pretriggerdict)
-            del SpiceBot.botevents.SpiceBot_Events["trigger_queue"][0]
+        if len(SpiceBot.events.dict["trigger_queue"]):
+            pretriggerdict = SpiceBot.events.dict["trigger_queue"][0]
+            SpiceBot.events.dispatch(bot, pretriggerdict)
+            del SpiceBot.events.dict["trigger_queue"][0]
diff --git a/sopel_modules/SpiceBot_Events/Ready.py b/sopel_modules/SpiceBot_Events/Ready.py
index 2ff6f28..9284475 100644
--- a/sopel_modules/SpiceBot_Events/Ready.py
+++ b/sopel_modules/SpiceBot_Events/Ready.py
@@ -7,8 +7,8 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_WELCOME)
+@sopel.module.event(SpiceBot.events.BOT_WELCOME)
 @sopel.module.rule('.*')
 def bot_events_start(bot, trigger):
     """This stage is redundant, but shows the system is working."""
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_READY, "Ready To Process module setup procedures")
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_READY, "Ready To Process module setup procedures")
diff --git a/sopel_modules/SpiceBot_Events/Welcome.py b/sopel_modules/SpiceBot_Events/Welcome.py
index 1102a53..27e3c3d 100644
--- a/sopel_modules/SpiceBot_Events/Welcome.py
+++ b/sopel_modules/SpiceBot_Events/Welcome.py
@@ -7,11 +7,11 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.RPL_WELCOME)
+@sopel.module.event(SpiceBot.events.RPL_WELCOME)
 @sopel.module.rule('.*')
 def bot_startup_welcome(bot, trigger):
     """The Bot events system does not start until RPL_WELCOME 001 is recieved
     from the server"""
-    if SpiceBot.botevents.check(SpiceBot.botevents.BOT_WELCOME):
+    if SpiceBot.events.check(SpiceBot.events.BOT_WELCOME):
         return
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_WELCOME, "Welcome to the SpiceBot Events System")
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_WELCOME, "Welcome to the SpiceBot Events System")
diff --git a/sopel_modules/SpiceBot_GifSearch/gif.py b/sopel_modules/SpiceBot_GifSearch/gif.py
index 9298bee..518f95d 100644
--- a/sopel_modules/SpiceBot_GifSearch/gif.py
+++ b/sopel_modules/SpiceBot_GifSearch/gif.py
@@ -11,7 +11,7 @@ import sopel_modules.SpiceBot as SpiceBot
 import spicemanip
 
 
-@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_GIFSEARCH])
+@SpiceBot.events.check_ready([SpiceBot.events.BOT_GIFSEARCH])
 @module.commands('gif')
 def gif_trigger(bot, trigger):
 
diff --git a/sopel_modules/SpiceBot_GifSearch/gifapi.py b/sopel_modules/SpiceBot_GifSearch/gifapi.py
index 147888f..dc119cd 100644
--- a/sopel_modules/SpiceBot_GifSearch/gifapi.py
+++ b/sopel_modules/SpiceBot_GifSearch/gifapi.py
@@ -11,7 +11,7 @@ import spicemanip
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_GIFSEARCH])
+@SpiceBot.events.check_ready([SpiceBot.events.BOT_GIFSEARCH])
 @sopel.module.commands('(.*)')
 def gifapi_triggers(bot, trigger):
 
diff --git a/sopel_modules/SpiceBot_GifSearch/gifsearch.py b/sopel_modules/SpiceBot_GifSearch/gifsearch.py
index 6e697e8..75e84d9 100644
--- a/sopel_modules/SpiceBot_GifSearch/gifsearch.py
+++ b/sopel_modules/SpiceBot_GifSearch/gifsearch.py
@@ -42,8 +42,8 @@ def configure(config):
 
 
 def setup(bot):
-    SpiceBot.botlogs.log('SpiceBot_GifSearch', "Starting Setup Procedure")
-    SpiceBot.botevents.startup_add([SpiceBot.botevents.BOT_GIFSEARCH])
+    SpiceBot.logs.log('SpiceBot_GifSearch', "Starting Setup Procedure")
+    SpiceBot.events.startup_add([SpiceBot.events.BOT_GIFSEARCH])
 
     if 'SpiceBot_GifSearch' not in bot.memory:
         bot.memory["SpiceBot_GifSearch"] = {"cache": {}, "badgiflinks": [], 'valid_gif_api_dict': {}}
@@ -70,12 +70,12 @@ def setup(bot):
         bot.memory["SpiceBot_GifSearch"]['valid_gif_api_dict'][gif_api] = valid_gif_api_dict[gif_api]
 
     for validgifapi in bot.memory["SpiceBot_GifSearch"]['valid_gif_api_dict'].keys():
-        SpiceBot.botcommands.commandsquery_register(bot, "prefix", validgifapi)
+        SpiceBot.commands.commandsquery_register(bot, "prefix", validgifapi)
 
         if validgifapi not in bot.memory["SpiceBot_GifSearch"]['cache'].keys():
             bot.memory["SpiceBot_GifSearch"]['cache'][validgifapi] = dict()
 
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_GIFSEARCH, "SpiceBot_GifSearch")
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_GIFSEARCH, "SpiceBot_GifSearch")
 
 
 def shutdown(bot):
diff --git a/sopel_modules/SpiceBot_InvalidCommand/InvalidCommand.py b/sopel_modules/SpiceBot_InvalidCommand/InvalidCommand.py
index 58536c1..63c18f5 100644
--- a/sopel_modules/SpiceBot_InvalidCommand/InvalidCommand.py
+++ b/sopel_modules/SpiceBot_InvalidCommand/InvalidCommand.py
@@ -17,14 +17,14 @@ def shutdown(bot):
         del bot.memory["SpiceBot_InvalidCommand"]
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_LOADED)
+@sopel.module.event(SpiceBot.events.BOT_LOADED)
 @sopel.module.rule('.*')
 def bot_events_complete(bot, trigger):
-    for comtype in SpiceBot.botcommands.SpiceBot_Commands['commands'].keys():
-        bot.memory["SpiceBot_InvalidCommand"]["valid"].extend(SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype].keys())
+    for comtype in SpiceBot.commands.dict['commands'].keys():
+        bot.memory["SpiceBot_InvalidCommand"]["valid"].extend(SpiceBot.commands.dict['commands'][comtype].keys())
 
 
-@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_LOADED, SpiceBot.botevents.BOT_COMMANDSQUERY])
+@SpiceBot.events.check_ready([SpiceBot.events.BOT_LOADED, SpiceBot.events.BOT_COMMANDSQUERY])
 @sopel.module.commands('(.*)')
 def InvalidCommand_triggers(bot, trigger):
     return
diff --git a/sopel_modules/SpiceBot_Kick/__init__.py b/sopel_modules/SpiceBot_Kick/__init__.py
index 03b230c..d00503b 100644
--- a/sopel_modules/SpiceBot_Kick/__init__.py
+++ b/sopel_modules/SpiceBot_Kick/__init__.py
@@ -35,12 +35,12 @@ def configure(config):
 def setup(bot):
 
     # Inject KICK
-    SpiceBot.botlogs.log('SpiceBot_Kick', "Implanting Kick function into bot")
+    SpiceBot.logs.log('SpiceBot_Kick', "Implanting Kick function into bot")
     bot.kick = SopelKICK.kick
     sopel.bot.SopelWrapper.kick = SopelWrapperKICK.kick
 
     # verify config settings for server
-    SpiceBot.botlogs.log('SpiceBot_Kick', "Checking for config settings")
+    SpiceBot.logs.log('SpiceBot_Kick', "Checking for config settings")
     bot.config.define_section("SpiceBot_Kick", SpiceBot_Kick, validate=False)
 
 
diff --git a/sopel_modules/SpiceBot_Logs/IRC_Events b/sopel_modules/SpiceBot_Logs/IRC_Events
index de5eb52..79a665d 100644
--- a/sopel_modules/SpiceBot_Logs/IRC_Events
+++ b/sopel_modules/SpiceBot_Logs/IRC_Events
@@ -11,1256 +11,1256 @@ import sopel_modules.SpiceBot as SpiceBot
 @sopel.moduleevent('NICK')
 @sopel.modulerule('.*')
 def parse_event_NICK(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 @sopel.moduleevent('QUIT')
 @sopel.modulerule('.*')
 def parse_event_QUIT(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 @sopel.moduleevent('PART')
 def parse_event_PART(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 @sopel.moduleevent('MODE')
 @sopel.modulerule('.*')
 def parse_event_MODE(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 @sopel.moduleevent('KICK')
 @sopel.modulerule('.*')
 def parse_event_KICK(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 @sopel.moduleevent('JOIN')
 @sopel.modulerule('.*')
 def parse_event_JOIN(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 @sopel.moduleevent('INVITE')
 @sopel.modulerule('.*')
 def parse_event_INVITE(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 @sopel.moduleevent('TOPIC')
 @sopel.modulerule('.*')
 def parse_event_TOPIC(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WELCOME = '001'
 @sopel.moduleevent('001')
 @sopel.modulerule('.*')
 def parse_event_001(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_YOURHOST = '002'
 @sopel.moduleevent('002')
 @sopel.modulerule('.*')
 def parse_event_002(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_CREATED = '003'
 @sopel.moduleevent('003')
 @sopel.modulerule('.*')
 def parse_event_003(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_MYINFO = '004'
 @sopel.moduleevent('004')
 @sopel.modulerule('.*')
 def parse_event_004(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_BOUNCE = '005'
 @sopel.moduleevent('005')
 @sopel.modulerule('.*')
 def parse_event_005(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ISUPPORT = '005'
 @sopel.moduleevent('005')
 @sopel.modulerule('.*')
 def parse_event_005b(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACELINK = '200'
 @sopel.moduleevent('200')
 @sopel.modulerule('.*')
 def parse_event_200(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACECONNECTING = '201'
 @sopel.moduleevent('201')
 @sopel.modulerule('.*')
 def parse_event_201(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACEHANDSHAKE = '202'
 @sopel.moduleevent('202')
 @sopel.modulerule('.*')
 def parse_event_202(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACEUNKNOWN = '203'
 @sopel.moduleevent('203')
 @sopel.modulerule('.*')
 def parse_event_203(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACEOPERATOR = '204'
 @sopel.moduleevent('204')
 @sopel.modulerule('.*')
 def parse_event_204(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACEUSER = '205'
 @sopel.moduleevent('205')
 @sopel.modulerule('.*')
 def parse_event_205(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACESERVER = '206'
 @sopel.moduleevent('206')
 @sopel.modulerule('.*')
 def parse_event_206(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACESERVICE = '207'
 @sopel.moduleevent('207')
 @sopel.modulerule('.*')
 def parse_event_207(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACENEWTYPE = '208'
 @sopel.moduleevent('208')
 @sopel.modulerule('.*')
 def parse_event_208(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACECLASS = '209'
 @sopel.moduleevent('209')
 @sopel.modulerule('.*')
 def parse_event_209(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACERECONNECT = '210'
 @sopel.moduleevent('210')
 @sopel.modulerule('.*')
 def parse_event_210(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSLINKINFO = '211'
 @sopel.moduleevent('211')
 @sopel.modulerule('.*')
 def parse_event_211(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSCOMMANDS = '212'
 @sopel.moduleevent('212')
 @sopel.modulerule('.*')
 def parse_event_212(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSCLINE = '213'
 @sopel.moduleevent('213')
 @sopel.modulerule('.*')
 def parse_event_213(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSNLINE = '214'
 @sopel.moduleevent('214')
 @sopel.modulerule('.*')
 def parse_event_214(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSILINE = '215'
 @sopel.moduleevent('215')
 @sopel.modulerule('.*')
 def parse_event_215(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSKLINE = '216'
 @sopel.moduleevent('216')
 @sopel.modulerule('.*')
 def parse_event_216(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSYLINE = '218'
 @sopel.moduleevent('218')
 @sopel.modulerule('.*')
 def parse_event_218(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFSTATS = '219'
 @sopel.moduleevent('219')
 @sopel.modulerule('.*')
 def parse_event_219(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_UMODEIS = '221'
 @sopel.moduleevent('221')
 @sopel.modulerule('.*')
 def parse_event_221(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_SERVLIST = '234'
 @sopel.moduleevent('234')
 @sopel.modulerule('.*')
 def parse_event_234(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_SERVLISTEND = '235'
 @sopel.moduleevent('235')
 @sopel.modulerule('.*')
 def parse_event_235(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSLLINE = '241'
 @sopel.moduleevent('241')
 @sopel.modulerule('.*')
 def parse_event_241(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSUPTIME = '242'
 @sopel.moduleevent('242')
 @sopel.modulerule('.*')
 def parse_event_242(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSOLINE = '243'
 @sopel.moduleevent('243')
 @sopel.modulerule('.*')
 def parse_event_243(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STATSHLINE = '244'
 @sopel.moduleevent('244')
 @sopel.modulerule('.*')
 def parse_event_244(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LUSERCLIENT = '251'
 @sopel.moduleevent('251')
 @sopel.modulerule('.*')
 def parse_event_251(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LUSEROP = '252'
 @sopel.moduleevent('252')
 @sopel.modulerule('.*')
 def parse_event_252(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LUSERUNKNOWN = '253'
 @sopel.moduleevent('253')
 @sopel.modulerule('.*')
 def parse_event_253(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LUSERCHANNELS = '254'
 @sopel.moduleevent('254')
 @sopel.modulerule('.*')
 def parse_event_254(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LUSERME = '255'
 @sopel.moduleevent('255')
 @sopel.modulerule('.*')
 def parse_event_255(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ADMINME = '256'
 @sopel.moduleevent('256')
 @sopel.modulerule('.*')
 def parse_event_256(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ADMINLOC1 = '257'
 @sopel.moduleevent('257')
 @sopel.modulerule('.*')
 def parse_event_257(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ADMINLOC2 = '258'
 @sopel.moduleevent('258')
 @sopel.modulerule('.*')
 def parse_event_258(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ADMINEMAIL = '259'
 @sopel.moduleevent('259')
 @sopel.modulerule('.*')
 def parse_event_259(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACELOG = '261'
 @sopel.moduleevent('261')
 @sopel.modulerule('.*')
 def parse_event_261(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRACEEND = '262'
 @sopel.moduleevent('262')
 @sopel.modulerule('.*')
 def parse_event_262(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TRYAGAIN = '263'
 @sopel.moduleevent('263')
 @sopel.modulerule('.*')
 def parse_event_263(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_NONE = '300'
 @sopel.moduleevent('300')
 @sopel.modulerule('.*')
 def parse_event_300(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_AWAY = '301'
 @sopel.moduleevent('301')
 @sopel.modulerule('.*')
 def parse_event_301(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_USERHOST = '302'
 @sopel.moduleevent('302')
 @sopel.modulerule('.*')
 def parse_event_302(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ISON = '303'
 @sopel.moduleevent('303')
 @sopel.modulerule('.*')
 def parse_event_303(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_UNAWAY = '305'
 @sopel.moduleevent('305')
 @sopel.modulerule('.*')
 def parse_event_305(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_NOWAWAY = '306'
 @sopel.moduleevent('306')
 @sopel.modulerule('.*')
 def parse_event_306(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WHOISUSER = '311'
 @sopel.moduleevent('311')
 @sopel.modulerule('.*')
 def parse_event_311(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WHOISSERVER = '312'
 @sopel.moduleevent('312')
 @sopel.modulerule('.*')
 def parse_event_312(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WHOISOPERATOR = '313'
 @sopel.moduleevent('313')
 @sopel.modulerule('.*')
 def parse_event_313(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WHOWASUSER = '314'
 @sopel.moduleevent('314')
 @sopel.modulerule('.*')
 def parse_event_314(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFWHO = '315'
 @sopel.moduleevent('315')
 @sopel.modulerule('.*')
 def parse_event_315(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WHOISIDLE = '317'
 @sopel.moduleevent('317')
 @sopel.modulerule('.*')
 def parse_event_317(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFWHOIS = '318'
 @sopel.moduleevent('318')
 @sopel.modulerule('.*')
 def parse_event_318(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WHOISCHANNELS = '319'
 @sopel.moduleevent('319')
 @sopel.modulerule('.*')
 def parse_event_319(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LISTSTART = '321'
 @sopel.moduleevent('321')
 @sopel.modulerule('.*')
 def parse_event_321(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LIST = '322'
 @sopel.moduleevent('322')
 @sopel.modulerule('.*')
 def parse_event_322(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LISTEND = '323'
 @sopel.moduleevent('323')
 @sopel.modulerule('.*')
 def parse_event_323(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_CHANNELMODEIS = '324'
 @sopel.moduleevent('324')
 @sopel.modulerule('.*')
 def parse_event_324(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_UNIQOPIS = '325'
 @sopel.moduleevent('325')
 @sopel.modulerule('.*')
 def parse_event_325(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_NOTOPIC = '331'
 @sopel.moduleevent('331')
 @sopel.modulerule('.*')
 def parse_event_331(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TOPIC = '332'
 @sopel.moduleevent('332')
 @sopel.modulerule('.*')
 def parse_event_332(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_INVITING = '341'
 @sopel.moduleevent('341')
 @sopel.modulerule('.*')
 def parse_event_341(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_SUMMONING = '342'
 @sopel.moduleevent('342')
 @sopel.modulerule('.*')
 def parse_event_342(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_INVITELIST = '346'
 @sopel.moduleevent('346')
 @sopel.modulerule('.*')
 def parse_event_346(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFINVITELIST = '347'
 @sopel.moduleevent('347')
 @sopel.modulerule('.*')
 def parse_event_347(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_EXCEPTLIST = '348'
 @sopel.moduleevent('348')
 @sopel.modulerule('.*')
 def parse_event_348(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFEXCEPTLIST = '349'
 @sopel.moduleevent('349')
 @sopel.modulerule('.*')
 def parse_event_349(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_VERSION = '351'
 @sopel.moduleevent('351')
 @sopel.modulerule('.*')
 def parse_event_351(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WHOREPLY = '352'
 @sopel.moduleevent('352')
 @sopel.modulerule('.*')
 def parse_event_352(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_NAMREPLY = '353'
 @sopel.moduleevent('353')
 @sopel.modulerule('.*')
 def parse_event_353(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WHOSPCRPL = '354'
 @sopel.moduleevent('354')
 @sopel.modulerule('.*')
 def parse_event_354(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LINKS = '364'
 @sopel.moduleevent('364')
 @sopel.modulerule('.*')
 def parse_event_364(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFLINKS = '365'
 @sopel.moduleevent('365')
 @sopel.modulerule('.*')
 def parse_event_365(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFNAMES = '366'
 @sopel.moduleevent('366')
 @sopel.modulerule('.*')
 def parse_event_366(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_BANLIST = '367'
 @sopel.moduleevent('367')
 @sopel.modulerule('.*')
 def parse_event_367(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFBANLIST = '368'
 @sopel.moduleevent('368')
 @sopel.modulerule('.*')
 def parse_event_368(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFWHOWAS = '369'
 @sopel.moduleevent('369')
 @sopel.modulerule('.*')
 def parse_event_369(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_INFO = '371'
 @sopel.moduleevent('371')
 @sopel.modulerule('.*')
 def parse_event_371(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_MOTD = '372'
 @sopel.moduleevent('372')
 @sopel.modulerule('.*')
 def parse_event_372(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFINFO = '374'
 @sopel.moduleevent('374')
 @sopel.modulerule('.*')
 def parse_event_374(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_MOTDSTART = '375'
 @sopel.moduleevent('375')
 @sopel.modulerule('.*')
 def parse_event_375(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFMOTD = '376'
 @sopel.moduleevent('376')
 @sopel.modulerule('.*')
 def parse_event_376(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_YOUREOPER = '381'
 @sopel.moduleevent('381')
 @sopel.modulerule('.*')
 def parse_event_381(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_REHASHING = '382'
 @sopel.moduleevent('382')
 @sopel.modulerule('.*')
 def parse_event_382(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_YOURESERVICE = '383'
 @sopel.moduleevent('383')
 @sopel.modulerule('.*')
 def parse_event_383(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_TIME = '391'
 @sopel.moduleevent('391')
 @sopel.modulerule('.*')
 def parse_event_391(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_USERSSTART = '392'
 @sopel.moduleevent('392')
 @sopel.modulerule('.*')
 def parse_event_392(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_USERS = '393'
 @sopel.moduleevent('393')
 @sopel.modulerule('.*')
 def parse_event_393(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFUSERS = '394'
 @sopel.moduleevent('394')
 @sopel.modulerule('.*')
 def parse_event_394(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_NOUSERS = '395'
 @sopel.moduleevent('395')
 @sopel.modulerule('.*')
 def parse_event_395(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOSUCHNICK = '401'
 @sopel.moduleevent('401')
 @sopel.modulerule('.*')
 def parse_event_401(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOSUCHSERVER = '402'
 @sopel.moduleevent('402')
 @sopel.modulerule('.*')
 def parse_event_402(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOSUCHCHANNEL = '403'
 @sopel.moduleevent('403')
 @sopel.modulerule('.*')
 def parse_event_403(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_CANNOTSENDTOCHAN = '404'
 @sopel.moduleevent('404')
 @sopel.modulerule('.*')
 def parse_event_404(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_TOOMANYCHANNELS = '405'
 @sopel.moduleevent('405')
 @sopel.modulerule('.*')
 def parse_event_405(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_WASNOSUCHNICK = '406'
 @sopel.moduleevent('406')
 @sopel.modulerule('.*')
 def parse_event_406(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_TOOMANYTARGETS = '407'
 @sopel.moduleevent('407')
 @sopel.modulerule('.*')
 def parse_event_407(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOSUCHSERVICE = '408'
 @sopel.moduleevent('408')
 @sopel.modulerule('.*')
 def parse_event_408(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOORIGIN = '409'
 @sopel.moduleevent('409')
 @sopel.modulerule('.*')
 def parse_event_409(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_INVALIDCAPCMD = '410'
 @sopel.moduleevent('410')
 @sopel.modulerule('.*')
 def parse_event_410(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NORECIPIENT = '411'
 @sopel.moduleevent('411')
 @sopel.modulerule('.*')
 def parse_event_411(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOTEXTTOSEND = '412'
 @sopel.moduleevent('412')
 @sopel.modulerule('.*')
 def parse_event_412(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOTOPLEVEL = '413'
 @sopel.moduleevent('413')
 @sopel.modulerule('.*')
 def parse_event_413(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_WILDTOPLEVEL = '414'
 @sopel.moduleevent('414')
 @sopel.modulerule('.*')
 def parse_event_414(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_BADMASK = '415'
 @sopel.moduleevent('415')
 @sopel.modulerule('.*')
 def parse_event_415(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_UNKNOWNCOMMAND = '421'
 @sopel.moduleevent('421')
 @sopel.modulerule('.*')
 def parse_event_421(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOMOTD = '422'
 @sopel.moduleevent('422')
 @sopel.modulerule('.*')
 def parse_event_422(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOADMININFO = '423'
 @sopel.moduleevent('423')
 @sopel.modulerule('.*')
 def parse_event_423(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_FILEERROR = '424'
 @sopel.moduleevent('424')
 @sopel.modulerule('.*')
 def parse_event_424(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NONICKNAMEGIVEN = '431'
 @sopel.moduleevent('431')
 @sopel.modulerule('.*')
 def parse_event_431(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_ERRONEUSNICKNAME = '432'
 @sopel.moduleevent('432')
 @sopel.modulerule('.*')
 def parse_event_432(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NICKNAMEINUSE = '433'
 @sopel.moduleevent('433')
 @sopel.modulerule('.*')
 def parse_event_433(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NICKCOLLISION = '436'
 @sopel.moduleevent('436')
 @sopel.modulerule('.*')
 def parse_event_436(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_UNAVAILRESOURCE = '437'
 @sopel.moduleevent('437')
 @sopel.modulerule('.*')
 def parse_event_437(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_USERNOTINCHANNEL = '441'
 @sopel.moduleevent('441')
 @sopel.modulerule('.*')
 def parse_event_441(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOTONCHANNEL = '442'
 @sopel.moduleevent('442')
 @sopel.modulerule('.*')
 def parse_event_442(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_USERONCHANNEL = '443'
 @sopel.moduleevent('443')
 @sopel.modulerule('.*')
 def parse_event_443(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOLOGIN = '444'
 @sopel.moduleevent('444')
 @sopel.modulerule('.*')
 def parse_event_444(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_SUMMONDISABLED = '445'
 @sopel.moduleevent('445')
 @sopel.modulerule('.*')
 def parse_event_445(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_USERSDISABLED = '446'
 @sopel.moduleevent('446')
 @sopel.modulerule('.*')
 def parse_event_446(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOTREGISTERED = '451'
 @sopel.moduleevent('451')
 @sopel.modulerule('.*')
 def parse_event_451(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NEEDMOREPARAMS = '461'
 @sopel.moduleevent('461')
 @sopel.modulerule('.*')
 def parse_event_461(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_ALREADYREGISTRED = '462'
 @sopel.moduleevent('462')
 @sopel.modulerule('.*')
 def parse_event_462(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOPERMFORHOST = '463'
 @sopel.moduleevent('463')
 @sopel.modulerule('.*')
 def parse_event_463(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_PASSWDMISMATCH = '464'
 @sopel.moduleevent('464')
 @sopel.modulerule('.*')
 def parse_event_464(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_YOUREBANNEDCREEP = '465'
 @sopel.moduleevent('465')
 @sopel.modulerule('.*')
 def parse_event_465(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_YOUWILLBEBANNED = '466'
 @sopel.moduleevent('466')
 @sopel.modulerule('.*')
 def parse_event_466(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_KEYSET = '467'
 @sopel.moduleevent('467')
 @sopel.modulerule('.*')
 def parse_event_467(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_CHANNELISFULL = '471'
 @sopel.moduleevent('471')
 @sopel.modulerule('.*')
 def parse_event_471(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_UNKNOWNMODE = '472'
 @sopel.moduleevent('472')
 @sopel.modulerule('.*')
 def parse_event_472(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_INVITEONLYCHAN = '473'
 @sopel.moduleevent('473')
 @sopel.modulerule('.*')
 def parse_event_473(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_BANNEDFROMCHAN = '474'
 @sopel.moduleevent('474')
 @sopel.modulerule('.*')
 def parse_event_474(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_BADCHANNELKEY = '475'
 @sopel.moduleevent('475')
 @sopel.modulerule('.*')
 def parse_event_475(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_BADCHANMASK = '476'
 @sopel.moduleevent('476')
 @sopel.modulerule('.*')
 def parse_event_476(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOCHANMODES = '477'
 @sopel.moduleevent('477')
 @sopel.modulerule('.*')
 def parse_event_477(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_BANLISTFULL = '478'
 @sopel.moduleevent('478')
 @sopel.modulerule('.*')
 def parse_event_478(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOPRIVILEGES = '481'
 @sopel.moduleevent('481')
 @sopel.modulerule('.*')
 def parse_event_481(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_CHANOPRIVSNEEDED = '482'
 @sopel.moduleevent('482')
 @sopel.modulerule('.*')
 def parse_event_482(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_CANTKILLSERVER = '483'
 @sopel.moduleevent('483')
 @sopel.modulerule('.*')
 def parse_event_483(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_RESTRICTED = '484'
 @sopel.moduleevent('484')
 @sopel.modulerule('.*')
 def parse_event_484(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_UNIQOPPRIVSNEEDED = '485'
 @sopel.moduleevent('485')
 @sopel.modulerule('.*')
 def parse_event_485(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOOPERHOST = '491'
 @sopel.moduleevent('491')
 @sopel.modulerule('.*')
 def parse_event_491(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_UMODEUNKNOWNFLAG = '501'
 @sopel.moduleevent('501')
 @sopel.modulerule('.*')
 def parse_event_501(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_USERSDONTMATCH = '502'
 @sopel.moduleevent('502')
 @sopel.modulerule('.*')
 def parse_event_502(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_STARTTLS = '670'
 @sopel.moduleevent('670')
 @sopel.modulerule('.*')
 def parse_event_670(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_STARTTLS = '691'
 @sopel.moduleevent('691')
 @sopel.modulerule('.*')
 def parse_event_691(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_MONONLINE = '730'
 @sopel.moduleevent('730')
 @sopel.modulerule('.*')
 def parse_event_730(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_MONOFFLINE = '731'
 @sopel.moduleevent('731')
 @sopel.modulerule('.*')
 def parse_event_731(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_MONLIST = '732'
 @sopel.moduleevent('732')
 @sopel.modulerule('.*')
 def parse_event_732(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_ENDOFMONLIST = '733'
 @sopel.moduleevent('733')
 @sopel.modulerule('.*')
 def parse_event_733(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_MONLISTFULL = '734'
 @sopel.moduleevent('734')
 @sopel.modulerule('.*')
 def parse_event_734(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_WHOISKEYVALUE = '760'
 @sopel.moduleevent('760')
 @sopel.modulerule('.*')
 def parse_event_760(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_KEYVALUE = '761'
 @sopel.moduleevent('761')
 @sopel.modulerule('.*')
 def parse_event_761(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_METADATAEND = '762'
 @sopel.moduleevent('762')
 @sopel.modulerule('.*')
 def parse_event_762(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_METADATALIMIT = '764'
 @sopel.moduleevent('764')
 @sopel.modulerule('.*')
 def parse_event_764(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_TARGETINVALID = '765'
 @sopel.moduleevent('765')
 @sopel.modulerule('.*')
 def parse_event_765(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NOMATCHINGKEY = '766'
 @sopel.moduleevent('766')
 @sopel.modulerule('.*')
 def parse_event_766(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_KEYINVALID = '767'
 @sopel.moduleevent('767')
 @sopel.modulerule('.*')
 def parse_event_767(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_KEYNOTSET = '768'
 @sopel.moduleevent('768')
 @sopel.modulerule('.*')
 def parse_event_768(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_KEYNOPERMISSION = '769'
 @sopel.moduleevent('769')
 @sopel.modulerule('.*')
 def parse_event_769(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LOGGEDIN = '900'
 @sopel.moduleevent('900')
 @sopel.modulerule('.*')
 def parse_event_900(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_LOGGEDOUT = '901'
 @sopel.moduleevent('901')
 @sopel.modulerule('.*')
 def parse_event_901(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_NICKLOCKED = '902'
 @sopel.moduleevent('902')
 @sopel.modulerule('.*')
 def parse_event_902(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_SASLSUCCESS = '903'
 @sopel.moduleevent('903')
 @sopel.modulerule('.*')
 def parse_event_903(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_SASLFAIL = '904'
 @sopel.moduleevent('904')
 @sopel.modulerule('.*')
 def parse_event_904(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_SASLTOOLONG = '905'
 @sopel.moduleevent('905')
 @sopel.modulerule('.*')
 def parse_event_905(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_SASLABORTED = '906'
 @sopel.moduleevent('906')
 @sopel.modulerule('.*')
 def parse_event_906(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # ERR_SASLALREADY = '907'
 @sopel.moduleevent('907')
 @sopel.modulerule('.*')
 def parse_event_907(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
 
 
 # RPL_SASLMECHS = '908'
 @sopel.moduleevent('908')
 @sopel.modulerule('.*')
 def parse_event_908(bot, trigger):
-   SpiceBot.botlogs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
+   SpiceBot.logs.log('SpiceBot_Logs_IRC', str(trigger.event) + "    " + str(trigger.args))
diff --git a/sopel_modules/SpiceBot_Logs/Logs_Command.py b/sopel_modules/SpiceBot_Logs/Logs_Command.py
index 2917e09..6c42b3f 100644
--- a/sopel_modules/SpiceBot_Logs/Logs_Command.py
+++ b/sopel_modules/SpiceBot_Logs/Logs_Command.py
@@ -8,7 +8,7 @@ import spicemanip
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_LOGS])
+@SpiceBot.events.check_ready([SpiceBot.events.BOT_LOGS])
 @sopel.module.nickname_commands('logs', 'debug')
 def bot_command_logs(bot, trigger):
 
@@ -20,11 +20,11 @@ def bot_command_logs(bot, trigger):
 
     logtype = spicemanip.main(triggerargs, 1) or None
     if not logtype:
-        bot.osd("Current valid log(s) include: " + spicemanip.main(SpiceBot.botlogs.SpiceBot_Logs["list"].keys(), 'andlist'), trigger.sender, 'action')
+        bot.osd("Current valid log(s) include: " + spicemanip.main(SpiceBot.logs.dict["list"].keys(), 'andlist'), trigger.sender, 'action')
         return
 
-    if not SpiceBot.inlist(logtype, SpiceBot.botlogs.SpiceBot_Logs["list"].keys()):
-        closestmatches = SpiceBot.similar_list(bot, logtype, SpiceBot.botlogs.SpiceBot_Logs["list"].keys(), 10, 'reverse')
+    if not SpiceBot.inlist(logtype, SpiceBot.logs.dict["list"].keys()):
+        closestmatches = SpiceBot.similar_list(bot, logtype, SpiceBot.logs.dict["list"].keys(), 10, 'reverse')
         if not len(closestmatches):
             bot.notice("No valid logs match " + str(logtype) + ".", trigger.nick)
         else:
@@ -32,14 +32,14 @@ def bot_command_logs(bot, trigger):
 
         return
 
-    logtype = SpiceBot.inlist_match(logtype, SpiceBot.botlogs.SpiceBot_Logs["list"].keys())
+    logtype = SpiceBot.inlist_match(logtype, SpiceBot.logs.dict["list"].keys())
 
     if logtype == "Sopel_systemd":
-        logindex = SpiceBot.botlogs.systemd_logs_fetch(bot)
+        logindex = SpiceBot.logs.systemd_logs_fetch(bot)
     elif logtype == "Sopel_stdio":
-        logindex = SpiceBot.botlogs.stdio_logs_fetch(bot)
+        logindex = SpiceBot.logs.stdio_logs_fetch(bot)
     else:
-        logindex = SpiceBot.botlogs.SpiceBot_Logs["list"][logtype]
+        logindex = SpiceBot.logs.dict["list"][logtype]
 
     if not len(logindex):
         bot.osd("No logs found for " + str(logtype) + ".")
diff --git a/sopel_modules/SpiceBot_Logs/Queue.py b/sopel_modules/SpiceBot_Logs/Queue.py
index 0b93ff8..bbfe113 100644
--- a/sopel_modules/SpiceBot_Logs/Queue.py
+++ b/sopel_modules/SpiceBot_Logs/Queue.py
@@ -9,12 +9,12 @@ import sopel_modules.SpiceBot as SpiceBot
 
 
 def setup(bot):
-    SpiceBot.botlogs.log('SpiceBot_Logs', "Starting Setup Procedure")
-    SpiceBot.botevents.startup_add([SpiceBot.botevents.BOT_LOGS])
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_LOGS, "SpiceBot_Logs")
+    SpiceBot.logs.log('SpiceBot_Logs', "Starting Setup Procedure")
+    SpiceBot.events.startup_add([SpiceBot.events.BOT_LOGS])
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_LOGS, "SpiceBot_Logs")
 
 
-@sopel.module.event(SpiceBot.botevents.RPL_WELCOME)
+@sopel.module.event(SpiceBot.events.RPL_WELCOME)
 @sopel.module.rule('.*')
 def join_log_channel(bot, trigger):
 
@@ -26,9 +26,9 @@ def join_log_channel(bot, trigger):
                 bot.write(('SAJOIN', bot.nick, channel))
 
         while True:
-            if len(SpiceBot.botlogs.SpiceBot_Logs["queue"]):
-                bot.say(str(SpiceBot.botlogs.SpiceBot_Logs["queue"][0]), channel)
-                del SpiceBot.botlogs.SpiceBot_Logs["queue"][0]
+            if len(SpiceBot.logs.dict["queue"]):
+                bot.say(str(SpiceBot.logs.dict["queue"][0]), channel)
+                del SpiceBot.logs.dict["queue"][0]
     else:
-        SpiceBot.botlogs.sopel_config["logging_channel"] = False
-        SpiceBot.botlogs.SpiceBot_Logs["queue"] = []
+        SpiceBot.logs.sopel_config["logging_channel"] = False
+        SpiceBot.logs.dict["queue"] = []
diff --git a/sopel_modules/SpiceBot_Messaging/Messaging.py b/sopel_modules/SpiceBot_Messaging/Messaging.py
index 17754ac..66e81f5 100644
--- a/sopel_modules/SpiceBot_Messaging/Messaging.py
+++ b/sopel_modules/SpiceBot_Messaging/Messaging.py
@@ -41,7 +41,7 @@ def bot_command_process(bot, trigger):
 
     target = spicemanip.main(triggerargs, 1)
     if (target not in ['allchans', 'allnicks']
-            and not SpiceBot.inlist(target.lower(), SpiceBot.botchannels.SpiceBot_Channels['list'].keys())
+            and not SpiceBot.inlist(target.lower(), SpiceBot.channels.dict['list'].keys())
             and not SpiceBot.inlist(target.lower(), bot.users)):
         bot.osd("Channel/nick name {} not valid.".format(target))
         return
diff --git a/sopel_modules/SpiceBot_Module_Parsing/ModuleParsing.py b/sopel_modules/SpiceBot_Module_Parsing/ModuleParsing.py
index 31c392c..01a90b9 100644
--- a/sopel_modules/SpiceBot_Module_Parsing/ModuleParsing.py
+++ b/sopel_modules/SpiceBot_Module_Parsing/ModuleParsing.py
@@ -13,8 +13,8 @@ import spicemanip
 
 
 def setup(bot):
-    SpiceBot.botlogs.log('SpiceBot_CommandsQuery', "Starting setup procedure")
-    SpiceBot.botevents.startup_add([SpiceBot.botevents.BOT_COMMANDSQUERY])
+    SpiceBot.logs.log('SpiceBot_CommandsQuery', "Starting setup procedure")
+    SpiceBot.events.startup_add([SpiceBot.events.BOT_COMMANDSQUERY])
 
     filepathlisting = []
 
@@ -36,7 +36,7 @@ def setup(bot):
                 pypi_modules_dir = os.path.join(plugin_dir, pathname)
                 filepathlisting.append(pypi_modules_dir)
     except Exception as e:
-        SpiceBot.botlogs.log('SpiceBot_CommandsQuery', "sopel_modules not loaded :" + str(e))
+        SpiceBot.logs.log('SpiceBot_CommandsQuery', "sopel_modules not loaded :" + str(e))
 
     # Extra directories
     filepathlist = []
@@ -120,7 +120,7 @@ def setup(bot):
                     currentsuccesslines += 1
 
             if currentsuccesslines:
-                SpiceBot.botcommands.SpiceBot_Commands['counts'] += 1
+                SpiceBot.commands.dict['counts'] += 1
 
             if len(filelinelist):
                 for atlinefound in filelinelist:
@@ -140,27 +140,27 @@ def setup(bot):
                     else:
                         comaliases = []
 
-                    SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype][maincom] = dict_from_file
+                    SpiceBot.commands.dict['commands'][comtype][maincom] = dict_from_file
                     for comalias in comaliases:
-                        if comalias not in SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype].keys():
-                            SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype][comalias] = {"aliasfor": maincom}
+                        if comalias not in SpiceBot.commands.dict['commands'][comtype].keys():
+                            SpiceBot.commands.dict['commands'][comtype][comalias] = {"aliasfor": maincom}
 
     for comtype in ['module', 'nickname', 'rule']:
-        SpiceBot.botlogs.log('SpiceBot_CommandsQuery', "Found " + str(len(SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype].keys())) + " " + comtype + " commands.", True)
+        SpiceBot.logs.log('SpiceBot_CommandsQuery', "Found " + str(len(SpiceBot.commands.dict['commands'][comtype].keys())) + " " + comtype + " commands.", True)
 
-    for command in SpiceBot.botcommands.SpiceBot_Commands['commands']['rule'].keys():
+    for command in SpiceBot.commands.dict['commands']['rule'].keys():
         if command.startswith("$nickname"):
             command = command.split("$nickname")[-1]
-            if command not in SpiceBot.botcommands.SpiceBot_Commands['nickrules']:
-                SpiceBot.botcommands.SpiceBot_Commands['nickrules'].append(command)
+            if command not in SpiceBot.commands.dict['nickrules']:
+                SpiceBot.commands.dict['nickrules'].append(command)
 
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_COMMANDSQUERY, "SpiceBot_CommandsQuery")
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_COMMANDSQUERY, "SpiceBot_CommandsQuery")
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_LOADED)
+@sopel.module.event(SpiceBot.events.BOT_LOADED)
 @sopel.module.rule('.*')
 def bot_events_complete(bot, trigger):
 
-    for comtype in SpiceBot.botcommands.SpiceBot_Commands['commands'].keys():
+    for comtype in SpiceBot.commands.dict['commands'].keys():
         if comtype not in ['module', 'nickname', 'rule']:
-            SpiceBot.botlogs.log('SpiceBot_CommandsQuery', "Found " + str(len(SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype].keys())) + " " + comtype + " commands.", True)
+            SpiceBot.logs.log('SpiceBot_CommandsQuery', "Found " + str(len(SpiceBot.commands.dict['commands'][comtype].keys())) + " " + comtype + " commands.", True)
diff --git a/sopel_modules/SpiceBot_Restart/Restart.py b/sopel_modules/SpiceBot_Restart/Restart.py
index 76d5f56..bc4ef6f 100644
--- a/sopel_modules/SpiceBot_Restart/Restart.py
+++ b/sopel_modules/SpiceBot_Restart/Restart.py
@@ -15,7 +15,7 @@ def nickname_comand_restart(bot, trigger):
         bot.say("You are not authorized to perform this function.")
 
     quitmessage = "Received command from " + trigger.nick + " to restart. Be Back Soon!"
-    SpiceBot.botlogs.log('SpiceBot_Restart', quitmessage)
+    SpiceBot.logs.log('SpiceBot_Restart', quitmessage)
     bot.osd(quitmessage, bot.channels.keys())
 
     # service_manip(bot, bot.nick, 'restart', 'SpiceBot_Restart')
diff --git a/sopel_modules/SpiceBot_SopelPatches/Patches.py b/sopel_modules/SpiceBot_SopelPatches/Patches.py
index 4df1c1e..eb4d009 100644
--- a/sopel_modules/SpiceBot_SopelPatches/Patches.py
+++ b/sopel_modules/SpiceBot_SopelPatches/Patches.py
@@ -11,9 +11,9 @@ import sopel_modules.SpiceBot as SpiceBot
 
 def setup(bot):
 
-    SpiceBot.botlogs.log('Sopel_Patch', "Patching Sopels built-in url_callbacks")
+    SpiceBot.logs.log('Sopel_Patch', "Patching Sopels built-in url_callbacks")
     if 'url_callbacks' not in bot.memory:
         bot.memory['url_callbacks'] = sopel.tools.SopelMemory()
 
-    SpiceBot.botlogs.log('Sopel_Patch', "Removing Stock Modules and verifying Dummy Command is present.")
+    SpiceBot.logs.log('Sopel_Patch', "Removing Stock Modules and verifying Dummy Command is present.")
     SpiceBot.stock_modules_begone(bot)
diff --git a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue.py b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue.py
index 9ffdaeb..05364c9 100644
--- a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue.py
+++ b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue.py
@@ -8,8 +8,8 @@ import sopel_modules.SpiceBot as SpiceBot
 
 
 def setup(bot):
-    SpiceBot.botlogs.log('SpiceBot_StartupMonologue', "Starting setup procedure")
-    SpiceBot.botevents.startup_add([SpiceBot.botevents.BOT_STARTUPMONOLOGUE_CHANNELS, SpiceBot.botevents.BOT_STARTUPMONOLOGUE_COMMANDSQUERY])  # ,SpiceBot.botevents.BOT_STARTUPMONOLOGUE_CONNECTED])
+    SpiceBot.logs.log('SpiceBot_StartupMonologue', "Starting setup procedure")
+    SpiceBot.events.startup_add([SpiceBot.events.BOT_STARTUPMONOLOGUE_CHANNELS, SpiceBot.events.BOT_STARTUPMONOLOGUE_COMMANDSQUERY])  # ,SpiceBot.events.BOT_STARTUPMONOLOGUE_CONNECTED])
 
     if 'SpiceBot_StartupMonologue' not in bot.memory:
         bot.memory['SpiceBot_StartupMonologue'] = []
diff --git a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Channels.py b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Channels.py
index 983e3e5..70eecdc 100644
--- a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Channels.py
+++ b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Channels.py
@@ -7,13 +7,13 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_CHANNELS)
+@sopel.module.event(SpiceBot.events.BOT_CHANNELS)
 @sopel.module.rule('.*')
 def bot_startup_monologue_channels(bot, trigger):
 
     botcount = len(bot.channels.keys())
-    servercount = len(SpiceBot.botchannels.SpiceBot_Channels['list'].keys())
+    servercount = len(SpiceBot.channels.dict['list'].keys())
     bot.memory['SpiceBot_StartupMonologue'].append("I am in " + str(botcount) + " of " + str(servercount) + " channel(s) available on this server.")
-    SpiceBot.botlogs.log('SpiceBot_StartupMonologue', "I am in " + str(botcount) + " of " + str(servercount) + " channel(s) available on this server.")
+    SpiceBot.logs.log('SpiceBot_StartupMonologue', "I am in " + str(botcount) + " of " + str(servercount) + " channel(s) available on this server.")
 
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_STARTUPMONOLOGUE_CHANNELS, "SpiceBot_StartupMonologue")
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_STARTUPMONOLOGUE_CHANNELS, "SpiceBot_StartupMonologue")
diff --git a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Commands.py b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Commands.py
index a9132b9..e5a490f 100644
--- a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Commands.py
+++ b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Commands.py
@@ -7,16 +7,16 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_COMMANDSQUERY)
+@sopel.module.event(SpiceBot.events.BOT_COMMANDSQUERY)
 @sopel.module.rule('.*')
 def bot_startup_monologue_commands(bot, trigger):
 
     availablecomsnum, availablecomsfiles = 0, 0
-    for commandstype in SpiceBot.botcommands.SpiceBot_Commands['commands'].keys():
-        availablecomsnum += len(SpiceBot.botcommands.SpiceBot_Commands['commands'][commandstype].keys())
-    availablecomsfiles += SpiceBot.botcommands.SpiceBot_Commands['counts']
+    for commandstype in SpiceBot.commands.dict['commands'].keys():
+        availablecomsnum += len(SpiceBot.commands.dict['commands'][commandstype].keys())
+    availablecomsfiles += SpiceBot.commands.dict['counts']
 
     bot.memory['SpiceBot_StartupMonologue'].append("There are " + str(availablecomsnum) + " commands available in " + str(availablecomsfiles) + " files.")
-    SpiceBot.botlogs.log('SpiceBot_StartupMonologue', "There are " + str(availablecomsnum) + " commands available in " + str(availablecomsfiles) + " files.")
+    SpiceBot.logs.log('SpiceBot_StartupMonologue', "There are " + str(availablecomsnum) + " commands available in " + str(availablecomsfiles) + " files.")
 
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_STARTUPMONOLOGUE_COMMANDSQUERY, "SpiceBot_StartupMonologue")
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_STARTUPMONOLOGUE_COMMANDSQUERY, "SpiceBot_StartupMonologue")
diff --git a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Connected.py b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Connected.py
index 4132e87..0eaa358 100644
--- a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Connected.py
+++ b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Connected.py
@@ -7,12 +7,12 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_CONNECTED)
+@sopel.module.event(SpiceBot.events.BOT_CONNECTED)
 @sopel.module.rule('.*')
 def bot_startup_monologue_start(bot, trigger):
 
     # Startup
-    SpiceBot.botlogs.log('SpiceBot_StartupMonologue', bot.nick + " is now starting. Please wait while I load my configuration")
+    SpiceBot.logs.log('SpiceBot_StartupMonologue', bot.nick + " is now starting. Please wait while I load my configuration")
     bot.osd(" is now starting. Please wait while I load my configuration.", bot.channels.keys(), 'ACTION')
 
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_STARTUPMONOLOGUE_CONNECTED, "SpiceBot_StartupMonologue")
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_STARTUPMONOLOGUE_CONNECTED, "SpiceBot_StartupMonologue")
diff --git a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Errors.py b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Errors.py
index dffc532..34b0ede 100644
--- a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Errors.py
+++ b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Errors.py
@@ -6,11 +6,11 @@ import sopel.module
 import sopel_modules.SpiceBot as SpiceBot
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_STARTUPMONOLOGUE)
+@sopel.module.event(SpiceBot.events.BOT_STARTUPMONOLOGUE)
 @sopel.module.rule('.*')
 def bot_startup_monologue_start(bot, trigger):
 
-    debuglines = SpiceBot.botlogs.stdio_logs_fetch(bot)
+    debuglines = SpiceBot.logs.stdio_logs_fetch(bot)
 
     searchphrasefound = []
     for line in debuglines:
@@ -19,9 +19,9 @@ def bot_startup_monologue_start(bot, trigger):
 
     if len(searchphrasefound):
         for foundphase in searchphrasefound:
-            SpiceBot.botlogs.log('SpiceBot_Logs', str(foundphase))
+            SpiceBot.logs.log('SpiceBot_Logs', str(foundphase))
         searchphrasefound.insert(0, "Notice to Bot Admins: ")
         searchphrasefound.append("Run the debug command for more information.")
         bot.osd(searchphrasefound, bot.channels.keys())
     else:
-        SpiceBot.botlogs.log('SpiceBot_Logs', "No issues found at bot startup!", True)
+        SpiceBot.logs.log('SpiceBot_Logs', "No issues found at bot startup!", True)
diff --git a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Loaded.py b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Loaded.py
index 84e1503..c7bb713 100644
--- a/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Loaded.py
+++ b/sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Loaded.py
@@ -9,19 +9,19 @@ import sopel_modules.SpiceBot as SpiceBot
 import time
 
 
-@sopel.module.event(SpiceBot.botevents.BOT_LOADED)
+@sopel.module.event(SpiceBot.events.BOT_LOADED)
 @sopel.module.rule('.*')
 def bot_startup_monologue_display(bot, trigger):
 
-    if SpiceBot.botevents.SpiceBot_Events["RPL_WELCOME_Count"] == 1:
+    if SpiceBot.events.dict["RPL_WELCOME_Count"] == 1:
         timesince = SpiceBot.humanized_time(time.time() - bot.memory["SpiceBot_Uptime"])
         SpiceBot.bot.memory['SpiceBot_StartupMonologue'].append("Startup took " + timesince)
 
     # Announce to chan, then handle some closing stuff
-    SpiceBot.botlogs.log('SpiceBot_StartupMonologue', bot.nick + " startup complete")
+    SpiceBot.logs.log('SpiceBot_StartupMonologue', bot.nick + " startup complete")
     bot.memory['SpiceBot_StartupMonologue'].insert(0, " startup complete")
 
     bot.osd(bot.memory['SpiceBot_StartupMonologue'], bot.channels.keys(), 'ACTION')
 
-    SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_STARTUPMONOLOGUE, "SpiceBot_StartupMonologue")
-    SpiceBot.botlogs.log('SpiceBot_StartupMonologue', "Startup Monologue has been issued to all channels.", True)
+    SpiceBot.events.trigger(bot, SpiceBot.events.BOT_STARTUPMONOLOGUE, "SpiceBot_StartupMonologue")
+    SpiceBot.logs.log('SpiceBot_StartupMonologue', "Startup Monologue has been issued to all channels.", True)
diff --git a/sopel_modules/SpiceBot_Update/Update.py b/sopel_modules/SpiceBot_Update/Update.py
index cda3d99..d0a4efc 100644
--- a/sopel_modules/SpiceBot_Update/Update.py
+++ b/sopel_modules/SpiceBot_Update/Update.py
@@ -23,7 +23,7 @@ def configure(config):
 
 
 def setup(bot):
-    SpiceBot.botlogs.log('SpiceBot_Update', "Initial Setup processing")
+    SpiceBot.logs.log('SpiceBot_Update', "Initial Setup processing")
     bot.config.define_section("SpiceBot_Update", SpiceBot_Update_MainSection, validate=False)
 
 
@@ -48,7 +48,7 @@ def nickname_comand_update(bot, trigger):
     triggerargs = spicemanip.main(triggerargs, '2+', 'list')
 
     quitmessage = "Received command from " + trigger.nick + " to update from Github and restart"
-    SpiceBot.botlogs.log('SpiceBot_Update', quitmessage)
+    SpiceBot.logs.log('SpiceBot_Update', quitmessage)
     bot.osd(quitmessage, bot.channels.keys())
 
     if commandused == 'nodeps':
diff --git a/sopel_modules/SpiceBot_Uptime/Uptime.py b/sopel_modules/SpiceBot_Uptime/Uptime.py
index 5a82333..8273582 100644
--- a/sopel_modules/SpiceBot_Uptime/Uptime.py
+++ b/sopel_modules/SpiceBot_Uptime/Uptime.py
@@ -12,7 +12,7 @@ import sopel_modules.SpiceBot as SpiceBot
 def setup(bot):
     if 'SpiceBot_Uptime' not in bot.memory:
         now = time.time()
-        SpiceBot.botlogs.log('SpiceBot_Uptime', "Start time set to " + str(time.time()))
+        SpiceBot.logs.log('SpiceBot_Uptime', "Start time set to " + str(time.time()))
         bot.memory["SpiceBot_Uptime"] = now
 
 
diff --git a/sopel_modules/SpiceBot_osd/__init__.py b/sopel_modules/SpiceBot_osd/__init__.py
index e753526..5dce22e 100644
--- a/sopel_modules/SpiceBot_osd/__init__.py
+++ b/sopel_modules/SpiceBot_osd/__init__.py
@@ -40,7 +40,7 @@ def configure(config):
 def setup(bot):
 
     # Inject OSD
-    SpiceBot.botlogs.log('SpiceBot_OSD', "Implanting OSD function into bot")
+    SpiceBot.logs.log('SpiceBot_OSD', "Implanting OSD function into bot")
     bot.osd = SopelOSD.osd
     sopel.bot.SopelWrapper.osd = SopelWrapperOSD.osd
     tools.get_available_message_bytes = ToolsOSD.get_available_message_bytes
@@ -48,7 +48,7 @@ def setup(bot):
     tools.get_message_recipientgroups = ToolsOSD.get_message_recipientgroups
 
     # overwrite default bot messaging
-    SpiceBot.botlogs.log('SpiceBot_OSD', "Overwrite Default Sopel messaging commands")
+    SpiceBot.logs.log('SpiceBot_OSD', "Overwrite Default Sopel messaging commands")
     bot.osd = SopelOSD.osd
     bot.say = SopelOSD.say
     bot.action = SopelOSD.action
@@ -61,7 +61,7 @@ def setup(bot):
     sopel.bot.SopelWrapper.reply = SopelWrapperOSD.reply
 
     # verify config settings for server
-    SpiceBot.botlogs.log('SpiceBot_OSD', "Checking for config settings")
+    SpiceBot.logs.log('SpiceBot_OSD', "Checking for config settings")
     bot.config.define_section("SpiceBot_OSD", SpiceBot_OSD, validate=False)