class WpPlugin(parsingplugintemplate):
def __init__(self, bot):
super(WpPlugin, self).__init__(bot,
command="wp",
description="Get things from wikipedia")
self._config = bot.getConfig()
self.parser = JanteParser(description='Get things from wikipedia',
prog='wp',
add_help=False)
self.parser.add_argument('-h',
'--help',
action='store_true',
required=False,
help="Shows this helpful message.")
self.parser.add_argument("search_terms",
nargs="*",
metavar="search terms",
help="Words that will be searched.")
self.parser.add_argument('-e',
'--english',
action='store_true',
required=False,
help="English wikipedia.")
def paste(self, text, message):
return self._bot.getService("paste").paste(text, message)
def search(self, word, lang):
wk.set_lang(lang)
message = ""
try:
page = wk.page(word)
except wk.exceptions.DisambiguationError as e:
return "Did not find anything with that name."
except wk.exceptions.PageError as e:
e
return "Did not find anything with that name."
message += wk.summary(word)
return message if message.strip(
) != "" else "Did not find anything with that name."
def parse(self, message):
try:
args = self.parser.parse_args(message.getText().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
search_terms = " ".join(args.search_terms)
if args.help:
return self.parser.format_help()
if args.english:
return self.paste(self.search(search_terms, "en"), message)
return self.paste(self.search(search_terms, "sv"), message)
class hdiPlugin(parsingplugintemplate):
def __init__(self, bot):
super(hdiPlugin, self).__init__(bot,
command="howdoi",
description="How to do things")
self._config = bot.getConfig()
self.parser = JanteParser(description='Get told how to do things',
prog='howdoi',
add_help=False)
self.parser.add_argument('-h',
'--help',
action='store_true',
required=False,
help="Shows this helpful message.")
self.parser.add_argument("search_terms",
nargs="*",
metavar="search terms",
help="Words that will be searched.")
def paste(self, text, message):
return self._bot.getService("paste").paste(text, message)
def search(self, word):
parser = howdoi.get_parser()
args = vars(parser.parse_args(word.split(' ')))
output = howdoi.howdoi(args)
return output if output.strip(
) != "" else "Did not find anything containing that"
def parse(self, message):
try:
args = self.parser.parse_args(message.getText().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
search_terms = " ".join(args.search_terms)
if args.help:
return self.parser.format_help()
return self.paste(self.search(search_terms), message)
class KanaPlugin(parsingplugintemplate):
def __init__(self, bot):
super(KanaPlugin,
self).__init__(bot,
command="kana",
description="Translates English to japanese kana")
self.parser = JanteParser(
description='Translates English to japanese kana',
prog='kana',
add_help=False)
self.parser.add_argument('-h',
'--help',
action='store_true',
required=False,
help="Shows this helpful message.")
self.parser.add_argument("words", nargs="*", help="The search words")
def kana(self, searchword):
query = urllib.parse.quote(searchword)
HEADER = {
'User-Agent':
"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/43.0.2357.134 Safari/537.36"
}
url = "https://www.sljfaq.org/cgi/e2k.cgi?word=" + query
req = urllib.request.Request(url, headers=HEADER)
response = urllib.request.urlopen(req)
html = response.read()
soup = BeautifulSoup(html, 'html.parser')
kana = soup.find("td", class_="katakana-string").text
return kana.strip()
def parse(self, message):
try:
args = self.parser.parse_args(message.getText().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
ans = " ".join(args.words)
if args.help:
return self.parser.format_help()
else:
return self.kana(ans)
class ArraksPlugin(parsingplugintemplate):
def __init__(self, bot):
super(ArraksPlugin,
self).__init__(bot,
command="arraks",
description="gets anagrams from arraks.fi")
self.parser = JanteParser(description='Gets anagrams from arraks.fi',
prog='arraks',
add_help=False)
self.parser.add_argument('-h',
'--help',
action='store_true',
required=False,
help="Shows this helpful message.")
self.parser.add_argument('-a',
'--all',
action='store_true',
required=False,
help="Gives all found anagrams.")
self.parser.add_argument(
'-l',
'--language',
type=str,
default="sw",
required=False,
help=
"Choose language to get the anagram in, languages being en,fi,no,da,fr,ge,du,la and sw"
)
self.parser.add_argument(
'-n',
'--mwords',
type=int,
default=0,
required=False,
help="Max number of words in anagram, from 1 to 8")
self.parser.add_argument("words", nargs="*", help="The search words")
def arraks(self, word, N, lang, all=False):
if N == 0:
if len(word.split(" ")) < 2:
N = 2
else:
N = len(word.split(" "))
br = mechanize.Browser()
br.set_handle_robots(False)
response = br.open("https://www.arrak.fi/sv/ag")
response.encoding = "utf-8"
br.form = list(br.forms())[0]
#word = word.encode('utf-8')
br["sourcetext"] = word.encode('windows-1252')
br["maxword"] = [str(N)]
languages = [
"Swedish", "English", "Finnish", "Norwegian", "Danish", "French",
"German", "Dutch", "Latin"
]
for language in languages:
if lang.lower() == language[:2].lower():
chlang = language
break
else:
chlang = "Swedish"
br["lang"] = [chlang]
resp = br.submit().read().decode('windows-1252')
resp1 = str(resp)[2:-1]
resp1 = resp1.replace("\n", " ")
print(resp1)
res = re.findall(r'"no">([^<]+)', resp1)
res = (res[0].replace("\\n", " "))
res = (res[:-4])
res = re.split(" | | ", res)
res = [x.strip() for x in res if x.strip()]
res = list(filter(None, res))
result = []
for anagram in res:
if sorted(re.split(r'\s+', word.lower())) != sorted(
re.split(r'\s+', anagram.lower())):
result.append(anagram)
message = ""
if len(result) == 0:
message = "No anagram found"
else:
if all:
for answer in result:
message += (answer + ", ")
message = message[:-2]
else:
message = result[random.randint(0, len(result) - 1)]
return message
def parse(self, message):
try:
args = self.parser.parse_args(message.getText().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
ans = " ".join(args.words)
if args.help:
return self.parser.format_help()
if args.all:
return self.arraks(ans, args.mwords, args.language, True)
else:
return self.arraks(ans, args.mwords, args.language)
class SlPlugin(parsingplugintemplate):
"""
Plugin for echoing things.
Works similar to echo in bash.
"""
def __init__(self, bot):
super(SlPlugin, self).__init__(
bot,
command="sl",
description=
"Shows sl traveling directions, there are no useful arguments yet."
)
self.parser = JanteParser(
description=
'Shows sl traveling directions\n No useful arguments yet.',
prog='sl',
add_help=False)
self.parser.add_argument('-h',
'--help',
action='store_true',
required=False,
help="Shows this helpful message.")
self.parser.add_argument('-a',
'--arrival',
type=str,
default="",
required=False,
help="Set arrival time in format HH:MM")
self.parser.add_argument('-s',
'--start',
type=str,
default="",
required=False,
help="Set starting time in format HH:MM")
self.parser.add_argument(
'-d',
'--date',
type=str,
default="",
required=False,
help="Set date for arrival or departure in format YY-MM-DD")
self.parser.add_argument("words", nargs="*", help="The search words")
def getdirections(self, json):
startnames = []
destnames = []
starttimes = []
desttimes = []
messageslist = []
transportlist = []
linelist = []
if 'Trip' not in json:
return "No trip found"
trip = json['Trip']
leglist = trip[0]['LegList']
leg = leglist['Leg']
for i in range(len(leg)):
if leg[i]['type'] == 'WALK':
continue
origin = leg[i]['Origin']
startnames.append(origin['name'])
starttimes.append(origin['time'][:-3])
destination = leg[i]['Destination']
destnames.append(destination['name'])
desttimes.append(destination['time'][:-3])
if 'Messages' in leg[i]:
messages = leg[i]['Messages']
message = messages['Message']
messageslist.append(message[0]['text'])
if 'Product' in leg[i]:
status = leg[i]['Product']
transport = status['catOutL'].lower()
transportlist.append(transport)
linelist.append(status['line'])
res = "Ta "
for i in range(len(startnames)):
res += (str(transportlist[i]) + "linje " + str(linelist[i]) +
" från " + str(startnames[i]) + " som går kl " +
str(starttimes[i]) + " som ankommer till " + destnames[i] +
" kl " + desttimes[i] + "\n")
if i < len(startnames) - 1:
res += "därefter "
FMT = "%H:%M"
tdelta = datetime.strptime(desttimes[len(desttimes) - 1],
FMT) - datetime.strptime(
starttimes[0], FMT)
res += ("\nDen totala restiden är " + str(tdelta)[:-6] +
" timmar och " + str(tdelta)[2:-3] + " minuter")
return res
def getids(self,
startinput,
destinationinput,
time="",
arrival=0,
date=""):
if startinput == destinationinput:
return "Can't have the same start and destination"
urlstart = "https://api.sl.se/api2/typeahead.json?key=4bae1902a34444108f283cc47fe5ccd3&searchstring=" + startinput
urldest = "https://api.sl.se/api2/typeahead.json?key=4bae1902a34444108f283cc47fe5ccd3&searchstring=" + destinationinput
f = requests.get(urlstart)
f2 = requests.get(urldest)
startlist = json.loads(f.text)
if len(startlist['ResponseData']) == 0:
return "No startlocation found"
start = (startlist['ResponseData'][0])
startid = (start['SiteId'])
destlist = json.loads(f2.text)
if len(destlist['ResponseData']) == 0:
return "No destination found"
dest = (destlist['ResponseData'][0])
destid = (dest['SiteId'])
trip = "https://api.sl.se/api2/TravelplannerV3_1/trip.json?key=d6dcb0574b8b4487a47e38a7079f3866&originExtId=" + startid + "&destExtId=" + destid + "&time=" + str(
time) + "&searchForArrival=" + str(arrival) + "&date=" + date
print(trip)
f3 = requests.get(trip)
tripjson = json.loads(f3.text)
#res += "Valda stationer är " + start['Name'] + " och " + dest['Name']
return self.getdirections(tripjson)
def parse(self, message):
try:
args = self.parser.parse_args(message.getText().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
ans = " ".join(args.words)
print(args.arrival)
print(args.start)
print(args.words)
if args.help:
return self.parser.format_help()
if args.arrival:
if args.date:
return self.getids(args.words[0], args.words[1], args.arrival,
1, args.date)
return self.getids(args.words[0], args.words[1], args.arrival, 1)
if args.start:
if args.date:
return self.getids(args.words[0], args.words[1], args.start, 0,
args.date)
return self.getids(args.words[0], args.words[1], args.start, 0)
if args.date:
return self.getids(args.words[0], args.words[1], args.start, 0,
args.date)
else:
return self.getids(args.words[0], args.words[1])
class PlexPlugin(parsingplugintemplate):
def __init__(self, bot):
super(PlexPlugin, self).__init__(
bot,
command="plex",
description="Search things on Robins Plex-server.")
self._config = bot.getConfig()
self.parser = JanteParser(description='Getting movies from plex',
prog='plex',
add_help=False)
self.parser.add_argument('-h',
'--help',
action='store_true',
required=False,
help="Shows this helpful message.")
self.parser.add_argument("search_terms",
nargs="*",
metavar="search terms",
help="Words that will be searched.")
self.parser.add_argument('-p',
'--plot',
action='store_true',
required=False,
help="Shows movie plot.")
self.parser.add_argument('-t',
'--tagline',
action='store_true',
required=False,
help="Shows movie tagline.")
self.parser.add_argument('-d',
'--duration',
action='store_true',
required=False,
help="Shows movie duration in minutes.")
def paste(self, text, message):
return self._bot.getService("paste").paste(text, message)
def search(self, word, plot=False, tagline=False, duration=False):
server_url = self._config["plex"]["serverUrl"]
api_key = self._config["plex"]["apiKey"]
xml = requests.get(f"{server_url}{api_key}").text
root = ET.fromstring(xml)
movies = {}
entry = {}
message = ""
self.log(word)
for video_tag in root.findall('Video'):
if word.lower() in video_tag.get('title').lower():
entry = {
(video_tag.get('title')): {
'name':
str((video_tag.get('title'))),
'year': (" (" + str(video_tag.get('year')) + ")"),
'plot':
str((video_tag.get('summary'))),
'tagline':
str((video_tag.get('tagline'))),
'duration':
str(round(int(video_tag.get('duration')) / 1000 / 60))
+ " minutes"
}
}
movies.update(entry)
for movie in movies:
message += movies.get(movie).get('name') + movies.get(movie).get(
'year')
if plot == True:
message += " Plot: " + movies.get(movie).get('plot')
if tagline == True:
message += " Tagline: " + movies.get(movie).get('tagline')
if duration == True:
message += " Duration: " + movies.get(movie).get('duration')
message += "\n"
return message if message.strip(
) != "" else "Did not find anything with that name."
def parse(self, message):
try:
args = self.parser.parse_args(message.getText().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
search_terms = " ".join(args.search_terms)
if args.help:
return self.parser.format_help()
if args.plot:
return self.paste(self.search(search_terms, True), message)
if args.tagline:
return self.paste(self.search(search_terms, False, True), message)
if args.duration:
return self.paste(self.search(search_terms, False, False, True),
message)
return self.paste(self.search(search_terms), message)
class EchoPlugin(ParsingPluginTemplate):
"""
Plugin for echoing things.
Works similar to echo in bash.
"""
def __init__(self, bot):
super(EchoPlugin,
self).__init__(bot,
command="echo",
description="Echo text back to the sender")
self.parser = JanteParser(description='Echos things',
prog='echo',
add_help=False)
self.parser.add_argument(
'-t',
'--title',
action='store_true',
required=False,
help="The first characters of each word will be made uppercase.")
self.parser.add_argument('-l',
'--lower',
action='store_true',
required=False,
help="Changes all letters to lowercase.")
self.parser.add_argument(
'-c',
'--capitalize',
action="store_true",
help="Converts the first character of a string to uppercase.")
self.parser.add_argument(
'--url-encode',
action="store_true",
help="Encodes the string according to URL-safe conventions")
self.parser.add_argument('-h',
'--help',
action='store_true',
required=False,
help="Shows this helpful message.")
self.parser.add_argument('-u',
'--all-caps',
'--upper',
action='store_true',
required=False,
help="Return the string in all caps.")
self.parser.add_argument("words",
nargs="*",
help="Words that will be echoed.")
def parse(self, message):
try:
args = self.parser.parse_args(message.get_text().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
ans = " ".join(args.words)
if args.help:
return self.parser.format_help()
if args.lower:
ans = ans.lower()
if args.title:
ans = ans.title()
if args.capitalize:
ans = ans.capitalize()
if args.all_caps:
ans = ans.upper()
if args.url_encode:
ans = urlencode({"": ans})[1:]
return ans
class google(parsingplugintemplate):
def __init__(self, bot):
super(google,
self).__init__(bot,
command="google",
description="Generates Google search queries.")
self.parser = JanteParser(description='Searches Google',
prog='google',
add_help=False)
self.parser.add_argument('-n',
'--results',
type=int,
default=1,
required=False,
help="Amount of results from 1 to 100")
self.parser.add_argument('-h',
'--help',
action='store_true',
required=False,
help="Shows this helpful message.")
self.parser.add_argument('-l',
'--lucky',
action='store_true',
required=False,
help="Displays first result.")
self.parser.add_argument('-i',
'--image',
action='store_true',
required=False,
help="Google Image Search.")
self.parser.add_argument('-r',
'--random',
action='store_true',
required=False,
help="Gives a random Google Search.")
self.parser.add_argument("words", nargs="*", help="The search words")
def gislink(self, searchword, N, random=False):
HEADER = {
'User-Agent':
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.104 Safari/537.36"
}
split_query = searchword.split()
split_query = '+'.join(split_query)
url = "https://www.google.co.in/search?q=" + split_query + "&tbm=isch"
soup = BeautifulSoup(
requests.get(url, headers=HEADER).text, 'html.parser')
imageList = re.findall(r".+(https:.+.jpg)", soup.text[-100000:])
if random:
message = "Searchword: " + searchword + "\n"
else:
message = ""
if len(imageList) == 0:
return "No match for searchword " + searchword
else:
message += imageList[0] + '\n'
message = message[:-1]
return message
def parse(self, message):
try:
args = self.parser.parse_args(message.getText().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
ans = " ".join(args.words)
if args.help:
return self.parser.format_help()
if args.results < 1 or args.results > 100:
return (str(args.results) + " is not a valid result")
if args.lucky:
if args.image:
return self.gislink(ans, args.results)
elif args.random:
words = self._bot.getService("ngramkeeper").getDictionary()
longwords = list(filter(lambda word: len(word) > 5, words))
ans = random.choice(longwords)
querystring = urllib.parse.urlencode({'q': ans, 'btnI': '1'})
return 'https://www.google.com/search?{}'.format(querystring)
else:
querystring = urllib.parse.urlencode({'q': ans, 'btnI': '1'})
return 'https://www.google.com/search?{}'.format(querystring)
if args.random:
if args.image:
words = self._bot.getService("ngramkeeper").getDictionary()
longwords = list(filter(lambda word: len(word) > 5, words))
ans = random.choice(longwords)
return self.gislink(ans, args.results, True)
else:
words = self._bot.getService("ngramkeeper").getDictionary()
longwords = list(filter(lambda word: len(word) > 5, words))
ans = random.choice(longwords)
querystring = urllib.parse.urlencode({'q': ans})
return 'https://www.google.com/search?{}'.format(querystring)
if args.image:
return self.gislink(ans, args.results)
else:
querystring = urllib.parse.urlencode({'q': ans})
return 'https://www.google.com/search?{}'.format(querystring)
class DictPlugin2(ParsingPluginTemplate):
class DictManager():
"""
self._datadict["__global__"] is data that is used by everyone
self._datadict["u_<username>"] is user specific data and can only be accessed by that user.
"""
def __init__(self, config, filename):
self._config = config
self._filename = filename
self._global_username = "******"
self._user_prefix = "u_"
try:
file_object = open(self._filename, "r").read()
if not len(file_object) == 0:
self._datadict = defaultdict(dict, json.loads(file_object))
else :
self._datadict = defaultdict(dict)
except:
self._datadict = defaultdict(dict)
self._mutex = threading.Lock()
def _location_key(self, user, global_):
if global_:
return self._global_username
else:
return "{}{}".format(self._user_prefix)
def exists(self, key, user="", global_=True):
return key in self._datadict[self._location_key(user, global_)]
def save(self):
with self._mutex:
file_object = open(self._filename, 'w+')
file_object.write(json.dumps(self._datadict))
file_object.close()
def keys(user="", global_=True):
return self._datadict[self._location_key(user, global_)].keys()
def items(user="", global_=True):
items_ = self._datadict[self._location_key(user, global_)].items()
return sorted(items_, key=lambda x: x[0])
def remove(self, key, user="", global_=True):
if not key in self._datadict[self._location_key(user, global_)]:
return False
del self._datadict[self._location_key(user, global_)][key]
return True
def get_dict(self):
return self._datadict
def get(self, key, user="", global_=True):
return self._datadict[self._location_key(user, global_)][key]
def size(self, user="", global_=True):
return len(self.keys(user=user,global_=global_))
def keys(self, user="", global_=True):
return self._datadict[self._location_key(user, global_)].keys()
def insert(self, key, value, force, global_=True, user=""):
"""
Returns true if value was inserted, false if it was already present and force == False
"""
current_time = time.time()
location = self._location_key(user, global_)
if key in self._datadict[location]:
if force:
user_insert = self._datadict[location][key]["user_insert"]
time_insert = self._datadict[location][key]["time_insert"]
else:
return False
else:
user_insert = user
time_insert = current_time
with self._mutex:
self._datadict[location][key] = {
"value": value,
"user_insert": user_insert,
"time_insert": time_insert,
"user_update": user,
"time_update": current_time
}
return True
def __init__(self, bot):
self._config = configparser.ConfigParser()
self._config.read("plugins/dict2/settings.ini")
super(DictPlugin2, self).__init__(bot, command=self._config.get('dict','command', fallback="dict"), description="Keys and values!")
filename = "{datapath}{filename}".format(datapath=self._bot.get_base_data_path(), filename=self._config.get("dict",'savefilename', fallback="dict2plugindata.json"))
self._dict_manager = DictPlugin2.DictManager(self._config, filename)
self._options = defaultdict(list)
self.parser = JanteParser(description='Keeps a dictionary of things.', prog='dict', add_help=False)
self.parser.add_argument('-h', '--help', action='store_true', required=False, help="Shows this helpful message.")
self.parser.add_argument('-k', '--key', help="The key to save the value with. Must be used with -v.")
self.parser.add_argument('-v', '--value', help="The value to be stored. Must be used with -k.")
self.parser.add_argument('-r', '--remove', '--delete', help="Remove a key-value pair.")
self.parser.add_argument('--list', action='store_true', help="List all key-value pairs.")
self.parser.add_argument('--raw', action='store_true', help="Output data as raw as possible.")
self.parser.add_argument('--size', action='store_true', help="Show the number of keys that are saved.")
self.parser.add_argument('--keys', action="store_true", help="Return a list of all keys.")
self.parser.add_argument('-p', '--pick', type=int, help="Pick option <index> from options recommended to you earlier.")
self.parser.add_argument('--force', '-f', action='store_true', help="Force an overwrite if the key already exists.")
self.parser.add_argument('--local', '-l', action='store_false', dest="global_", default=True, help="Store or retrieve values stored by the user.")
self.parser.add_argument('--global', dest="global_", action="store_true", default=True, help="Store or retrieve globally stored values")
self.parser.add_argument('--info', action="store_true", help="Show more info about when supplying a key.")
self.parser.add_argument("ARGS", nargs="*", help="Positional arguments to dict.")
def save(self):
self._dict_manager.save()
def paste(self, text, message):
return self._bot.get_service("paste").paste(text, message)
def add_new_pair(self, key, value, force=False, user=0, global_=True):
if len(key) < int(self._config.get('dict','min_key_length',fallback=3)):
return ValueError("Key length was shorter than the minimum key length {}.".format(self._config.get('dict','min_key_length',fallback=3)))
if "\n" in key:
return ValueError("Can't have a newline in the key.")
if self._dict_manager.insert(key, value, force=force, user=user, global_=global_):
self.save()
return "Inserted keypair \"{key}: {value}\".".format(key=key,value=value)
else:
return ValueError('Key "{}" is already present in the dict. Use --force to overwrite it.'.format(key))
def get(self, key, extra_info=False, user="", global_=True):
if not self._dict_manager.exists(key, user=user, global_=global_):
if self._dict_manager.size(user=user, global_=global_) == 0:
return RuntimeError("No keys currently exist")
options = similar.possibilities(key, list(self._dict_manager.keys(user=user, global_=global_)), use_random=True, subsets=True)
if global_:
location = None
else:
location = user
self._options[location] = options
if len(options) == 1:
return KeyError('\n"{}" is the only key similar to what you looked after. Here is its contents:\n{}'.format(options[0], self.get(options[0], extra_info=extra_info, user=user, global_=global_)))
tmp = []
for i in range(1, len(options) + 1):
tmp.append('{}: "{}"'.format(i, options[i - 1]))
return KeyError('\nCould not find key "{}". Could you have meant:\n{}?'.format(key, '; '.join(tmp)))
data = self._dict_manager.get(key, user=user, global_=global_)
if not extra_info:
return data["value"]
return "Key: {key}\nValue: {value}\nKey created by {insert_person} on {inserted}\nLatest update by {update_person} on {update}".format(key=key, value=data["value"], inserted=datetime.datetime.fromtimestamp(data["time_insert"]).strftime('%c'), insert_person=data["user_insert"], update=datetime.datetime.fromtimestamp(data["time_update"]).strftime('%c'), update_person=data["user_update"])
def parse(self, message):
try:
args = self.parser.parse_args(shlex.split(message.get_text()))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
user = message.get_alias()
if args.help:
return self.parser.format_help()
if args.list:
ans = ""
for key, value in self._dict_manager.items():
ans += "{}\n\t{}\n".format(key, value)
if ans == "":
return "No pairs are stored."
return self.paste(ans, message)
if args.pick:
if args.global_:
location = None
else:
location = user
if len(self._options[location]) == 0:
return RuntimeError('There are no options to pick at this moment.')
if args.pick > len(self._options[location]) or args.pick < 1:
return RuntimeError('You can only pick numbers between 1 and {}.'.format(len(self._options)))
return self.paste(self.get(self._options[location][args.pick - 1], user=user, global_=args.global_, extra_info=args.info), message)
if args.remove:
key = args.remove.strip()
if self._dict_manager.remove(key, user=user, global_=args.global_):
self.save()
return 'Value associated with key "{}" was removed.'.format(key)
else:
return 'Could not remove the key. Are you sure it is present?'
if args.keys:
return self.paste("\n".join(sorted(self._dict_manager.keys(user=user, global_=args.global_))), message)
if args.size:
size = self._dict_manager.size(user=user, global_=args.global_)
if args.raw:
return str(size)
return 'There are {} keys at the moment.'.format(size)
if (args.value or args.key):
if not (args.value and args.key):
return ValueError("Must supply both key and value")
return self.add_new_pair(args.key, args.value, args.force, message)
m = re.match(r"(.*[^\s]+)\s*:=\s*(.+)", " ".join(args.ARGS))
if m:
return self.add_new_pair(m.group(1), m.group(2), force=args.force, user=user, global_=args.global_)
key = " ".join(args.ARGS)
return self.paste(self.get(key, extra_info=args.info, user=user, global_=args.global_), message)
class AnidbPlugin(parsingplugintemplate):
def __init__(self, bot):
super(AnidbPlugin, self).__init__(bot,
command="anidb",
description="Searches anidb")
self.parser = JanteParser(description='Searches anidb',
prog='anidb',
add_help=False)
self.parser.add_argument('-h',
'--help',
action='store_true',
required=False,
help="Shows this helpful message.")
self.parser.add_argument("words", nargs="*", help="The search words")
def anidb(self, searchword):
headers = {}
headers[
'User-Agent'] = "Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1312.27 Safari/537.17"
query = urllib.parse.quote(searchword)
url = "https://anidb.net/search/fulltext/?adb.search=" + query + "&do.search=1&entity.animetb=1&field.titles=1"
req = urllib.request.Request(url, headers=headers)
response = urllib.request.urlopen(req)
html = response.read()
soup = BeautifulSoup(html, 'html.parser')
score = soup.find_all('td', {'class': 'score'})
name = soup.find_all('td', {'class': 'relid'})
link = re.findall(r'href="([^"]+)',
str(soup.find_all('td', {'class': 'relid'})))
distance = 100
count = 0
index = 0
for series in name:
tmpdistance = self.levenshteinDistanceDP(series.text.lower(),
searchword.lower())
if tmpdistance < distance:
distance = tmpdistance
index = count
count += 1
if len(link) == 0:
message = ("No anime found (" + searchword + ")")
else:
descNImg = self.aniDescImg(link[index])
if descNImg[0] == "Adult":
message = "Adult content you f*****g hentai!"
else:
message = (name[index].text + ": Score: " + score[index].text +
"\n\n" + descNImg[0] + "\n\n" + descNImg[1])
return message
def aniDescImg(self, url):
headers = {}
headers[
'User-Agent'] = "Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1312.27 Safari/537.17"
url = ("https://anidb.net" + url)
req = urllib.request.Request(url, headers=headers)
response = urllib.request.urlopen(req)
html = response.read()
soup = BeautifulSoup(html, 'html.parser')
adult = soup.find('h1', {'class': 'anime'}).text
if adult == "Adult Content Warning":
desc = "Adult"
img = None
else:
desc = soup.find_all('div',
{'class': 'g_bubble g_section desc resized'})
if len(desc) == 0:
desc = ""
image = soup.find('img', alt=True)
img = image["src"]
else:
desc = desc[0].text
image = soup.find('img', alt=True)
img = image["src"]
return [desc, img]
def levenshteinDistanceDP(self, token1, token2):
distances = numpy.zeros((len(token1) + 1, len(token2) + 1))
for t1 in range(len(token1) + 1):
distances[t1][0] = t1
for t2 in range(len(token2) + 1):
distances[0][t2] = t2
a = 0
b = 0
c = 0
for t1 in range(1, len(token1) + 1):
for t2 in range(1, len(token2) + 1):
if (token1[t1 - 1] == token2[t2 - 1]):
distances[t1][t2] = distances[t1 - 1][t2 - 1]
else:
a = distances[t1][t2 - 1]
b = distances[t1 - 1][t2]
c = distances[t1 - 1][t2 - 1]
if (a <= b and a <= c):
distances[t1][t2] = a + 1
elif (b <= a and b <= c):
distances[t1][t2] = b + 1
else:
distances[t1][t2] = c + 1
return distances[len(token1)][len(token2)]
def parse(self, message):
try:
args = self.parser.parse_args(message.getText().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
ans = " ".join(args.words)
if args.help:
return self.parser.format_help()
else:
return self.anidb(ans)
class YoutubePlugin(parsingplugintemplate):
def __init__(self, bot):
super(YoutubePlugin, self).__init__(bot,
command="youtube", description="Searches youtube")
self.parser = JanteParser(description='Searches youtube', prog='youtube', add_help=False)
self.parser.add_argument('-n', '--results', type=int, default=1, required=False,
help="Amount of results from 1 to 20")
self.parser.add_argument('-h', '--help', action='store_true', required=False,
help="Shows this helpful message.")
self.parser.add_argument('-r', '--random', action='store_true', required=False,
help="Gives a random youtube link.")
self.parser.add_argument('-s', '--streaming', action='store_true', required=False,
help="Check if anyone is streaming.")
self.parser.add_argument("words", nargs="*",
help="The search words")
def ytstreaming(self):
url = ["https://www.youtube.com/channel/UCRU8PSSNf8n_68UZ1iXyr3A", "https://www.youtube.com/user/lurlurlur", "https://www.youtube.com/user/FxH1337", "https://www.youtube.com/channel/UCM9th0j-83uvnP8yfVkqEYw"]
message = ""
for channel in url:
req = urllib.request.Request(channel)
req.add_header("Accept-Language", "en-US,en;q=0.5")
response = urllib.request.urlopen(req)
html = response.read()
live = re.findall("(text\":\"LIVE)", str(html))
if len(live) == 0:
message += ""
#print(channel + " is empty")
else:
if "68UZ1iXyr3A" in channel or "83uvnP8yfVkqEYw" in channel:
name = "Sork: "
elif "FxH1337" in channel:
name = "Felix: "
else:
name = "Lur: "
link = re.findall("watch\?v=([A-Za-z0-9-_]*)", str(html))
title = self.yt("https://www.youtube.com/watch?v=" + link[0])
message += name + title + " https://www.youtube.com/watch?v=" + link[0] + "\n"
if message == "":
return "No one is streaming atm"
else:
return message
def yt(self, yturl):
url = yturl
response = urllib.request.urlopen(url)
html = response.read().decode('utf-8')
soup = BeautifulSoup(html, 'html.parser')
title = soup.find("meta", {"name":"title"})
title = title["content"]
message = ""
if len(title) == 0:
message += ("There is no such video")
else:
message += str(title)
return message
def ytlink(self, searchword, N, random = False):
query = urllib.parse.quote(searchword)
url = "https://www.youtube.com/results?search_query=" + query
response = urllib.request.urlopen(url)
html = response.read()
soup = BeautifulSoup(html, 'html.parser')
ytlist = []
i = 1
video = re.findall(r'videoIds":\["([^"]+)', soup.text)
#title = re.findall(r'title":{"runs":\[{"text":"([^"]+)', soup.text)
#ytlist.append(str(youtuber) + ": " + vid['title'] + ' https://www.youtube.com' + vid['href'])
ytlist.append(self.yt('https://www.youtube.com/watch?v=' + video[0]) + ' https://www.youtube.com/watch?v=' + video[0])
#i = i + 1
ytlist = ytlist[0:N]
if random:
message = "Searchword: " + searchword + "\n"
else:
message = ""
for link in ytlist:
message += link + '\n'
message = message[:-1]
if message == "":
return "No match for searchword " + searchword
else:
return message
def parse(self, message):
try:
args = self.parser.parse_args(message.getText().split(" "))
except ArgumentParserError as error:
return ArgumentParserError("\n{}".format(error))
ans = " ".join(args.words)
if args.help:
return self.parser.format_help()
if args.streaming:
return self.ytstreaming()
if args.results < 1 or args.results > 20:
return (str(args.results) + " is not a valid result")
if args.random:
words = self._bot.getService("ngramkeeper").getDictionary()
longwords = list(filter(lambda word: len(word) > 5, words))
ans = random.choice(longwords)
return self.ytlink(ans, args.results, True)
else:
return self.ytlink(ans, args.results)