deathbybandaid/SpiceBot-migrated
1
0
Fork 0
mirror of https://github.com/SpiceBot/SpiceBot.git synced 2026-11-13 06:59:53 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

SpiceBot Class Consistancy

Browse Source
This commit is contained in:
deathbybandaid 2019-05-22 13:01:00 -04:00
parent 78c3793fbc
commit d099e3fc2b
40 changed files with 468 additions and 468 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
sopel_modules/SpiceBot/Channels.py
View File

@ -24,15 +24,15 @@ class BotChannels():
def channel_list_recieve_input(self, trigger): def channel_list_recieve_input(self, trigger):
channel, _, topic = trigger.args[1:] channel, _, topic = trigger.args[1:]
if channel.lower() not in self.SpiceBot_Channels['list'].keys(): if channel.lower() not in self.dict['list'].keys():
self.SpiceBot_Channels['list'][channel.lower()] = dict() self.dict['list'][channel.lower()] = dict()
self.SpiceBot_Channels['list'][channel.lower()]['name'] = channel self.dict['list'][channel.lower()]['name'] = channel
self.SpiceBot_Channels['list'][channel.lower()]['topic'] = self.topic_compile(topic) self.dict['list'][channel.lower()]['topic'] = self.topic_compile(topic)
self.channel_lock = True self.channel_lock = True
def channel_list_recieve_finish(self): def channel_list_recieve_finish(self):
if not self.SpiceBot_Channels['InitialProcess']: if not self.dict['InitialProcess']:
self.SpiceBot_Channels['InitialProcess'] = True self.dict['InitialProcess'] = True
self.channel_lock = False self.channel_lock = False
def topic_compile(self, topic): def topic_compile(self, topic):
@ -48,17 +48,17 @@ class BotChannels():
for channel in bot.channels.keys(): for channel in bot.channels.keys():
if len(bot.channels[channel].privileges.keys()) == 1 and channel not in ignorepartlist and channel.startswith("#"): if len(bot.channels[channel].privileges.keys()) == 1 and channel not in ignorepartlist and channel.startswith("#"):
bot.part(channel, "Leaving Empty Channel") bot.part(channel, "Leaving Empty Channel")
if channel.lower() in self.SpiceBot_Channels['list']: if channel.lower() in self.dict['list']:
del self.SpiceBot_Channels['list'][channel.lower()] del self.dict['list'][channel.lower()]
def join_all_channels(self, bot): def join_all_channels(self, bot):
if bot.config.SpiceBot_Channels.joinall: 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.startswith("#"):
if channel not in bot.channels.keys() and channel not in bot.config.SpiceBot_Channels.chanignore: 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: 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): def chanadmin_all_channels(self, bot):
# Chan ADMIN +a # Chan ADMIN +a
@ -72,4 +72,4 @@ class BotChannels():
bot.part(channel) bot.part(channel)
botchannels = BotChannels() channels = BotChannels()

14
sopel_modules/SpiceBot/Commands.py
View File

@ -27,9 +27,9 @@ class BotCommands():
if not isinstance(validcoms, list): if not isinstance(validcoms, list):
validcoms = [validcoms] validcoms = [validcoms]
if command_type not in self.SpiceBot_Commands['commands'].keys(): if command_type not in self.dict['commands'].keys():
self.SpiceBot_Commands['commands'][command_type] = dict() self.dict['commands'][command_type] = dict()
self.SpiceBot_Commands['counts'] += 1 self.dict['counts'] += 1
dict_from_file = dict() dict_from_file = dict()
@ -44,13 +44,13 @@ class BotCommands():
comaliases = spicemanip.main(dict_from_file["validcoms"], '2+', 'list') comaliases = spicemanip.main(dict_from_file["validcoms"], '2+', 'list')
else: else:
comaliases = [] comaliases = []
self.SpiceBot_Commands['commands'][command_type][maincom] = dict_from_file self.dict['commands'][command_type][maincom] = dict_from_file
else: else:
comaliases = validcoms comaliases = validcoms
for comalias in comaliases: for comalias in comaliases:
if comalias not in self.SpiceBot_Commands['commands'][command_type].keys(): if comalias not in self.dict['commands'][command_type].keys():
self.SpiceBot_Commands['commands'][command_type][comalias] = {"aliasfor": aliasfor} self.dict['commands'][command_type][comalias] = {"aliasfor": aliasfor}
botcommands = BotCommands() commands = BotCommands()

154
sopel_modules/SpiceBot/Database.py
View File

@ -28,18 +28,18 @@ class BotDatabase():
nick = Identifier(nick) nick = Identifier(nick)
nick_id = bot.db.get_nick_id(nick, create=True) nick_id = bot.db.get_nick_id(nick, create=True)
if nick_id not in self.SpiceBot_Database["nicks"].keys(): if nick_id not in self.dict["nicks"].keys():
self.SpiceBot_Database["nicks"][nick_id] = {} self.dict["nicks"][nick_id] = {}
if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys(): if sorting_key not in self.dict["nicks"][nick_id].keys():
self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict() self.dict["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict()
self.lock.release() 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 return None
else: 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'): def set_nick_value(self, bot, nick, key, value, sorting_key='unsorted'):
@ -48,15 +48,15 @@ class BotDatabase():
nick = Identifier(nick) nick = Identifier(nick)
nick_id = bot.db.get_nick_id(nick, create=True) nick_id = bot.db.get_nick_id(nick, create=True)
if nick_id not in self.SpiceBot_Database["nicks"].keys(): if nick_id not in self.dict["nicks"].keys():
self.SpiceBot_Database["nicks"][nick_id] = {} self.dict["nicks"][nick_id] = {}
if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys(): if sorting_key not in self.dict["nicks"][nick_id].keys():
self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict() 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() self.lock.release()
@ -67,14 +67,14 @@ class BotDatabase():
nick = Identifier(nick) nick = Identifier(nick)
nick_id = bot.db.get_nick_id(nick, create=True) nick_id = bot.db.get_nick_id(nick, create=True)
if nick_id not in self.SpiceBot_Database["nicks"].keys(): if nick_id not in self.dict["nicks"].keys():
self.SpiceBot_Database["nicks"][nick_id] = {} self.dict["nicks"][nick_id] = {}
if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys(): if sorting_key not in self.dict["nicks"][nick_id].keys():
self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict() 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] del self.dict["nicks"][nick_id][sorting_key][key]
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() self.lock.release()
@ -85,22 +85,22 @@ class BotDatabase():
nick = Identifier(nick) nick = Identifier(nick)
nick_id = bot.db.get_nick_id(nick, create=True) nick_id = bot.db.get_nick_id(nick, create=True)
if nick_id not in self.SpiceBot_Database["nicks"].keys(): if nick_id not in self.dict["nicks"].keys():
self.SpiceBot_Database["nicks"][nick_id] = {} self.dict["nicks"][nick_id] = {}
if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys(): if sorting_key not in self.dict["nicks"][nick_id].keys():
self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict() 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 = [] oldvalue = []
else: else:
oldvalue = self.SpiceBot_Database["nicks"][nick_id][sorting_key][key] oldvalue = self.dict["nicks"][nick_id][sorting_key][key]
if not oldvalue: if not oldvalue:
self.SpiceBot_Database["nicks"][nick_id][sorting_key][key] = value self.dict["nicks"][nick_id][sorting_key][key] = value
else: else:
self.SpiceBot_Database["nicks"][nick_id][sorting_key][key] = oldvalue + value self.dict["nicks"][nick_id][sorting_key][key] = oldvalue + 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() self.lock.release()
@ -114,24 +114,24 @@ class BotDatabase():
nick = Identifier(nick) nick = Identifier(nick)
nick_id = bot.db.get_nick_id(nick, create=True) nick_id = bot.db.get_nick_id(nick, create=True)
if nick_id not in self.SpiceBot_Database["nicks"].keys(): if nick_id not in self.dict["nicks"].keys():
self.SpiceBot_Database["nicks"][nick_id] = {} self.dict["nicks"][nick_id] = {}
if sorting_key not in self.SpiceBot_Database["nicks"][nick_id].keys(): if sorting_key not in self.dict["nicks"][nick_id].keys():
self.SpiceBot_Database["nicks"][nick_id][sorting_key] = bot.db.get_nick_value(nick, sorting_key) or dict() 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():
self.SpiceBot_Database["nicks"][nick_id][sorting_key][key] = [] self.dict["nicks"][nick_id][sorting_key][key] = []
if adjustmentdirection == 'add': if adjustmentdirection == 'add':
for entry in entries: for entry in entries:
if entry not in self.SpiceBot_Database["nicks"][nick_id][sorting_key][key]: if entry not in self.dict["nicks"][nick_id][sorting_key][key]:
self.SpiceBot_Database["nicks"][nick_id][sorting_key][key].append(entry) self.dict["nicks"][nick_id][sorting_key][key].append(entry)
elif adjustmentdirection == 'del': elif adjustmentdirection == 'del':
for entry in entries: for entry in entries:
while entry in self.SpiceBot_Database["nicks"][nick_id][sorting_key][key]: while entry in self.dict["nicks"][nick_id][sorting_key][key]:
self.SpiceBot_Database["nicks"][nick_id][sorting_key][key].remove(entry) self.dict["nicks"][nick_id][sorting_key][key].remove(entry)
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() self.lock.release()
@ -143,18 +143,18 @@ class BotDatabase():
channel = Identifier(channel) channel = Identifier(channel)
if channel not in self.SpiceBot_Database["channels"].keys(): if channel not in self.dict["channels"].keys():
self.SpiceBot_Database["channels"][channel] = {} self.dict["channels"][channel] = {}
if sorting_key not in self.SpiceBot_Database["channels"][channel].keys(): if sorting_key not in self.dict["channels"][channel].keys():
self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict() self.dict["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict()
self.lock.release() 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 return None
else: 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'): def set_channel_value(self, bot, channel, key, value, sorting_key='unsorted'):
@ -162,14 +162,14 @@ class BotDatabase():
channel = Identifier(channel) channel = Identifier(channel)
if channel not in self.SpiceBot_Database["channels"].keys(): if channel not in self.dict["channels"].keys():
self.SpiceBot_Database["channels"][channel] = {} self.dict["channels"][channel] = {}
if sorting_key not in self.SpiceBot_Database["channels"][channel].keys(): if sorting_key not in self.dict["channels"][channel].keys():
self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict() 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 self.dict["channels"][channel][sorting_key][key] = value
bot.db.set_channel_value(channel, sorting_key, self.SpiceBot_Database["channels"][channel][sorting_key]) bot.db.set_channel_value(channel, sorting_key, self.dict["channels"][channel][sorting_key])
self.lock.release() self.lock.release()
@ -179,14 +179,14 @@ class BotDatabase():
channel = Identifier(channel) channel = Identifier(channel)
if channel not in self.SpiceBot_Database["channels"].keys(): if channel not in self.dict["channels"].keys():
self.SpiceBot_Database["channels"][channel] = {} self.dict["channels"][channel] = {}
if sorting_key not in self.SpiceBot_Database["channels"][channel].keys(): if sorting_key not in self.dict["channels"][channel].keys():
self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict() 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] del self.dict["channels"][channel][sorting_key][key]
bot.db.set_channel_value(channel, sorting_key, self.SpiceBot_Database["channels"][channel][sorting_key]) bot.db.set_channel_value(channel, sorting_key, self.dict["channels"][channel][sorting_key])
self.lock.release() self.lock.release()
@ -196,22 +196,22 @@ class BotDatabase():
channel = Identifier(channel) channel = Identifier(channel)
if channel not in self.SpiceBot_Database["channels"].keys(): if channel not in self.dict["channels"].keys():
self.SpiceBot_Database["channels"][channel] = {} self.dict["channels"][channel] = {}
if sorting_key not in self.SpiceBot_Database["channels"][channel].keys(): if sorting_key not in self.dict["channels"][channel].keys():
self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict() 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 oldvalue = None
else: else:
oldvalue = self.SpiceBot_Database["channels"][channel][sorting_key][key] oldvalue = self.dict["channels"][channel][sorting_key][key]
if not oldvalue: if not oldvalue:
self.SpiceBot_Database["channels"][channel][sorting_key][key] = value self.dict["channels"][channel][sorting_key][key] = value
else: else:
self.SpiceBot_Database["channels"][channel][sorting_key][key] = oldvalue + value self.dict["channels"][channel][sorting_key][key] = oldvalue + value
bot.db.set_channel_value(channel, sorting_key, self.SpiceBot_Database["channels"][channel][sorting_key]) bot.db.set_channel_value(channel, sorting_key, self.dict["channels"][channel][sorting_key])
self.lock.release() self.lock.release()
@ -224,26 +224,26 @@ class BotDatabase():
channel = Identifier(channel) channel = Identifier(channel)
if channel not in self.SpiceBot_Database["channels"].keys(): if channel not in self.dict["channels"].keys():
self.SpiceBot_Database["channels"][channel] = {} self.dict["channels"][channel] = {}
if sorting_key not in self.SpiceBot_Database["channels"][channel].keys(): if sorting_key not in self.dict["channels"][channel].keys():
self.SpiceBot_Database["channels"][channel][sorting_key] = bot.db.get_channel_value(channel, sorting_key) or dict() 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():
self.SpiceBot_Database["channels"][channel][sorting_key][key] = [] self.dict["channels"][channel][sorting_key][key] = []
if adjustmentdirection == 'add': if adjustmentdirection == 'add':
for entry in entries: for entry in entries:
if entry not in self.SpiceBot_Database["channels"][channel][sorting_key][key]: if entry not in self.dict["channels"][channel][sorting_key][key]:
self.SpiceBot_Database["channels"][channel][sorting_key][key].append(entry) self.dict["channels"][channel][sorting_key][key].append(entry)
elif adjustmentdirection == 'del': elif adjustmentdirection == 'del':
for entry in entries: for entry in entries:
while entry in self.SpiceBot_Database["channels"][channel][sorting_key][key]: while entry in self.dict["channels"][channel][sorting_key][key]:
self.SpiceBot_Database["channels"][channel][sorting_key][key].remove(entry) self.dict["channels"][channel][sorting_key][key].remove(entry)
bot.db.set_channel_value(channel, sorting_key, self.SpiceBot_Database["channels"][channel][sorting_key]) bot.db.set_channel_value(channel, sorting_key, self.dict["channels"][channel][sorting_key])
self.lock.release() self.lock.release()
botdb = BotDatabase() db = BotDatabase()

30
sopel_modules/SpiceBot/Events.py
View File

@ -17,7 +17,7 @@ class BotEvents(object):
Events will be assigned a 4-digit number above 1000. 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. Triggers handled by this module will be processed immediately.
Others will be placed into a queue. Others will be placed into a queue.
@ -43,8 +43,8 @@ class BotEvents(object):
def __getattr__(self, name): def __getattr__(self, name):
''' will only get called for undefined attributes ''' ''' will only get called for undefined attributes '''
eventnumber = max(list(self.SpiceBot_Events["assigned_IDs"].keys())) + 1 eventnumber = max(list(self.dict["assigned_IDs"].keys())) + 1
self.SpiceBot_Events["assigned_IDs"][eventnumber] = str(name) self.dict["assigned_IDs"][eventnumber] = str(name)
setattr(self, name, str(eventnumber)) setattr(self, name, str(eventnumber))
return str(eventnumber) return str(eventnumber)
@ -53,7 +53,7 @@ class BotEvents(object):
if number in self.defaultevents: if number in self.defaultevents:
self.dispatch(bot, pretriggerdict) self.dispatch(bot, pretriggerdict)
else: else:
self.SpiceBot_Events["trigger_queue"].append(pretriggerdict) self.dict["trigger_queue"].append(pretriggerdict)
def dispatch(self, bot, pretriggerdict): def dispatch(self, bot, pretriggerdict):
number = pretriggerdict["number"] number = pretriggerdict["number"]
@ -72,37 +72,37 @@ class BotEvents(object):
else: else:
eventnumber = str(trigger.event) eventnumber = str(trigger.event)
message = trigger.args[1] message = trigger.args[1]
if eventnumber not in self.SpiceBot_Events["triggers_recieved"]: if eventnumber not in self.dict["triggers_recieved"]:
self.SpiceBot_Events["triggers_recieved"][eventnumber] = [] self.dict["triggers_recieved"][eventnumber] = []
self.SpiceBot_Events["triggers_recieved"][eventnumber].append(message) self.dict["triggers_recieved"][eventnumber].append(message)
def check(self, checklist): def check(self, checklist):
if not isinstance(checklist, list): if not isinstance(checklist, list):
checklist = [str(checklist)] checklist = [str(checklist)]
for number in 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 False
return True return True
def startup_add(self, startlist): def startup_add(self, startlist):
if not isinstance(startlist, list): if not isinstance(startlist, list):
startlist = [str(startlist)] startlist = [str(startlist)]
self.SpiceBot_Events["startup_required"].extend(startlist) self.dict["startup_required"].extend(startlist)
def startup_check(self): def startup_check(self):
for number in self.SpiceBot_Events["startup_required"]: for number in self.dict["startup_required"]:
if str(number) not in self.SpiceBot_Events["triggers_recieved"].keys(): if str(number) not in self.dict["triggers_recieved"].keys():
return False return False
return True return True
def startup_debug(self): def startup_debug(self):
not_done = [] not_done = []
for number in self.SpiceBot_Events["startup_required"]: for number in self.dict["startup_required"]:
if str(number) not in self.SpiceBot_Events["triggers_recieved"].keys(): if str(number) not in self.dict["triggers_recieved"].keys():
not_done.append(int(number)) not_done.append(int(number))
reference_not_done = [] reference_not_done = []
for item in 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 return reference_not_done
def check_ready(self, checklist): def check_ready(self, checklist):
@ -126,4 +126,4 @@ class BotEvents(object):
return actual_decorator return actual_decorator
botevents = BotEvents() events = BotEvents()

12
sopel_modules/SpiceBot/Logs.py
View File

@ -28,14 +28,14 @@ class BotLogs():
logmessage = logtitle + " " + logentry logmessage = logtitle + " " + logentry
if self.sopel_config["logging_channel"]: if self.sopel_config["logging_channel"]:
self.SpiceBot_Logs["queue"].append(logmessage) self.dict["queue"].append(logmessage)
if stdio: if stdio:
sopel.tools.stderr(logmessage) sopel.tools.stderr(logmessage)
if logtype not in self.SpiceBot_Logs["list"].keys(): if logtype not in self.dict["list"].keys():
self.SpiceBot_Logs["list"][logtype] = [] self.dict["list"][logtype] = []
self.SpiceBot_Logs["list"][logtype].append(logentry) self.dict["list"][logtype].append(logentry)
def get_logs(self): def get_logs(self):
return [] return []
@ -43,7 +43,7 @@ class BotLogs():
def stdio_logs_fetch(self, bot): def stdio_logs_fetch(self, bot):
stdio_ignore = [] stdio_ignore = []
for logtype in self.SpiceBot_Logs["list"].keys(): for logtype in self.dict["list"].keys():
stdio_ignore.append("[" + logtype + "]") stdio_ignore.append("[" + logtype + "]")
logfile = os.path.os.path.join(bot.config.core.logdir, 'stdio.log') logfile = os.path.os.path.join(bot.config.core.logdir, 'stdio.log')
@ -103,4 +103,4 @@ class BotLogs():
return pidnum return pidnum
botlogs = BotLogs() logs = BotLogs()

22
sopel_modules/SpiceBot/Tools.py
View File

@ -19,7 +19,7 @@ from pygit2 import clone_repository
import spicemanip import spicemanip
from .Logs import botlogs from .Logs import logs
"""Variable References""" """Variable References"""
@ -298,7 +298,7 @@ def spicebot_update(bot, deps=False):
if not os.path.exists(clonepath) or not os.path.isdir(clonepath): if not os.path.exists(clonepath) or not os.path.isdir(clonepath):
os.system(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) 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 += " git+" + str(bot.config.SpiceBot_Update.gitrepo) + "@" + str(bot.config.SpiceBot_Update.gitbranch)
pipcommand += " /tmp/SpiceBot/" 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'): # for line in os.popen(pipcommand).read().split('\n'):
# botlogs.log('SpiceBot_Update', " " + line) # logs.log('SpiceBot_Update', " " + line)
os.system(pipcommand) os.system(pipcommand)
botlogs.log('SpiceBot_Update', "Deleting " + clonepath, True) logs.log('SpiceBot_Update', "Deleting " + clonepath, True)
os.system("sudo rm -r /tmp/SpiceBot") 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"]: if str(dowhat) not in ["start", "stop", "restart"]:
return return
try: 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)) os.system("sudo service " + str(servicename) + " " + str(dowhat))
except Exception as e: 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""" """Config Reading Functions"""
@ -365,7 +365,7 @@ def read_directory_json_to_dict(bot, directories, configtypename="Config File",
except Exception as e: except Exception as e:
filereadgood = False filereadgood = False
if bot: 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() dict_from_file = dict()
# Close File # Close File
inf.close() inf.close()
@ -380,10 +380,10 @@ def read_directory_json_to_dict(bot, directories, configtypename="Config File",
if filecount: if filecount:
if bot: if bot:
botlogs.log(log_from, 'Registered %d %s dict files,' % (filecount, configtypename)) logs.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, '%d %s dict files failed to load' % (fileopenfail, configtypename), True)
else: else:
if bot: 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 return configs_dict

8
sopel_modules/SpiceBot_AI/AI.py
View File

@ -9,7 +9,7 @@ import spicemanip
import sopel_modules.SpiceBot as SpiceBot 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('(.*)') @sopel.module.nickname_commands('(.*)')
def bot_command_nick(bot, trigger): def bot_command_nick(bot, trigger):
@ -21,13 +21,13 @@ def bot_command_nick(bot, trigger):
if triggercommand[0] == "?": if triggercommand[0] == "?":
return return
if triggercommand in SpiceBot.botcommands.SpiceBot_Commands['commands']["nickname"].keys(): if triggercommand in SpiceBot.commands.dict['commands']["nickname"].keys():
return return
triggerargs.insert(0, triggercommand) triggerargs.insert(0, triggercommand)
fulltrigger = spicemanip.main(triggerargs, 0).lower() fulltrigger = spicemanip.main(triggerargs, 0).lower()
if fulltrigger in SpiceBot.botcommands.SpiceBot_Commands['nickrules']: if fulltrigger in SpiceBot.commands.dict['nickrules']:
return return
if fulltrigger.lower().startswith("what is"): if fulltrigger.lower().startswith("what is"):
@ -154,7 +154,7 @@ def bot_command_nick(bot, trigger):
else: 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): if len(closestmatches):
closestmatches = spicemanip.main(closestmatches, "andlist") closestmatches = spicemanip.main(closestmatches, "andlist")

32
sopel_modules/SpiceBot_Channels_Command/Channels_Command.py
View File

@ -9,7 +9,7 @@ import spicemanip
import sopel_modules.SpiceBot as SpiceBot 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') @sopel.module.nickname_commands('channels', 'channel')
def nickname_comand_channels(bot, trigger): def nickname_comand_channels(bot, trigger):
@ -29,14 +29,14 @@ def nickname_comand_channels(bot, trigger):
elif commandused == 'total': elif commandused == 'total':
botcount = len(bot.channels.keys()) 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.") bot.osd("I am in " + str(botcount) + " of " + str(servercount) + " channel(s) available on this server.")
return return
elif commandused == 'random': elif commandused == 'random':
channel = spicemanip.main(SpiceBot.botchannels.SpiceBot_Channels['list'], 'random') channel = spicemanip.main(SpiceBot.channels.dict['list'], 'random')
topic = SpiceBot.botchannels.SpiceBot_Channels['list'][channel]['topic'] topic = SpiceBot.channels.dict['list'][channel]['topic']
msg = ["Random channel for you: {}.".format(SpiceBot.botchannels.SpiceBot_Channels['list'][channel]['name'])] msg = ["Random channel for you: {}.".format(SpiceBot.channels.dict['list'][channel]['name'])]
if topic and not topic.isspace(): if topic and not topic.isspace():
msg.append("The topic is: {}".format(topic)) msg.append("The topic is: {}".format(topic))
else: else:
@ -48,15 +48,15 @@ def nickname_comand_channels(bot, trigger):
if not trigger.admin: if not trigger.admin:
bot.osd("You do not have permission to update the channel listing.") bot.osd("You do not have permission to update the channel listing.")
return return
SpiceBot.botchannels.bot_part_empty(bot) SpiceBot.channels.bot_part_empty(bot)
SpiceBot.botchannels.channel_list_request(bot) SpiceBot.channels.channel_list_request(bot)
bot.osd(["[SpiceBot_Channels]", "I am now updating the channel listing for this server."]) 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 pass
SpiceBot.botchannels.join_all_channels(bot) SpiceBot.channels.join_all_channels(bot)
foundchannelcount = len(SpiceBot.botchannels.SpiceBot_Channels['list'].keys()) foundchannelcount = len(SpiceBot.channels.dict['list'].keys())
bot.osd("[SpiceBot_Channels]", "Channel listing finished!", str(foundchannelcount) + " channel(s) found.") 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 return
elif commandused == 'topic': elif commandused == 'topic':
@ -64,11 +64,11 @@ def nickname_comand_channels(bot, trigger):
bot.osd("Channel name input missing.") bot.osd("Channel name input missing.")
return return
channel = spicemanip.main(triggerargs, 1) 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)) bot.osd("Channel name {} not valid.".format(channel))
return return
topic = SpiceBot.botchannels.SpiceBot_Channels['list'][channel.lower()]['topic'] topic = SpiceBot.channels.dict['list'][channel.lower()]['topic']
channel = SpiceBot.botchannels.SpiceBot_Channels['list'][channel.lower()]['name'] channel = SpiceBot.channels.dict['list'][channel.lower()]['name']
bot.osd("Topic for {}: {}".format(channel, topic)) bot.osd("Topic for {}: {}".format(channel, topic))
return return
@ -81,7 +81,7 @@ def nickname_comand_channels(bot, trigger):
channel = trigger.sender channel = trigger.sender
else: else:
channel = spicemanip.main(triggerargs, 1) 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)) bot.osd("Channel name {} not valid.".format(channel))
return return
if not SpiceBot.inlist(channel.lower(), bot.channels.keys()): if not SpiceBot.inlist(channel.lower(), bot.channels.keys()):
@ -101,7 +101,7 @@ def nickname_comand_channels(bot, trigger):
# Users List # Users List
if commandused == 'users': if commandused == 'users':
channel = spicemanip.main(triggerargs, 1) 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)) bot.osd("Channel name {} not valid.".format(channel))
return return
if not SpiceBot.inlist(channel.lower(), bot.channels.keys()): if not SpiceBot.inlist(channel.lower(), bot.channels.keys()):

64
sopel_modules/SpiceBot_Channels_Parsing/Channels_Parsing.py
View File

@ -29,91 +29,91 @@ def configure(config):
def setup(bot): def setup(bot):
SpiceBot.botlogs.log('SpiceBot_Channels', "Starting setup procedure") SpiceBot.logs.log('SpiceBot_Channels', "Starting setup procedure")
SpiceBot.botevents.startup_add([SpiceBot.botevents.BOT_CHANNELS]) SpiceBot.events.startup_add([SpiceBot.events.BOT_CHANNELS])
bot.config.define_section("SpiceBot_Channels", SpiceBot_Channels_MainSection, validate=False) 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('.*') @sopel.module.rule('.*')
def unkickable_bot(bot, trigger): def unkickable_bot(bot, trigger):
if bot.config.SpiceBot_Channels.operadmin: if bot.config.SpiceBot_Channels.operadmin:
bot.write(('SAMODE', bot.nick, '+q')) bot.write(('SAMODE', bot.nick, '+q'))
@sopel.module.event(SpiceBot.botevents.RPL_WELCOME) @sopel.module.event(SpiceBot.events.RPL_WELCOME)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def request_channels_list_initial(bot, trigger): 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.logs.log('SpiceBot_Channels', "Sending Request for all server channels")
SpiceBot.botchannels.channel_list_request(bot) SpiceBot.channels.channel_list_request(bot)
starttime = time.time() starttime = time.time()
# wait 60 seconds for initial population of information # 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: if time.time() - starttime >= 60:
SpiceBot.botlogs.log('SpiceBot_Channels', "Initial Channel list populating Timed Out") SpiceBot.logs.log('SpiceBot_Channels', "Initial Channel list populating Timed Out")
SpiceBot.botchannels.SpiceBot_Channels['InitialProcess'] = True SpiceBot.channels.dict['InitialProcess'] = True
else: else:
pass pass
foundchannelcount = len(SpiceBot.botchannels.SpiceBot_Channels['list'].keys()) foundchannelcount = len(SpiceBot.channels.dict['list'].keys())
SpiceBot.botlogs.log('SpiceBot_Channels', "Channel listing finished! " + str(foundchannelcount) + " channel(s) found.") SpiceBot.logs.log('SpiceBot_Channels', "Channel listing finished! " + str(foundchannelcount) + " channel(s) found.")
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(): if "*" in SpiceBot.channels.dict['list'].keys():
del SpiceBot.botchannels.SpiceBot_Channels['list']["*"] del SpiceBot.channels.dict['list']["*"]
SpiceBot.botchannels.bot_part_empty(bot) SpiceBot.channels.bot_part_empty(bot)
SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_CHANNELS, "SpiceBot_Channels") SpiceBot.events.trigger(bot, SpiceBot.events.BOT_CHANNELS, "SpiceBot_Channels")
@sopel.module.event('321') @sopel.module.event('321')
@sopel.module.rule('.*') @sopel.module.rule('.*')
def watch_chanlist_start(bot, trigger): def watch_chanlist_start(bot, trigger):
SpiceBot.botchannels.channel_list_recieve_start() SpiceBot.channels.channel_list_recieve_start()
@sopel.module.event('322') @sopel.module.event('322')
@sopel.module.rule('.*') @sopel.module.rule('.*')
def watch_chanlist_populate(bot, trigger): 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.event('323')
@sopel.module.rule('.*') @sopel.module.rule('.*')
def watch_chanlist_complete(bot, trigger): 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('.*') @sopel.module.rule('.*')
def trigger_channel_list_recurring(bot, trigger): def trigger_channel_list_recurring(bot, trigger):
while True: while True:
time.sleep(1800) time.sleep(1800)
SpiceBot.botchannels.bot_part_empty(bot) SpiceBot.channels.bot_part_empty(bot)
oldlist = list(SpiceBot.botchannels.SpiceBot_Channels['list'].keys()) oldlist = list(SpiceBot.channels.dict['list'].keys())
SpiceBot.botchannels.channel_list_request(bot) SpiceBot.channels.channel_list_request(bot)
while SpiceBot.botchannels.channel_lock: while SpiceBot.channels.channel_lock:
pass 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: if "*" in newlist:
newlist.remove("*") newlist.remove("*")
if len(newlist) and bot.config.SpiceBot_Channels.announcenew: if len(newlist) and bot.config.SpiceBot_Channels.announcenew:
bot.osd(["The Following channel(s) are new:", spicemanip.main(newlist, 'andlist')], bot.channels.keys()) 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(): if "*" in SpiceBot.channels.dict['list'].keys():
del SpiceBot.botchannels.SpiceBot_Channels['list']["*"] del SpiceBot.channels.dict['list']["*"]
SpiceBot.botchannels.bot_part_empty(bot) SpiceBot.channels.bot_part_empty(bot)

6
sopel_modules/SpiceBot_CommandsQuery/NickQueryCommand.py
View File

@ -10,7 +10,7 @@ import sopel_modules.SpiceBot as SpiceBot
import spicemanip import spicemanip
@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_COMMANDSQUERY]) @SpiceBot.events.check_ready([SpiceBot.events.BOT_COMMANDSQUERY])
@sopel.module.nickname_commands('(.*)') @sopel.module.nickname_commands('(.*)')
def query_detection_nick(bot, trigger): def query_detection_nick(bot, trigger):
@ -28,9 +28,9 @@ def query_detection_nick(bot, trigger):
return return
commands_list = dict() 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(): 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("+"): if triggercommand.endswith("+"):

8
sopel_modules/SpiceBot_CommandsQuery/QueryCommand.py
View File

@ -10,7 +10,7 @@ import sopel_modules.SpiceBot as SpiceBot
import spicemanip import spicemanip
@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_COMMANDSQUERY]) @SpiceBot.events.check_ready([SpiceBot.events.BOT_COMMANDSQUERY])
@sopel.module.rule('^\?(.*)') @sopel.module.rule('^\?(.*)')
def query_detection(bot, trigger): def query_detection(bot, trigger):
@ -24,11 +24,11 @@ def query_detection(bot, trigger):
return return
commands_list = dict() 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']: 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(): 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] == "+": if triggercommand[:-1] == "+":

2
sopel_modules/SpiceBot_Database_Addons/Databaseaddons.py
View File

@ -16,7 +16,7 @@ import sopel_modules.SpiceBot as SpiceBot
def setup(bot): def setup(bot):
# Inject Database Functions # 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.delete_nick_value = SopelDBCache.delete_nick_value
SopelDB.adjust_nick_value = SopelDBCache.adjust_nick_value SopelDB.adjust_nick_value = SopelDBCache.adjust_nick_value
SopelDB.delete_channel_value = SopelDBCache.delete_channel_value SopelDB.delete_channel_value = SopelDBCache.delete_channel_value

4
sopel_modules/SpiceBot_Events/Connected.py
View File

@ -7,10 +7,10 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@sopel.module.event(SpiceBot.botevents.BOT_WELCOME) @sopel.module.event(SpiceBot.events.BOT_WELCOME)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_events_Connected(bot, trigger): def bot_events_Connected(bot, trigger):
"""Here, we wait until we are in at least one channel""" """Here, we wait until we are in at least one channel"""
while not len(bot.channels.keys()) > 0: while not len(bot.channels.keys()) > 0:
pass 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")

8
sopel_modules/SpiceBot_Events/Connection_Count.py
View File

@ -7,9 +7,9 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@sopel.module.event(SpiceBot.botevents.RPL_WELCOME) @sopel.module.event(SpiceBot.events.RPL_WELCOME)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_startup_welcome(bot, trigger): def bot_startup_welcome(bot, trigger):
SpiceBot.botevents.SpiceBot_Events["RPL_WELCOME_Count"] += 1 SpiceBot.events.dict["RPL_WELCOME_Count"] += 1
if SpiceBot.botevents.SpiceBot_Events["RPL_WELCOME_Count"] > 1: if SpiceBot.events.dict["RPL_WELCOME_Count"] > 1:
SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_RECONNECTED, "Bot ReConnected to IRC") SpiceBot.events.trigger(bot, SpiceBot.events.BOT_RECONNECTED, "Bot ReConnected to IRC")

6
sopel_modules/SpiceBot_Events/Loaded.py
View File

@ -7,9 +7,9 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@SpiceBot.botevents.startup_check_ready() @SpiceBot.events.startup_check_ready()
@sopel.module.event(SpiceBot.botevents.BOT_READY) @sopel.module.event(SpiceBot.events.BOT_READY)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_events_startup_complete(bot, trigger): def bot_events_startup_complete(bot, trigger):
"""All events registered as required for startup have completed""" """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")

4
sopel_modules/SpiceBot_Events/Logging.py
View File

@ -7,8 +7,8 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot 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('.*') @sopel.module.rule('.*')
def bot_events_complete(bot, trigger): def bot_events_complete(bot, trigger):
"""This is here simply to log to stderr that this was recieved.""" """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)

10
sopel_modules/SpiceBot_Events/Queue.py
View File

@ -7,12 +7,12 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@sopel.module.event(SpiceBot.botevents.BOT_WELCOME) @sopel.module.event(SpiceBot.events.BOT_WELCOME)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_events_connected(bot, trigger): def bot_events_connected(bot, trigger):
"""For items tossed in a queue, this will trigger them accordingly""" """For items tossed in a queue, this will trigger them accordingly"""
while True: while True:
if len(SpiceBot.botevents.SpiceBot_Events["trigger_queue"]): if len(SpiceBot.events.dict["trigger_queue"]):
pretriggerdict = SpiceBot.botevents.SpiceBot_Events["trigger_queue"][0] pretriggerdict = SpiceBot.events.dict["trigger_queue"][0]
SpiceBot.botevents.dispatch(bot, pretriggerdict) SpiceBot.events.dispatch(bot, pretriggerdict)
del SpiceBot.botevents.SpiceBot_Events["trigger_queue"][0] del SpiceBot.events.dict["trigger_queue"][0]

4
sopel_modules/SpiceBot_Events/Ready.py
View File

@ -7,8 +7,8 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@sopel.module.event(SpiceBot.botevents.BOT_WELCOME) @sopel.module.event(SpiceBot.events.BOT_WELCOME)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_events_start(bot, trigger): def bot_events_start(bot, trigger):
"""This stage is redundant, but shows the system is working.""" """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")

6
sopel_modules/SpiceBot_Events/Welcome.py
View File

@ -7,11 +7,11 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@sopel.module.event(SpiceBot.botevents.RPL_WELCOME) @sopel.module.event(SpiceBot.events.RPL_WELCOME)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_startup_welcome(bot, trigger): def bot_startup_welcome(bot, trigger):
"""The Bot events system does not start until RPL_WELCOME 001 is recieved """The Bot events system does not start until RPL_WELCOME 001 is recieved
from the server""" from the server"""
if SpiceBot.botevents.check(SpiceBot.botevents.BOT_WELCOME): if SpiceBot.events.check(SpiceBot.events.BOT_WELCOME):
return 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")

2
sopel_modules/SpiceBot_GifSearch/gif.py
View File

@ -11,7 +11,7 @@ import sopel_modules.SpiceBot as SpiceBot
import spicemanip import spicemanip
@SpiceBot.botevents.check_ready([SpiceBot.botevents.BOT_GIFSEARCH]) @SpiceBot.events.check_ready([SpiceBot.events.BOT_GIFSEARCH])
@module.commands('gif') @module.commands('gif')
def gif_trigger(bot, trigger): def gif_trigger(bot, trigger):

2
sopel_modules/SpiceBot_GifSearch/gifapi.py
View File

@ -11,7 +11,7 @@ import spicemanip
import sopel_modules.SpiceBot as SpiceBot 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('(.*)') @sopel.module.commands('(.*)')
def gifapi_triggers(bot, trigger): def gifapi_triggers(bot, trigger):

8
sopel_modules/SpiceBot_GifSearch/gifsearch.py
View File

@ -42,8 +42,8 @@ def configure(config):
def setup(bot): def setup(bot):
SpiceBot.botlogs.log('SpiceBot_GifSearch', "Starting Setup Procedure") SpiceBot.logs.log('SpiceBot_GifSearch', "Starting Setup Procedure")
SpiceBot.botevents.startup_add([SpiceBot.botevents.BOT_GIFSEARCH]) SpiceBot.events.startup_add([SpiceBot.events.BOT_GIFSEARCH])
if 'SpiceBot_GifSearch' not in bot.memory: if 'SpiceBot_GifSearch' not in bot.memory:
bot.memory["SpiceBot_GifSearch"] = {"cache": {}, "badgiflinks": [], 'valid_gif_api_dict': {}} 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] 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(): 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(): if validgifapi not in bot.memory["SpiceBot_GifSearch"]['cache'].keys():
bot.memory["SpiceBot_GifSearch"]['cache'][validgifapi] = dict() 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): def shutdown(bot):

8
sopel_modules/SpiceBot_InvalidCommand/InvalidCommand.py
View File

@ -17,14 +17,14 @@ def shutdown(bot):
del bot.memory["SpiceBot_InvalidCommand"] del bot.memory["SpiceBot_InvalidCommand"]
@sopel.module.event(SpiceBot.botevents.BOT_LOADED) @sopel.module.event(SpiceBot.events.BOT_LOADED)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_events_complete(bot, trigger): def bot_events_complete(bot, trigger):
for comtype in SpiceBot.botcommands.SpiceBot_Commands['commands'].keys(): for comtype in SpiceBot.commands.dict['commands'].keys():
bot.memory["SpiceBot_InvalidCommand"]["valid"].extend(SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype].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('(.*)') @sopel.module.commands('(.*)')
def InvalidCommand_triggers(bot, trigger): def InvalidCommand_triggers(bot, trigger):
return return

4
sopel_modules/SpiceBot_Kick/__init__.py
View File

@ -35,12 +35,12 @@ def configure(config):
def setup(bot): def setup(bot):
# Inject KICK # 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 bot.kick = SopelKICK.kick
sopel.bot.SopelWrapper.kick = SopelWrapperKICK.kick sopel.bot.SopelWrapper.kick = SopelWrapperKICK.kick
# verify config settings for server # 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) bot.config.define_section("SpiceBot_Kick", SpiceBot_Kick, validate=False)

362
sopel_modules/SpiceBot_Logs/IRC_Events
View File

File diff suppressed because it is too large Load Diff

16
sopel_modules/SpiceBot_Logs/Logs_Command.py
View File

@ -8,7 +8,7 @@ import spicemanip
import sopel_modules.SpiceBot as SpiceBot 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') @sopel.module.nickname_commands('logs', 'debug')
def bot_command_logs(bot, trigger): def bot_command_logs(bot, trigger):
@ -20,11 +20,11 @@ def bot_command_logs(bot, trigger):
logtype = spicemanip.main(triggerargs, 1) or None logtype = spicemanip.main(triggerargs, 1) or None
if not logtype: 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 return
if not SpiceBot.inlist(logtype, SpiceBot.botlogs.SpiceBot_Logs["list"].keys()): if not SpiceBot.inlist(logtype, SpiceBot.logs.dict["list"].keys()):
closestmatches = SpiceBot.similar_list(bot, logtype, SpiceBot.botlogs.SpiceBot_Logs["list"].keys(), 10, 'reverse') closestmatches = SpiceBot.similar_list(bot, logtype, SpiceBot.logs.dict["list"].keys(), 10, 'reverse')
if not len(closestmatches): if not len(closestmatches):
bot.notice("No valid logs match " + str(logtype) + ".", trigger.nick) bot.notice("No valid logs match " + str(logtype) + ".", trigger.nick)
else: else:
@ -32,14 +32,14 @@ def bot_command_logs(bot, trigger):
return 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": if logtype == "Sopel_systemd":
logindex = SpiceBot.botlogs.systemd_logs_fetch(bot) logindex = SpiceBot.logs.systemd_logs_fetch(bot)
elif logtype == "Sopel_stdio": elif logtype == "Sopel_stdio":
logindex = SpiceBot.botlogs.stdio_logs_fetch(bot) logindex = SpiceBot.logs.stdio_logs_fetch(bot)
else: else:
logindex = SpiceBot.botlogs.SpiceBot_Logs["list"][logtype] logindex = SpiceBot.logs.dict["list"][logtype]
if not len(logindex): if not len(logindex):
bot.osd("No logs found for " + str(logtype) + ".") bot.osd("No logs found for " + str(logtype) + ".")

18
sopel_modules/SpiceBot_Logs/Queue.py
View File

@ -9,12 +9,12 @@ import sopel_modules.SpiceBot as SpiceBot
def setup(bot): def setup(bot):
SpiceBot.botlogs.log('SpiceBot_Logs', "Starting Setup Procedure") SpiceBot.logs.log('SpiceBot_Logs', "Starting Setup Procedure")
SpiceBot.botevents.startup_add([SpiceBot.botevents.BOT_LOGS]) SpiceBot.events.startup_add([SpiceBot.events.BOT_LOGS])
SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_LOGS, "SpiceBot_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('.*') @sopel.module.rule('.*')
def join_log_channel(bot, trigger): def join_log_channel(bot, trigger):
@ -26,9 +26,9 @@ def join_log_channel(bot, trigger):
bot.write(('SAJOIN', bot.nick, channel)) bot.write(('SAJOIN', bot.nick, channel))
while True: while True:
if len(SpiceBot.botlogs.SpiceBot_Logs["queue"]): if len(SpiceBot.logs.dict["queue"]):
bot.say(str(SpiceBot.botlogs.SpiceBot_Logs["queue"][0]), channel) bot.say(str(SpiceBot.logs.dict["queue"][0]), channel)
del SpiceBot.botlogs.SpiceBot_Logs["queue"][0] del SpiceBot.logs.dict["queue"][0]
else: else:
SpiceBot.botlogs.sopel_config["logging_channel"] = False SpiceBot.logs.sopel_config["logging_channel"] = False
SpiceBot.botlogs.SpiceBot_Logs["queue"] = [] SpiceBot.logs.dict["queue"] = []

2
sopel_modules/SpiceBot_Messaging/Messaging.py
View File

@ -41,7 +41,7 @@ def bot_command_process(bot, trigger):
target = spicemanip.main(triggerargs, 1) target = spicemanip.main(triggerargs, 1)
if (target not in ['allchans', 'allnicks'] 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)): and not SpiceBot.inlist(target.lower(), bot.users)):
bot.osd("Channel/nick name {} not valid.".format(target)) bot.osd("Channel/nick name {} not valid.".format(target))
return return

30
sopel_modules/SpiceBot_Module_Parsing/ModuleParsing.py
View File

@ -13,8 +13,8 @@ import spicemanip
def setup(bot): def setup(bot):
SpiceBot.botlogs.log('SpiceBot_CommandsQuery', "Starting setup procedure") SpiceBot.logs.log('SpiceBot_CommandsQuery', "Starting setup procedure")
SpiceBot.botevents.startup_add([SpiceBot.botevents.BOT_COMMANDSQUERY]) SpiceBot.events.startup_add([SpiceBot.events.BOT_COMMANDSQUERY])
filepathlisting = [] filepathlisting = []
@ -36,7 +36,7 @@ def setup(bot):
pypi_modules_dir = os.path.join(plugin_dir, pathname) pypi_modules_dir = os.path.join(plugin_dir, pathname)
filepathlisting.append(pypi_modules_dir) filepathlisting.append(pypi_modules_dir)
except Exception as e: 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 # Extra directories
filepathlist = [] filepathlist = []
@ -120,7 +120,7 @@ def setup(bot):
currentsuccesslines += 1 currentsuccesslines += 1
if currentsuccesslines: if currentsuccesslines:
SpiceBot.botcommands.SpiceBot_Commands['counts'] += 1 SpiceBot.commands.dict['counts'] += 1
if len(filelinelist): if len(filelinelist):
for atlinefound in filelinelist: for atlinefound in filelinelist:
@ -140,27 +140,27 @@ def setup(bot):
else: else:
comaliases = [] comaliases = []
SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype][maincom] = dict_from_file SpiceBot.commands.dict['commands'][comtype][maincom] = dict_from_file
for comalias in comaliases: for comalias in comaliases:
if comalias not in SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype].keys(): if comalias not in SpiceBot.commands.dict['commands'][comtype].keys():
SpiceBot.botcommands.SpiceBot_Commands['commands'][comtype][comalias] = {"aliasfor": maincom} SpiceBot.commands.dict['commands'][comtype][comalias] = {"aliasfor": maincom}
for comtype in ['module', 'nickname', 'rule']: 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"): if command.startswith("$nickname"):
command = command.split("$nickname")[-1] command = command.split("$nickname")[-1]
if command not in SpiceBot.botcommands.SpiceBot_Commands['nickrules']: if command not in SpiceBot.commands.dict['nickrules']:
SpiceBot.botcommands.SpiceBot_Commands['nickrules'].append(command) 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('.*') @sopel.module.rule('.*')
def bot_events_complete(bot, trigger): 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']: 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)

2
sopel_modules/SpiceBot_Restart/Restart.py
View File

@ -15,7 +15,7 @@ def nickname_comand_restart(bot, trigger):
bot.say("You are not authorized to perform this function.") bot.say("You are not authorized to perform this function.")
quitmessage = "Received command from " + trigger.nick + " to restart. Be Back Soon!" 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()) bot.osd(quitmessage, bot.channels.keys())
# service_manip(bot, bot.nick, 'restart', 'SpiceBot_Restart') # service_manip(bot, bot.nick, 'restart', 'SpiceBot_Restart')

4
sopel_modules/SpiceBot_SopelPatches/Patches.py
View File

@ -11,9 +11,9 @@ import sopel_modules.SpiceBot as SpiceBot
def setup(bot): 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: if 'url_callbacks' not in bot.memory:
bot.memory['url_callbacks'] = sopel.tools.SopelMemory() 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) SpiceBot.stock_modules_begone(bot)

4
sopel_modules/SpiceBot_StartupMonologue/StartupMonologue.py
View File

@ -8,8 +8,8 @@ import sopel_modules.SpiceBot as SpiceBot
def setup(bot): def setup(bot):
SpiceBot.botlogs.log('SpiceBot_StartupMonologue', "Starting setup procedure") SpiceBot.logs.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.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: if 'SpiceBot_StartupMonologue' not in bot.memory:
bot.memory['SpiceBot_StartupMonologue'] = [] bot.memory['SpiceBot_StartupMonologue'] = []

8
sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Channels.py
View File

@ -7,13 +7,13 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@sopel.module.event(SpiceBot.botevents.BOT_CHANNELS) @sopel.module.event(SpiceBot.events.BOT_CHANNELS)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_startup_monologue_channels(bot, trigger): def bot_startup_monologue_channels(bot, trigger):
botcount = len(bot.channels.keys()) 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.") 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")

12
sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Commands.py
View File

@ -7,16 +7,16 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@sopel.module.event(SpiceBot.botevents.BOT_COMMANDSQUERY) @sopel.module.event(SpiceBot.events.BOT_COMMANDSQUERY)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_startup_monologue_commands(bot, trigger): def bot_startup_monologue_commands(bot, trigger):
availablecomsnum, availablecomsfiles = 0, 0 availablecomsnum, availablecomsfiles = 0, 0
for commandstype in SpiceBot.botcommands.SpiceBot_Commands['commands'].keys(): for commandstype in SpiceBot.commands.dict['commands'].keys():
availablecomsnum += len(SpiceBot.botcommands.SpiceBot_Commands['commands'][commandstype].keys()) availablecomsnum += len(SpiceBot.commands.dict['commands'][commandstype].keys())
availablecomsfiles += SpiceBot.botcommands.SpiceBot_Commands['counts'] availablecomsfiles += SpiceBot.commands.dict['counts']
bot.memory['SpiceBot_StartupMonologue'].append("There are " + str(availablecomsnum) + " commands available in " + str(availablecomsfiles) + " files.") 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")

6
sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Connected.py
View File

@ -7,12 +7,12 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@sopel.module.event(SpiceBot.botevents.BOT_CONNECTED) @sopel.module.event(SpiceBot.events.BOT_CONNECTED)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_startup_monologue_start(bot, trigger): def bot_startup_monologue_start(bot, trigger):
# Startup # 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') 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")

8
sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Errors.py
View File

@ -6,11 +6,11 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot import sopel_modules.SpiceBot as SpiceBot
@sopel.module.event(SpiceBot.botevents.BOT_STARTUPMONOLOGUE) @sopel.module.event(SpiceBot.events.BOT_STARTUPMONOLOGUE)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_startup_monologue_start(bot, trigger): def bot_startup_monologue_start(bot, trigger):
debuglines = SpiceBot.botlogs.stdio_logs_fetch(bot) debuglines = SpiceBot.logs.stdio_logs_fetch(bot)
searchphrasefound = [] searchphrasefound = []
for line in debuglines: for line in debuglines:
@ -19,9 +19,9 @@ def bot_startup_monologue_start(bot, trigger):
if len(searchphrasefound): if len(searchphrasefound):
for foundphase in 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.insert(0, "Notice to Bot Admins: ")
searchphrasefound.append("Run the debug command for more information.") searchphrasefound.append("Run the debug command for more information.")
bot.osd(searchphrasefound, bot.channels.keys()) bot.osd(searchphrasefound, bot.channels.keys())
else: 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)

10
sopel_modules/SpiceBot_StartupMonologue/StartupMonologue_Display_Loaded.py
View File

@ -9,19 +9,19 @@ import sopel_modules.SpiceBot as SpiceBot
import time import time
@sopel.module.event(SpiceBot.botevents.BOT_LOADED) @sopel.module.event(SpiceBot.events.BOT_LOADED)
@sopel.module.rule('.*') @sopel.module.rule('.*')
def bot_startup_monologue_display(bot, trigger): 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"]) timesince = SpiceBot.humanized_time(time.time() - bot.memory["SpiceBot_Uptime"])
SpiceBot.bot.memory['SpiceBot_StartupMonologue'].append("Startup took " + timesince) SpiceBot.bot.memory['SpiceBot_StartupMonologue'].append("Startup took " + timesince)
# Announce to chan, then handle some closing stuff # 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.memory['SpiceBot_StartupMonologue'].insert(0, " startup complete")
bot.osd(bot.memory['SpiceBot_StartupMonologue'], bot.channels.keys(), 'ACTION') bot.osd(bot.memory['SpiceBot_StartupMonologue'], bot.channels.keys(), 'ACTION')
SpiceBot.botevents.trigger(bot, SpiceBot.botevents.BOT_STARTUPMONOLOGUE, "SpiceBot_StartupMonologue") SpiceBot.events.trigger(bot, SpiceBot.events.BOT_STARTUPMONOLOGUE, "SpiceBot_StartupMonologue")
SpiceBot.botlogs.log('SpiceBot_StartupMonologue', "Startup Monologue has been issued to all channels.", True) SpiceBot.logs.log('SpiceBot_StartupMonologue', "Startup Monologue has been issued to all channels.", True)

4
sopel_modules/SpiceBot_Update/Update.py
View File

@ -23,7 +23,7 @@ def configure(config):
def setup(bot): 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) 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') triggerargs = spicemanip.main(triggerargs, '2+', 'list')
quitmessage = "Received command from " + trigger.nick + " to update from Github and restart" 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()) bot.osd(quitmessage, bot.channels.keys())
if commandused == 'nodeps': if commandused == 'nodeps':

2
sopel_modules/SpiceBot_Uptime/Uptime.py
View File

@ -12,7 +12,7 @@ import sopel_modules.SpiceBot as SpiceBot
def setup(bot): def setup(bot):
if 'SpiceBot_Uptime' not in bot.memory: if 'SpiceBot_Uptime' not in bot.memory:
now = time.time() 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 bot.memory["SpiceBot_Uptime"] = now

6
sopel_modules/SpiceBot_osd/__init__.py
View File

@ -40,7 +40,7 @@ def configure(config):
def setup(bot): def setup(bot):
# Inject OSD # 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 bot.osd = SopelOSD.osd
sopel.bot.SopelWrapper.osd = SopelWrapperOSD.osd sopel.bot.SopelWrapper.osd = SopelWrapperOSD.osd
tools.get_available_message_bytes = ToolsOSD.get_available_message_bytes 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 tools.get_message_recipientgroups = ToolsOSD.get_message_recipientgroups
# overwrite default bot messaging # 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.osd = SopelOSD.osd
bot.say = SopelOSD.say bot.say = SopelOSD.say
bot.action = SopelOSD.action bot.action = SopelOSD.action
@ -61,7 +61,7 @@ def setup(bot):
sopel.bot.SopelWrapper.reply = SopelWrapperOSD.reply sopel.bot.SopelWrapper.reply = SopelWrapperOSD.reply
# verify config settings for server # 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) bot.config.define_section("SpiceBot_OSD", SpiceBot_OSD, validate=False)