deathbybandaid/SpiceBot-migrated
1
0
Fork 0
mirror of https://github.com/SpiceBot/SpiceBot.git synced 2026-11-12 14:39:54 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

, botcom

Browse Source
This commit is contained in:
deathbybandaid 2019-07-05 10:03:51 -04:00
parent c92420bb5d
commit 03aefc7c50
12 changed files with 392 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

218
sopel_modules/SpiceBot/Prerun.py
View File

@ -87,7 +87,7 @@ def prerun(t_command_type='module', t_command_subtype=None):
# split into && groupings # split into && groupings
and_split = trigger_and_split(trigger_args) and_split = trigger_and_split(trigger_args)
# Create dict listings for trigger.sb # Create dict listings for botcom.dict
argsdict_list = trigger_argsdict_list(argsdict_default, and_split) argsdict_list = trigger_argsdict_list(argsdict_default, and_split)
# Run the function for all splits # Run the function for all splits
@ -95,12 +95,12 @@ def prerun(t_command_type='module', t_command_subtype=None):
runcount = 0 runcount = 0
for argsdict in argsdict_list: for argsdict in argsdict_list:
runcount += 1 runcount += 1
trigger.sb = copy.deepcopy(argsdict) botcom.dict = copy.deepcopy(argsdict)
trigger.sb["runcount"] = runcount botcom.dict["runcount"] = runcount
trigger.sb["args"], trigger.sb["hyphen_arg"] = trigger_hyphen_args(trigger.sb["args"]) botcom.dict["args"], botcom.dict["hyphen_arg"] = trigger_hyphen_args(botcom.dict["args"])
if not trigger.sb["hyphen_arg"]: if not botcom.dict["hyphen_arg"]:
# check if anything prohibits the nick from running the command # check if anything prohibits the nick from running the command
if trigger_runstatus(bot, trigger): if trigger_runstatus(bot, trigger):
function(bot, trigger, botcom, *args, **kwargs) function(bot, trigger, botcom, *args, **kwargs)
@ -165,15 +165,15 @@ def prerun_query(t_command_type='module', t_command_subtype=None):
argsdict_default["dict"] = botcommands.get_command_dict("query", 'nickname') argsdict_default["dict"] = botcommands.get_command_dict("query", 'nickname')
# Create dict listings for trigger.sb # Create dict listings for botcom.dict
argsdict = trigger_argsdict_single(argsdict_default, trigger_args) argsdict = trigger_argsdict_single(argsdict_default, trigger_args)
# Run the function for all splits # Run the function for all splits
botmessagelog.messagelog_start(bot, trigger, argsdict_default["log_id"], argsdict_default["realcomtext"]) botmessagelog.messagelog_start(bot, trigger, argsdict_default["log_id"], argsdict_default["realcomtext"])
trigger.sb = copy.deepcopy(argsdict) botcom.dict = copy.deepcopy(argsdict)
trigger.sb["runcount"] = 1 botcom.dict["runcount"] = 1
# check if anything prohibits the nick from running the command # check if anything prohibits the nick from running the command
if trigger_runstatus_query(bot, trigger): if trigger_runstatus_query(bot, trigger):
@ -267,11 +267,11 @@ def trigger_runstatus_query(bot, trigger):
return False return False
# Allow permissions for enabling and disabling commands via hyphenargs # Allow permissions for enabling and disabling commands via hyphenargs
if trigger.sb["adminswitch"]: if botcom.dict["adminswitch"]:
if command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']): if command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']):
return True return True
else: else:
botmessagelog.messagelog_error(trigger.sb["log_id"], "The admin switch (-a) is for use by authorized nicks ONLY.") botmessagelog.messagelog_error(botcom.dict["log_id"], "The admin switch (-a) is for use by authorized nicks ONLY.")
return False return False
# don't run commands that are disabled in channels # don't run commands that are disabled in channels
@ -288,25 +288,25 @@ def trigger_runstatus_query(bot, trigger):
# don't run commands that are disabled in channels # don't run commands that are disabled in channels
if not trigger.is_privmsg: if not trigger.is_privmsg:
channel_disabled_list = botcommands.get_commands_disabled(str(trigger.sender)) channel_disabled_list = botcommands.get_commands_disabled(str(trigger.sender))
if trigger.sb["realcomref"] in list(channel_disabled_list.keys()): if botcom.dict["realcomref"] in list(channel_disabled_list.keys()):
reason = channel_disabled_list[trigger.sb["realcomref"]]["reason"] reason = channel_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = channel_disabled_list[trigger.sb["realcomref"]]["timestamp"] timestamp = channel_disabled_list[botcom.dict["realcomref"]]["timestamp"]
bywhom = channel_disabled_list[trigger.sb["realcomref"]]["disabledby"] bywhom = channel_disabled_list[botcom.dict["realcomref"]]["disabledby"]
message = "The " + str(trigger.sb["comtext"]) + " command was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason) message = "The " + str(botcom.dict["comtext"]) + " command was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason)
return trigger_cant_run(bot, trigger, message) return trigger_cant_run(bot, trigger, message)
# don't run commands that are disabled for specific users # don't run commands that are disabled for specific users
nick_disabled_list = botcommands.get_commands_disabled(str(trigger.nick)) nick_disabled_list = botcommands.get_commands_disabled(str(trigger.nick))
if trigger.sb["realcomref"] in list(nick_disabled_list.keys()): if botcom.dict["realcomref"] in list(nick_disabled_list.keys()):
bywhom = nick_disabled_list[trigger.sb["realcomref"]]["disabledby"] bywhom = nick_disabled_list[botcom.dict["realcomref"]]["disabledby"]
if botusers.ID(bywhom) != botusers.ID(trigger.nick): if botusers.ID(bywhom) != botusers.ID(trigger.nick):
reason = nick_disabled_list[trigger.sb["realcomref"]]["reason"] reason = nick_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = nick_disabled_list[trigger.sb["realcomref"]]["timestamp"] timestamp = nick_disabled_list[botcom.dict["realcomref"]]["timestamp"]
message = "The " + str(trigger.sb["comtext"]) + " command was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason) message = "The " + str(botcom.dict["comtext"]) + " command was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason)
return trigger_cant_run(bot, trigger, message) return trigger_cant_run(bot, trigger, message)
else: else:
botcommands.unset_command_disabled(trigger.sb["realcomref"], trigger.nick) botcommands.unset_command_disabled(botcom.dict["realcomref"], trigger.nick)
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " is now enabled for " + str(trigger.nick)) botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " is now enabled for " + str(trigger.nick))
return True return True
@ -318,75 +318,75 @@ def trigger_runstatus(bot, trigger):
return False return False
# Allow permissions for enabling and disabling commands via hyphenargs # Allow permissions for enabling and disabling commands via hyphenargs
if trigger.sb["adminswitch"]: if botcom.dict["adminswitch"]:
if command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']): if command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']):
return True return True
else: else:
botmessagelog.messagelog_error(trigger.sb["log_id"], "The admin switch (-a) is for use by authorized nicks ONLY.") botmessagelog.messagelog_error(botcom.dict["log_id"], "The admin switch (-a) is for use by authorized nicks ONLY.")
return False return False
if trigger.sb["hyphen_arg"]: if botcom.dict["hyphen_arg"]:
return False return False
if not trigger.is_privmsg: if not trigger.is_privmsg:
if str(trigger.sender).lower() in [x.lower() for x in trigger.sb["dict"]["hardcoded_channel_block"]]: if str(trigger.sender).lower() in [x.lower() for x in botcom.dict["dict"]["hardcoded_channel_block"]]:
botmessagelog.messagelog_error(trigger.sb["log_id"], "The " + str(trigger.sb["comtext"]) + " command cannot be used in " + str(trigger.sender) + " because it is hardcoded not to.") botmessagelog.messagelog_error(botcom.dict["log_id"], "The " + str(botcom.dict["comtext"]) + " command cannot be used in " + str(trigger.sender) + " because it is hardcoded not to.")
if trigger.sb["runcount"] > 1: if botcom.dict["runcount"] > 1:
# check channel multirun blocks # check channel multirun blocks
if not trigger.is_privmsg: if not trigger.is_privmsg:
channel_disabled_list = botcommands.get_commands_disabled(str(trigger.sender), "multirun") channel_disabled_list = botcommands.get_commands_disabled(str(trigger.sender), "multirun")
if trigger.sb["realcomref"] in list(channel_disabled_list.keys()): if botcom.dict["realcomref"] in list(channel_disabled_list.keys()):
reason = channel_disabled_list[trigger.sb["realcomref"]]["reason"] reason = channel_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = channel_disabled_list[trigger.sb["realcomref"]]["timestamp"] timestamp = channel_disabled_list[botcom.dict["realcomref"]]["timestamp"]
bywhom = channel_disabled_list[trigger.sb["realcomref"]]["disabledby"] bywhom = channel_disabled_list[botcom.dict["realcomref"]]["disabledby"]
message = "The " + str(trigger.sb["comtext"]) + " command multirun usage was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason) message = "The " + str(botcom.dict["comtext"]) + " command multirun usage was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason)
return trigger_cant_run(bot, trigger, message) return trigger_cant_run(bot, trigger, message)
# don't run commands that are disabled for specific users # don't run commands that are disabled for specific users
nick_disabled_list = botcommands.get_commands_disabled(str(trigger.nick), "multirun") nick_disabled_list = botcommands.get_commands_disabled(str(trigger.nick), "multirun")
if trigger.sb["realcomref"] in list(nick_disabled_list.keys()): if botcom.dict["realcomref"] in list(nick_disabled_list.keys()):
bywhom = nick_disabled_list[trigger.sb["realcomref"]]["disabledby"] bywhom = nick_disabled_list[botcom.dict["realcomref"]]["disabledby"]
if botusers.ID(bywhom) != botusers.ID(trigger.nick): if botusers.ID(bywhom) != botusers.ID(trigger.nick):
reason = nick_disabled_list[trigger.sb["realcomref"]]["reason"] reason = nick_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = nick_disabled_list[trigger.sb["realcomref"]]["timestamp"] timestamp = nick_disabled_list[botcom.dict["realcomref"]]["timestamp"]
message = "The " + str(trigger.sb["comtext"]) + " command was multirun unsage disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason) message = "The " + str(botcom.dict["comtext"]) + " command was multirun unsage disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason)
return trigger_cant_run(bot, trigger, message) return trigger_cant_run(bot, trigger, message)
else: else:
botcommands.unset_command_disabled(trigger.sb["realcomref"], trigger.nick, "multirun") botcommands.unset_command_disabled(botcom.dict["realcomref"], trigger.nick, "multirun")
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is now enabled for " + str(trigger.nick)) botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " multirun is now enabled for " + str(trigger.nick))
# don't run commands that are disabled in channels # don't run commands that are disabled in channels
if not trigger.is_privmsg: if not trigger.is_privmsg:
channel_disabled_list = botcommands.get_commands_disabled(str(trigger.sender)) channel_disabled_list = botcommands.get_commands_disabled(str(trigger.sender))
if trigger.sb["realcomref"] in list(channel_disabled_list.keys()): if botcom.dict["realcomref"] in list(channel_disabled_list.keys()):
reason = channel_disabled_list[trigger.sb["realcomref"]]["reason"] reason = channel_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = channel_disabled_list[trigger.sb["realcomref"]]["timestamp"] timestamp = channel_disabled_list[botcom.dict["realcomref"]]["timestamp"]
bywhom = channel_disabled_list[trigger.sb["realcomref"]]["disabledby"] bywhom = channel_disabled_list[botcom.dict["realcomref"]]["disabledby"]
message = "The " + str(trigger.sb["comtext"]) + " command was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason) message = "The " + str(botcom.dict["comtext"]) + " command was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason)
return trigger_cant_run(bot, trigger, message) return trigger_cant_run(bot, trigger, message)
# don't run commands that are disabled for specific users # don't run commands that are disabled for specific users
nick_disabled_list = botcommands.get_commands_disabled(str(trigger.nick)) nick_disabled_list = botcommands.get_commands_disabled(str(trigger.nick))
if trigger.sb["realcomref"] in list(nick_disabled_list.keys()): if botcom.dict["realcomref"] in list(nick_disabled_list.keys()):
bywhom = nick_disabled_list[trigger.sb["realcomref"]]["disabledby"] bywhom = nick_disabled_list[botcom.dict["realcomref"]]["disabledby"]
if botusers.ID(bywhom) != botusers.ID(trigger.nick): if botusers.ID(bywhom) != botusers.ID(trigger.nick):
reason = nick_disabled_list[trigger.sb["realcomref"]]["reason"] reason = nick_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = nick_disabled_list[trigger.sb["realcomref"]]["timestamp"] timestamp = nick_disabled_list[botcom.dict["realcomref"]]["timestamp"]
message = "The " + str(trigger.sb["comtext"]) + " command was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason) message = "The " + str(botcom.dict["comtext"]) + " command was disabled by " + bywhom + " for " + str(trigger.sender) + " at " + str(timestamp) + " for the following reason: " + str(reason)
return trigger_cant_run(bot, trigger, message) return trigger_cant_run(bot, trigger, message)
else: else:
botcommands.unset_command_disabled(trigger.sb["realcomref"], trigger.nick) botcommands.unset_command_disabled(botcom.dict["realcomref"], trigger.nick)
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " is now enabled for " + str(trigger.nick)) botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " is now enabled for " + str(trigger.nick))
return True return True
def trigger_cant_run(bot, trigger, message=None): def trigger_cant_run(bot, trigger, message=None):
if message: if message:
botmessagelog.messagelog_error(trigger.sb["log_id"], message) botmessagelog.messagelog_error(botcom.dict["log_id"], message)
if command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']): if command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']):
botmessagelog.messagelog_error(trigger.sb["log_id"], "You however are authorized to bypass this warning with the (-a) admin switch.") botmessagelog.messagelog_error(botcom.dict["log_id"], "You however are authorized to bypass this warning with the (-a) admin switch.")
return False return False
@ -423,137 +423,137 @@ def trigger_hyphen_arg_handler(bot, trigger):
# Commands that cannot run via privmsg # Commands that cannot run via privmsg
# TODO --check should work for commands that don't exist # TODO --check should work for commands that don't exist
if trigger.sb["hyphen_arg"] in ['check']: if botcom.dict["hyphen_arg"] in ['check']:
if trigger.sb["com"].lower() != trigger.sb["realcom"]: if botcom.dict["com"].lower() != botcom.dict["realcom"]:
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " is a valid alias command for " + trigger.sb["realcomtext"]) botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " is a valid alias command for " + botcom.dict["realcomtext"])
else: else:
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " is a valid command") botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " is a valid command")
return return
elif trigger.sb["hyphen_arg"] in [ elif botcom.dict["hyphen_arg"] in [
'enable', 'disable', 'enable', 'disable',
'block', 'unblock', 'block', 'unblock',
"activate", "deactivate", "activate", "deactivate",
"on", "off" "on", "off"
]: ]:
target = spicemanip.main(trigger.sb["args"], 1) or trigger.nick target = spicemanip.main(botcom.dict["args"], 1) or trigger.nick
if not target: if not target:
if trigger.sb["hyphen_arg"] in ['enable', 'unblock', "activate", "on"]: if botcom.dict["hyphen_arg"] in ['enable', 'unblock', "activate", "on"]:
botmessagelog.messagelog_error(trigger.sb["log_id"], "Who/Where am I enabling " + str(trigger.sb["comtext"]) + " usage for?") botmessagelog.messagelog_error(botcom.dict["log_id"], "Who/Where am I enabling " + str(botcom.dict["comtext"]) + " usage for?")
else: else:
botmessagelog.messagelog_error(trigger.sb["log_id"], "Who/Where am I disabling " + str(trigger.sb["comtext"]) + " usage for?") botmessagelog.messagelog_error(botcom.dict["log_id"], "Who/Where am I disabling " + str(botcom.dict["comtext"]) + " usage for?")
return return
trigger.sb["args"] = spicemanip.main(trigger.sb["args"], "2+", "list") botcom.dict["args"] = spicemanip.main(botcom.dict["args"], "2+", "list")
if not botdb.check_nick_id(target) and not botchannels.check_channel_bot(target, True): if not botdb.check_nick_id(target) and not botchannels.check_channel_bot(target, True):
botmessagelog.messagelog_error(trigger.sb["log_id"], "I don't know who/what " + str(target) + " is.") botmessagelog.messagelog_error(botcom.dict["log_id"], "I don't know who/what " + str(target) + " is.")
return return
if not command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']): if not command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']):
if target != trigger.nick: if target != trigger.nick:
if trigger.sb["hyphen_arg"] in ['enable', 'unblock', "activate", "on"]: if botcom.dict["hyphen_arg"] in ['enable', 'unblock', "activate", "on"]:
botmessagelog.messagelog_error(trigger.sb["log_id"], "I was unable to enable this command for " + str(target) + " due to privilege issues.") botmessagelog.messagelog_error(botcom.dict["log_id"], "I was unable to enable this command for " + str(target) + " due to privilege issues.")
else: else:
botmessagelog.messagelog_error(trigger.sb["log_id"], "I was unable to disable this command for " + str(target) + " due to privilege issues.") botmessagelog.messagelog_error(botcom.dict["log_id"], "I was unable to disable this command for " + str(target) + " due to privilege issues.")
return return
if trigger.sb["hyphen_arg"] in ['enable', 'unblock', "activate", "on"]: if botcom.dict["hyphen_arg"] in ['enable', 'unblock', "activate", "on"]:
if not botcommands.check_commands_disabled(trigger.sb["realcomref"], target): if not botcommands.check_commands_disabled(botcom.dict["realcomref"], target):
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " is already enabled for " + str(target)) botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " is already enabled for " + str(target))
return return
botcommands.unset_command_disabled(trigger.sb["realcomref"], target) botcommands.unset_command_disabled(botcom.dict["realcomref"], target)
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " is now enabled for " + str(target)) botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " is now enabled for " + str(target))
return return
else: else:
if botcommands.check_commands_disabled(trigger.sb["realcomref"], target): if botcommands.check_commands_disabled(botcom.dict["realcomref"], target):
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " is already disabled for " + str(target)) botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " is already disabled for " + str(target))
return return
trailingmessage = spicemanip.main(trigger.sb["args"], 0) or "No reason given." trailingmessage = spicemanip.main(botcom.dict["args"], 0) or "No reason given."
timestamp = str(datetime.datetime.utcnow()) timestamp = str(datetime.datetime.utcnow())
botcommands.set_command_disabled(trigger.sb["realcomref"], target, timestamp, trailingmessage, trigger.nick) botcommands.set_command_disabled(botcom.dict["realcomref"], target, timestamp, trailingmessage, trigger.nick)
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " is now disabled for " + str(target)) botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " is now disabled for " + str(target))
return return
if trigger.sb["hyphen_arg"] in ['multirun', 'multiruns']: if botcom.dict["hyphen_arg"] in ['multirun', 'multiruns']:
onoff = spicemanip.main(trigger.sb["args"], 1) or None onoff = spicemanip.main(botcom.dict["args"], 1) or None
if not onoff or onoff not in ['enable', 'unblock', "activate", "on"]: if not onoff or onoff not in ['enable', 'unblock', "activate", "on"]:
botmessagelog.messagelog_error(trigger.sb["log_id"], "Do you want to enable or disable " + str(trigger.sb["comtext"]) + " multirun usage?") botmessagelog.messagelog_error(botcom.dict["log_id"], "Do you want to enable or disable " + str(botcom.dict["comtext"]) + " multirun usage?")
return return
target = spicemanip.main(trigger.sb["args"], 1) or trigger.nick target = spicemanip.main(botcom.dict["args"], 1) or trigger.nick
if not target: if not target:
if onoff in ['enable', 'unblock', "activate", "on"]: if onoff in ['enable', 'unblock', "activate", "on"]:
botmessagelog.messagelog_error(trigger.sb["log_id"], "Who/Where am I enabling " + str(trigger.sb["comtext"]) + " multirun usage for?") botmessagelog.messagelog_error(botcom.dict["log_id"], "Who/Where am I enabling " + str(botcom.dict["comtext"]) + " multirun usage for?")
else: else:
botmessagelog.messagelog_error(trigger.sb["log_id"], "Who/Where am I disabling " + str(trigger.sb["comtext"]) + " multirun usage for?") botmessagelog.messagelog_error(botcom.dict["log_id"], "Who/Where am I disabling " + str(botcom.dict["comtext"]) + " multirun usage for?")
return return
trigger.sb["args"] = spicemanip.main(trigger.sb["args"], "2+", "list") botcom.dict["args"] = spicemanip.main(botcom.dict["args"], "2+", "list")
if not botdb.check_nick_id(target) and not botchannels.check_channel_bot(target, True): if not botdb.check_nick_id(target) and not botchannels.check_channel_bot(target, True):
botmessagelog.messagelog_error(trigger.sb["log_id"], "I don't know who/what " + str(target) + " is.") botmessagelog.messagelog_error(botcom.dict["log_id"], "I don't know who/what " + str(target) + " is.")
return return
if not command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']): if not command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']):
if target != trigger.nick: if target != trigger.nick:
if onoff in ['enable', 'unblock', "activate", "on"]: if onoff in ['enable', 'unblock', "activate", "on"]:
botmessagelog.messagelog_error(trigger.sb["log_id"], "I was unable to enable multirun usage on " + str(trigger.sb["comtext"]) + " for " + str(target) + " due to privilege issues.") botmessagelog.messagelog_error(botcom.dict["log_id"], "I was unable to enable multirun usage on " + str(botcom.dict["comtext"]) + " for " + str(target) + " due to privilege issues.")
else: else:
botmessagelog.messagelog_error(trigger.sb["log_id"], "I was unable to enable multirun usage on " + str(trigger.sb["comtext"]) + " for " + str(target) + " due to privilege issues.") botmessagelog.messagelog_error(botcom.dict["log_id"], "I was unable to enable multirun usage on " + str(botcom.dict["comtext"]) + " for " + str(target) + " due to privilege issues.")
return return
if onoff in ['enable', 'unblock', "activate", "on"]: if onoff in ['enable', 'unblock', "activate", "on"]:
if not botcommands.check_commands_disabled(trigger.sb["realcomref"], target, "multirun"): if not botcommands.check_commands_disabled(botcom.dict["realcomref"], target, "multirun"):
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is already enabled for " + str(target)) botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " multirun is already enabled for " + str(target))
return return
botcommands.unset_command_disabled(trigger.sb["realcomref"], target, "multirun") botcommands.unset_command_disabled(botcom.dict["realcomref"], target, "multirun")
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is now enabled for " + str(target)) botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " multirun is now enabled for " + str(target))
return return
else: else:
if botcommands.check_commands_disabled(trigger.sb["realcomref"], target, "multirun"): if botcommands.check_commands_disabled(botcom.dict["realcomref"], target, "multirun"):
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is already disabled for " + str(target)) botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " multirun is already disabled for " + str(target))
return return
trailingmessage = spicemanip.main(trigger.sb["args"], 0) or "No reason given." trailingmessage = spicemanip.main(botcom.dict["args"], 0) or "No reason given."
timestamp = str(datetime.datetime.utcnow()) timestamp = str(datetime.datetime.utcnow())
botcommands.set_command_disabled(trigger.sb["realcomref"], target, timestamp, trailingmessage, trigger.nick, "multirun") botcommands.set_command_disabled(botcom.dict["realcomref"], target, timestamp, trailingmessage, trigger.nick, "multirun")
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is now disabled for " + str(target)) botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " multirun is now disabled for " + str(target))
return return
elif trigger.sb["hyphen_arg"] in ['example', 'usage']: elif botcom.dict["hyphen_arg"] in ['example', 'usage']:
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + ": " + str(trigger.sb["dict"]["example"])) botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + ": " + str(botcom.dict["dict"]["example"]))
return return
elif trigger.sb["hyphen_arg"] in ['filename', 'filepath']: elif botcom.dict["hyphen_arg"] in ['filename', 'filepath']:
botmessagelog.messagelog(trigger.sb["log_id"], "The " + str(trigger.sb["comtext"]) + " file is located at " + str(trigger.sb["dict"][trigger.sb["hyphen_arg"]])) botmessagelog.messagelog(botcom.dict["log_id"], "The " + str(botcom.dict["comtext"]) + " file is located at " + str(botcom.dict["dict"][botcom.dict["hyphen_arg"]]))
return return
elif trigger.sb["hyphen_arg"] in ['foldername', 'folderpath']: elif botcom.dict["hyphen_arg"] in ['foldername', 'folderpath']:
botmessagelog.messagelog(trigger.sb["log_id"], "The " + str(trigger.sb["comtext"]) + " folder is located at " + str(trigger.sb["dict"][trigger.sb["hyphen_arg"]])) botmessagelog.messagelog(botcom.dict["log_id"], "The " + str(botcom.dict["comtext"]) + " folder is located at " + str(botcom.dict["dict"][botcom.dict["hyphen_arg"]]))
return return
elif trigger.sb["hyphen_arg"] in ['author']: elif botcom.dict["hyphen_arg"] in ['author']:
botmessagelog.messagelog(trigger.sb["log_id"], "The author of the " + str(trigger.sb["comtext"]) + " command is " + trigger.sb["dict"]["author"] + ".") botmessagelog.messagelog(botcom.dict["log_id"], "The author of the " + str(botcom.dict["comtext"]) + " command is " + botcom.dict["dict"]["author"] + ".")
return return
elif trigger.sb["hyphen_arg"] in ['contribs', 'contrib', "contributors"]: elif botcom.dict["hyphen_arg"] in ['contribs', 'contrib', "contributors"]:
botmessagelog.messagelog(trigger.sb["log_id"], "The contributors of the " + str(trigger.sb["comtext"]) + " command are " + spicemanip.main(trigger.sb["dict"]["contributors"], "andlist") + ".") botmessagelog.messagelog(botcom.dict["log_id"], "The contributors of the " + str(botcom.dict["comtext"]) + " command are " + spicemanip.main(botcom.dict["dict"]["contributors"], "andlist") + ".")
return return
elif trigger.sb["hyphen_arg"] in ['alias', 'aliases']: elif botcom.dict["hyphen_arg"] in ['alias', 'aliases']:
botmessagelog.messagelog(trigger.sb["log_id"], "The alaises of the " + str(trigger.sb["comtext"]) + " command are " + spicemanip.main(trigger.sb["dict"]["validcoms"], "andlist") + ".") botmessagelog.messagelog(botcom.dict["log_id"], "The alaises of the " + str(botcom.dict["comtext"]) + " command are " + spicemanip.main(botcom.dict["dict"]["validcoms"], "andlist") + ".")
return return
return return

14
sopel_modules/SpiceBot_Core_Commands/BotPrivs.py
View File

@ -12,19 +12,19 @@ import sopel_modules.SpiceBot as SpiceBot
@SpiceBot.prerun('nickname') @SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('owners', 'owner') @sopel.module.nickname_commands('owners', 'owner')
def bot_command_owners(bot, trigger, botcom): def bot_command_owners(bot, trigger, botcom):
bot_command_process(bot, trigger) bot_command_process(bot, trigger, botcom)
@SpiceBot.prerun('nickname') @SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('admins', 'admin') @sopel.module.nickname_commands('admins', 'admin')
def bot_command_admins(bot, trigger, botcom): def bot_command_admins(bot, trigger, botcom):
bot_command_process(bot, trigger) bot_command_process(bot, trigger, botcom)
def bot_command_process(bot, trigger): def bot_command_process(bot, trigger, botcom):
if not trigger.sb['com'].endswith("s"): if not botcom.dict['com'].endswith("s"):
trigger.sb['com'] = str(trigger.sb['com'] + "s") botcom.dict['com'] = str(botcom.dict['com'] + "s")
privlist = spicemanip.main(SpiceBot.bot_privs(trigger.sb['com']), 'andlist') privlist = spicemanip.main(SpiceBot.bot_privs(botcom.dict['com']), 'andlist')
bot.osd(str(bot.nick) + " " + trigger.sb['com'] + ": " + privlist) bot.osd(str(bot.nick) + " " + botcom.dict['com'] + ": " + privlist)

32
sopel_modules/SpiceBot_Core_Commands/Channels.py
View File

@ -14,12 +14,12 @@ import sopel_modules.SpiceBot as SpiceBot
@sopel.module.nickname_commands('channels', 'channel') @sopel.module.nickname_commands('channels', 'channel')
def nickname_comand_channels(bot, trigger, botcom): def nickname_comand_channels(bot, trigger, botcom):
if not len(trigger.sb['args']): if not len(botcom.dict['args']):
commandused = 'list' commandused = 'list'
else: else:
commandused = spicemanip.main(trigger.sb['args'], 1).lower() commandused = spicemanip.main(botcom.dict['args'], 1).lower()
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list') botcom.dict['args'] = spicemanip.main(botcom.dict['args'], '2+', 'list')
if commandused == 'list': if commandused == 'list':
botcount = len(list(bot.channels.keys())) botcount = len(list(bot.channels.keys()))
@ -48,7 +48,7 @@ def nickname_comand_channels(bot, trigger, botcom):
elif commandused == 'update': elif commandused == 'update':
if not trigger.admin: if not trigger.admin:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "You do not have permission to update the channel listing.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "You do not have permission to update the channel listing.")
return return
SpiceBot.channels.bot_part_empty(bot) SpiceBot.channels.bot_part_empty(bot)
SpiceBot.channels.channel_list_request(bot) SpiceBot.channels.channel_list_request(bot)
@ -62,12 +62,12 @@ def nickname_comand_channels(bot, trigger, botcom):
return return
elif commandused == 'topic': elif commandused == 'topic':
if not len(trigger.sb['args']): if not len(botcom.dict['args']):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Channel name input missing.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Channel name input missing.")
return return
channel = spicemanip.main(trigger.sb['args'], 1) channel = spicemanip.main(botcom.dict['args'], 1)
if not SpiceBot.inlist(channel.lower(), list(SpiceBot.channels.dict['list'].keys())): if not SpiceBot.inlist(channel.lower(), list(SpiceBot.channels.dict['list'].keys())):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Channel name {} not valid.".format(channel)) SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Channel name {} not valid.".format(channel))
return return
topic = SpiceBot.channels.dict['list'][channel.lower()]['topic'] topic = SpiceBot.channels.dict['list'][channel.lower()]['topic']
channel = SpiceBot.channels.dict['list'][channel.lower()]['name'] channel = SpiceBot.channels.dict['list'][channel.lower()]['name']
@ -75,19 +75,19 @@ def nickname_comand_channels(bot, trigger, botcom):
return return
if commandused.upper() in ['OP', 'HOP', 'VOICE', 'OWNER', 'ADMIN']: if commandused.upper() in ['OP', 'HOP', 'VOICE', 'OWNER', 'ADMIN']:
if not len(trigger.sb['args']): if not len(botcom.dict['args']):
if trigger.is_privmsg: if trigger.is_privmsg:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Channel name required.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Channel name required.")
return return
else: else:
channel = trigger.sender channel = trigger.sender
else: else:
channel = spicemanip.main(trigger.sb['args'], 1) channel = spicemanip.main(botcom.dict['args'], 1)
if not SpiceBot.inlist(channel.lower(), list(SpiceBot.channels.dict['list'].keys())): if not SpiceBot.inlist(channel.lower(), list(SpiceBot.channels.dict['list'].keys())):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Channel name {} not valid.".format(channel)) SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Channel name {} not valid.".format(channel))
return return
if not SpiceBot.inlist(channel.lower(), list(bot.channels.keys())): if not SpiceBot.inlist(channel.lower(), list(bot.channels.keys())):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "I need to be in {} to see nick privileges.".format(channel)) SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "I need to be in {} to see nick privileges.".format(channel))
return return
privlist = SpiceBot.channel_privs(bot, channel, commandused.upper()) privlist = SpiceBot.channel_privs(bot, channel, commandused.upper())
@ -102,12 +102,12 @@ def nickname_comand_channels(bot, trigger, botcom):
# Users List # Users List
if commandused == 'users': if commandused == 'users':
channel = spicemanip.main(trigger.sb['args'], 1) channel = spicemanip.main(botcom.dict['args'], 1)
if not SpiceBot.inlist(channel.lower(), list(SpiceBot.channels.dict['list'].keys())): if not SpiceBot.inlist(channel.lower(), list(SpiceBot.channels.dict['list'].keys())):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Channel name {} not valid.".format(channel)) SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Channel name {} not valid.".format(channel))
return return
if not SpiceBot.inlist(channel.lower(), list(bot.channels.keys())): if not SpiceBot.inlist(channel.lower(), list(bot.channels.keys())):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "I need to be in {} to see user list.".format(channel)) SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "I need to be in {} to see user list.".format(channel))
return return
dispmsg = [] dispmsg = []
if not len(list(bot.channels[channel].privileges.keys())): if not len(list(bot.channels[channel].privileges.keys())):

4
sopel_modules/SpiceBot_Core_Commands/Commands.py
View File

@ -18,10 +18,10 @@ import sopel_modules.SpiceBot as SpiceBot
@sopel.module.nickname_commands('commands', 'command') @sopel.module.nickname_commands('commands', 'command')
def nickname_comand_commands(bot, trigger, botcom): def nickname_comand_commands(bot, trigger, botcom):
if not len(trigger.sb['args']): if not len(botcom.dict['args']):
commandused = 'list' commandused = 'list'
else: else:
commandused = spicemanip.main(trigger.sb['args'], 1).lower() commandused = spicemanip.main(botcom.dict['args'], 1).lower()
if commandused == 'list': if commandused == 'list':
availablecomsnum, availablecomsfiles = 0, [] availablecomsnum, availablecomsfiles = 0, []

92
sopel_modules/SpiceBot_Core_Commands/CommandsQuery.py
View File

@ -23,14 +23,14 @@ def query_trigger(bot, trigger, botcom):
def query_detection_nick(bot, trigger, botcom): def query_detection_nick(bot, trigger, botcom):
# command issued, check if valid # command issued, check if valid
if not trigger.sb['com'] or not len(trigger.sb['com']): if not botcom.dict['com'] or not len(botcom.dict['com']):
return return
if not trigger.sb['com'][0] == bot.config.SpiceBot_Commands.query_prefix: if not botcom.dict['com'][0] == bot.config.SpiceBot_Commands.query_prefix:
return return
trigger.sb['com'] = trigger.sb['com'][1:] botcom.dict['com'] = botcom.dict['com'][1:]
if not SpiceBot.letters_in_string(trigger.sb['com']): if not SpiceBot.letters_in_string(botcom.dict['com']):
return return
commands_list = dict() commands_list = dict()
@ -38,49 +38,49 @@ def query_detection_nick(bot, trigger, botcom):
if com not in list(commands_list.keys()): if com not in list(commands_list.keys()):
commands_list[com] = SpiceBot.commands.dict['commands']['nickname'][com] commands_list[com] = SpiceBot.commands.dict['commands']['nickname'][com]
if trigger.sb['com'].endswith("+"): if botcom.dict['com'].endswith("+"):
trigger.sb['com'] = trigger.sb['com'][:-1] botcom.dict['com'] = botcom.dict['com'][:-1]
if not trigger.sb['com'] or not len(trigger.sb['com']): if not botcom.dict['com'] or not len(botcom.dict['com']):
return return
if trigger.sb['com'].lower() not in list(commands_list.keys()): if botcom.dict['com'].lower() not in list(commands_list.keys()):
dispmsg = ["Cannot find any alias " + bot.nick + " commands: No valid commands match " + str(trigger.sb['com']) + "."] dispmsg = ["Cannot find any alias " + bot.nick + " commands: No valid commands match " + str(botcom.dict['com']) + "."]
closestmatches = SpiceBot.similar_list(trigger.sb['com'], list(commands_list.keys()), 10, 'reverse') closestmatches = SpiceBot.similar_list(botcom.dict['com'], list(commands_list.keys()), 10, 'reverse')
if len(closestmatches): if len(closestmatches):
dispmsg.append("The following " + bot.nick + " commands match " + str(trigger.sb['com']) + ": " + spicemanip.main(closestmatches, 'andlist') + ".") dispmsg.append("The following " + bot.nick + " commands match " + str(botcom.dict['com']) + ": " + spicemanip.main(closestmatches, 'andlist') + ".")
bot.osd(dispmsg, trigger.nick, 'notice') bot.osd(dispmsg, trigger.nick, 'notice')
return return
realcom = trigger.sb['com'] realcom = botcom.dict['com']
if "aliasfor" in list(commands_list[trigger.sb['com']].keys()): if "aliasfor" in list(commands_list[botcom.dict['com']].keys()):
realcom = commands_list[trigger.sb['com']]["aliasfor"] realcom = commands_list[botcom.dict['com']]["aliasfor"]
validcomlist = commands_list[realcom]["validcoms"] validcomlist = commands_list[realcom]["validcoms"]
bot.osd("The following " + bot.nick + " commands match " + str(trigger.sb['com']) + ": " + spicemanip.main(validcomlist, 'andlist') + ".", trigger.nick, 'notice') bot.osd("The following " + bot.nick + " commands match " + str(botcom.dict['com']) + ": " + spicemanip.main(validcomlist, 'andlist') + ".", trigger.nick, 'notice')
return return
if trigger.sb['com'].endswith(bot.config.SpiceBot_Commands.query_prefix): if botcom.dict['com'].endswith(bot.config.SpiceBot_Commands.query_prefix):
trigger.sb['com'] = trigger.sb['com'][:-1] botcom.dict['com'] = botcom.dict['com'][:-1]
if not trigger.sb['com'] or not len(trigger.sb['com']): if not botcom.dict['com'] or not len(botcom.dict['com']):
return return
closestmatches = SpiceBot.similar_list(trigger.sb['com'], list(commands_list.keys()), 10, 'reverse') closestmatches = SpiceBot.similar_list(botcom.dict['com'], list(commands_list.keys()), 10, 'reverse')
if not len(closestmatches): if not len(closestmatches):
bot.osd("Cannot find any similar " + bot.nick + " commands for " + str(trigger.sb['com']) + ".", trigger.nick, 'notice') bot.osd("Cannot find any similar " + bot.nick + " commands for " + str(botcom.dict['com']) + ".", trigger.nick, 'notice')
else: else:
bot.osd("The following " + bot.nick + " commands may match " + str(trigger.sb['com']) + ": " + spicemanip.main(closestmatches, 'andlist') + ".", trigger.nick, 'notice') bot.osd("The following " + bot.nick + " commands may match " + str(botcom.dict['com']) + ": " + spicemanip.main(closestmatches, 'andlist') + ".", trigger.nick, 'notice')
return return
commandlist = [] commandlist = []
for command in list(commands_list.keys()): for command in list(commands_list.keys()):
if command.lower().startswith(str(trigger.sb['com']).lower()): if command.lower().startswith(str(botcom.dict['com']).lower()):
commandlist.append(command) commandlist.append(command)
if not len(commandlist): if not len(commandlist):
bot.osd("No " + bot.nick + " commands start with " + str(trigger.sb['com']) + ".", trigger.nick, 'notice') bot.osd("No " + bot.nick + " commands start with " + str(botcom.dict['com']) + ".", trigger.nick, 'notice')
else: else:
bot.osd("The following " + bot.nick + " commands start with " + str(trigger.sb['com']) + ": " + spicemanip.main(commandlist, 'andlist') + ".", trigger.nick, 'notice') bot.osd("The following " + bot.nick + " commands start with " + str(botcom.dict['com']) + ": " + spicemanip.main(commandlist, 'andlist') + ".", trigger.nick, 'notice')
@SpiceBot.prerun_query('module', 'module') @SpiceBot.prerun_query('module', 'module')
@ -88,10 +88,10 @@ def query_detection_nick(bot, trigger, botcom):
def query_detection(bot, trigger, botcom): def query_detection(bot, trigger, botcom):
# command issued, check if valid # command issued, check if valid
if not trigger.sb['com'] or not len(trigger.sb['com']): if not botcom.dict['com'] or not len(botcom.dict['com']):
return return
if not SpiceBot.letters_in_string(trigger.sb['com']): if not SpiceBot.letters_in_string(botcom.dict['com']):
return return
commands_list = dict() commands_list = dict()
@ -101,46 +101,46 @@ def query_detection(bot, trigger, botcom):
if com not in list(commands_list.keys()): if com not in list(commands_list.keys()):
commands_list[com] = SpiceBot.commands.dict['commands'][commandstype][com] commands_list[com] = SpiceBot.commands.dict['commands'][commandstype][com]
if trigger.sb['com'][:-1] == "+": if botcom.dict['com'][:-1] == "+":
trigger.sb['com'] = trigger.sb['com'][:-1] botcom.dict['com'] = botcom.dict['com'][:-1]
if not trigger.sb['com'] or not len(trigger.sb['com']): if not botcom.dict['com'] or not len(botcom.dict['com']):
return return
if trigger.sb['com'].lower() not in list(commands_list.keys()): if botcom.dict['com'].lower() not in list(commands_list.keys()):
dispmsg = ["Cannot find any alias commands: No valid commands match " + str(trigger.sb['com']) + "."] dispmsg = ["Cannot find any alias commands: No valid commands match " + str(botcom.dict['com']) + "."]
closestmatches = SpiceBot.similar_list(trigger.sb['com'], list(commands_list.keys()), 10, 'reverse') closestmatches = SpiceBot.similar_list(botcom.dict['com'], list(commands_list.keys()), 10, 'reverse')
if len(closestmatches): if len(closestmatches):
dispmsg.append("The following commands match " + str(trigger.sb['com']) + ": " + spicemanip.main(closestmatches, 'andlist') + ".") dispmsg.append("The following commands match " + str(botcom.dict['com']) + ": " + spicemanip.main(closestmatches, 'andlist') + ".")
bot.osd(dispmsg, trigger.nick, 'notice') bot.osd(dispmsg, trigger.nick, 'notice')
return return
realcom = trigger.sb['com'] realcom = botcom.dict['com']
if "aliasfor" in list(commands_list[trigger.sb['com']].keys()): if "aliasfor" in list(commands_list[botcom.dict['com']].keys()):
realcom = commands_list[trigger.sb['com']]["aliasfor"] realcom = commands_list[botcom.dict['com']]["aliasfor"]
validcomlist = commands_list[realcom]["validcoms"] validcomlist = commands_list[realcom]["validcoms"]
bot.osd("The following commands match " + str(trigger.sb['com']) + ": " + spicemanip.main(validcomlist, 'andlist') + ".", trigger.nick, 'notice') bot.osd("The following commands match " + str(botcom.dict['com']) + ": " + spicemanip.main(validcomlist, 'andlist') + ".", trigger.nick, 'notice')
return return
if trigger.sb['com'][:-1] == "?": if botcom.dict['com'][:-1] == "?":
trigger.sb['com'] = trigger.sb['com'][:-1] botcom.dict['com'] = botcom.dict['com'][:-1]
if not trigger.sb['com'] or not len(trigger.sb['com']): if not botcom.dict['com'] or not len(botcom.dict['com']):
return return
closestmatches = SpiceBot.similar_list(trigger.sb['com'], list(commands_list.keys()), 10, 'reverse') closestmatches = SpiceBot.similar_list(botcom.dict['com'], list(commands_list.keys()), 10, 'reverse')
if not len(closestmatches): if not len(closestmatches):
bot.osd("Cannot find any similar commands for " + str(trigger.sb['com']) + ".", trigger.nick, 'notice') bot.osd("Cannot find any similar commands for " + str(botcom.dict['com']) + ".", trigger.nick, 'notice')
else: else:
bot.osd("The following commands may match " + str(trigger.sb['com']) + ": " + spicemanip.main(closestmatches, 'andlist') + ".", trigger.nick, 'notice') bot.osd("The following commands may match " + str(botcom.dict['com']) + ": " + spicemanip.main(closestmatches, 'andlist') + ".", trigger.nick, 'notice')
return return
commandlist = [] commandlist = []
for command in list(commands_list.keys()): for command in list(commands_list.keys()):
if command.lower().startswith(str(trigger.sb['com']).lower()): if command.lower().startswith(str(botcom.dict['com']).lower()):
commandlist.append(command) commandlist.append(command)
if not len(commandlist): if not len(commandlist):
bot.osd("No commands start with " + str(trigger.sb['com']) + ".", trigger.nick, 'notice') bot.osd("No commands start with " + str(botcom.dict['com']) + ".", trigger.nick, 'notice')
else: else:
bot.osd("The following commands start with " + str(trigger.sb['com']) + ": " + spicemanip.main(commandlist, 'andlist') + ".", trigger.nick, 'notice') bot.osd("The following commands start with " + str(botcom.dict['com']) + ": " + spicemanip.main(commandlist, 'andlist') + ".", trigger.nick, 'notice')

322
sopel_modules/SpiceBot_Core_Commands/DictComs.py
View File

@ -20,78 +20,78 @@ import time
@sopel.module.commands('(.*)') @sopel.module.commands('(.*)')
def command_dictcom(bot, trigger, botcom): def command_dictcom(bot, trigger, botcom):
if trigger.sb['com'] not in list(SpiceBot.commands.dict['commands']["dictcom"].keys()): if botcom.dict['com'] not in list(SpiceBot.commands.dict['commands']["dictcom"].keys()):
return return
bot_dictcom_process(bot, trigger) bot_dictcom_process(bot, trigger, botcom)
return return
time.time() time.time()
def bot_dictcom_process(bot, trigger): def bot_dictcom_process(bot, trigger, botcom):
# use the default key, unless otherwise specified # use the default key, unless otherwise specified
trigger.sb["responsekey"] = "?default" botcom.dict["responsekey"] = "?default"
# handling for special cases # handling for special cases
posscom = spicemanip.main(trigger.sb['args'], 1) posscom = spicemanip.main(botcom.dict['args'], 1)
if posscom.lower() in [command.lower() for command in trigger.sb["dict"].keys()]: if posscom.lower() in [command.lower() for command in botcom.dict["dict"].keys()]:
for command in trigger.sb["dict"].keys(): for command in botcom.dict["dict"].keys():
if command.lower() == posscom.lower(): if command.lower() == posscom.lower():
posscom = command posscom = command
trigger.sb["responsekey"] = posscom botcom.dict["responsekey"] = posscom
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list') botcom.dict['args'] = spicemanip.main(botcom.dict['args'], '2+', 'list')
trigger.sb["dict"][trigger.sb["responsekey"]]["type"] = trigger.sb["dict"][trigger.sb["responsekey"]]["type"] botcom.dict["dict"][botcom.dict["responsekey"]]["type"] = botcom.dict["dict"][botcom.dict["responsekey"]]["type"]
trigger.sb["nonstockoptions"] = [] botcom.dict["nonstockoptions"] = []
for command in trigger.sb["dict"].keys(): for command in botcom.dict["dict"].keys():
if command not in ["?default", "validcoms", "type", "hardcoded_channel_block"]: if command not in ["?default", "validcoms", "type", "hardcoded_channel_block"]:
trigger.sb["nonstockoptions"].append(command) botcom.dict["nonstockoptions"].append(command)
# This allows users to specify which reply by number by using an ! and a digit (first or last in string) # This allows users to specify which reply by number by using an ! and a digit (first or last in string)
validspecifides = ['last', 'random', 'count', 'view', 'add', 'del', 'remove', 'special'] validspecifides = ['last', 'random', 'count', 'view', 'add', 'del', 'remove', 'special']
trigger.sb["specified"] = None botcom.dict["specified"] = None
argone = spicemanip.main(trigger.sb['args'], 1) argone = spicemanip.main(botcom.dict['args'], 1)
if str(argone).startswith("--") and len(str(argone)) > 2: if str(argone).startswith("--") and len(str(argone)) > 2:
if str(argone[2:]).isdigit(): if str(argone[2:]).isdigit():
trigger.sb["specified"] = int(argone[2:]) botcom.dict["specified"] = int(argone[2:])
elif SpiceBot.inlist(str(argone[2:]), validspecifides): elif SpiceBot.inlist(str(argone[2:]), validspecifides):
trigger.sb["specified"] = str(argone[2:]).lower() botcom.dict["specified"] = str(argone[2:]).lower()
elif SpiceBot.inlist(str(argone[2:]), trigger.sb["nonstockoptions"]): elif SpiceBot.inlist(str(argone[2:]), botcom.dict["nonstockoptions"]):
trigger.sb["specified"] = str(argone[2:]).lower() botcom.dict["specified"] = str(argone[2:]).lower()
trigger.sb["responsekey"] = trigger.sb["specified"] botcom.dict["responsekey"] = botcom.dict["specified"]
else: else:
try: try:
trigger.sb["specified"] = w2n.word_to_num(str(argone[1:])) botcom.dict["specified"] = w2n.word_to_num(str(argone[1:]))
trigger.sb["specified"] = int(trigger.sb["specified"]) botcom.dict["specified"] = int(botcom.dict["specified"])
except ValueError: except ValueError:
trigger.sb["specified"] = None botcom.dict["specified"] = None
if trigger.sb["specified"]: if botcom.dict["specified"]:
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list') botcom.dict['args'] = spicemanip.main(botcom.dict['args'], '2+', 'list')
# commands that can be updated # commands that can be updated
if trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"]:
if trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"] == "shared": if botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "shared":
SpiceBot.dictcoms.adjust_nick_array(str(SpiceBot.config.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), trigger.sb["dict"][trigger.sb["responsekey"]]["responses"], 'startup') SpiceBot.dictcoms.adjust_nick_array(str(SpiceBot.config.nick), 'sayings', botcom.dict["realcom"] + "_" + str(botcom.dict["responsekey"]), botcom.dict["dict"][botcom.dict["responsekey"]]["responses"], 'startup')
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = SpiceBot.db.get_nick_value(str(bot.nick), trigger.sb["dict"]["validcoms"][0] + "_" + str(trigger.sb["responsekey"]), 'sayings') or [] botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = SpiceBot.db.get_nick_value(str(bot.nick), botcom.dict["dict"]["validcoms"][0] + "_" + str(botcom.dict["responsekey"]), 'sayings') or []
elif trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"] == "user": elif botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "user":
SpiceBot.dictcoms.adjust_nick_array(str(trigger.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), trigger.sb["dict"][trigger.sb["responsekey"]]["responses"], 'startup') SpiceBot.dictcoms.adjust_nick_array(str(trigger.nick), 'sayings', botcom.dict["realcom"] + "_" + str(botcom.dict["responsekey"]), botcom.dict["dict"][botcom.dict["responsekey"]]["responses"], 'startup')
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = SpiceBot.db.get_nick_value(str(trigger.nick), trigger.sb["dict"]["validcoms"][0] + "_" + str(trigger.sb["responsekey"]), 'sayings') or [] botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = SpiceBot.db.get_nick_value(str(trigger.nick), botcom.dict["dict"]["validcoms"][0] + "_" + str(botcom.dict["responsekey"]), 'sayings') or []
if trigger.sb["specified"] == 'special': if botcom.dict["specified"] == 'special':
nonstockoptions = spicemanip.main(trigger.sb["nonstockoptions"], "andlist") nonstockoptions = spicemanip.main(botcom.dict["nonstockoptions"], "andlist")
return bot.osd("The special options for " + str(trigger.sb["realcom"]) + " command include: " + str(nonstockoptions) + ".") return bot.osd("The special options for " + str(botcom.dict["realcom"]) + " command include: " + str(nonstockoptions) + ".")
elif trigger.sb["specified"] == 'count': elif botcom.dict["specified"] == 'count':
return bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " command has " + str(len(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"])) + " entries.") return bot.osd("The " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " command has " + str(len(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"])) + " entries.")
elif trigger.sb["specified"] == 'view': elif botcom.dict["specified"] == 'view':
if trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] == []: if botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] == []:
return bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " command appears to have no entries!") return bot.osd("The " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " command appears to have no entries!")
else: else:
bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " command contains:", trigger.nick, 'notice') bot.osd("The " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " command contains:", trigger.nick, 'notice')
listnumb, relist = 1, [] listnumb, relist = 1, []
for item in trigger.sb["dict"][trigger.sb["responsekey"]]["responses"]: for item in botcom.dict["dict"][botcom.dict["responsekey"]]["responses"]:
if isinstance(item, dict): if isinstance(item, dict):
relist.append(str("[#" + str(listnumb) + "] COMPLEX dict Entry")) relist.append(str("[#" + str(listnumb) + "] COMPLEX dict Entry"))
elif isinstance(item, list): elif isinstance(item, list):
@ -101,143 +101,143 @@ def bot_dictcom_process(bot, trigger):
bot.osd(relist, trigger.nick) bot.osd(relist, trigger.nick)
return return
elif trigger.sb["specified"] == 'add': elif botcom.dict["specified"] == 'add':
if not trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"]: if not botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"]:
return bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list cannot be updated.") return bot.osd("The " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " entry list cannot be updated.")
fulltext = spicemanip.main(trigger.sb['args'], 0) fulltext = spicemanip.main(botcom.dict['args'], 0)
if not fulltext: if not fulltext:
return bot.osd("What would you like to add to the " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list?") return bot.osd("What would you like to add to the " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " entry list?")
if fulltext in trigger.sb["dict"][trigger.sb["responsekey"]]["responses"]: if fulltext in botcom.dict["dict"][botcom.dict["responsekey"]]["responses"]:
return bot.osd("The following was already in the " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list: '" + str(fulltext) + "'") return bot.osd("The following was already in the " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " entry list: '" + str(fulltext) + "'")
if trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"] == "shared": if botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "shared":
SpiceBot.dictcoms.adjust_nick_array(str(bot.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), fulltext, trigger.sb["specified"]) SpiceBot.dictcoms.adjust_nick_array(str(bot.nick), 'sayings', botcom.dict["realcom"] + "_" + str(botcom.dict["responsekey"]), fulltext, botcom.dict["specified"])
elif trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"] == "user": elif botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "user":
SpiceBot.dictcoms.adjust_nick_array(str(trigger.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), fulltext, trigger.sb["specified"]) SpiceBot.dictcoms.adjust_nick_array(str(trigger.nick), 'sayings', botcom.dict["realcom"] + "_" + str(botcom.dict["responsekey"]), fulltext, botcom.dict["specified"])
return bot.osd("The following was added to the " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list: '" + str(fulltext) + "'") return bot.osd("The following was added to the " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " entry list: '" + str(fulltext) + "'")
elif trigger.sb["specified"] in ['del', 'remove']: elif botcom.dict["specified"] in ['del', 'remove']:
if not trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"]: if not botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"]:
return bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list cannot be updated.") return bot.osd("The " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " entry list cannot be updated.")
fulltext = spicemanip.main(trigger.sb['args'], 0) fulltext = spicemanip.main(botcom.dict['args'], 0)
if not fulltext: if not fulltext:
return bot.osd("What would you like to remove from the " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list?") return bot.osd("What would you like to remove from the " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " entry list?")
if fulltext not in trigger.sb["dict"][trigger.sb["responsekey"]]["responses"]: if fulltext not in botcom.dict["dict"][botcom.dict["responsekey"]]["responses"]:
return bot.osd("The following was already not in the " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list: '" + str(fulltext) + "'") return bot.osd("The following was already not in the " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " entry list: '" + str(fulltext) + "'")
if trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"] == "shared": if botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "shared":
SpiceBot.dictcoms.adjust_nick_array(str(bot.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), fulltext, trigger.sb["specified"]) SpiceBot.dictcoms.adjust_nick_array(str(bot.nick), 'sayings', botcom.dict["realcom"] + "_" + str(botcom.dict["responsekey"]), fulltext, botcom.dict["specified"])
elif trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"] == "user": elif botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "user":
SpiceBot.dictcoms.adjust_nick_array(str(trigger.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), fulltext, trigger.sb["specified"]) SpiceBot.dictcoms.adjust_nick_array(str(trigger.nick), 'sayings', botcom.dict["realcom"] + "_" + str(botcom.dict["responsekey"]), fulltext, botcom.dict["specified"])
return bot.osd("The following was removed from the " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list: '" + str(fulltext) + "'") return bot.osd("The following was removed from the " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " entry list: '" + str(fulltext) + "'")
elif trigger.sb["specified"] and not trigger.sb["dict"][trigger.sb["responsekey"]]["selection_allowed"]: elif botcom.dict["specified"] and not botcom.dict["dict"][botcom.dict["responsekey"]]["selection_allowed"]:
return bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " response list cannot be specified.") return bot.osd("The " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " response list cannot be specified.")
trigger.sb["target"] = False botcom.dict["target"] = False
trigger.sb["success"] = True botcom.dict["success"] = True
if trigger.sb["dict"][trigger.sb["responsekey"]]["type"] in ['simple', 'fillintheblank', "target", 'targetplusreason', 'sayings', "readfromfile", "readfromurl", "ascii_art", "translate", "responses"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["type"] in ['simple', 'fillintheblank', "target", 'targetplusreason', 'sayings', "readfromfile", "readfromurl", "ascii_art", "translate", "responses"]:
return bot_dictcom_responses(bot, trigger) return bot_dictcom_responses(bot, trigger)
else: else:
command_function_run = str('bot_dictcom_' + trigger.sb["dict"][trigger.sb["responsekey"]]["type"] + '(bot, trigger)') command_function_run = str('bot_dictcom_' + botcom.dict["dict"][botcom.dict["responsekey"]]["type"] + '(bot, trigger, botcom)')
eval(command_function_run) eval(command_function_run)
def bot_dictcom_responses(bot, trigger): def bot_dictcom_responses(bot, trigger, botcom):
commandrunconsensus = [] commandrunconsensus = []
reaction = False reaction = False
# A target is required # A target is required
if trigger.sb["dict"][trigger.sb["responsekey"]]["target_required"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["target_required"]:
# try first term as a target # try first term as a target
posstarget = spicemanip.main(trigger.sb['args'], 1) or 0 posstarget = spicemanip.main(botcom.dict['args'], 1) or 0
targetbypass = trigger.sb["dict"][trigger.sb["responsekey"]]["target_bypass"] targetbypass = botcom.dict["dict"][botcom.dict["responsekey"]]["target_bypass"]
targetchecking = SpiceBot.users.target_check(bot, trigger, posstarget, targetbypass) targetchecking = SpiceBot.users.target_check(bot, trigger, posstarget, targetbypass)
if not targetchecking["targetgood"]: if not targetchecking["targetgood"]:
if trigger.sb["dict"][trigger.sb["responsekey"]]["target_backup"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["target_backup"]:
trigger.sb["target"] = trigger.sb["dict"][trigger.sb["responsekey"]]["target_backup"] botcom.dict["target"] = botcom.dict["dict"][botcom.dict["responsekey"]]["target_backup"]
if trigger.sb["target"] == 'instigator': if botcom.dict["target"] == 'instigator':
trigger.sb["target"] = trigger.nick botcom.dict["target"] = trigger.nick
elif trigger.sb["target"] == 'random': elif botcom.dict["target"] == 'random':
trigger.sb["target"] = SpiceBot.users.random_valid_target(bot, trigger, 'random') botcom.dict["target"] = SpiceBot.users.random_valid_target(bot, trigger, 'random')
else: else:
for reason in ['self', 'bot', 'bots', 'offline', 'unknown', 'privmsg', 'diffchannel', 'diffbot']: for reason in ['self', 'bot', 'bots', 'offline', 'unknown', 'privmsg', 'diffchannel', 'diffbot']:
if targetchecking["reason"] == reason and trigger.sb["dict"][trigger.sb["responsekey"]]["react_"+reason]: if targetchecking["reason"] == reason and botcom.dict["dict"][botcom.dict["responsekey"]]["react_"+reason]:
reaction = True reaction = True
commandrunconsensus.append(trigger.sb["dict"][trigger.sb["responsekey"]]["react_"+reason]) commandrunconsensus.append(botcom.dict["dict"][botcom.dict["responsekey"]]["react_"+reason])
if not reaction: if not reaction:
commandrunconsensus.append([targetchecking["error"]]) commandrunconsensus.append([targetchecking["error"]])
else: else:
trigger.sb["target"] = spicemanip.main(trigger.sb['args'], 1) botcom.dict["target"] = spicemanip.main(botcom.dict['args'], 1)
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list') botcom.dict['args'] = spicemanip.main(botcom.dict['args'], '2+', 'list')
# $blank input # $blank input
trigger.sb["completestring"] = spicemanip.main(trigger.sb['args'], 0) or '' botcom.dict["completestring"] = spicemanip.main(botcom.dict['args'], 0) or ''
if trigger.sb["dict"][trigger.sb["responsekey"]]["blank_required"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["blank_required"]:
if trigger.sb["completestring"] == '' or not trigger.sb["completestring"]: if botcom.dict["completestring"] == '' or not botcom.dict["completestring"]:
if trigger.sb["dict"][trigger.sb["responsekey"]]["blank_backup"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["blank_backup"]:
trigger.sb["completestring"] = trigger.sb["dict"][trigger.sb["responsekey"]]["blank_backup"] botcom.dict["completestring"] = botcom.dict["dict"][botcom.dict["responsekey"]]["blank_backup"]
else: else:
commandrunconsensus.append(trigger.sb["dict"][trigger.sb["responsekey"]]["blank_fail"]) commandrunconsensus.append(botcom.dict["dict"][botcom.dict["responsekey"]]["blank_fail"])
if trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"]:
if trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"] != []: if botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"] != []:
if spicemanip.main(trigger.sb["completestring"], 1).lower() not in trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"]: if spicemanip.main(botcom.dict["completestring"], 1).lower() not in botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"]:
trigger.sb["completestring"] = trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"][0] + " " + trigger.sb["completestring"] botcom.dict["completestring"] = botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"][0] + " " + botcom.dict["completestring"]
elif spicemanip.main(trigger.sb["completestring"], 1).lower() in trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"]: elif spicemanip.main(botcom.dict["completestring"], 1).lower() in botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"]:
if spicemanip.main(trigger.sb["completestring"], 1).lower() != trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"][0]: if spicemanip.main(botcom.dict["completestring"], 1).lower() != botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"][0]:
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list') botcom.dict['args'] = spicemanip.main(botcom.dict['args'], '2+', 'list')
if trigger.sb['args'] != []: if botcom.dict['args'] != []:
trigger.sb["completestring"] = trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"][0] + " " + spicemanip.main(trigger.sb['args'], 0) botcom.dict["completestring"] = botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"][0] + " " + spicemanip.main(botcom.dict['args'], 0)
if commandrunconsensus != []: if commandrunconsensus != []:
trigger.sb["success"] = False botcom.dict["success"] = False
if trigger.sb["dict"][trigger.sb["responsekey"]]["response_fail"] and not reaction: if botcom.dict["dict"][botcom.dict["responsekey"]]["response_fail"] and not reaction:
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = trigger.sb["dict"][trigger.sb["responsekey"]]["response_fail"] botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = botcom.dict["dict"][botcom.dict["responsekey"]]["response_fail"]
else: else:
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = commandrunconsensus[0] botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = commandrunconsensus[0]
bot_dictcom_reply_shared(bot, trigger) bot_dictcom_reply_shared(bot, trigger, botcom)
def bot_dictcom_reply_shared(bot, trigger): def bot_dictcom_reply_shared(bot, trigger, botcom):
if trigger.sb["specified"]: if botcom.dict["specified"]:
if trigger.sb["specified"] > len(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"]): if botcom.dict["specified"] > len(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"]):
currentspecified = len(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"]) currentspecified = len(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"])
else: else:
currentspecified = trigger.sb["specified"] currentspecified = botcom.dict["specified"]
trigger.sb["replies"] = spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"], currentspecified, 'return') botcom.dict["replies"] = spicemanip.main(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"], currentspecified, 'return')
trigger.sb["replynum"] = currentspecified botcom.dict["replynum"] = currentspecified
else: else:
trigger.sb["replies"] = spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"], 'random', 'return') botcom.dict["replies"] = spicemanip.main(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"], 'random', 'return')
try: try:
trigger.sb["replynum"] = trigger.sb["dict"][trigger.sb["responsekey"]]["responses"].index(trigger.sb["replies"]) botcom.dict["replynum"] = botcom.dict["dict"][botcom.dict["responsekey"]]["responses"].index(botcom.dict["replies"])
except Exception as e: except Exception as e:
trigger.sb["replynum"] = e botcom.dict["replynum"] = e
trigger.sb["replynum"] = 0 botcom.dict["replynum"] = 0
trigger.sb["replynum"] += 1 botcom.dict["replynum"] += 1
trigger.sb["totalreplies"] = len(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"]) botcom.dict["totalreplies"] = len(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"])
# This handles responses in list form # This handles responses in list form
if not isinstance(trigger.sb["replies"], list): if not isinstance(botcom.dict["replies"], list):
trigger.sb["replies"] = [trigger.sb["replies"]] botcom.dict["replies"] = [botcom.dict["replies"]]
for rply in trigger.sb["replies"]: for rply in botcom.dict["replies"]:
# replies that can be evaluated as code # replies that can be evaluated as code
if rply.startswith("time.sleep"): if rply.startswith("time.sleep"):
@ -246,31 +246,31 @@ def bot_dictcom_reply_shared(bot, trigger):
# random number # random number
if "$randnum" in rply: if "$randnum" in rply:
if trigger.sb["dict"][trigger.sb["responsekey"]]["randnum"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["randnum"]:
randno = randint(trigger.sb["dict"][trigger.sb["responsekey"]]["randnum"][0], trigger.sb["dict"][trigger.sb["responsekey"]]["randnum"][1]) randno = randint(botcom.dict["dict"][botcom.dict["responsekey"]]["randnum"][0], botcom.dict["dict"][botcom.dict["responsekey"]]["randnum"][1])
else: else:
randno = randint(0, 50) randno = randint(0, 50)
rply = rply.replace("$randnum", str(randno)) rply = rply.replace("$randnum", str(randno))
# blank # blank
if "$blank" in rply: if "$blank" in rply:
rply = rply.replace("$blank", trigger.sb["completestring"] or '') rply = rply.replace("$blank", botcom.dict["completestring"] or '')
# the remaining input # the remaining input
if "$input" in rply: if "$input" in rply:
rply = rply.replace("$input", spicemanip.main(trigger.sb['args'], 0) or trigger.sb["realcom"]) rply = rply.replace("$input", spicemanip.main(botcom.dict['args'], 0) or botcom.dict["realcom"])
# translation # translation
if trigger.sb["dict"][trigger.sb["responsekey"]]["translations"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["translations"]:
rply = SpiceBot.translate.bot_translate_process(rply, trigger.sb["dict"][trigger.sb["responsekey"]]["translations"]) rply = SpiceBot.translate.bot_translate_process(rply, botcom.dict["dict"][botcom.dict["responsekey"]]["translations"])
# text to precede the output # text to precede the output
if trigger.sb["dict"][trigger.sb["responsekey"]]["prefixtext"] and trigger.sb["success"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["prefixtext"] and botcom.dict["success"]:
rply = spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["prefixtext"], 'random') + rply rply = spicemanip.main(botcom.dict["dict"][botcom.dict["responsekey"]]["prefixtext"], 'random') + rply
# text to follow the output # text to follow the output
if trigger.sb["dict"][trigger.sb["responsekey"]]["suffixtext"] and trigger.sb["success"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["suffixtext"] and botcom.dict["success"]:
rply = rply + spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["suffixtext"], 'random') rply = rply + spicemanip.main(botcom.dict["dict"][botcom.dict["responsekey"]]["suffixtext"], 'random')
# trigger.nick # trigger.nick
if "$instigator" in rply: if "$instigator" in rply:
@ -294,7 +294,7 @@ def bot_dictcom_reply_shared(bot, trigger):
# target # target
if "$target" in rply: if "$target" in rply:
targetnames = trigger.sb["target"] or '' targetnames = botcom.dict["target"] or ''
if "$targets" in rply: if "$targets" in rply:
if targetnames.lower() == "your": if targetnames.lower() == "your":
targetnames = targetnames targetnames = targetnames
@ -309,23 +309,23 @@ def bot_dictcom_reply_shared(bot, trigger):
# smaller variations for the text # smaller variations for the text
if "$replyvariation" in rply: if "$replyvariation" in rply:
if trigger.sb["dict"][trigger.sb["responsekey"]]["replyvariation"] != []: if botcom.dict["dict"][botcom.dict["responsekey"]]["replyvariation"] != []:
variation = spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["replyvariation"], 'random') variation = spicemanip.main(botcom.dict["dict"][botcom.dict["responsekey"]]["replyvariation"], 'random')
rply = rply.replace("$replyvariation", variation) rply = rply.replace("$replyvariation", variation)
else: else:
rply = rply.replace("$replyvariation", '') rply = rply.replace("$replyvariation", '')
# smaller variations for the text # smaller variations for the text
if "$responsekey" in rply: if "$responsekey" in rply:
rply = rply.replace("$responsekey", str(trigger.sb["responsekey"])) rply = rply.replace("$responsekey", str(botcom.dict["responsekey"]))
if "$index" in rply: if "$index" in rply:
rply = rply.replace("$index", str(str(trigger.sb["replynum"]) + "/" + str(trigger.sb["totalreplies"]))) rply = rply.replace("$index", str(str(botcom.dict["replynum"]) + "/" + str(botcom.dict["totalreplies"])))
# display special options for this command # display special options for this command
if "$specialoptions" in rply: if "$specialoptions" in rply:
nonstockoptions = [] nonstockoptions = []
for command in trigger.sb["dict"].keys(): for command in botcom.dict["dict"].keys():
if command not in ["?default", "validcoms", "contributors", "author", "type", "filepath", "filename", "hardcoded_channel_block", "description", "exampleresponse", "example", "usage", "privs"]: if command not in ["?default", "validcoms", "contributors", "author", "type", "filepath", "filename", "hardcoded_channel_block", "description", "exampleresponse", "example", "usage", "privs"]:
nonstockoptions.append(command) nonstockoptions.append(command)
nonstockoptions = spicemanip.main(nonstockoptions, "andlist") nonstockoptions = spicemanip.main(nonstockoptions, "andlist")
@ -341,26 +341,26 @@ def bot_dictcom_reply_shared(bot, trigger):
bot.osd(rply, trigger.sender, rplytype) bot.osd(rply, trigger.sender, rplytype)
def bot_dictcom_gif(bot, trigger): def bot_dictcom_gif(bot, trigger, botcom):
if trigger.sb["dict"][trigger.sb["responsekey"]]["blank_required"] and not trigger.sb["completestring"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["blank_required"] and not botcom.dict["completestring"]:
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = trigger.sb["dict"][trigger.sb["responsekey"]]["blank_fail"] botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = botcom.dict["dict"][botcom.dict["responsekey"]]["blank_fail"]
return bot_dictcom_reply_shared(bot, trigger) return bot_dictcom_reply_shared(bot, trigger, botcom)
elif trigger.sb["dict"][trigger.sb["responsekey"]]["blank_required"] and trigger.sb["completestring"]: elif botcom.dict["dict"][botcom.dict["responsekey"]]["blank_required"] and botcom.dict["completestring"]:
queries = [trigger.sb["completestring"]] queries = [botcom.dict["completestring"]]
else: else:
queries = trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] queries = botcom.dict["dict"][botcom.dict["responsekey"]]["responses"]
# which api's are we using to search # which api's are we using to search
if "queryapi" in trigger.sb["dict"].keys(): if "queryapi" in botcom.dict["dict"].keys():
searchapis = trigger.sb["dict"][trigger.sb["responsekey"]]["queryapi"] searchapis = botcom.dict["dict"][botcom.dict["responsekey"]]["queryapi"]
else: else:
searchapis = list(SpiceBot.gif.valid_api.keys()) searchapis = list(SpiceBot.gif.valid_api.keys())
if trigger.sb["specified"]: if botcom.dict["specified"]:
if trigger.sb["specified"] > len(queries): if botcom.dict["specified"] > len(queries):
trigger.sb["specified"] = len(queries) botcom.dict["specified"] = len(queries)
query = spicemanip.main(queries, trigger.sb["specified"], 'return') query = spicemanip.main(queries, botcom.dict["specified"], 'return')
else: else:
query = spicemanip.main(queries, 'random', 'return') query = spicemanip.main(queries, 'random', 'return')
@ -374,18 +374,18 @@ def bot_dictcom_gif(bot, trigger):
gifdict = SpiceBot.gif.get_gif(searchdict) gifdict = SpiceBot.gif.get_gif(searchdict)
if gifdict["error"]: if gifdict["error"]:
trigger.sb["success"] = False botcom.dict["success"] = False
if trigger.sb["dict"][trigger.sb["responsekey"]]["search_fail"]: if botcom.dict["dict"][botcom.dict["responsekey"]]["search_fail"]:
gifdict["error"] = trigger.sb["dict"][trigger.sb["responsekey"]]["search_fail"] gifdict["error"] = botcom.dict["dict"][botcom.dict["responsekey"]]["search_fail"]
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = [gifdict["error"]] botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = [gifdict["error"]]
else: else:
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = [str(gifdict['gifapi'].title() + " Result (" + str(query) + " #" + str(gifdict["returnnum"]) + "): " + str(gifdict["returnurl"]))] botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = [str(gifdict['gifapi'].title() + " Result (" + str(query) + " #" + str(gifdict["returnnum"]) + "): " + str(gifdict["returnurl"]))]
trigger.sb["specified"] = False botcom.dict["specified"] = False
bot_dictcom_reply_shared(bot, trigger) bot_dictcom_reply_shared(bot, trigger, botcom)
def bot_dictcom_feeds(bot, trigger): def bot_dictcom_feeds(bot, trigger, botcom):
return bot.osd("WIP") return bot.osd("WIP")
""" """
@ -394,7 +394,7 @@ def bot_dictcom_feeds(bot, trigger):
bot_startup_requirements_set(bot, "feeds") bot_startup_requirements_set(bot, "feeds")
feed = trigger.sb["dict"][trigger.sb["responsekey"]]["responses"][0] feed = botcom.dict["dict"][botcom.dict["responsekey"]]["responses"][0]
if feed not in bot.memory['feeds'].keys(): if feed not in bot.memory['feeds'].keys():
return bot.osd(feed + " does not appear to be a valid feed.") return bot.osd(feed + " does not appear to be a valid feed.")
@ -407,5 +407,5 @@ def bot_dictcom_feeds(bot, trigger):
""" """
def bot_dictcom_search(bot, trigger): def bot_dictcom_search(bot, trigger, botcom):
bot.say("testing done") bot.say("testing done")

20
sopel_modules/SpiceBot_Core_Commands/Gif.py
View File

@ -15,17 +15,17 @@ import spicemanip
@sopel.module.commands('gif') @sopel.module.commands('gif')
def gif_trigger(bot, trigger, botcom): def gif_trigger(bot, trigger, botcom):
if not len(trigger.sb['args']): if not len(botcom.dict['args']):
return SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Please present a query to search.") return SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Please present a query to search.")
query = spicemanip.main(trigger.sb['args'], 0) query = spicemanip.main(botcom.dict['args'], 0)
searchapis = list(SpiceBot.gif.valid_api.keys()) searchapis = list(SpiceBot.gif.valid_api.keys())
searchdict = {"query": query, "gifsearch": searchapis} searchdict = {"query": query, "gifsearch": searchapis}
gifdict = SpiceBot.gif.get_gif(searchdict) gifdict = SpiceBot.gif.get_gif(searchdict)
if gifdict["error"]: if gifdict["error"]:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], gifdict["error"]) SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], gifdict["error"])
else: else:
bot.osd(str(gifdict['gifapi'].title() + " Result (" + str(query) + " #" + str(gifdict["returnnum"]) + "): " + str(gifdict["returnurl"]))) bot.osd(str(gifdict['gifapi'].title() + " Result (" + str(query) + " #" + str(gifdict["returnnum"]) + "): " + str(gifdict["returnurl"])))
@ -34,18 +34,18 @@ def gif_trigger(bot, trigger, botcom):
@sopel.module.commands('(.*)') @sopel.module.commands('(.*)')
def gifapi_triggers(bot, trigger, botcom): def gifapi_triggers(bot, trigger, botcom):
if trigger.sb['com'] not in list(SpiceBot.gif.valid_api.keys()): if botcom.dict['com'] not in list(SpiceBot.gif.valid_api.keys()):
return return
if not len(trigger.sb['args']): if not len(botcom.dict['args']):
return SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Please present a query to search.") return SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Please present a query to search.")
query = spicemanip.main(trigger.sb['args'], 0) query = spicemanip.main(botcom.dict['args'], 0)
searchdict = {"query": query, "gifsearch": trigger.sb['com']} searchdict = {"query": query, "gifsearch": botcom.dict['com']}
gifdict = SpiceBot.gif.get_gif(searchdict) gifdict = SpiceBot.gif.get_gif(searchdict)
if gifdict["error"]: if gifdict["error"]:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], gifdict["error"]) SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], gifdict["error"])
else: else:
bot.osd(str(gifdict['gifapi'].title() + " Result (" + str(query) + " #" + str(gifdict["returnnum"]) + "): " + str(gifdict["returnurl"]))) bot.osd(str(gifdict['gifapi'].title() + " Result (" + str(query) + " #" + str(gifdict["returnnum"]) + "): " + str(gifdict["returnurl"])))

10
sopel_modules/SpiceBot_Core_Commands/Logs.py
View File

@ -17,10 +17,10 @@ import sopel_modules.SpiceBot as SpiceBot
def bot_command_logs(bot, trigger, botcom): def bot_command_logs(bot, trigger, botcom):
if not SpiceBot.command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']): if not SpiceBot.command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "I was unable to process this Bot Nick command due to privilege issues.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "I was unable to process this Bot Nick command due to privilege issues.")
return return
logtype = spicemanip.main(trigger.sb['args'], 1) or None logtype = spicemanip.main(botcom.dict['args'], 1) or None
if not logtype: if not logtype:
bot.osd("Current valid log(s) include: " + spicemanip.main(list(SpiceBot.logs.dict["list"].keys()), 'andlist'), trigger.sender, 'action') bot.osd("Current valid log(s) include: " + spicemanip.main(list(SpiceBot.logs.dict["list"].keys()), 'andlist'), trigger.sender, 'action')
return return
@ -28,9 +28,9 @@ def bot_command_logs(bot, trigger, botcom):
if not SpiceBot.inlist(logtype, list(SpiceBot.logs.dict["list"].keys())): if not SpiceBot.inlist(logtype, list(SpiceBot.logs.dict["list"].keys())):
closestmatches = SpiceBot.similar_list(logtype, list(SpiceBot.logs.dict["list"].keys()), 10, 'reverse') closestmatches = SpiceBot.similar_list(logtype, list(SpiceBot.logs.dict["list"].keys()), 10, 'reverse')
if not len(closestmatches): if not len(closestmatches):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "No valid logs match " + str(logtype) + ".", trigger.nick, 'notice') SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "No valid logs match " + str(logtype) + ".", trigger.nick, 'notice')
else: else:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "The following commands may match " + str(logtype) + ": " + spicemanip.main(closestmatches, 'andlist') + ".", trigger.nick, 'notice') SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "The following commands may match " + str(logtype) + ": " + spicemanip.main(closestmatches, 'andlist') + ".", trigger.nick, 'notice')
return return
@ -39,7 +39,7 @@ def bot_command_logs(bot, trigger, botcom):
logindex = SpiceBot.logs.get_logs(logtype) logindex = SpiceBot.logs.get_logs(logtype)
if not len(logindex): if not len(logindex):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "No logs found for " + str(logtype) + ".") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "No logs found for " + str(logtype) + ".")
return return
bot.osd("Is Examining " + str(logtype) + " log(s).") bot.osd("Is Examining " + str(logtype) + " log(s).")

30
sopel_modules/SpiceBot_Core_Commands/Messaging.py
View File

@ -12,42 +12,42 @@ import sopel_modules.SpiceBot as SpiceBot
@SpiceBot.prerun('nickname') @SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('action') @sopel.module.nickname_commands('action')
def bot_command_action(bot, trigger, botcom): def bot_command_action(bot, trigger, botcom):
bot_command_process(bot, trigger) bot_command_process(bot, trigger, botcom)
@SpiceBot.prerun('nickname') @SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('notice') @sopel.module.nickname_commands('notice')
def bot_command_notice(bot, trigger, botcom): def bot_command_notice(bot, trigger, botcom):
bot_command_process(bot, trigger) bot_command_process(bot, trigger, botcom)
@SpiceBot.prerun('nickname') @SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('privmsg', 'say', 'msg') @sopel.module.nickname_commands('privmsg', 'say', 'msg')
def bot_command_privmsg(bot, trigger, botcom): def bot_command_privmsg(bot, trigger, botcom):
bot_command_process(bot, trigger) bot_command_process(bot, trigger, botcom)
def bot_command_process(bot, trigger): def bot_command_process(bot, trigger, botcom):
if not SpiceBot.command_permissions_check(bot, trigger, ['admins', 'owner']): if not SpiceBot.command_permissions_check(bot, trigger, ['admins', 'owner']):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "I was unable to process this Bot Nick command due to privilege issues.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "I was unable to process this Bot Nick command due to privilege issues.")
return return
if trigger.sb['com'] in ['say', 'msg']: if botcom.dict['com'] in ['say', 'msg']:
trigger.sb['com'] = 'privmsg' botcom.dict['com'] = 'privmsg'
if not len(trigger.sb['args']): if not len(botcom.dict['args']):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "You must specify a channel or nick.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "You must specify a channel or nick.")
return return
target = spicemanip.main(trigger.sb['args'], 1) target = spicemanip.main(botcom.dict['args'], 1)
if (target not in ['allchans', 'allnicks'] if (target not in ['allchans', 'allnicks']
and not SpiceBot.inlist(target.lower(), list(SpiceBot.channels.dict['list'].keys())) and not SpiceBot.inlist(target.lower(), list(SpiceBot.channels.dict['list'].keys()))
and not SpiceBot.inlist(target.lower(), bot.users)): and not SpiceBot.inlist(target.lower(), bot.users)):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Channel/nick name {} not valid.".format(target)) SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Channel/nick name {} not valid.".format(target))
return return
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list') botcom.dict['args'] = spicemanip.main(botcom.dict['args'], '2+', 'list')
if target == 'allchans': if target == 'allchans':
targetsendlist = list(bot.channels.keys()) targetsendlist = list(bot.channels.keys())
@ -56,9 +56,9 @@ def bot_command_process(bot, trigger):
else: else:
targetsendlist = [target] targetsendlist = [target]
botmessage = spicemanip.main(trigger.sb['args'], 0) botmessage = spicemanip.main(botcom.dict['args'], 0)
if not botmessage: if not botmessage:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "You must specify a message to send.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "You must specify a message to send.")
return return
bot.osd(botmessage, targetsendlist, trigger.sb['com'].upper()) bot.osd(botmessage, targetsendlist, botcom.dict['com'].upper())

12
sopel_modules/SpiceBot_Core_Commands/Runtime_Controls.py
View File

@ -14,19 +14,19 @@ import sopel_modules.SpiceBot as SpiceBot
def nickname_comand_update(bot, trigger, botcom): def nickname_comand_update(bot, trigger, botcom):
if not SpiceBot.command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']): if not SpiceBot.command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "I was unable to process this Bot Nick command due to privilege issues.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "I was unable to process this Bot Nick command due to privilege issues.")
return return
if not len(trigger.sb['args']): if not len(botcom.dict['args']):
commandused = 'nodeps' commandused = 'nodeps'
else: else:
commandused = spicemanip.main(trigger.sb['args'], 1).lower() commandused = spicemanip.main(botcom.dict['args'], 1).lower()
if commandused not in ['deps', 'nodeps']: if commandused not in ['deps', 'nodeps']:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Please specify deps or nodeps") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Please specify deps or nodeps")
return return
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list') botcom.dict['args'] = spicemanip.main(botcom.dict['args'], '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.logs.log('SpiceBot_Update', quitmessage) SpiceBot.logs.log('SpiceBot_Update', quitmessage)
@ -46,7 +46,7 @@ def nickname_comand_update(bot, trigger, botcom):
def nickname_comand_restart(bot, trigger, botcom): def nickname_comand_restart(bot, trigger, botcom):
if not trigger.admin: if not trigger.admin:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "You are not authorized to perform this function.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "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.logs.log('SpiceBot_Restart', quitmessage) SpiceBot.logs.log('SpiceBot_Restart', quitmessage)

24
sopel_modules/SpiceBot_Core_Commands/Search.py
View File

@ -14,14 +14,14 @@ import sopel_modules.SpiceBot as SpiceBot
@sopel.module.commands('search', 'find', 'google', 'lookup') @sopel.module.commands('search', 'find', 'google', 'lookup')
def search_main(bot, trigger, botcom): def search_main(bot, trigger, botcom):
searchterm = spicemanip.main(trigger.sb['args'], 0) or None searchterm = spicemanip.main(botcom.dict['args'], 0) or None
if not searchterm: if not searchterm:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Not sure what you want me to look for.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Not sure what you want me to look for.")
return return
searchreturn = SpiceBot.google.search(searchterm) searchreturn = SpiceBot.google.search(searchterm)
if not searchreturn: if not searchreturn:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], 'I cannot find anything about that') SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], 'I cannot find anything about that')
else: else:
bot.osd(["[Information search for '" + str(searchterm) + "']", str(searchreturn)]) bot.osd(["[Information search for '" + str(searchterm) + "']", str(searchreturn)])
@ -30,14 +30,14 @@ def search_main(bot, trigger, botcom):
@sopel.module.commands("where", "whereis") @sopel.module.commands("where", "whereis")
def search_where(bot, trigger, botcom): def search_where(bot, trigger, botcom):
searchterm = spicemanip.main(trigger.sb['args'], 0) or None searchterm = spicemanip.main(botcom.dict['args'], 0) or None
if not searchterm: if not searchterm:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Not sure what you want me to look for.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Not sure what you want me to look for.")
return return
searchreturn = SpiceBot.google.search(searchterm, 'maps') searchreturn = SpiceBot.google.search(searchterm, 'maps')
if not searchreturn: if not searchreturn:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], 'I cannot find anything about that') SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], 'I cannot find anything about that')
else: else:
bot.osd(["[Location search for " + str(searchterm) + "]", str(searchreturn)]) bot.osd(["[Location search for " + str(searchterm) + "]", str(searchreturn)])
@ -46,14 +46,14 @@ def search_where(bot, trigger, botcom):
@sopel.module.commands("what", "whatis") @sopel.module.commands("what", "whatis")
def search_what(bot, trigger, botcom): def search_what(bot, trigger, botcom):
searchterm = spicemanip.main(trigger.sb['args'], 0) or None searchterm = spicemanip.main(botcom.dict['args'], 0) or None
if not searchterm: if not searchterm:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Not sure what you want me to look for.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Not sure what you want me to look for.")
return return
searchreturn = SpiceBot.google.search(searchterm) searchreturn = SpiceBot.google.search(searchterm)
if not searchreturn: if not searchreturn:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], 'I cannot find anything about that') SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], 'I cannot find anything about that')
else: else:
bot.osd(["[Information search for '" + str(searchterm) + "']", str(searchreturn)]) bot.osd(["[Information search for '" + str(searchterm) + "']", str(searchreturn)])
@ -62,13 +62,13 @@ def search_what(bot, trigger, botcom):
@sopel.module.commands("youtube", "video") @sopel.module.commands("youtube", "video")
def search_video(bot, trigger, botcom): def search_video(bot, trigger, botcom):
searchterm = spicemanip.main(trigger.sb['args'], 0) or None searchterm = spicemanip.main(botcom.dict['args'], 0) or None
if not searchterm: if not searchterm:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Not sure what you want me to look for.") SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Not sure what you want me to look for.")
return return
searchreturn = SpiceBot.google.search(searchterm, 'youtube') searchreturn = SpiceBot.google.search(searchterm, 'youtube')
if not searchreturn: if not searchreturn:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], 'I cannot find anything about that') SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], 'I cannot find anything about that')
else: else:
bot.osd(["[Youtube search for '" + str(searchterm) + "']", str(searchreturn)]) bot.osd(["[Youtube search for '" + str(searchterm) + "']", str(searchreturn)])

6
sopel_modules/SpiceBot_Core_Commands/Sherlock.py
View File

@ -15,15 +15,15 @@ def bot_command_sherlock(bot, trigger, botcom):
netlist = list(SpiceBot.sherlock.dict.keys()) netlist = list(SpiceBot.sherlock.dict.keys())
username = spicemanip.main(trigger.sb["args"], 1) or trigger.nick username = spicemanip.main(botcom.dict["args"], 1) or trigger.nick
trigger.sb["args"] = spicemanip.main(trigger.sb["args"], "2+", 'list') botcom.dict["args"] = spicemanip.main(botcom.dict["args"], "2+", 'list')
checklist = netlist checklist = netlist
checklistname = 'all' checklistname = 'all'
if SpiceBot.inlist(username, netlist): if SpiceBot.inlist(username, netlist):
checklistname = SpiceBot.inlist_match(username, netlist) checklistname = SpiceBot.inlist_match(username, netlist)
checklist = [checklistname] checklist = [checklistname]
username = spicemanip.main(trigger.sb["args"], 1) or trigger.nick username = spicemanip.main(botcom.dict["args"], 1) or trigger.nick
bot.osd("Checking username " + username + " in " + checklistname + " network.") bot.osd("Checking username " + username + " in " + checklistname + " network.")