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

Merge pull request #100 from deathbybandaid/development

Browse Source 
Development
This commit is contained in:
Deathbybandaid 2019-07-10 08:31:12 -04:00 committed by GitHub
commit fabd637540
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
30 changed files with 1376 additions and 568 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
sopel_modules/SpiceBot/AI.py
View File

@ -15,7 +15,7 @@ from .Database import db as botdb
from .Config import config as botconfig
from .Read import read as botread
import spicemanip
from sopel_modules.spicemanip import spicemanip
class SpiceBot_AI_MainSection(StaticSection):
@ -138,18 +138,18 @@ class SpiceBot_AI():
# bot items
for botitem in ["nick"]:
messagelist = spicemanip.main(message, "create")
messagelist = spicemanip(message, "create")
for i in range(len(messagelist)):
if messagelist[i].upper() == str(eval("bot." + botitem)).upper():
messagelist[i] = str("bot" + botitem).upper()
message = spicemanip.main(messagelist, 0)
message = spicemanip(messagelist, 0)
for triggeritem in ["nick", "sender"]:
messagelist = spicemanip.main(message, "create")
messagelist = spicemanip(message, "create")
for i in range(len(messagelist)):
if messagelist[i].upper() == str(eval("trigger." + botitem)).upper():
messagelist[i] = str("trigger" + botitem).upper()
message = spicemanip.main(messagelist, 0)
message = spicemanip(messagelist, 0)
return message

86
sopel_modules/SpiceBot/Commands.py
View File

@ -13,7 +13,7 @@ import os
import threading
import copy
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules
from .Logs import logs
@ -43,6 +43,7 @@ class BotCommands():
},
'disabled': {},
}
self.todo_list = []
self.module_files_parse()
self.nickrules()
for comtype in ['module', 'nickname', 'rule']:
@ -196,7 +197,7 @@ class BotCommands():
maincom = command_dict["validcoms"][0]
if len(command_dict["validcoms"]) > 1:
comaliases = spicemanip.main(command_dict["validcoms"], '2+', 'list')
comaliases = spicemanip(command_dict["validcoms"], '2+', 'list')
else:
comaliases = []
@ -271,15 +272,16 @@ class BotCommands():
foldername = str(folderpath).split("/")[-1]
# check for json reference file
validcomdict = botread.module_json_to_dict(str(modulefile))
comdict = botread.module_json_to_dict(str(modulefile))
# replace json defaults
validcomdict["filepath"] = str(modulefile)
validcomdict["filename"] = str(filename_base)
validcomdict["folderpath"] = str(folderpath)
validcomdict["foldername"] = str(foldername)
comdict["filepath"] = str(modulefile)
comdict["filename"] = str(filename_base)
comdict["folderpath"] = str(folderpath)
comdict["foldername"] = str(foldername)
detected_lines = []
todo_list = []
for line in module_file_lines:
if str(line).startswith("@"):
@ -302,46 +304,58 @@ class BotCommands():
if line:
detected_lines.append(line)
elif "TODO" in str(line):
todo_list.append(str(line))
if len(todo_list):
self.todo_list.extend(todo_list)
if len(detected_lines):
filelinelist = []
currentsuccesslines = 0
for detected_line in detected_lines:
try:
validcomdict = copy.deepcopy(comdict)
# Commands
if str(detected_line).startswith("commands"):
comtype = "module"
validcomdict["TODO"] = todo_list
# Commands
if str(detected_line).startswith("commands"):
comtype = "module"
try:
validcoms = eval(str(detected_line).split("commands")[-1])
elif str(detected_line).startswith("nickname_commands"):
comtype = "nickname"
except Exception as e:
validcoms = e
validcoms = []
elif str(detected_line).startswith("nickname_commands"):
comtype = "nickname"
try:
validcoms = eval(str(detected_line).split("nickname_commands")[-1])
elif str(detected_line).startswith("rule"):
comtype = "rule"
except Exception as e:
validcoms = e
validcoms = []
elif str(detected_line).startswith("rule"):
comtype = "rule"
try:
validcoms = eval(str(detected_line).split("rule")[-1])
except Exception as e:
validcoms = e
validcoms = []
if isinstance(validcoms, tuple):
validcoms = list(validcoms)
else:
validcoms = [validcoms]
for regexcom in ["(.*)", '^\?(.*)']:
if regexcom in validcoms:
while regexcom in validcoms:
validcoms.remove(regexcom)
if isinstance(validcoms, tuple):
validcoms = list(validcoms)
if not isinstance(validcoms, list):
validcoms = [validcoms]
for regexcom in ["(.*)", '^\?(.*)']:
if regexcom in validcoms:
while regexcom in validcoms:
validcoms.remove(regexcom)
if len(validcoms):
validcomdict["comtype"] = comtype
validcomdict["validcoms"] = validcoms
filelinelist.append(validcomdict)
currentsuccesslines += 1
except Exception as e:
addnothing = e
if addnothing:
currentsuccesslines += 0
if len(validcoms):
validcomdict["comtype"] = comtype
validcomdict["validcoms"] = validcoms
filelinelist.append(validcomdict)
if len(filelinelist):
for vcomdict in filelinelist:
self.register(vcomdict)
self.register(validcomdict)
commands = BotCommands()

8
sopel_modules/SpiceBot/Gif.py
View File

@ -8,7 +8,7 @@ from .Config import config as botconfig
from .Read import read as botread
from .Commands import commands as botcommands
import spicemanip
from sopel_modules.spicemanip import spicemanip
from fake_useragent import UserAgent
import urllib
@ -134,13 +134,13 @@ class BotGif():
gifapiresults.extend(self.valid_api[currentapi]["cache"][searchdict["searchquery"].lower()])
if not len(gifapiresults):
return {"error": "No Results were found for '" + searchdict["query"] + "' in the " + str(spicemanip.main(searchdict['gifsearch'], 'orlist')) + " api(s)"}
return {"error": "No Results were found for '" + searchdict["query"] + "' in the " + str(spicemanip(searchdict['gifsearch'], 'orlist')) + " api(s)"}
random.shuffle(gifapiresults)
random.shuffle(gifapiresults)
randombad = True
while randombad:
gifdict = spicemanip.main(gifapiresults, "random")
gifdict = spicemanip(gifapiresults, "random")
try:
gifpage = requests.get(gifdict["returnurl"], headers=None)
@ -159,7 +159,7 @@ class BotGif():
gifapiresults = newlist
if not len(gifapiresults):
return {"error": "No Results were found for '" + searchdict["query"] + "' in the " + str(spicemanip.main(searchdict['gifsearch'], 'orlist')) + " api(s)"}
return {"error": "No Results were found for '" + searchdict["query"] + "' in the " + str(spicemanip(searchdict['gifsearch'], 'orlist')) + " api(s)"}
# return dict
gifdict['error'] = None

6
sopel_modules/SpiceBot/Logs.py
View File

@ -9,7 +9,7 @@ This Class stores logs in an easy to access manner
import threading
import os
import sys
import spicemanip
from sopel_modules.spicemanip import spicemanip
from .Config import config as botconfig
@ -98,7 +98,7 @@ class BotLogs():
else:
if not line.startswith(tuple(stdio_ignore)) and not line.isspace():
debuglines.append(str(line))
loadedmodules = "Loaded: " + spicemanip.main(loadedmodules, 'andlist')
loadedmodules = "Loaded: " + spicemanip(loadedmodules, 'andlist')
debuglines.insert(1, loadedmodules)
return debuglines
@ -110,7 +110,7 @@ class BotLogs():
line = str(line).split(str(os.uname()[1] + " "))[-1]
lineparts = str(line).split(": ")
del lineparts[0]
line = spicemanip.main(lineparts, 0)
line = spicemanip(lineparts, 0)
if not line.isspace():
debuglines.append(str(line))
return debuglines

368
sopel_modules/SpiceBot/Prerun.py
View File

@ -9,8 +9,9 @@ from sopel.tools import Identifier
import functools
import copy
import datetime
from word2number import w2n
import spicemanip
from sopel_modules.spicemanip import spicemanip
from .Tools import command_permissions_check, class_create
from .Commands import commands as botcommands
@ -40,7 +41,7 @@ def prerun(t_command_type='module', t_command_subtype=None):
botcom = class_create('botcom')
if t_command_type == "nickname":
check_nick = spicemanip.main(trigger.args[1], 1).lower()
check_nick = spicemanip(trigger.args[1], 1).lower()
if check_nick != str(bot.nick).lower():
return
else:
@ -52,7 +53,7 @@ def prerun(t_command_type='module', t_command_subtype=None):
# Primary command used for trigger, and a list of all words
trigger_args, trigger_command, trigger_prefix = make_trigger_args(trigger.args[1], trigger_command_type)
if trigger_prefix == botconfig.SpiceBot_Commands.query_prefix:
if trigger_prefix in [botconfig.SpiceBot_Commands.query_prefix]:
return
trigger_command_type = botcommands.find_command_type(trigger_command)
@ -87,7 +88,7 @@ def prerun(t_command_type='module', t_command_subtype=None):
# split into && groupings
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)
# Run the function for all splits
@ -95,17 +96,15 @@ def prerun(t_command_type='module', t_command_subtype=None):
runcount = 0
for argsdict in argsdict_list:
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"])
if not trigger.sb["hyphen_arg"]:
# check if anything prohibits the nick from running the command
if trigger_runstatus(bot, trigger):
botcom.dict["args"], botcom.dict["hyphen_arg"] = trigger_hyphen_args(botcom.dict["args"])
args_pass = trigger_hyphen_arg_handler(bot, trigger, botcom)
if args_pass:
if trigger_runstatus(bot, trigger, botcom):
function(bot, trigger, botcom, *args, **kwargs)
else:
trigger_hyphen_arg_handler(bot, trigger)
botmessagelog.messagelog_exit(bot, argsdict_default["log_id"])
return internal_prerun
@ -130,7 +129,7 @@ def prerun_query(t_command_type='module', t_command_subtype=None):
botcom = class_create('botcom')
if t_command_type == "nickname":
check_nick = spicemanip.main(trigger.args[1], 1).lower()
check_nick = spicemanip(trigger.args[1], 1).lower()
if check_nick != str(bot.nick).lower():
return
else:
@ -165,18 +164,18 @@ def prerun_query(t_command_type='module', t_command_subtype=None):
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)
# Run the function for all splits
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
if trigger_runstatus_query(bot, trigger):
if trigger_runstatus_query(bot, trigger, botcom):
function(bot, trigger, botcom, *args, **kwargs)
botmessagelog.messagelog_exit(bot, argsdict_default["log_id"])
@ -208,22 +207,22 @@ def verify_channel(trigger):
def make_trigger_args(triggerargs_one, trigger_command_type='module'):
trigger_args = spicemanip.main(triggerargs_one, 'create')
trigger_args = spicemanip(triggerargs_one, 'create')
if trigger_command_type in ['nickname']:
trigger_prefix = spicemanip.main(trigger_args, 2).lower()[0]
trigger_prefix = spicemanip(trigger_args, 2).lower()[0]
if trigger_prefix.isupper() or trigger_prefix.islower():
trigger_prefix = None
trigger_command = spicemanip.main(trigger_args, 2).lower()
trigger_args = spicemanip.main(trigger_args, '3+', 'list')
trigger_command = spicemanip(trigger_args, 2).lower()
trigger_args = spicemanip(trigger_args, '3+', 'list')
else:
trigger_prefix = spicemanip.main(trigger_args, 1).lower()[0]
trigger_command = spicemanip.main(trigger_args, 1).lower()[1:]
trigger_args = spicemanip.main(trigger_args, '2+', 'list')
trigger_prefix = spicemanip(trigger_args, 1).lower()[0]
trigger_command = spicemanip(trigger_args, 1).lower()[1:]
trigger_args = spicemanip(trigger_args, '2+', 'list')
return trigger_args, trigger_command, trigger_prefix
def trigger_and_split(trigger_args):
trigger_args_list_split = spicemanip.main(trigger_args, "split_&&")
trigger_args_list_split = spicemanip(trigger_args, "split_&&")
if not len(trigger_args_list_split):
trigger_args_list_split.append([])
return trigger_args_list_split
@ -233,11 +232,11 @@ def trigger_argsdict_list(argsdict_default, and_split):
prerun_split = []
for trigger_args_part in and_split:
argsdict_part = copy.deepcopy(argsdict_default)
argsdict_part["args"] = spicemanip.main(trigger_args_part, 'create')
argsdict_part["args"] = spicemanip(trigger_args_part, 'create')
if len(argsdict_part["args"]) and (argsdict_part["args"][0] == "-a" or argsdict_part["args"][-1] == "-a"):
argsdict_part["adminswitch"] = True
if argsdict_part["args"][0] == "-a":
argsdict_part["args"] = spicemanip.main(argsdict_part["args"], '2+', 'list')
argsdict_part["args"] = spicemanip(argsdict_part["args"], '2+', 'list')
elif argsdict_part["args"][-1] == "-a":
del argsdict_part["args"][-1]
else:
@ -248,11 +247,11 @@ def trigger_argsdict_list(argsdict_default, and_split):
def trigger_argsdict_single(argsdict_default, trigger_args_part):
argsdict_part = copy.deepcopy(argsdict_default)
argsdict_part["args"] = spicemanip.main(trigger_args_part, 'create')
argsdict_part["args"] = spicemanip(trigger_args_part, 'create')
if len(argsdict_part["args"]) and (argsdict_part["args"][0] == "-a" or argsdict_part["args"][-1] == "-a"):
argsdict_part["adminswitch"] = True
if argsdict_part["args"][0] == "-a":
argsdict_part["args"] = spicemanip.main(argsdict_part["args"], '2+', 'list')
argsdict_part["args"] = spicemanip(argsdict_part["args"], '2+', 'list')
elif argsdict_part["args"][-1] == "-a":
del argsdict_part["args"][-1]
else:
@ -260,18 +259,18 @@ def trigger_argsdict_single(argsdict_default, trigger_args_part):
return argsdict_part
def trigger_runstatus_query(bot, trigger):
def trigger_runstatus_query(bot, trigger, botcom):
# Bots can't run commands
if Identifier(trigger.nick) == bot.nick:
return False
# 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']):
return True
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
# don't run commands that are disabled in channels
@ -288,101 +287,105 @@ def trigger_runstatus_query(bot, trigger):
# don't run commands that are disabled in channels
if not trigger.is_privmsg:
channel_disabled_list = botcommands.get_commands_disabled(str(trigger.sender))
if trigger.sb["realcomref"] in list(channel_disabled_list.keys()):
reason = channel_disabled_list[trigger.sb["realcomref"]]["reason"]
timestamp = channel_disabled_list[trigger.sb["realcomref"]]["timestamp"]
bywhom = channel_disabled_list[trigger.sb["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)
return trigger_cant_run(bot, trigger, message)
if botcom.dict["realcomref"] in list(channel_disabled_list.keys()):
reason = channel_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = channel_disabled_list[botcom.dict["realcomref"]]["timestamp"]
bywhom = channel_disabled_list[botcom.dict["realcomref"]]["disabledby"]
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, botcom, message)
# don't run commands that are disabled for specific users
nick_disabled_list = botcommands.get_commands_disabled(str(trigger.nick))
if trigger.sb["realcomref"] in list(nick_disabled_list.keys()):
bywhom = nick_disabled_list[trigger.sb["realcomref"]]["disabledby"]
if botcom.dict["realcomref"] in list(nick_disabled_list.keys()):
bywhom = nick_disabled_list[botcom.dict["realcomref"]]["disabledby"]
if botusers.ID(bywhom) != botusers.ID(trigger.nick):
reason = nick_disabled_list[trigger.sb["realcomref"]]["reason"]
timestamp = nick_disabled_list[trigger.sb["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)
return trigger_cant_run(bot, trigger, message)
reason = nick_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = nick_disabled_list[botcom.dict["realcomref"]]["timestamp"]
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, botcom, message)
else:
botcommands.unset_command_disabled(trigger.sb["realcomref"], trigger.nick)
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " is now enabled for " + str(trigger.nick))
botcommands.unset_command_disabled(botcom.dict["realcomref"], trigger.nick)
botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " is now enabled for " + str(trigger.nick))
return True
def trigger_runstatus(bot, trigger):
def trigger_runstatus(bot, trigger, botcom):
# Bots can't run commands
if Identifier(trigger.nick) == bot.nick:
return False
# 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']):
return True
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
if trigger.sb["hyphen_arg"]:
return False
# if botcom.dict["hyphen_arg"]:
# return False
if trigger.sb["runcount"] > 1:
if not trigger.is_privmsg:
if str(trigger.sender).lower() in [x.lower() for x in botcom.dict["dict"]["hardcoded_channel_block"]]:
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 botcom.dict["runcount"] > 1:
# check channel multirun blocks
if not trigger.is_privmsg:
channel_disabled_list = botcommands.get_commands_disabled(str(trigger.sender), "multirun")
if trigger.sb["realcomref"] in list(channel_disabled_list.keys()):
reason = channel_disabled_list[trigger.sb["realcomref"]]["reason"]
timestamp = channel_disabled_list[trigger.sb["realcomref"]]["timestamp"]
bywhom = channel_disabled_list[trigger.sb["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)
return trigger_cant_run(bot, trigger, message)
if botcom.dict["realcomref"] in list(channel_disabled_list.keys()):
reason = channel_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = channel_disabled_list[botcom.dict["realcomref"]]["timestamp"]
bywhom = channel_disabled_list[botcom.dict["realcomref"]]["disabledby"]
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, botcom, message)
# don't run commands that are disabled for specific users
nick_disabled_list = botcommands.get_commands_disabled(str(trigger.nick), "multirun")
if trigger.sb["realcomref"] in list(nick_disabled_list.keys()):
bywhom = nick_disabled_list[trigger.sb["realcomref"]]["disabledby"]
if botcom.dict["realcomref"] in list(nick_disabled_list.keys()):
bywhom = nick_disabled_list[botcom.dict["realcomref"]]["disabledby"]
if botusers.ID(bywhom) != botusers.ID(trigger.nick):
reason = nick_disabled_list[trigger.sb["realcomref"]]["reason"]
timestamp = nick_disabled_list[trigger.sb["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)
return trigger_cant_run(bot, trigger, message)
reason = nick_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = nick_disabled_list[botcom.dict["realcomref"]]["timestamp"]
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, botcom, message)
else:
botcommands.unset_command_disabled(trigger.sb["realcomref"], trigger.nick, "multirun")
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is now enabled for " + str(trigger.nick))
botcommands.unset_command_disabled(botcom.dict["realcomref"], trigger.nick, "multirun")
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
if not trigger.is_privmsg:
channel_disabled_list = botcommands.get_commands_disabled(str(trigger.sender))
if trigger.sb["realcomref"] in list(channel_disabled_list.keys()):
reason = channel_disabled_list[trigger.sb["realcomref"]]["reason"]
timestamp = channel_disabled_list[trigger.sb["realcomref"]]["timestamp"]
bywhom = channel_disabled_list[trigger.sb["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)
return trigger_cant_run(bot, trigger, message)
if botcom.dict["realcomref"] in list(channel_disabled_list.keys()):
reason = channel_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = channel_disabled_list[botcom.dict["realcomref"]]["timestamp"]
bywhom = channel_disabled_list[botcom.dict["realcomref"]]["disabledby"]
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, botcom, message)
# don't run commands that are disabled for specific users
nick_disabled_list = botcommands.get_commands_disabled(str(trigger.nick))
if trigger.sb["realcomref"] in list(nick_disabled_list.keys()):
bywhom = nick_disabled_list[trigger.sb["realcomref"]]["disabledby"]
if botcom.dict["realcomref"] in list(nick_disabled_list.keys()):
bywhom = nick_disabled_list[botcom.dict["realcomref"]]["disabledby"]
if botusers.ID(bywhom) != botusers.ID(trigger.nick):
reason = nick_disabled_list[trigger.sb["realcomref"]]["reason"]
timestamp = nick_disabled_list[trigger.sb["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)
return trigger_cant_run(bot, trigger, message)
reason = nick_disabled_list[botcom.dict["realcomref"]]["reason"]
timestamp = nick_disabled_list[botcom.dict["realcomref"]]["timestamp"]
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, botcom, message)
else:
botcommands.unset_command_disabled(trigger.sb["realcomref"], trigger.nick)
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " is now enabled for " + str(trigger.nick))
botcommands.unset_command_disabled(botcom.dict["realcomref"], trigger.nick)
botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " is now enabled for " + str(trigger.nick))
return True
def trigger_cant_run(bot, trigger, message=None):
def trigger_cant_run(bot, trigger, botcom, message=None):
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']):
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
@ -401,155 +404,190 @@ def trigger_hyphen_args(trigger_args_part):
'contribs', 'contrib', "contributors",
'alias', 'aliases'
]
numdict = {
"last": -1
}
hyphen_args = []
trigger_args_unhyphend = []
for worditem in trigger_args_part:
if str(worditem).startswith("--") and worditem[2:] in valid_hyphen_args:
hyphen_args.append(worditem[2:])
if str(worditem).startswith("--"):
clipped_word = str(worditem[2:]).lower()
# valid arg above
if clipped_word in valid_hyphen_args:
hyphen_args.append(clipped_word)
# numbered args
elif str(clipped_word).isdigit():
hyphen_args.append(int(clipped_word))
elif clipped_word in list(numdict.keys()):
hyphen_args.append(int(numdict[clipped_word]))
else:
# check if arg word is a number
try:
clipped_word = w2n.word_to_num(str(clipped_word))
hyphen_args.append(int(clipped_word))
# word is not a valid arg or number
except ValueError:
trigger_args_unhyphend.append(worditem)
else:
trigger_args_unhyphend.append(worditem)
# only one arg allowed per && split
if len(hyphen_args):
hyphenarg = hyphen_args[0]
else:
hyphenarg = None
return trigger_args_unhyphend, hyphenarg
def trigger_hyphen_arg_handler(bot, trigger):
def trigger_hyphen_arg_handler(bot, trigger, botcom):
# Commands that cannot run via privmsg
# TODO --check should work for commands that don't exist
if trigger.sb["hyphen_arg"] in ['check']:
if trigger.sb["com"].lower() != trigger.sb["realcom"]:
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " is a valid alias command for " + trigger.sb["realcomtext"])
else:
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " is a valid command")
return
elif trigger.sb["hyphen_arg"] in [
if not botcom.dict["hyphen_arg"]:
return True
# handle numbered args
if str(botcom.dict["hyphen_arg"]).isdigit() or botcom.dict["hyphen_arg"] in [-1, 'random']:
return True
elif botcom.dict["hyphen_arg"] in ['check']:
if botcom.dict["com"].lower() != botcom.dict["realcom"]:
botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " is a valid alias command for " + botcom.dict["realcomtext"])
else:
botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " is a valid command")
return False
elif botcom.dict["hyphen_arg"] in [
'enable', 'disable',
'block', 'unblock',
"activate", "deactivate",
"on", "off"
]:
target = spicemanip.main(trigger.sb["args"], 1) or trigger.nick
target = spicemanip(botcom.dict["args"], 1) or trigger.nick
if not target:
if trigger.sb["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?")
if botcom.dict["hyphen_arg"] in ['enable', 'unblock', "activate", "on"]:
botmessagelog.messagelog_error(botcom.dict["log_id"], "Who/Where am I enabling " + str(botcom.dict["comtext"]) + " usage for?")
else:
botmessagelog.messagelog_error(trigger.sb["log_id"], "Who/Where am I disabling " + str(trigger.sb["comtext"]) + " usage for?")
return
trigger.sb["args"] = spicemanip.main(trigger.sb["args"], "2+", "list")
botmessagelog.messagelog_error(botcom.dict["log_id"], "Who/Where am I disabling " + str(botcom.dict["comtext"]) + " usage for?")
return False
botcom.dict["args"] = spicemanip(botcom.dict["args"], "2+", "list")
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.")
return
botmessagelog.messagelog_error(botcom.dict["log_id"], "I don't know who/what " + str(target) + " is.")
return False
if not command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']):
if target != trigger.nick:
if trigger.sb["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.")
if botcom.dict["hyphen_arg"] in ['enable', 'unblock', "activate", "on"]:
botmessagelog.messagelog_error(botcom.dict["log_id"], "I was unable to enable this command for " + str(target) + " due to privilege issues.")
else:
botmessagelog.messagelog_error(trigger.sb["log_id"], "I was unable to disable this command for " + str(target) + " due to privilege issues.")
return
botmessagelog.messagelog_error(botcom.dict["log_id"], "I was unable to disable this command for " + str(target) + " due to privilege issues.")
return False
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):
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " is already enabled for " + str(target))
return
if not botcommands.check_commands_disabled(botcom.dict["realcomref"], target):
botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " is already enabled for " + str(target))
return False
botcommands.unset_command_disabled(trigger.sb["realcomref"], target)
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " is now enabled for " + str(target))
return
botcommands.unset_command_disabled(botcom.dict["realcomref"], target)
botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " is now enabled for " + str(target))
return False
else:
if botcommands.check_commands_disabled(trigger.sb["realcomref"], target):
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " is already disabled for " + str(target))
return
if botcommands.check_commands_disabled(botcom.dict["realcomref"], target):
botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " is already disabled for " + str(target))
return False
trailingmessage = spicemanip.main(trigger.sb["args"], 0) or "No reason given."
trailingmessage = spicemanip(botcom.dict["args"], 0) or "No reason given."
timestamp = str(datetime.datetime.utcnow())
botcommands.set_command_disabled(trigger.sb["realcomref"], target, timestamp, trailingmessage, trigger.nick)
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " is now disabled for " + str(target))
return
botcommands.set_command_disabled(botcom.dict["realcomref"], target, timestamp, trailingmessage, trigger.nick)
botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " is now disabled for " + str(target))
return False
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(botcom.dict["args"], 1) or None
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?")
return
botmessagelog.messagelog_error(botcom.dict["log_id"], "Do you want to enable or disable " + str(botcom.dict["comtext"]) + " multirun usage?")
return False
target = spicemanip.main(trigger.sb["args"], 1) or trigger.nick
target = spicemanip(botcom.dict["args"], 1) or trigger.nick
if not target:
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:
botmessagelog.messagelog_error(trigger.sb["log_id"], "Who/Where am I disabling " + str(trigger.sb["comtext"]) + " multirun usage for?")
return
trigger.sb["args"] = spicemanip.main(trigger.sb["args"], "2+", "list")
botmessagelog.messagelog_error(botcom.dict["log_id"], "Who/Where am I disabling " + str(botcom.dict["comtext"]) + " multirun usage for?")
return False
botcom.dict["args"] = spicemanip(botcom.dict["args"], "2+", "list")
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.")
return
botmessagelog.messagelog_error(botcom.dict["log_id"], "I don't know who/what " + str(target) + " is.")
return False
if not command_permissions_check(bot, trigger, ['admins', 'owner', 'OP', 'ADMIN', 'OWNER']):
if target != trigger.nick:
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:
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.")
return
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 False
if onoff in ['enable', 'unblock', "activate", "on"]:
if not botcommands.check_commands_disabled(trigger.sb["realcomref"], target, "multirun"):
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is already enabled for " + str(target))
return
if not botcommands.check_commands_disabled(botcom.dict["realcomref"], target, "multirun"):
botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " multirun is already enabled for " + str(target))
return False
botcommands.unset_command_disabled(trigger.sb["realcomref"], target, "multirun")
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is now enabled for " + str(target))
return
botcommands.unset_command_disabled(botcom.dict["realcomref"], target, "multirun")
botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " multirun is now enabled for " + str(target))
return False
else:
if botcommands.check_commands_disabled(trigger.sb["realcomref"], target, "multirun"):
botmessagelog.messagelog_error(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is already disabled for " + str(target))
return
if botcommands.check_commands_disabled(botcom.dict["realcomref"], target, "multirun"):
botmessagelog.messagelog_error(botcom.dict["log_id"], botcom.dict["comtext"] + " multirun is already disabled for " + str(target))
return False
trailingmessage = spicemanip.main(trigger.sb["args"], 0) or "No reason given."
trailingmessage = spicemanip(botcom.dict["args"], 0) or "No reason given."
timestamp = str(datetime.datetime.utcnow())
botcommands.set_command_disabled(trigger.sb["realcomref"], target, timestamp, trailingmessage, trigger.nick, "multirun")
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + " multirun is now disabled for " + str(target))
return
botcommands.set_command_disabled(botcom.dict["realcomref"], target, timestamp, trailingmessage, trigger.nick, "multirun")
botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + " multirun is now disabled for " + str(target))
return False
elif trigger.sb["hyphen_arg"] in ['example', 'usage']:
botmessagelog.messagelog(trigger.sb["log_id"], trigger.sb["comtext"] + ": " + str(trigger.sb["dict"]["example"]))
return
elif botcom.dict["hyphen_arg"] in ['example', 'usage']:
botmessagelog.messagelog(botcom.dict["log_id"], botcom.dict["comtext"] + ": " + str(botcom.dict["dict"]["example"]))
return False
elif trigger.sb["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"]]))
return
elif botcom.dict["hyphen_arg"] in ['filename', 'filepath']:
botmessagelog.messagelog(botcom.dict["log_id"], "The " + str(botcom.dict["comtext"]) + " file is located at " + str(botcom.dict["dict"][botcom.dict["hyphen_arg"]]))
return False
elif trigger.sb["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"]]))
return
elif botcom.dict["hyphen_arg"] in ['foldername', 'folderpath']:
botmessagelog.messagelog(botcom.dict["log_id"], "The " + str(botcom.dict["comtext"]) + " folder is located at " + str(botcom.dict["dict"][botcom.dict["hyphen_arg"]]))
return False
elif trigger.sb["hyphen_arg"] in ['author']:
botmessagelog.messagelog(trigger.sb["log_id"], "The author of the " + str(trigger.sb["comtext"]) + " command is " + trigger.sb["dict"]["author"] + ".")
return
elif botcom.dict["hyphen_arg"] in ['author']:
botmessagelog.messagelog(botcom.dict["log_id"], "The author of the " + str(botcom.dict["comtext"]) + " command is " + botcom.dict["dict"]["author"] + ".")
return False
elif trigger.sb["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") + ".")
return
elif botcom.dict["hyphen_arg"] in ['contribs', 'contrib', "contributors"]:
botmessagelog.messagelog(botcom.dict["log_id"], "The contributors of the " + str(botcom.dict["comtext"]) + " command are " + spicemanip(botcom.dict["dict"]["contributors"], "andlist") + ".")
return False
elif trigger.sb["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") + ".")
return
elif botcom.dict["hyphen_arg"] in ['alias', 'aliases']:
botmessagelog.messagelog(botcom.dict["log_id"], "The alaises of the " + str(botcom.dict["comtext"]) + " command are " + spicemanip(botcom.dict["dict"]["validcoms"], "andlist") + ".")
return False
return
return False

5
sopel_modules/SpiceBot/Read.py
View File

@ -204,7 +204,7 @@ class BotRead():
if "example" not in list(dict_from_file.keys()):
dict_from_file["example"] = "$maincom"
# TODO
#if dict_from_file["comtype"] == "nickname":
# if dict_from_file["comtype"] == "nickname":
# dict_from_file["example"] = str(botconfig.nick + " $maincom")
# else:
# dict_from_file["example"] = str(botconfig.core.prefix_list[0] + "$maincom")
@ -220,6 +220,9 @@ class BotRead():
if "privs" not in list(dict_from_file.keys()):
dict_from_file["privs"] = []
if "hardcoded_channel_block" not in list(dict_from_file.keys()):
dict_from_file["hardcoded_channel_block"] = []
return dict_from_file

18
sopel_modules/SpiceBot/Reddit.py
View File

@ -7,7 +7,7 @@ This is the SpiceBot Reddit system.
from sopel.config.types import StaticSection, ValidatedAttribute
from sopel.formatting import bold, color, colors
import spicemanip
from sopel_modules.spicemanip import spicemanip
import datetime as dt
import praw
@ -56,7 +56,7 @@ class BotReddit():
def user_handler(self, trigger_argsdict):
subcommand_valid = ['check']
subcommand = spicemanip.main([x for x in trigger_argsdict["args"] if x in subcommand_valid], 1) or 'check'
subcommand = spicemanip([x for x in trigger_argsdict["args"] if x in subcommand_valid], 1) or 'check'
userreal = self.reddit_user_exists(trigger_argsdict["command"])
if not userreal["exists"]:
@ -97,7 +97,7 @@ class BotReddit():
def subreddit_handler(self, trigger_argsdict):
subcommand_valid = ['check', 'hot', 'new', 'top', 'random', 'controversial', 'gilded', 'rising', 'best']
subcommand = spicemanip.main([x for x in trigger_argsdict["args"] if x in subcommand_valid], 1) or 'check'
subcommand = spicemanip([x for x in trigger_argsdict["args"] if x in subcommand_valid], 1) or 'check'
fullrurul = str("https://www.reddit.com/" + trigger_argsdict["slashcomm"] + "/" + trigger_argsdict["command"])
@ -116,9 +116,9 @@ class BotReddit():
return dispmsg
if subcommand == 'random':
targnum = spicemanip.main([x for x in trigger_argsdict["args"] if str(x).isdigit()], 1) or 500
targnum = spicemanip([x for x in trigger_argsdict["args"] if str(x).isdigit()], 1) or 500
else:
targnum = spicemanip.main([x for x in trigger_argsdict["args"] if str(x).isdigit()], 1) or 1
targnum = spicemanip([x for x in trigger_argsdict["args"] if str(x).isdigit()], 1) or 1
targnum = int(targnum)
if subcommand == 'new':
@ -162,11 +162,11 @@ class BotReddit():
return dispmsg
def trigger_handler(self, trigger):
trigger_args = spicemanip.main(trigger.args[1], 'create')
trigger_args = spicemanip(trigger.args[1], 'create')
trigger_argsdict = {
"slashcomm": spicemanip.main(trigger_args, 1).lower()[:1],
"command": spicemanip.main(trigger_args, 1).lower()[2:],
"args": spicemanip.main(trigger_args, "2+", 'list')
"slashcomm": spicemanip(trigger_args, 1).lower()[:1],
"command": spicemanip(trigger_args, 1).lower()[2:],
"args": spicemanip(trigger_args, "2+", 'list')
}
if trigger_argsdict["slashcomm"] == "u":
trigger_argsdict["urltypetxt"] = "user"

4
sopel_modules/SpiceBot/Tools.py
View File

@ -14,7 +14,7 @@ from operator import itemgetter
from collections import abc
from pygit2 import clone_repository
import spicemanip
from sopel_modules.spicemanip import spicemanip
from .Logs import logs
from .Config import config as botconfig
@ -231,7 +231,7 @@ def similar_list(searchitem, searchlist, matchcount=1, searchorder='reverse'):
sim_num, sim_listitems = (list(x) for x in zip(*sorted(zip(sim_num, sim_listitems), key=itemgetter(0))))
if searchorder == 'reverse':
sim_listitems = spicemanip.main(sim_listitems, 'reverse', "list")
sim_listitems = spicemanip(sim_listitems, 'reverse', "list")
sim_listitems[-matchcount:]

22
sopel_modules/SpiceBot/Translate.py
View File

@ -1,7 +1,7 @@
# coding=utf8
from __future__ import unicode_literals, absolute_import, division, print_function
import spicemanip
from sopel_modules.spicemanip import spicemanip
import re
from num2words import num2words
@ -21,10 +21,10 @@ class Translate():
for translationtype in translationtypes:
if translationtype == "hyphen":
totranslate = spicemanip.main(totranslate, 0).replace(' ', '-')
totranslate = spicemanip(totranslate, 0).replace(' ', '-')
elif translationtype == "underscore":
totranslate = spicemanip.main(totranslate, 0).replace(' ', '_')
totranslate = spicemanip(totranslate, 0).replace(' ', '_')
elif translationtype == "ermahgerd":
totranslate = self.trernslert(totranslate)
@ -42,10 +42,10 @@ class Translate():
totranslate = self.text_one_to_zero_swap(totranslate)
elif translationtype == "upper":
totranslate = spicemanip.main(totranslate, 0).upper()
totranslate = spicemanip(totranslate, 0).upper()
elif translationtype == "lower":
totranslate = spicemanip.main(totranslate, 0).lower()
totranslate = spicemanip(totranslate, 0).lower()
return totranslate
@ -66,7 +66,7 @@ class Translate():
else:
new_word = word[1:] + first + 'ay'
rebuildarray.append(new_word)
words = spicemanip.main(rebuildarray, 0)
words = spicemanip(rebuildarray, 0)
return words
def trernslert(self, werds):
@ -143,7 +143,7 @@ class Translate():
return "No input provided"
if not isinstance(words, list):
words = [words]
words = spicemanip.main(words, 0).split(" ")
words = spicemanip(words, 0).split(" ")
outputarray = []
for word in words:
if not self.isitbinary(word):
@ -152,7 +152,7 @@ class Translate():
word = str(word).replace('0', '1')
word = str(word).replace('2', '0')
outputarray.append(str(word))
outputarray = spicemanip.main(outputarray, 0)
outputarray = spicemanip(outputarray, 0)
return outputarray
def text_binary_swap(self, words):
@ -160,16 +160,16 @@ class Translate():
return "No input provided"
if not isinstance(words, list):
words = [words]
words = spicemanip.main(words, 0).split(" ")
words = spicemanip(words, 0).split(" ")
outputarray = []
for word in words:
if self.isitbinary(word):
word = self.bits2string(word) or 'error'
else:
word = self.string2bits(word) or 1
word = spicemanip.main(word, 0)
word = spicemanip(word, 0)
outputarray.append(str(word))
outputarray = spicemanip.main(outputarray, 0)
outputarray = spicemanip(outputarray, 0)
return outputarray
def unicode_string_cleanup(string):

8
sopel_modules/SpiceBot/Users.py
View File

@ -8,7 +8,7 @@ from sopel.tools import Identifier
from .Database import db as botdb
from .Tools import is_number, inlist, similar, array_arrangesort
import spicemanip
from sopel_modules.spicemanip import spicemanip
import threading
import re
@ -393,13 +393,13 @@ class BotUsers():
sim_num.append(similarlevel)
if sim_user != [] and sim_num != []:
sim_num, sim_user = array_arrangesort(bot, sim_num, sim_user)
closestmatch = spicemanip.main(sim_user, 'reverse', "list")
closestmatch = spicemanip(sim_user, 'reverse', "list")
listnumb, relist = 1, []
for item in closestmatch:
if listnumb <= 3:
relist.append(str(item))
listnumb += 1
closestmatches = spicemanip.main(relist, "andlist")
closestmatches = spicemanip(relist, "andlist")
targetgooderror = "It looks like you're trying to target someone! Did you mean: " + str(closestmatches) + "?"
else:
targetgooderror = "I am not sure who that is."
@ -437,7 +437,7 @@ class BotUsers():
if outputtype == 'list':
return validtargs
elif outputtype == 'random':
return spicemanip.main(validtargs, 'random')
return spicemanip(validtargs, 'random')
users = BotUsers()

31
sopel_modules/SpiceBot_Core_Commands/AI.py
View File

@ -6,7 +6,9 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot
import spicemanip
from sopel_modules.spicemanip import spicemanip
# TODO split functionality for "no command"
@SpiceBot.prerun('nickname')
@ -59,7 +61,7 @@ def bot_command_rule_ai(bot, trigger):
command_type = 'nickname'
trigger_args, trigger_command, trigger_prefix = SpiceBot.make_trigger_args(message, 'nickname')
trigger_args.insert(0, trigger_command)
fulltrigger = bot.nick + " " + spicemanip.main(trigger_args, 0)
fulltrigger = bot.nick + " " + spicemanip(trigger_args, 0)
if str(trigger_command).startswith(bot.config.SpiceBot_Commands.query_prefix):
return
if fulltrigger in SpiceBot.commands.dict['nickrules']:
@ -73,7 +75,7 @@ def bot_command_rule_ai(bot, trigger):
command_type = 'module'
trigger_args, trigger_command, trigger_prefix = SpiceBot.make_trigger_args(message, 'module')
trigger_args.insert(0, trigger_command)
fulltrigger = spicemanip.main(trigger_args, 0)
fulltrigger = spicemanip(trigger_args, 0)
# patch for people typing "...", maybe other stuff, but this verifies that there is still a command here
if trigger_command.startswith(tuple(bot.config.core.prefix_list)):
return
@ -82,11 +84,11 @@ def bot_command_rule_ai(bot, trigger):
return
else:
command_type = 'other'
trigger_args = spicemanip.main(message, 'create')
trigger_args = spicemanip(message, 'create')
if not len(trigger_args):
return
trigger_command = trigger_args[0]
fulltrigger = spicemanip.main(trigger_args, 0)
fulltrigger = spicemanip(trigger_args, 0)
returnmessage = SpiceBot.botai.on_message(bot, trigger, fulltrigger)
if returnmessage:
@ -94,14 +96,13 @@ def bot_command_rule_ai(bot, trigger):
return
if command_type == 'nickname':
try_trigger = spicemanip.main(fulltrigger, "2+")
try_trigger = spicemanip(fulltrigger, "2+")
returnmessage = SpiceBot.botai.on_message(bot, trigger, try_trigger)
if returnmessage:
bot.osd(str(returnmessage))
return
if command_type == 'module':
return # TODO
if trigger_command not in commands_list:
if not SpiceBot.letters_in_string(trigger_command):
return
@ -116,7 +117,7 @@ def bot_command_rule_ai(bot, trigger):
if trigger_args[0].lower() in ["what", "where"] and trigger_args[1].lower() in ["is", "are"]:
# TODO saved definitions
searchterm = spicemanip.main(trigger_args, "3+") or None
searchterm = spicemanip(trigger_args, "3+") or None
if searchterm:
if trigger_args[0].lower() == "where":
searchreturn = SpiceBot.google.search(searchterm, 'maps')
@ -132,7 +133,7 @@ def bot_command_rule_ai(bot, trigger):
return
elif trigger_args[0].lower() in ["can", "have"] and trigger_args[1].lower() in ["you"] and trigger_args[2].lower() in ["see", "seen"]:
target = spicemanip.main(trigger_args, "4+") or None
target = spicemanip(trigger_args, "4+") or None
if target:
if SpiceBot.inlist(trigger.nick, bot.users):
realtarget = SpiceBot.inlist_match(target, bot.users)
@ -141,7 +142,7 @@ def bot_command_rule_ai(bot, trigger):
for channel in list(bot.channels.keys()):
if SpiceBot.inlist(trigger.nick, list(bot.channels[channel].privileges.keys())):
targetchannels.append(channel)
dispmsg.append(realtarget + " is in " + spicemanip.main(targetchannels, 'andlist'))
dispmsg.append(realtarget + " is in " + spicemanip(targetchannels, 'andlist'))
bot.osd(dispmsg)
else:
bot.osd(trigger.nick + ", no. I cannot see " + target + " right now!")
@ -164,7 +165,7 @@ def bot_command_rule_ai(bot, trigger):
for nonjedi in [bot.nick, trigger.nick]:
if nonjedi in jedilist:
jedilist.remove(nonjedi)
jedi = spicemanip.main(jedilist, 'random')
jedi = spicemanip(jedilist, 'random')
if jedi:
bot.osd("turns to " + jedi + " and shoots him.", trigger.sender, 'action')
@ -183,7 +184,7 @@ def bot_command_rule_ai(bot, trigger):
return
elif fulltrigger.lower().startswith(tuple(["make me a", "beam me a"])):
makemea = spicemanip.main(trigger_args, "4+") or None
makemea = spicemanip(trigger_args, "4+") or None
if makemea:
bot.osd("beams " + trigger.nick + " a " + makemea, trigger.sender, 'action')
else:
@ -191,7 +192,7 @@ def bot_command_rule_ai(bot, trigger):
return
elif fulltrigger.lower().startswith("beam me to"):
location = spicemanip.main(trigger_args, "4+") or None
location = spicemanip(trigger_args, "4+") or None
if location:
bot.osd("locks onto " + trigger.nick + "s coordinates and transports them to " + location, 'action')
else:
@ -209,7 +210,7 @@ def bot_command_rule_ai(bot, trigger):
# TODO
# elif fulltrigger.lower().startswith(tuple(["have you seen"])):
# posstarget = spicemanip.main(trigger_args, 4) or 0
# posstarget = spicemanip(trigger_args, 4) or 0
# message = seen_search(bot, trigger, posstarget)
# bot.osd(message)
# return
@ -217,7 +218,7 @@ def bot_command_rule_ai(bot, trigger):
closestmatches = SpiceBot.similar_list(trigger_command, list(SpiceBot.commands.dict['commands']["nickname"].keys()), 3, 'reverse')
if len(closestmatches):
closestmatches = spicemanip.main(closestmatches, "andlist")
closestmatches = spicemanip(closestmatches, "andlist")
bot.osd("I don't know what you are asking me to do! Did you mean: " + str(closestmatches) + "?")
return
else:

16
sopel_modules/SpiceBot_Core_Commands/BotPrivs.py
View File

@ -4,7 +4,7 @@ from __future__ import unicode_literals, absolute_import, division, print_functi
import sopel.module
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -12,19 +12,19 @@ import sopel_modules.SpiceBot as SpiceBot
@SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('owners', 'owner')
def bot_command_owners(bot, trigger, botcom):
bot_command_process(bot, trigger)
bot_command_process(bot, trigger, botcom)
@SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('admins', 'admin')
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"):
trigger.sb['com'] = str(trigger.sb['com'] + "s")
if not botcom.dict['com'].endswith("s"):
botcom.dict['com'] = str(botcom.dict['com'] + "s")
privlist = spicemanip.main(SpiceBot.bot_privs(trigger.sb['com']), 'andlist')
bot.osd(str(bot.nick) + " " + trigger.sb['com'] + ": " + privlist)
privlist = spicemanip(SpiceBot.bot_privs(botcom.dict['com']), 'andlist')
bot.osd(str(bot.nick) + " " + botcom.dict['com'] + ": " + privlist)

42
sopel_modules/SpiceBot_Core_Commands/Channels.py
View File

@ -5,7 +5,7 @@ This is the SpiceBot Channels system.
"""
import sopel
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -14,18 +14,18 @@ import sopel_modules.SpiceBot as SpiceBot
@sopel.module.nickname_commands('channels', 'channel')
def nickname_comand_channels(bot, trigger, botcom):
if not len(trigger.sb['args']):
if not len(botcom.dict['args']):
commandused = 'list'
else:
commandused = spicemanip.main(trigger.sb['args'], 1).lower()
commandused = spicemanip(botcom.dict['args'], 1).lower()
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list')
botcom.dict['args'] = spicemanip(botcom.dict['args'], '2+', 'list')
if commandused == 'list':
botcount = len(list(bot.channels.keys()))
servercount = len(list(SpiceBot.channels.dict['list'].keys()))
displayval = "I am in " + str(botcount) + " of " + str(servercount) + " channel(s) available on this server."
chanlist = spicemanip.main(list(bot.channels.keys()), 'andlist')
chanlist = spicemanip(list(bot.channels.keys()), 'andlist')
bot.osd([displayval, "You can find me in " + chanlist])
return
@ -36,7 +36,7 @@ def nickname_comand_channels(bot, trigger, botcom):
return
elif commandused == 'random':
channel = spicemanip.main(SpiceBot.channels.dict['list'], 'random')
channel = spicemanip(SpiceBot.channels.dict['list'], 'random')
topic = SpiceBot.channels.dict['list'][channel]['topic']
msg = ["Random channel for you: {}.".format(SpiceBot.channels.dict['list'][channel]['name'])]
if topic and not topic.isspace():
@ -48,7 +48,7 @@ def nickname_comand_channels(bot, trigger, botcom):
elif commandused == 'update':
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
SpiceBot.channels.bot_part_empty(bot)
SpiceBot.channels.channel_list_request(bot)
@ -62,12 +62,12 @@ def nickname_comand_channels(bot, trigger, botcom):
return
elif commandused == 'topic':
if not len(trigger.sb['args']):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Channel name input missing.")
if not len(botcom.dict['args']):
SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Channel name input missing.")
return
channel = spicemanip.main(trigger.sb['args'], 1)
channel = spicemanip(botcom.dict['args'], 1)
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
topic = SpiceBot.channels.dict['list'][channel.lower()]['topic']
channel = SpiceBot.channels.dict['list'][channel.lower()]['name']
@ -75,19 +75,19 @@ def nickname_comand_channels(bot, trigger, botcom):
return
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:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Channel name required.")
SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Channel name required.")
return
else:
channel = trigger.sender
else:
channel = spicemanip.main(trigger.sb['args'], 1)
channel = spicemanip(botcom.dict['args'], 1)
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
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
privlist = SpiceBot.channel_privs(bot, channel, commandused.upper())
@ -95,25 +95,25 @@ def nickname_comand_channels(bot, trigger, botcom):
if not len(privlist):
dispmsg.append("There are no Channel " + commandused.upper() + "s for " + str(channel))
else:
oplist = spicemanip.main(privlist, 'andlist')
oplist = spicemanip(privlist, 'andlist')
dispmsg.append("Channel " + commandused.upper() + "s for " + str(channel) + " are: " + oplist)
bot.osd(dispmsg, trigger.nick, 'notice')
return
# Users List
if commandused == 'users':
channel = spicemanip.main(trigger.sb['args'], 1)
channel = spicemanip(botcom.dict['args'], 1)
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
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
dispmsg = []
if not len(list(bot.channels[channel].privileges.keys())):
dispmsg.append("There are no Channel users for " + str(channel))
else:
userslist = spicemanip.main(list(bot.channels[channel].privileges.keys()), 'andlist')
userslist = spicemanip(list(bot.channels[channel].privileges.keys()), 'andlist')
dispmsg.append("Channel users for " + str(channel) + " are: " + userslist)
bot.osd(dispmsg, trigger.nick, 'notice')
return

8
sopel_modules/SpiceBot_Core_Commands/Commands.py
View File

@ -7,7 +7,7 @@ This Class stores commands in an easy to access manner
"""
import sopel
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -18,10 +18,10 @@ import sopel_modules.SpiceBot as SpiceBot
@sopel.module.nickname_commands('commands', 'command')
def nickname_comand_commands(bot, trigger, botcom):
if not len(trigger.sb['args']):
if not len(botcom.dict['args']):
commandused = 'list'
else:
commandused = spicemanip.main(trigger.sb['args'], 1).lower()
commandused = spicemanip(botcom.dict['args'], 1).lower()
if commandused == 'list':
availablecomsnum, availablecomsfiles = 0, []
@ -52,5 +52,5 @@ def nickname_comand_commands(bot, trigger, botcom):
return
if commandused == 'random':
bot.osd(["Here's a random command for you:", spicemanip.main(commands_list, 'random')])
bot.osd(["Here's a random command for you:", spicemanip(commands_list, 'random')])
return

94
sopel_modules/SpiceBot_Core_Commands/CommandsQuery.py
View File

@ -7,7 +7,7 @@ This Class stores commands in an easy to access manner
"""
import sopel
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -23,14 +23,14 @@ def query_trigger(bot, trigger, botcom):
def query_detection_nick(bot, trigger, botcom):
# 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
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
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
commands_list = dict()
@ -38,49 +38,49 @@ def query_detection_nick(bot, trigger, botcom):
if com not in list(commands_list.keys()):
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]
if not trigger.sb['com'] or not len(trigger.sb['com']):
botcom.dict['com'] = botcom.dict['com'][:-1]
if not botcom.dict['com'] or not len(botcom.dict['com']):
return
if trigger.sb['com'].lower() not in list(commands_list.keys()):
dispmsg = ["Cannot find any alias " + bot.nick + " commands: No valid commands match " + str(trigger.sb['com']) + "."]
closestmatches = SpiceBot.similar_list(trigger.sb['com'], list(commands_list.keys()), 10, 'reverse')
if botcom.dict['com'].lower() not in list(commands_list.keys()):
dispmsg = ["Cannot find any alias " + bot.nick + " commands: No valid commands match " + str(botcom.dict['com']) + "."]
closestmatches = SpiceBot.similar_list(botcom.dict['com'], list(commands_list.keys()), 10, 'reverse')
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(closestmatches, 'andlist') + ".")
bot.osd(dispmsg, trigger.nick, 'notice')
return
realcom = trigger.sb['com']
if "aliasfor" in list(commands_list[trigger.sb['com']].keys()):
realcom = commands_list[trigger.sb['com']]["aliasfor"]
realcom = botcom.dict['com']
if "aliasfor" in list(commands_list[botcom.dict['com']].keys()):
realcom = commands_list[botcom.dict['com']]["aliasfor"]
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(validcomlist, 'andlist') + ".", trigger.nick, 'notice')
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]
if not trigger.sb['com'] or not len(trigger.sb['com']):
botcom.dict['com'] = botcom.dict['com'][:-1]
if not botcom.dict['com'] or not len(botcom.dict['com']):
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):
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:
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(closestmatches, 'andlist') + ".", trigger.nick, 'notice')
return
commandlist = []
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)
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:
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(commandlist, 'andlist') + ".", trigger.nick, 'notice')
@SpiceBot.prerun_query('module', 'module')
@ -88,10 +88,10 @@ def query_detection_nick(bot, trigger, botcom):
def query_detection(bot, trigger, botcom):
# 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
if not SpiceBot.letters_in_string(trigger.sb['com']):
if not SpiceBot.letters_in_string(botcom.dict['com']):
return
commands_list = dict()
@ -101,46 +101,46 @@ def query_detection(bot, trigger, botcom):
if com not in list(commands_list.keys()):
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]
if not trigger.sb['com'] or not len(trigger.sb['com']):
botcom.dict['com'] = botcom.dict['com'][:-1]
if not botcom.dict['com'] or not len(botcom.dict['com']):
return
if trigger.sb['com'].lower() not in list(commands_list.keys()):
dispmsg = ["Cannot find any alias commands: No valid commands match " + str(trigger.sb['com']) + "."]
closestmatches = SpiceBot.similar_list(trigger.sb['com'], list(commands_list.keys()), 10, 'reverse')
if botcom.dict['com'].lower() not in list(commands_list.keys()):
dispmsg = ["Cannot find any alias commands: No valid commands match " + str(botcom.dict['com']) + "."]
closestmatches = SpiceBot.similar_list(botcom.dict['com'], list(commands_list.keys()), 10, 'reverse')
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(closestmatches, 'andlist') + ".")
bot.osd(dispmsg, trigger.nick, 'notice')
return
realcom = trigger.sb['com']
if "aliasfor" in list(commands_list[trigger.sb['com']].keys()):
realcom = commands_list[trigger.sb['com']]["aliasfor"]
realcom = botcom.dict['com']
if "aliasfor" in list(commands_list[botcom.dict['com']].keys()):
realcom = commands_list[botcom.dict['com']]["aliasfor"]
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(validcomlist, 'andlist') + ".", trigger.nick, 'notice')
return
if trigger.sb['com'][:-1] == "?":
if botcom.dict['com'][:-1] == "?":
trigger.sb['com'] = trigger.sb['com'][:-1]
if not trigger.sb['com'] or not len(trigger.sb['com']):
botcom.dict['com'] = botcom.dict['com'][:-1]
if not botcom.dict['com'] or not len(botcom.dict['com']):
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):
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:
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(closestmatches, 'andlist') + ".", trigger.nick, 'notice')
return
commandlist = []
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)
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:
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(commandlist, 'andlist') + ".", trigger.nick, 'notice')

332
sopel_modules/SpiceBot_Core_Commands/DictComs.py
View File

@ -9,7 +9,7 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot
import spicemanip
from sopel_modules.spicemanip import spicemanip
from word2number import w2n
from random import randint
@ -20,78 +20,78 @@ import time
@sopel.module.commands('(.*)')
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
bot_dictcom_process(bot, trigger)
bot_dictcom_process(bot, trigger, botcom)
return
time.time()
def bot_dictcom_process(bot, trigger):
def bot_dictcom_process(bot, trigger, botcom):
# use the default key, unless otherwise specified
trigger.sb["responsekey"] = "?default"
botcom.dict["responsekey"] = "?default"
# handling for special cases
posscom = spicemanip.main(trigger.sb['args'], 1)
if posscom.lower() in [command.lower() for command in trigger.sb["dict"].keys()]:
for command in trigger.sb["dict"].keys():
posscom = spicemanip(botcom.dict['args'], 1)
if posscom.lower() in [command.lower() for command in list(botcom.dict["dict"].keys())]:
for command in botcom.dict["dict"].keys():
if command.lower() == posscom.lower():
posscom = command
trigger.sb["responsekey"] = posscom
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list')
trigger.sb["dict"][trigger.sb["responsekey"]]["type"] = trigger.sb["dict"][trigger.sb["responsekey"]]["type"]
botcom.dict["responsekey"] = posscom
botcom.dict['args'] = spicemanip(botcom.dict['args'], '2+', 'list')
botcom.dict["dict"][botcom.dict["responsekey"]]["type"] = botcom.dict["dict"][botcom.dict["responsekey"]]["type"]
trigger.sb["nonstockoptions"] = []
for command in trigger.sb["dict"].keys():
botcom.dict["nonstockoptions"] = []
for command in list(botcom.dict["dict"].keys()):
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)
validspecifides = ['last', 'random', 'count', 'view', 'add', 'del', 'remove', 'special']
trigger.sb["specified"] = None
argone = spicemanip.main(trigger.sb['args'], 1)
botcom.dict["specified"] = None
argone = spicemanip(botcom.dict['args'], 1)
if str(argone).startswith("--") and len(str(argone)) > 2:
if str(argone[2:]).isdigit():
trigger.sb["specified"] = int(argone[2:])
botcom.dict["specified"] = int(argone[2:])
elif SpiceBot.inlist(str(argone[2:]), validspecifides):
trigger.sb["specified"] = str(argone[2:]).lower()
elif SpiceBot.inlist(str(argone[2:]), trigger.sb["nonstockoptions"]):
trigger.sb["specified"] = str(argone[2:]).lower()
trigger.sb["responsekey"] = trigger.sb["specified"]
botcom.dict["specified"] = str(argone[2:]).lower()
elif SpiceBot.inlist(str(argone[2:]), botcom.dict["nonstockoptions"]):
botcom.dict["specified"] = str(argone[2:]).lower()
botcom.dict["responsekey"] = botcom.dict["specified"]
else:
try:
trigger.sb["specified"] = w2n.word_to_num(str(argone[1:]))
trigger.sb["specified"] = int(trigger.sb["specified"])
botcom.dict["specified"] = w2n.word_to_num(str(argone[1:]))
botcom.dict["specified"] = int(botcom.dict["specified"])
except ValueError:
trigger.sb["specified"] = None
if trigger.sb["specified"]:
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list')
botcom.dict["specified"] = None
if botcom.dict["specified"]:
botcom.dict['args'] = spicemanip(botcom.dict['args'], '2+', 'list')
# commands that can be updated
if trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"]:
if trigger.sb["dict"][trigger.sb["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')
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 []
elif trigger.sb["dict"][trigger.sb["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')
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 []
if botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"]:
if botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "shared":
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')
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 botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "user":
SpiceBot.dictcoms.adjust_nick_array(str(trigger.nick), 'sayings', botcom.dict["realcom"] + "_" + str(botcom.dict["responsekey"]), botcom.dict["dict"][botcom.dict["responsekey"]]["responses"], 'startup')
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':
nonstockoptions = spicemanip.main(trigger.sb["nonstockoptions"], "andlist")
return bot.osd("The special options for " + str(trigger.sb["realcom"]) + " command include: " + str(nonstockoptions) + ".")
if botcom.dict["specified"] == 'special':
nonstockoptions = spicemanip(botcom.dict["nonstockoptions"], "andlist")
return bot.osd("The special options for " + str(botcom.dict["realcom"]) + " command include: " + str(nonstockoptions) + ".")
elif trigger.sb["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.")
elif botcom.dict["specified"] == 'count':
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':
if trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] == []:
return bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " command appears to have no entries!")
elif botcom.dict["specified"] == 'view':
if botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] == []:
return bot.osd("The " + str(botcom.dict["realcom"]) + " " + str(botcom.dict["responsekey"] or '') + " command appears to have no entries!")
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, []
for item in trigger.sb["dict"][trigger.sb["responsekey"]]["responses"]:
for item in botcom.dict["dict"][botcom.dict["responsekey"]]["responses"]:
if isinstance(item, dict):
relist.append(str("[#" + str(listnumb) + "] COMPLEX dict Entry"))
elif isinstance(item, list):
@ -101,143 +101,143 @@ def bot_dictcom_process(bot, trigger):
bot.osd(relist, trigger.nick)
return
elif trigger.sb["specified"] == 'add':
elif botcom.dict["specified"] == 'add':
if not trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"]:
return bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list cannot be updated.")
if not botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"]:
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(botcom.dict['args'], 0)
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"]:
return bot.osd("The following was already in the " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list: '" + str(fulltext) + "'")
if fulltext in botcom.dict["dict"][botcom.dict["responsekey"]]["responses"]:
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":
SpiceBot.dictcoms.adjust_nick_array(str(bot.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), fulltext, trigger.sb["specified"])
elif trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"] == "user":
SpiceBot.dictcoms.adjust_nick_array(str(trigger.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), fulltext, trigger.sb["specified"])
if botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "shared":
SpiceBot.dictcoms.adjust_nick_array(str(bot.nick), 'sayings', botcom.dict["realcom"] + "_" + str(botcom.dict["responsekey"]), fulltext, botcom.dict["specified"])
elif botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "user":
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"]:
return bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list cannot be updated.")
if not botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"]:
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(botcom.dict['args'], 0)
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"]:
return bot.osd("The following was already not in the " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " entry list: '" + str(fulltext) + "'")
if fulltext not in botcom.dict["dict"][botcom.dict["responsekey"]]["responses"]:
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":
SpiceBot.dictcoms.adjust_nick_array(str(bot.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), fulltext, trigger.sb["specified"])
elif trigger.sb["dict"][trigger.sb["responsekey"]]["updates_enabled"] == "user":
SpiceBot.dictcoms.adjust_nick_array(str(trigger.nick), 'sayings', trigger.sb["realcom"] + "_" + str(trigger.sb["responsekey"]), fulltext, trigger.sb["specified"])
if botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "shared":
SpiceBot.dictcoms.adjust_nick_array(str(bot.nick), 'sayings', botcom.dict["realcom"] + "_" + str(botcom.dict["responsekey"]), fulltext, botcom.dict["specified"])
elif botcom.dict["dict"][botcom.dict["responsekey"]]["updates_enabled"] == "user":
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"]:
return bot.osd("The " + str(trigger.sb["realcom"]) + " " + str(trigger.sb["responsekey"] or '') + " response list cannot be specified.")
elif botcom.dict["specified"] and not botcom.dict["dict"][botcom.dict["responsekey"]]["selection_allowed"]:
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
if trigger.sb["dict"][trigger.sb["responsekey"]]["type"] in ['simple', 'fillintheblank', "target", 'targetplusreason', 'sayings', "readfromfile", "readfromurl", "ascii_art", "translate", "responses"]:
return bot_dictcom_responses(bot, trigger)
botcom.dict["success"] = True
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, botcom)
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)
def bot_dictcom_responses(bot, trigger):
def bot_dictcom_responses(bot, trigger, botcom):
commandrunconsensus = []
reaction = False
# 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
posstarget = spicemanip.main(trigger.sb['args'], 1) or 0
targetbypass = trigger.sb["dict"][trigger.sb["responsekey"]]["target_bypass"]
posstarget = spicemanip(botcom.dict['args'], 1) or 0
targetbypass = botcom.dict["dict"][botcom.dict["responsekey"]]["target_bypass"]
targetchecking = SpiceBot.users.target_check(bot, trigger, posstarget, targetbypass)
if not targetchecking["targetgood"]:
if trigger.sb["dict"][trigger.sb["responsekey"]]["target_backup"]:
trigger.sb["target"] = trigger.sb["dict"][trigger.sb["responsekey"]]["target_backup"]
if trigger.sb["target"] == 'instigator':
trigger.sb["target"] = trigger.nick
elif trigger.sb["target"] == 'random':
trigger.sb["target"] = SpiceBot.users.random_valid_target(bot, trigger, 'random')
if botcom.dict["dict"][botcom.dict["responsekey"]]["target_backup"]:
botcom.dict["target"] = botcom.dict["dict"][botcom.dict["responsekey"]]["target_backup"]
if botcom.dict["target"] == 'instigator':
botcom.dict["target"] = trigger.nick
elif botcom.dict["target"] == 'random':
botcom.dict["target"] = SpiceBot.users.random_valid_target(bot, trigger, 'random')
else:
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
commandrunconsensus.append(trigger.sb["dict"][trigger.sb["responsekey"]]["react_"+reason])
commandrunconsensus.append(botcom.dict["dict"][botcom.dict["responsekey"]]["react_"+reason])
if not reaction:
commandrunconsensus.append([targetchecking["error"]])
else:
trigger.sb["target"] = spicemanip.main(trigger.sb['args'], 1)
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list')
botcom.dict["target"] = spicemanip(botcom.dict['args'], 1)
botcom.dict['args'] = spicemanip(botcom.dict['args'], '2+', 'list')
# $blank input
trigger.sb["completestring"] = spicemanip.main(trigger.sb['args'], 0) or ''
if trigger.sb["dict"][trigger.sb["responsekey"]]["blank_required"]:
botcom.dict["completestring"] = spicemanip(botcom.dict['args'], 0) or ''
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"]:
trigger.sb["completestring"] = trigger.sb["dict"][trigger.sb["responsekey"]]["blank_backup"]
if botcom.dict["dict"][botcom.dict["responsekey"]]["blank_backup"]:
botcom.dict["completestring"] = botcom.dict["dict"][botcom.dict["responsekey"]]["blank_backup"]
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 trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"] != []:
if spicemanip.main(trigger.sb["completestring"], 1).lower() not in trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"]:
trigger.sb["completestring"] = trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"][0] + " " + trigger.sb["completestring"]
elif spicemanip.main(trigger.sb["completestring"], 1).lower() in trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"]:
if spicemanip.main(trigger.sb["completestring"], 1).lower() != trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"][0]:
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list')
if trigger.sb['args'] != []:
trigger.sb["completestring"] = trigger.sb["dict"][trigger.sb["responsekey"]]["blank_phrasehandle"][0] + " " + spicemanip.main(trigger.sb['args'], 0)
if botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"]:
if botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"] != []:
if spicemanip(botcom.dict["completestring"], 1).lower() not in botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"]:
botcom.dict["completestring"] = botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"][0] + " " + botcom.dict["completestring"]
elif spicemanip(botcom.dict["completestring"], 1).lower() in botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"]:
if spicemanip(botcom.dict["completestring"], 1).lower() != botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"][0]:
botcom.dict['args'] = spicemanip(botcom.dict['args'], '2+', 'list')
if botcom.dict['args'] != []:
botcom.dict["completestring"] = botcom.dict["dict"][botcom.dict["responsekey"]]["blank_phrasehandle"][0] + " " + spicemanip(botcom.dict['args'], 0)
if commandrunconsensus != []:
trigger.sb["success"] = False
if trigger.sb["dict"][trigger.sb["responsekey"]]["response_fail"] and not reaction:
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = trigger.sb["dict"][trigger.sb["responsekey"]]["response_fail"]
botcom.dict["success"] = False
if botcom.dict["dict"][botcom.dict["responsekey"]]["response_fail"] and not reaction:
botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = botcom.dict["dict"][botcom.dict["responsekey"]]["response_fail"]
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 trigger.sb["specified"] > len(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"]):
currentspecified = len(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"])
if botcom.dict["specified"]:
if botcom.dict["specified"] > len(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"]):
currentspecified = len(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"])
else:
currentspecified = trigger.sb["specified"]
trigger.sb["replies"] = spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"], currentspecified, 'return')
trigger.sb["replynum"] = currentspecified
currentspecified = botcom.dict["specified"]
botcom.dict["replies"] = spicemanip(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"], currentspecified, 'return')
botcom.dict["replynum"] = currentspecified
else:
trigger.sb["replies"] = spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"], 'random', 'return')
botcom.dict["replies"] = spicemanip(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"], 'random', 'return')
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:
trigger.sb["replynum"] = e
trigger.sb["replynum"] = 0
trigger.sb["replynum"] += 1
trigger.sb["totalreplies"] = len(trigger.sb["dict"][trigger.sb["responsekey"]]["responses"])
botcom.dict["replynum"] = e
botcom.dict["replynum"] = 0
botcom.dict["replynum"] += 1
botcom.dict["totalreplies"] = len(botcom.dict["dict"][botcom.dict["responsekey"]]["responses"])
# This handles responses in list form
if not isinstance(trigger.sb["replies"], list):
trigger.sb["replies"] = [trigger.sb["replies"]]
if not isinstance(botcom.dict["replies"], list):
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
if rply.startswith("time.sleep"):
@ -246,31 +246,31 @@ def bot_dictcom_reply_shared(bot, trigger):
# random number
if "$randnum" in rply:
if trigger.sb["dict"][trigger.sb["responsekey"]]["randnum"]:
randno = randint(trigger.sb["dict"][trigger.sb["responsekey"]]["randnum"][0], trigger.sb["dict"][trigger.sb["responsekey"]]["randnum"][1])
if botcom.dict["dict"][botcom.dict["responsekey"]]["randnum"]:
randno = randint(botcom.dict["dict"][botcom.dict["responsekey"]]["randnum"][0], botcom.dict["dict"][botcom.dict["responsekey"]]["randnum"][1])
else:
randno = randint(0, 50)
rply = rply.replace("$randnum", str(randno))
# blank
if "$blank" in rply:
rply = rply.replace("$blank", trigger.sb["completestring"] or '')
rply = rply.replace("$blank", botcom.dict["completestring"] or '')
# the remaining input
if "$input" in rply:
rply = rply.replace("$input", spicemanip.main(trigger.sb['args'], 0) or trigger.sb["realcom"])
rply = rply.replace("$input", spicemanip(botcom.dict['args'], 0) or botcom.dict["realcom"])
# translation
if trigger.sb["dict"][trigger.sb["responsekey"]]["translations"]:
rply = SpiceBot.translate.bot_translate_process(rply, trigger.sb["dict"][trigger.sb["responsekey"]]["translations"])
if botcom.dict["dict"][botcom.dict["responsekey"]]["translations"]:
rply = SpiceBot.translate.bot_translate_process(rply, botcom.dict["dict"][botcom.dict["responsekey"]]["translations"])
# text to precede the output
if trigger.sb["dict"][trigger.sb["responsekey"]]["prefixtext"] and trigger.sb["success"]:
rply = spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["prefixtext"], 'random') + rply
if botcom.dict["dict"][botcom.dict["responsekey"]]["prefixtext"] and botcom.dict["success"]:
rply = spicemanip(botcom.dict["dict"][botcom.dict["responsekey"]]["prefixtext"], 'random') + rply
# text to follow the output
if trigger.sb["dict"][trigger.sb["responsekey"]]["suffixtext"] and trigger.sb["success"]:
rply = rply + spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["suffixtext"], 'random')
if botcom.dict["dict"][botcom.dict["responsekey"]]["suffixtext"] and botcom.dict["success"]:
rply = rply + spicemanip(botcom.dict["dict"][botcom.dict["responsekey"]]["suffixtext"], 'random')
# trigger.nick
if "$instigator" in rply:
@ -279,7 +279,7 @@ def bot_dictcom_reply_shared(bot, trigger):
# random user
if "$randuser" in rply:
if not trigger.is_privmsg:
randuser = spicemanip.main(SpiceBot.users.random_valid_target(trigger, 'random'))
randuser = spicemanip(SpiceBot.users.random_valid_target(trigger, 'random'))
else:
randuser = trigger.nick
rply = rply.replace("$randuser", randuser)
@ -294,7 +294,7 @@ def bot_dictcom_reply_shared(bot, trigger):
# target
if "$target" in rply:
targetnames = trigger.sb["target"] or ''
targetnames = botcom.dict["target"] or ''
if "$targets" in rply:
if targetnames.lower() == "your":
targetnames = targetnames
@ -309,26 +309,26 @@ def bot_dictcom_reply_shared(bot, trigger):
# smaller variations for the text
if "$replyvariation" in rply:
if trigger.sb["dict"][trigger.sb["responsekey"]]["replyvariation"] != []:
variation = spicemanip.main(trigger.sb["dict"][trigger.sb["responsekey"]]["replyvariation"], 'random')
if botcom.dict["dict"][botcom.dict["responsekey"]]["replyvariation"] != []:
variation = spicemanip(botcom.dict["dict"][botcom.dict["responsekey"]]["replyvariation"], 'random')
rply = rply.replace("$replyvariation", variation)
else:
rply = rply.replace("$replyvariation", '')
# smaller variations for the text
if "$responsekey" in rply:
rply = rply.replace("$responsekey", str(trigger.sb["responsekey"]))
rply = rply.replace("$responsekey", str(botcom.dict["responsekey"]))
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
if "$specialoptions" in rply:
nonstockoptions = []
for command in trigger.sb["dict"].keys():
for command in list(botcom.dict["dict"].keys()):
if command not in ["?default", "validcoms", "contributors", "author", "type", "filepath", "filename", "hardcoded_channel_block", "description", "exampleresponse", "example", "usage", "privs"]:
nonstockoptions.append(command)
nonstockoptions = spicemanip.main(nonstockoptions, "andlist")
nonstockoptions = spicemanip(nonstockoptions, "andlist")
rply = rply.replace("$specialoptions", nonstockoptions)
# saying, or action?
@ -341,28 +341,28 @@ def bot_dictcom_reply_shared(bot, trigger):
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"]:
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = trigger.sb["dict"][trigger.sb["responsekey"]]["blank_fail"]
return bot_dictcom_reply_shared(bot, trigger)
elif trigger.sb["dict"][trigger.sb["responsekey"]]["blank_required"] and trigger.sb["completestring"]:
queries = [trigger.sb["completestring"]]
if botcom.dict["dict"][botcom.dict["responsekey"]]["blank_required"] and not botcom.dict["completestring"]:
botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = botcom.dict["dict"][botcom.dict["responsekey"]]["blank_fail"]
return bot_dictcom_reply_shared(bot, trigger, botcom)
elif botcom.dict["dict"][botcom.dict["responsekey"]]["blank_required"] and botcom.dict["completestring"]:
queries = [botcom.dict["completestring"]]
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
if "queryapi" in trigger.sb["dict"].keys():
searchapis = trigger.sb["dict"][trigger.sb["responsekey"]]["queryapi"]
if "queryapi" in list(botcom.dict["dict"].keys()):
searchapis = botcom.dict["dict"][botcom.dict["responsekey"]]["queryapi"]
else:
searchapis = list(SpiceBot.gif.valid_api.keys())
if trigger.sb["specified"]:
if trigger.sb["specified"] > len(queries):
trigger.sb["specified"] = len(queries)
query = spicemanip.main(queries, trigger.sb["specified"], 'return')
if botcom.dict["specified"]:
if botcom.dict["specified"] > len(queries):
botcom.dict["specified"] = len(queries)
query = spicemanip(queries, botcom.dict["specified"], 'return')
else:
query = spicemanip.main(queries, 'random', 'return')
query = spicemanip(queries, 'random', 'return')
searchdict = {"query": query, "gifsearch": searchapis}
@ -374,18 +374,18 @@ def bot_dictcom_gif(bot, trigger):
gifdict = SpiceBot.gif.get_gif(searchdict)
if gifdict["error"]:
trigger.sb["success"] = False
if trigger.sb["dict"][trigger.sb["responsekey"]]["search_fail"]:
gifdict["error"] = trigger.sb["dict"][trigger.sb["responsekey"]]["search_fail"]
trigger.sb["dict"][trigger.sb["responsekey"]]["responses"] = [gifdict["error"]]
botcom.dict["success"] = False
if botcom.dict["dict"][botcom.dict["responsekey"]]["search_fail"]:
gifdict["error"] = botcom.dict["dict"][botcom.dict["responsekey"]]["search_fail"]
botcom.dict["dict"][botcom.dict["responsekey"]]["responses"] = [gifdict["error"]]
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
bot_dictcom_reply_shared(bot, trigger)
botcom.dict["specified"] = False
bot_dictcom_reply_shared(bot, trigger, botcom)
def bot_dictcom_feeds(bot, trigger):
def bot_dictcom_feeds(bot, trigger, botcom):
return bot.osd("WIP")
"""
@ -394,7 +394,7 @@ def bot_dictcom_feeds(bot, trigger):
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():
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")

14
sopel_modules/SpiceBot_Core_Commands/Logs.py
View File

@ -7,7 +7,7 @@ This is the SpiceBot Logs System
# sopel imports
import sopel.module
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -17,20 +17,20 @@ import sopel_modules.SpiceBot as SpiceBot
def bot_command_logs(bot, trigger, botcom):
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
logtype = spicemanip.main(trigger.sb['args'], 1) or None
logtype = spicemanip(botcom.dict['args'], 1) or None
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(list(SpiceBot.logs.dict["list"].keys()), 'andlist'), trigger.sender, 'action')
return
if not SpiceBot.inlist(logtype, list(SpiceBot.logs.dict["list"].keys())):
closestmatches = SpiceBot.similar_list(logtype, list(SpiceBot.logs.dict["list"].keys()), 10, 'reverse')
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:
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(closestmatches, 'andlist') + ".", trigger.nick, 'notice')
return
@ -39,7 +39,7 @@ def bot_command_logs(bot, trigger, botcom):
logindex = SpiceBot.logs.get_logs(logtype)
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
bot.osd("Is Examining " + str(logtype) + " log(s).")

32
sopel_modules/SpiceBot_Core_Commands/Messaging.py
View File

@ -4,7 +4,7 @@ from __future__ import unicode_literals, absolute_import, division, print_functi
import sopel.module
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -12,42 +12,42 @@ import sopel_modules.SpiceBot as SpiceBot
@SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('action')
def bot_command_action(bot, trigger, botcom):
bot_command_process(bot, trigger)
bot_command_process(bot, trigger, botcom)
@SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('notice')
def bot_command_notice(bot, trigger, botcom):
bot_command_process(bot, trigger)
bot_command_process(bot, trigger, botcom)
@SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('privmsg', 'say', 'msg')
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']):
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
if trigger.sb['com'] in ['say', 'msg']:
trigger.sb['com'] = 'privmsg'
if botcom.dict['com'] in ['say', 'msg']:
botcom.dict['com'] = 'privmsg'
if not len(trigger.sb['args']):
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "You must specify a channel or nick.")
if not len(botcom.dict['args']):
SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "You must specify a channel or nick.")
return
target = spicemanip.main(trigger.sb['args'], 1)
target = spicemanip(botcom.dict['args'], 1)
if (target not in ['allchans', 'allnicks']
and not SpiceBot.inlist(target.lower(), list(SpiceBot.channels.dict['list'].keys()))
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
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list')
botcom.dict['args'] = spicemanip(botcom.dict['args'], '2+', 'list')
if target == 'allchans':
targetsendlist = list(bot.channels.keys())
@ -56,9 +56,9 @@ def bot_command_process(bot, trigger):
else:
targetsendlist = [target]
botmessage = spicemanip.main(trigger.sb['args'], 0)
botmessage = spicemanip(botcom.dict['args'], 0)
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
bot.osd(botmessage, targetsendlist, trigger.sb['com'].upper())
bot.osd(botmessage, targetsendlist, botcom.dict['com'].upper())

14
sopel_modules/SpiceBot_Core_Commands/Runtime_Controls.py
View File

@ -4,7 +4,7 @@ from __future__ import unicode_literals, absolute_import, division, print_functi
import sopel.module
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -14,19 +14,19 @@ import sopel_modules.SpiceBot as SpiceBot
def nickname_comand_update(bot, trigger, botcom):
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
if not len(trigger.sb['args']):
if not len(botcom.dict['args']):
commandused = 'nodeps'
else:
commandused = spicemanip.main(trigger.sb['args'], 1).lower()
commandused = spicemanip(botcom.dict['args'], 1).lower()
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
trigger.sb['args'] = spicemanip.main(trigger.sb['args'], '2+', 'list')
botcom.dict['args'] = spicemanip(botcom.dict['args'], '2+', 'list')
quitmessage = "Received command from " + trigger.nick + " to update from Github and restart"
SpiceBot.logs.log('SpiceBot_Update', quitmessage)
@ -46,7 +46,7 @@ def nickname_comand_update(bot, trigger, botcom):
def nickname_comand_restart(bot, trigger, botcom):
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!"
SpiceBot.logs.log('SpiceBot_Restart', quitmessage)

16
sopel_modules/SpiceBot_Core_Commands/TODO.py Normal file
View File

@ -0,0 +1,16 @@
# coding=utf8
from __future__ import unicode_literals, absolute_import, division, print_function
"""
This is the SpiceBot Users system.
"""
import sopel
import sopel_modules.SpiceBot as SpiceBot
from sopel_modules.spicemanip import spicemanip
@SpiceBot.prerun('nickname')
@sopel.module.nickname_commands('todo')
def nickname_comand_users(bot, trigger, botcom):
todo_task = spicemanip(SpiceBot.commands.todo_list, 'random')
bot.osd(["Random TODO task for you: {}.".format(todo_task)])

5
sopel_modules/SpiceBot_Core_Commands/__init__.py
View File

@ -19,12 +19,9 @@ from .Runtime_Controls import *
from .Messaging import *
from .Docs import *
from .BotPrivs import *
from .Search import *
from .AI import *
from .Gif import *
from .Sherlock import *
from .Reddit import *
from .DictComs import *
from .TODO import *
__author__ = 'Sam Zick'
__email__ = 'sam@deathbybandaid.net'

9
sopel_modules/SpiceBot_Core_Extra/__init__.py Normal file
View File

@ -0,0 +1,9 @@
# coding=utf8
from __future__ import unicode_literals, absolute_import, division, print_function
# pylama:ignore=W0401,W0611
from .flip import *
__author__ = 'Sam Zick'
__email__ = 'sam@deathbybandaid.net'
__version__ = '0.1.1'

34
sopel_modules/SpiceBot_Core_Extra/flip.py Normal file
View File

@ -0,0 +1,34 @@
# coding=utf-8
from __future__ import unicode_literals, absolute_import, division, print_function
import sopel.module
# import sopel_modules.SpiceBot as SpiceBot
# from sopel_modules.spicemanip import spicemanip
from upsidedown import transform
# TODO add upsidedown to spicemanip
@sopel.module.rule('^flips (.+)')
@sopel.module.intent('ACTION')
def flips(bot, trigger):
target = trigger.group(1).strip()
if target == 'a table':
bot.say("(╯°□°）╯︵ ┻━┻")
else:
bot.say("(╯°□°）╯︵ %s" % transform(target))
@sopel.module.rule('^rolls (.+)')
@sopel.module.intent('ACTION')
def roll(bot, trigger):
target = trigger.group(1).strip()
if target.endswith(' down a hill'):
target = target[:-12]
tegrat = transform(target)
bot.say("(╮°-°)╯︵ %s %s %s %s %s (@_@;)" % (tegrat, target, tegrat, target, tegrat))
else:
bot.say("(╮°-°)╯︵ %s" % transform(target))

4
sopel_modules/SpiceBot_Core_Processing/Channels.py
View File

@ -7,7 +7,7 @@ import sopel
import time
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -86,7 +86,7 @@ def trigger_channel_list_recurring(bot, trigger):
if "*" in newlist:
newlist.remove("*")
if len(newlist) and SpiceBot.config.SpiceBot_Channels.announcenew:
bot.osd(["The Following channel(s) are new:", spicemanip.main(newlist, 'andlist')], list(bot.channels.keys()))
bot.osd(["The Following channel(s) are new:", spicemanip(newlist, 'andlist')], list(bot.channels.keys()))
SpiceBot.channels.join_all_channels(bot)

22
sopel_modules/SpiceBot_Core_Commands/Gif.py → sopel_modules/SpiceBot_Core_Tools/Gif.py
View File

@ -6,7 +6,7 @@ import sopel.module
import sopel_modules.SpiceBot as SpiceBot
import spicemanip
from sopel_modules.spicemanip import spicemanip
# TODO custom gif shortcut commands
@ -15,17 +15,17 @@ import spicemanip
@sopel.module.commands('gif')
def gif_trigger(bot, trigger, botcom):
if not len(trigger.sb['args']):
return SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Please present a query to search.")
if not len(botcom.dict['args']):
return SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Please present a query to search.")
query = spicemanip.main(trigger.sb['args'], 0)
query = spicemanip(botcom.dict['args'], 0)
searchapis = list(SpiceBot.gif.valid_api.keys())
searchdict = {"query": query, "gifsearch": searchapis}
gifdict = SpiceBot.gif.get_gif(searchdict)
if gifdict["error"]:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], gifdict["error"])
SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], gifdict["error"])
else:
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('(.*)')
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
if not len(trigger.sb['args']):
return SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], "Please present a query to search.")
if not len(botcom.dict['args']):
return SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], "Please present a query to search.")
query = spicemanip.main(trigger.sb['args'], 0)
searchdict = {"query": query, "gifsearch": trigger.sb['com']}
query = spicemanip(botcom.dict['args'], 0)
searchdict = {"query": query, "gifsearch": botcom.dict['com']}
gifdict = SpiceBot.gif.get_gif(searchdict)
if gifdict["error"]:
SpiceBot.messagelog.messagelog_error(trigger.sb["log_id"], gifdict["error"])
SpiceBot.messagelog.messagelog_error(botcom.dict["log_id"], gifdict["error"])
else:
bot.osd(str(gifdict['gifapi'].title() + " Result (" + str(query) + " #" + str(gifdict["returnnum"]) + "): " + str(gifdict["returnurl"])))

0
sopel_modules/SpiceBot_Core_Commands/Reddit.py → sopel_modules/SpiceBot_Core_Tools/Reddit.py
View File

26
sopel_modules/SpiceBot_Core_Commands/Search.py → sopel_modules/SpiceBot_Core_Tools/Search.py
View File

@ -5,7 +5,7 @@ This is the SpiceBot search system.
"""
import sopel
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -14,14 +14,14 @@ import sopel_modules.SpiceBot as SpiceBot
@sopel.module.commands('search', 'find', 'google', 'lookup')
def search_main(bot, trigger, botcom):
searchterm = spicemanip.main(trigger.sb['args'], 0) or None
searchterm = spicemanip(botcom.dict['args'], 0) or None
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
searchreturn = SpiceBot.google.search(searchterm)
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:
bot.osd(["[Information search for '" + str(searchterm) + "']", str(searchreturn)])
@ -30,14 +30,14 @@ def search_main(bot, trigger, botcom):
@sopel.module.commands("where", "whereis")
def search_where(bot, trigger, botcom):
searchterm = spicemanip.main(trigger.sb['args'], 0) or None
searchterm = spicemanip(botcom.dict['args'], 0) or None
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
searchreturn = SpiceBot.google.search(searchterm, 'maps')
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:
bot.osd(["[Location search for " + str(searchterm) + "]", str(searchreturn)])
@ -46,14 +46,14 @@ def search_where(bot, trigger, botcom):
@sopel.module.commands("what", "whatis")
def search_what(bot, trigger, botcom):
searchterm = spicemanip.main(trigger.sb['args'], 0) or None
searchterm = spicemanip(botcom.dict['args'], 0) or None
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
searchreturn = SpiceBot.google.search(searchterm)
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:
bot.osd(["[Information search for '" + str(searchterm) + "']", str(searchreturn)])
@ -62,13 +62,13 @@ def search_what(bot, trigger, botcom):
@sopel.module.commands("youtube", "video")
def search_video(bot, trigger, botcom):
searchterm = spicemanip.main(trigger.sb['args'], 0) or None
searchterm = spicemanip(botcom.dict['args'], 0) or None
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
searchreturn = SpiceBot.google.search(searchterm, 'youtube')
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:
bot.osd(["[Youtube search for '" + str(searchterm) + "']", str(searchreturn)])

14
sopel_modules/SpiceBot_Core_Commands/Sherlock.py → sopel_modules/SpiceBot_Core_Tools/Sherlock.py
View File

@ -4,7 +4,7 @@ from __future__ import unicode_literals, absolute_import, division, print_functi
# sopel imports
import sopel.module
import spicemanip
from sopel_modules.spicemanip import spicemanip
import sopel_modules.SpiceBot as SpiceBot
@ -15,15 +15,15 @@ def bot_command_sherlock(bot, trigger, botcom):
netlist = list(SpiceBot.sherlock.dict.keys())
username = spicemanip.main(trigger.sb["args"], 1) or trigger.nick
trigger.sb["args"] = spicemanip.main(trigger.sb["args"], "2+", 'list')
username = spicemanip(botcom.dict["args"], 1) or trigger.nick
botcom.dict["args"] = spicemanip(botcom.dict["args"], "2+", 'list')
checklist = netlist
checklistname = 'all'
if SpiceBot.inlist(username, netlist):
checklistname = SpiceBot.inlist_match(username, netlist)
checklist = [checklistname]
username = spicemanip.main(trigger.sb["args"], 1) or trigger.nick
username = spicemanip(botcom.dict["args"], 1) or trigger.nick
bot.osd("Checking username " + username + " in " + checklistname + " network.")
@ -41,9 +41,9 @@ def bot_command_sherlock(bot, trigger, botcom):
if checklistname != 'all':
bot.osd(["The username " + username + " is in " + checklist[0], SpiceBot.sherlock.dict.get(social_network).get("url").format(username)])
else:
bot.osd(["The username " + username + " is in the following:", spicemanip.main(inlist, "andlist")], trigger.nick, 'NOTICE')
bot.osd(["The username " + username + " is in the following:", spicemanip(inlist, "andlist")], trigger.nick, 'NOTICE')
if len(notinlist):
if checklistname != 'all':
bot.osd(["The username " + username + " is NOT in the following:", spicemanip.main(notinlist, "andlist")])
bot.osd(["The username " + username + " is NOT in the following:", spicemanip(notinlist, "andlist")])
else:
bot.osd(["The username " + username + " is NOT in the following:", spicemanip.main(notinlist, "andlist")], trigger.nick, 'NOTICE')
bot.osd(["The username " + username + " is NOT in the following:", spicemanip(notinlist, "andlist")], trigger.nick, 'NOTICE')

12
sopel_modules/SpiceBot_Core_Tools/__init__.py Normal file
View File

@ -0,0 +1,12 @@
# coding=utf8
from __future__ import unicode_literals, absolute_import, division, print_function
# pylama:ignore=W0401,W0611
from .Gif import *
from .Sherlock import *
from .Reddit import *
from .Search import *
__author__ = 'Sam Zick'
__email__ = 'sam@deathbybandaid.net'
__version__ = '0.1.1'

684
sopel_modules/spicemanip/__init__.py Normal file
View File

@ -0,0 +1,684 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Top-level package for spicemanip."""
__author__ = """Sam Zick"""
__email__ = 'sam@deathbybandaid.net'
__version__ = '0.1.8'
import random
import collections
# TODO 'this*that' or '1*that' replace either all strings matching, or an index value
# TODO reverse sort z.sort(reverse = True)
# list.extend adds lists to eachother
class Spicemanip():
def __init__(self):
pass
def __call__(self, inputs, outputtask, output_type='default'):
mainoutputtask, suboutputtask = None, None
# Input needs to be a list, but don't split a word into letters
if not inputs:
inputs = []
if isinstance(inputs, collections.abc.KeysView):
inputs = list(inputs)
elif isinstance(inputs, dict):
inputs = list(inputs.keys())
if not isinstance(inputs, list):
inputs = list(inputs.split(" "))
inputs = [x for x in inputs if x and x not in ['', ' ']]
inputs = [inputspart.strip() for inputspart in inputs]
# Create return
if outputtask == 'create':
return inputs
# Make temparray to preserve original order
temparray = []
for inputpart in inputs:
temparray.append(inputpart)
inputs = temparray
# Convert outputtask to standard
if outputtask in [0, 'complete']:
outputtask = 'string'
elif outputtask == 'index':
mainoutputtask = inputs[1]
suboutputtask = inputs[2]
inputs = inputs[0]
elif str(outputtask).isdigit():
mainoutputtask, outputtask = int(outputtask), 'number'
elif "^" in str(outputtask):
mainoutputtask = str(outputtask).split("^", 1)[0]
suboutputtask = str(outputtask).split("^", 1)[1]
outputtask = 'rangebetween'
if int(suboutputtask) < int(mainoutputtask):
mainoutputtask, suboutputtask = suboutputtask, mainoutputtask
elif str(outputtask).startswith("split_"):
mainoutputtask = str(outputtask).replace("split_", "")
outputtask = 'split'
elif str(outputtask).endswith(tuple(["!", "+", "-", "<", ">"])):
mainoutputtask = str(outputtask)
if str(outputtask).endswith("!"):
outputtask = 'exclude'
if str(outputtask).endswith("+"):
outputtask = 'incrange_plus'
if str(outputtask).endswith("-"):
outputtask = 'incrange_minus'
if str(outputtask).endswith(">"):
outputtask = 'excrange_plus'
if str(outputtask).endswith("<"):
outputtask = 'excrange_minus'
for r in (("!", ""), ("+", ""), ("-", ""), ("<", ""), (">", "")):
mainoutputtask = mainoutputtask.replace(*r)
if mainoutputtask == 'last':
mainoutputtask = len(inputs)
if outputtask == 'string':
returnvalue = inputs
else:
returnvalue = eval(
'self.' + outputtask +
'(inputs, outputtask, mainoutputtask, suboutputtask)')
# default return if not specified
if output_type == 'default':
if outputtask in [
'string', 'number', 'rangebetween', 'exclude', 'random',
'incrange_plus', 'incrange_minus', 'excrange_plus',
'excrange_minus'
]:
output_type = 'string'
elif outputtask in ['count']:
output_type = 'dict'
# verify output is correct
if output_type == 'return':
return returnvalue
if output_type == 'string':
if isinstance(returnvalue, list):
returnvalue = ' '.join(returnvalue)
elif output_type in ['list', 'array']:
if not isinstance(returnvalue, list):
returnvalue = list(returnvalue.split(" "))
returnvalue = [x for x in returnvalue if x and x not in ['', ' ']]
returnvalue = [inputspart.strip() for inputspart in returnvalue]
return returnvalue
# compare 2 lists, based on the location of an index item, passthrough needs to be [indexitem, arraytoindex, arraytocompare]
def index(self, indexitem, outputtask, arraytoindex, arraytocompare):
item = ''
for x, y in zip(arraytoindex, arraytocompare):
if x == indexitem:
item = y
return item
# split list by string
def split(self, inputs, outputtask, mainoutputtask, suboutputtask):
split_array = []
restring = ' '.join(inputs)
if mainoutputtask not in inputs:
split_array = [restring]
else:
split_array = restring.split(mainoutputtask)
split_array = [x for x in split_array if x and x not in ['', ' ']]
split_array = [inputspart.strip() for inputspart in split_array]
if split_array == []:
split_array = [[]]
return split_array
# dedupe list
def dedupe(self, inputs, outputtask, mainoutputtask, suboutputtask):
newlist = []
for inputspart in inputs:
if inputspart not in newlist:
newlist.append(inputspart)
return newlist
# Sort list
def sort(self, inputs, outputtask, mainoutputtask, suboutputtask):
return sorted(inputs)
# reverse sort list
def rsort(self, inputs, outputtask, mainoutputtask, suboutputtask):
return sorted(inputs)[::-1]
# count items in list, return dictionary
def count(self, inputs, outputtask, mainoutputtask, suboutputtask):
returndict = dict()
if not len(inputs):
return returndict
uniqueinputitems, uniquecount = [], []
for inputspart in inputs:
if inputspart not in uniqueinputitems:
uniqueinputitems.append(inputspart)
for uniqueinputspart in uniqueinputitems:
count = 0
for ele in inputs:
if (ele == uniqueinputspart):
count += 1
uniquecount.append(count)
for inputsitem, unumber in zip(uniqueinputitems, uniquecount):
returndict[inputsitem] = unumber
return returndict
# random item from list
def random(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
randomselectlist = []
for temppart in inputs:
randomselectlist.append(temppart)
while len(randomselectlist) > 1:
random.shuffle(randomselectlist)
randomselect = randomselectlist[random.randint(
0,
len(randomselectlist) - 1)]
randomselectlist.remove(randomselect)
randomselect = randomselectlist[0]
return randomselect
# remove random item from list
def exrandom(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return []
randremove = self.random(inputs, outputtask, mainoutputtask, suboutputtask)
inputs.remove(randremove)
return inputs
# Convert list into lowercase
def lower(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return [inputspart.lower() for inputspart in inputs]
# Convert list to uppercase
def upper(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return [inputspart.upper() for inputspart in inputs]
# Convert list to uppercase
def title(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return [inputspart.title() for inputspart in inputs]
# Reverse List Order
def reverse(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return []
return inputs[::-1]
# comma seperated list
def list(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return ', '.join(str(x) for x in inputs)
def list_nospace(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return ','.join(str(x) for x in inputs)
# comma seperated list with and
def andlist(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
if len(inputs) < 2:
return ' '.join(inputs)
lastentry = str("and " + str(inputs[len(inputs) - 1]))
del inputs[-1]
inputs.append(lastentry)
if len(inputs) == 2:
return ' '.join(inputs)
return ', '.join(str(x) for x in inputs)
# comma seperated list with or
def orlist(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
if len(inputs) < 2:
return ' '.join(inputs)
lastentry = str("or " + str(inputs[len(inputs) - 1]))
del inputs[-1]
inputs.append(lastentry)
if len(inputs) == 2:
return ' '.join(inputs)
return ', '.join(str(x) for x in inputs)
# exclude number
def exclude(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
del inputs[int(mainoutputtask) - 1]
return ' '.join(inputs)
# Convert list to string
def string(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return ' '.join(inputs)
# Get number item from list
def number(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
elif len(inputs) == 1:
return inputs[0]
elif int(mainoutputtask) > len(inputs) or int(mainoutputtask) < 0:
return ''
else:
return inputs[int(mainoutputtask) - 1]
# Get Last item from list
def last(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return inputs[len(inputs) - 1]
# range between items in list
def rangebetween(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
if not str(mainoutputtask).isdigit() or not str(
suboutputtask).isdigit():
return ''
mainoutputtask, suboutputtask = int(mainoutputtask), int(suboutputtask)
if suboutputtask == mainoutputtask:
return self.number(inputs, outputtask, mainoutputtask, suboutputtask)
if suboutputtask < mainoutputtask:
return []
if mainoutputtask < 0:
mainoutputtask = 1
if suboutputtask > len(inputs):
suboutputtask = len(inputs)
newlist = []
for i in range(mainoutputtask, suboutputtask + 1):
newlist.append(
str(
self.number(inputs, outputtask, i, suboutputtask)))
if newlist == []:
return ''
return ' '.join(newlist)
# Forward Range includes index number
def incrange_plus(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return self.rangebetween(inputs, outputtask, int(mainoutputtask), len(inputs))
# Reverse Range includes index number
def incrange_minus(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return self.rangebetween(inputs, outputtask, 1, int(mainoutputtask))
# Forward Range excludes index number
def excrange_plus(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return self.rangebetween(inputs, outputtask, int(mainoutputtask) + 1, len(inputs))
# Reverse Range excludes index number
def excrange_minus(self, inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return self.rangebetween(inputs, outputtask, 1, int(mainoutputtask) - 1)
spicemanip = Spicemanip()
"""
# Hub
def spicemanip(inputs, outputtask, output_type='default'):
mainoutputtask, suboutputtask = None, None
# Input needs to be a list, but don't split a word into letters
if not inputs:
inputs = []
if isinstance(inputs, collections.abc.KeysView):
inputs = list(inputs)
elif isinstance(inputs, dict):
inputs = list(inputs.keys())
if not isinstance(inputs, list):
inputs = list(inputs.split(" "))
inputs = [x for x in inputs if x and x not in ['', ' ']]
inputs = [inputspart.strip() for inputspart in inputs]
# Create return
if outputtask == 'create':
return inputs
# Make temparray to preserve original order
temparray = []
for inputpart in inputs:
temparray.append(inputpart)
inputs = temparray
# Convert outputtask to standard
if outputtask in [0, 'complete']:
outputtask = 'string'
elif outputtask == 'index':
mainoutputtask = inputs[1]
suboutputtask = inputs[2]
inputs = inputs[0]
elif str(outputtask).isdigit():
mainoutputtask, outputtask = int(outputtask), 'number'
elif "^" in str(outputtask):
mainoutputtask = str(outputtask).split("^", 1)[0]
suboutputtask = str(outputtask).split("^", 1)[1]
outputtask = 'rangebetween'
if int(suboutputtask) < int(mainoutputtask):
mainoutputtask, suboutputtask = suboutputtask, mainoutputtask
elif str(outputtask).startswith("split_"):
mainoutputtask = str(outputtask).replace("split_", "")
outputtask = 'split'
elif str(outputtask).endswith(tuple(["!", "+", "-", "<", ">"])):
mainoutputtask = str(outputtask)
if str(outputtask).endswith("!"):
outputtask = 'exclude'
if str(outputtask).endswith("+"):
outputtask = 'incrange_plus'
if str(outputtask).endswith("-"):
outputtask = 'incrange_minus'
if str(outputtask).endswith(">"):
outputtask = 'excrange_plus'
if str(outputtask).endswith("<"):
outputtask = 'excrange_minus'
for r in (("!", ""), ("+", ""), ("-", ""), ("<", ""), (">", "")):
mainoutputtask = mainoutputtask.replace(*r)
if mainoutputtask == 'last':
mainoutputtask = len(inputs)
if outputtask == 'string':
returnvalue = inputs
else:
returnvalue = eval(
'spicemanip_' + outputtask +
'(inputs, outputtask, mainoutputtask, suboutputtask)')
# default return if not specified
if output_type == 'default':
if outputtask in [
'string', 'number', 'rangebetween', 'exclude', 'random',
'incrange_plus', 'incrange_minus', 'excrange_plus',
'excrange_minus'
]:
output_type = 'string'
elif outputtask in ['count']:
output_type = 'dict'
# verify output is correct
if output_type == 'return':
return returnvalue
if output_type == 'string':
if isinstance(returnvalue, list):
returnvalue = ' '.join(returnvalue)
elif output_type in ['list', 'array']:
if not isinstance(returnvalue, list):
returnvalue = list(returnvalue.split(" "))
returnvalue = [x for x in returnvalue if x and x not in ['', ' ']]
returnvalue = [inputspart.strip() for inputspart in returnvalue]
return returnvalue
# compare 2 lists, based on the location of an index item, passthrough needs to be [indexitem, arraytoindex, arraytocompare]
def spicemanip_index(indexitem, outputtask, arraytoindex, arraytocompare):
item = ''
for x, y in zip(arraytoindex, arraytocompare):
if x == indexitem:
item = y
return item
# split list by string
def spicemanip_split(inputs, outputtask, mainoutputtask, suboutputtask):
split_array = []
restring = ' '.join(inputs)
if mainoutputtask not in inputs:
split_array = [restring]
else:
split_array = restring.split(mainoutputtask)
split_array = [x for x in split_array if x and x not in ['', ' ']]
split_array = [inputspart.strip() for inputspart in split_array]
if split_array == []:
split_array = [[]]
return split_array
# dedupe list
def spicemanip_dedupe(inputs, outputtask, mainoutputtask, suboutputtask):
newlist = []
for inputspart in inputs:
if inputspart not in newlist:
newlist.append(inputspart)
return newlist
# Sort list
def spicemanip_sort(inputs, outputtask, mainoutputtask, suboutputtask):
return sorted(inputs)
# reverse sort list
def spicemanip_rsort(inputs, outputtask, mainoutputtask, suboutputtask):
return sorted(inputs)[::-1]
# count items in list, return dictionary
def spicemanip_count(inputs, outputtask, mainoutputtask, suboutputtask):
returndict = dict()
if not len(inputs):
return returndict
uniqueinputitems, uniquecount = [], []
for inputspart in inputs:
if inputspart not in uniqueinputitems:
uniqueinputitems.append(inputspart)
for uniqueinputspart in uniqueinputitems:
count = 0
for ele in inputs:
if (ele == uniqueinputspart):
count += 1
uniquecount.append(count)
for inputsitem, unumber in zip(uniqueinputitems, uniquecount):
returndict[inputsitem] = unumber
return returndict
# random item from list
def spicemanip_random(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
randomselectlist = []
for temppart in inputs:
randomselectlist.append(temppart)
while len(randomselectlist) > 1:
random.shuffle(randomselectlist)
randomselect = randomselectlist[random.randint(
0,
len(randomselectlist) - 1)]
randomselectlist.remove(randomselect)
randomselect = randomselectlist[0]
return randomselect
# remove random item from list
def spicemanip_exrandom(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return []
randremove = spicemanip_random(inputs, outputtask, mainoutputtask,
suboutputtask)
inputs.remove(randremove)
return inputs
# Convert list into lowercase
def spicemanip_lower(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return [inputspart.lower() for inputspart in inputs]
# Convert list to uppercase
def spicemanip_upper(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return [inputspart.upper() for inputspart in inputs]
# Convert list to uppercase
def spicemanip_title(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return [inputspart.title() for inputspart in inputs]
# Reverse List Order
def spicemanip_reverse(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return []
return inputs[::-1]
# comma seperated list
def spicemanip_list(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return ', '.join(str(x) for x in inputs)
def spicemanip_list_nospace(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return ','.join(str(x) for x in inputs)
# comma seperated list with and
def spicemanip_andlist(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
if len(inputs) < 2:
return ' '.join(inputs)
lastentry = str("and " + str(inputs[len(inputs) - 1]))
del inputs[-1]
inputs.append(lastentry)
if len(inputs) == 2:
return ' '.join(inputs)
return ', '.join(str(x) for x in inputs)
# comma seperated list with or
def spicemanip_orlist(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
if len(inputs) < 2:
return ' '.join(inputs)
lastentry = str("or " + str(inputs[len(inputs) - 1]))
del inputs[-1]
inputs.append(lastentry)
if len(inputs) == 2:
return ' '.join(inputs)
return ', '.join(str(x) for x in inputs)
# exclude number
def spicemanip_exclude(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
del inputs[int(mainoutputtask) - 1]
return ' '.join(inputs)
# Convert list to string
def spicemanip_string(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return ' '.join(inputs)
# Get number item from list
def spicemanip_number(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
elif len(inputs) == 1:
return inputs[0]
elif int(mainoutputtask) > len(inputs) or int(mainoutputtask) < 0:
return ''
else:
return inputs[int(mainoutputtask) - 1]
# Get Last item from list
def spicemanip_last(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
return inputs[len(inputs) - 1]
# range between items in list
def spicemanip_rangebetween(inputs, outputtask, mainoutputtask, suboutputtask):
if not len(inputs):
return ''
if not str(mainoutputtask).isdigit() or not str(suboutputtask).isdigit():
return ''
mainoutputtask, suboutputtask = int(mainoutputtask), int(suboutputtask)
if suboutputtask == mainoutputtask:
return spicemanip_number(inputs, outputtask, mainoutputtask,
suboutputtask)
if suboutputtask < mainoutputtask:
return []
if mainoutputtask < 0:
mainoutputtask = 1
if suboutputtask > len(inputs):
suboutputtask = len(inputs)
newlist = []
for i in range(mainoutputtask, suboutputtask + 1):
newlist.append(
str(spicemanip_number(inputs, outputtask, i, suboutputtask)))
if newlist == []:
return ''
return ' '.join(newlist)
# Forward Range includes index number
def spicemanip_incrange_plus(inputs, outputtask, mainoutputtask,
suboutputtask):
if not len(inputs):
return ''
return spicemanip_rangebetween(inputs, outputtask, int(mainoutputtask),
len(inputs))
# Reverse Range includes index number
def spicemanip_incrange_minus(inputs, outputtask, mainoutputtask,
suboutputtask):
if not len(inputs):
return ''
return spicemanip_rangebetween(inputs, outputtask, 1, int(mainoutputtask))
# Forward Range excludes index number
def spicemanip_excrange_plus(inputs, outputtask, mainoutputtask,
suboutputtask):
if not len(inputs):
return ''
return spicemanip_rangebetween(inputs, outputtask,
int(mainoutputtask) + 1, len(inputs))
# Reverse Range excludes index number
def spicemanip_excrange_minus(inputs, outputtask, mainoutputtask,
suboutputtask):
if not len(inputs):
return ''
return spicemanip_rangebetween(inputs, outputtask, 1,
int(mainoutputtask) - 1)
"""