def yt(self, event):
"""
:help: Find a video on youtube
:usage: [query/URL]
"""
url = None
search = None
if event["args"]:
search = event["args"]
url_match = re.match(REGEX_YOUTUBE, event["args"])
if url_match:
url = event["args"]
else:
search = event["args"]
else:
url = event["target"].buffer.find(REGEX_YOUTUBE)
url = utils.http.url_sanitise(url.match) if url else None
from_url = not url == None
if not url:
safe_setting = event["target"].get_setting("youtube-safesearch",
True)
safe = "moderate" if safe_setting else "none"
search_page = utils.http.request(
URL_YOUTUBESEARCH,
get_params={
"q": search,
"part": "snippet",
"maxResults": "1",
"type": "video",
"key": self.bot.config["google-api-key"],
"safeSearch": safe
},
json=True)
if search_page:
if search_page.data["pageInfo"]["totalResults"] > 0:
url = URL_VIDEO % search_page.data["items"][0]["id"][
"videoId"]
else:
raise utils.EventError("No videos found")
else:
raise utils.EventsResultsError()
if url:
out = self._from_url(url)
if not out == None:
out, short_url = out
if not from_url:
out = "%s %s" % (out, short_url)
event["stdout"].write(out)
else:
raise utils.EventsResultsError()
else:
event["stderr"].write("No search phrase provided")
def yt(self, event):
"""
:help: Find a video on youtube
:usage: [query/URL]
"""
video_id = None
search = None
if event["args"]:
search = event["args"]
else:
last_youtube = event["target"].buffer.find(REGEX_YOUTUBE)
if last_youtube:
search = last_youtube.message
if search:
url_match = re.search(REGEX_YOUTUBE, search)
if url_match:
video_id = url_match.group(1)
if search or video_id:
safe_setting = event["target"].get_setting("youtube-safesearch",
True)
safe = "moderate" if safe_setting else "none"
if not video_id:
search_page = utils.http.request(
URL_YOUTUBESEARCH,
get_params={
"q": search,
"part": "snippet",
"maxResults": "1",
"type": "video",
"key": self.bot.config["google-api-key"],
"safeSearch": safe
},
json=True)
if search_page:
if search_page.data["pageInfo"]["totalResults"] > 0:
video_id = search_page.data["items"][0]["id"][
"videoId"]
else:
raise utils.EventError("No videos found")
else:
raise utils.EventsResultsError()
if video_id:
details = self.video_details(video_id)
if details:
event["stdout"].write(self.video_details(video_id))
else:
raise utils.EventsResultsError()
else:
event["stderr"].write("No search phrase provided")
else:
event["stderr"].write("No search phrase provided")
def ud(self, event):
"""
:help: Get the definition of a provided term from Urban Dictionary
:usage: <term> [#<number>]
"""
number = 1
term = event["args_split"]
if (event["args_split"][-1].startswith("#")
and len(event["args_split"]) > 1
and event["args_split"][-1][1:].isdigit()):
number = int(event["args_split"][-1][1:])
term = term[:-1]
term = " ".join(term)
page = utils.http.request(URL_URBANDICTIONARY,
get_params={"term": term},
json=True)
if page:
if len(page.data["list"]):
if number > 0 and len(page.data["list"]) > number - 1:
definition = page.data["list"][number - 1]
event["stdout"].write(
"%s: %s" %
(definition["word"], definition["definition"].replace(
"\n", " ").replace("\r", "").replace(" ", " ")))
else:
event["stderr"].write("Definition number does not exist")
else:
event["stderr"].write("No results found")
else:
raise utils.EventsResultsError()
def suggest(self, event):
"""
:help: Get suggested phrases from Google
:usage: [phrase]
"""
phrase = event["args"] or event["target"].buffer.get()
if phrase:
page = utils.http.request(URL_GOOGLESUGGEST,
get_params={
"output": "json",
"client": "hp",
"gl": "gb",
"q": phrase
})
if page:
# google gives us jsonp, so we need to unwrap it.
page = page.data.split("(", 1)[1][:-1]
page = json.loads(page)
suggestions = page[1]
suggestions = [
utils.http.strip_html(s[0]) for s in suggestions
]
if suggestions:
event["stdout"].write("%s: %s" %
(phrase, ", ".join(suggestions)))
else:
event["stderr"].write("No suggestions found")
else:
raise utils.EventsResultsError()
else:
event["stderr"].write("No phrase provided")
def google(self, event):
"""
:help: Get first Google result for a given search term
:usage: [search term]
"""
phrase = event["args"] or event["target"].buffer.get()
if phrase:
safe_setting = event["target"].get_setting("google-safesearch",
True)
safe = "active" if safe_setting else "off"
page = utils.http.request(URL_GOOGLESEARCH,
get_params={
"q": phrase,
"key":
self.bot.config["google-api-key"],
"cx":
self.bot.config["google-search-id"],
"prettyPrint": "true",
"num": 1,
"gl": "gb",
"safe": safe
},
json=True)
if page:
if "items" in page.data and len(page.data["items"]):
event["stdout"].write(
"(%s) %s" % (phrase, page.data["items"][0]["link"]))
else:
event["stderr"].write("No results found")
else:
raise utils.EventsResultsError()
else:
event["stderr"].write("No phrase provided")
def spotify(self, event):
"""
:help: Search for a track on spotify
:usage: <term>
"""
token = self._get_token()
page = utils.http.request(
URL_SEARCH,
get_params={
"type": "track",
"limit": 1,
"q": event["args"]
},
headers={"Authorization": "Bearer %s" % token},
json=True)
if page:
if len(page.data["tracks"]["items"]):
item = page.data["tracks"]["items"][0]
title = item["name"]
artist_name = item["artists"][0]["name"]
url = item["external_urls"]["spotify"]
event["stdout"].write("%s (by %s) %s" %
(title, artist_name, url))
else:
event["stderr"].write("No results found")
else:
raise utils.EventsResultsError()
def time(self, event):
"""
:help: Get the time for you or someone else
:usage: [nickname]
"""
target_user = event["user"]
if event["args"]:
target_user = event["server"].get_user(event["args_split"][0])
location = target_user.get_setting("location", None)
if not location == None:
page = utils.http.request(API % location["timezone"], json=True)
if page and page.data and not page.data.get("error", None):
dt = utils.iso8601_parse(page.data["datetime"],
microseconds=True)
human = utils.datetime_human(dt)
event["stdout"].write("Time for %s: %s" % (target_user.nickname,
human))
else:
raise utils.EventsResultsError()
else:
event["stderr"].write("%s doesn't have a location set" %
target_user.nickname)
def wikipedia(self, event):
"""
:help: Get information from wikipedia
:usage: <term>
"""
page = utils.http.request(URL_WIKIPEDIA,
get_params={
"action": "query",
"prop": "extracts",
"titles": event["args"],
"exintro": "",
"explaintext": "",
"exchars": "500",
"redirects": "",
"format": "json"
},
json=True)
if page:
pages = page.data["query"]["pages"]
article = list(pages.items())[0][1]
if not "missing" in article:
title, info = article["title"], article["extract"]
info = info.replace("\n\n", " ").split("\n")[0]
event["stdout"].write("%s: %s" % (title, info))
else:
event["stderr"].write("No results found")
else:
raise utils.EventsResultsError()
def ud(self, event):
"""
:help: Get the definition of a provided term from Urban Dictionary
:usage: <term>
"""
term = event["args"]
number = 1
match = re.match(REGEX_DEFNUMBER, term)
if match:
number = int(match.group(1))
term = term.split(" ", 1)[1]
page = utils.http.request(URL_URBANDICTIONARY,
get_params={"term": term},
json=True)
if page:
if len(page.data["list"]):
if number > 0 and len(page.data["list"]) > number - 1:
definition = page.data["list"][number - 1]
event["stdout"].write(
"%s: %s" %
(definition["word"], definition["definition"].replace(
"\n", " ").replace("\r", "").replace(" ", " ")))
else:
event["stderr"].write("Definition number does not exist")
else:
event["stderr"].write("No results found")
else:
raise utils.EventsResultsError()
def cve(self, event):
"""
:help: Get information for a CVE number
:usage: <CVE>
"""
cve_id = event["args_split"][0].upper()
if not cve_id.startswith("CVE-"):
cve_id = "CVE-%s" % cve_id
page = utils.http.request(URL_CVE % cve_id).json()
if page:
cve_id = page["id"]
published = "%sZ" % page["Published"].rsplit(".", 1)[0]
published = datetime.datetime.strptime(published,
utils.ISO8601_PARSE)
published = datetime.datetime.strftime(published, "%Y-%m-%d")
rank = page["cvss"]
summary = page["summary"]
event["stdout"].write("%s, %s (%s): %s" %
(cve_id, published, rank, summary))
else:
raise utils.EventsResultsError()
def wa(self, event):
"""
:help: Evauate a given string on Wolfram|Alpha
:usage: <query>
"""
try:
page = utils.http.request(
URL_WA,
get_params={
"i": event["args"],
"appid": self.bot.config["wolframalpha-api-key"],
"reinterpret": "true",
"units": "metric"
},
code=True)
except utils.http.HTTPTimeoutException:
page = None
if page:
if page.code == 200:
event["stdout"].write("%s: %s" % (event["args"], page.data))
else:
event["stdout"].write("No results")
else:
raise utils.EventsResultsError()
def get_book(self, query, event):
page = utils.http.request(URL_GOOGLEBOOKS,
get_params={
"q": query,
"country": "us"
}).json()
if page:
if page["totalItems"] > 0:
book = page["items"][0]["volumeInfo"]
title = book["title"]
sub_title = (
", %s" %
book.get("subtitle")) if book.get("subtitle") else ""
authors = ", ".join(book.get("authors", []))
authors = " - %s" % authors if authors else ""
date = book.get("publishedDate", "")
date = " (%s)" % date if date else ""
rating = book.get("averageRating", -1)
rating = " (%s/5.0)" % rating if not rating == -1 else ""
id = re.search(REGEX_BOOKID, book["infoLink"]).group(1)
info_link = " %s" % (URL_BOOKINFO % id)
event["stdout"].write(
"%s%s%s%s%s%s" %
(title, authors, date, sub_title, info_link, rating))
else:
event["stderr"].write("Unable to find book")
else:
raise utils.EventsResultsError()
def random_word(self, event):
"""
:help: Define a random word
"""
if not self._last_called or (time.time() - self._last_called >=
RANDOM_DELAY_SECONDS):
self._last_called = time.time()
page = utils.http.request(URL_WORDNIK_RANDOM,
get_params={
"api_key":
self.bot.config["wordnik-api-key"],
"min_dictionary_count":
1
},
json=True)
if page and len(page.data):
definition = self._get_definition(page.data["word"])
if definition and len(definition.data):
definition = definition.data[0]
else:
raise utils.EventError("Try again in a couple of seconds")
event["stdout"].write("Random Word: %s - Definition: %s" %
(page.data["word"], definition["text"]))
else:
raise utils.EventsResultsError()
else:
event["stderr"].write("Try again in a couple of seconds")
def _get_relays_details(search):
page = utils.http.request(URL_ONIONOO_DETAILS,
get_params={"search": search},
json=True)
if page and "relays" in page.data:
return page.data["relays"]
raise utils.EventsResultsError()
def drug(self, event):
drug = self._get_drug(event["args_split"][0])
if drug:
if not drug["err"]:
pretty_name = drug["data"][0]["pretty_name"]
drug = drug["data"][0]["properties"]
if len(event["args_split"]) > 1:
category = event["args_split"][1].lower()
if category in drug:
data = drug[category]
if isinstance(data, list):
data = ", ".join(data)
event["stdout"].write("%s %s: %s - %s" %
(pretty_name, category, data,
URL_WIKI % pretty_name))
else:
event["stderr"].write("Unknown category '%s'" %
category)
else:
categories = ", ".join(drug.keys())
event["stdout"].write("%s data categories: %s" %
(pretty_name, categories))
else:
event["stderr"].write("Unknown drug")
else:
raise utils.EventsResultsError()
def weather(self, event):
"""
:help: Get current weather data for a provided location
:usage: <location>
"""
api_key = self.bot.config["openweathermap-api-key"]
page = utils.http.request(URL_WEATHER,
get_params={
"q": event["args"],
"units": "metric",
"APPID": api_key
},
json=True)
if page:
if "weather" in page.data:
location = "%s, %s" % (page.data["name"],
page.data["sys"]["country"])
celsius = "%dC" % page.data["main"]["temp"]
fahrenheit = "%dF" % ((page.data["main"]["temp"] *
(9 / 5)) + 32)
description = page.data["weather"][0]["description"].title()
humidity = "%s%%" % page.data["main"]["humidity"]
wind_speed = "%sKM/h" % page.data["wind"]["speed"]
event["stdout"].write(
"(%s) %s/%s | %s | Humidity: %s | Wind: %s" %
(location, celsius, fahrenheit, description, humidity,
wind_speed))
else:
event["stderr"].write(
"No weather information for this location")
else:
raise utils.EventsResultsError()
def acronym(self, event):
query = event["args_split"][0].upper()
response = utils.http.request(API % query, soup=True)
if response.data:
acronyms = []
for element in response.data.find_all("acro"):
acronyms.append(element.expan.string)
event["stdout"].write("%s: %s" % (query, ", ".join(acronyms)))
else:
raise utils.EventsResultsError()
def soundcloud(self, event):
"""
:help: Search SoundCloud
:usage: <term>
"""
query = None
url = None
if event["args"]:
match = re.search(REGEX_SOUNDCLOUD, event["args"])
if match:
url = match.string
else:
query = event["args"]
else:
last_soundcloud = event["target"].buffer.find(REGEX_SOUNDCLOUD)
if last_soundcloud:
url = re.match(REGEX_SOUNDCLOUD,
last_soundcloud.message).string
if not query and not url:
raise utils.EventError("no search phrase provided")
has_query = not query == None
get_params = {
"limit": 1,
"client_id": self.bot.config["soundcloud-api-key"]
}
if query:
get_params["q"] = query
else:
get_params["url"] = url
page = utils.http.request(
URL_SOUNDCLOUD_TRACK if has_query else URL_SOUNDCLOUD_RESOLVE,
get_params=get_params,
json=True)
if page:
if len(page.data):
page = page.data[0] if has_query else page
title = page["title"]
user = page["user"]["username"]
duration = time.strftime("%H:%M:%S",
time.gmtime(page["duration"] / 1000))
if duration.startswith("00:"):
duration = duration[3:]
link = page["permalink_url"]
event["stdout"].write("%s [%s] (posted by %s) %s" %
(title, duration, user, link))
else:
event["stderr"].write("No results found")
else:
raise utils.EventsResultsError()
def weather(self, event):
"""
:help: Get current weather for you or someone else
:usage: [nickname]
:require_setting: location
:require_setting_unless: 1
"""
api_key = self.bot.config["openweathermap-api-key"]
location = None
if event["args"]:
if len(event["args_split"]) == 1 and event["server"].has_user_id(
event["args_split"][0]):
target_user = event["server"].get_user(event["args_split"][0])
location = self._user_location(target_user)
if location == None:
raise utils.EventError("%s doesn't have a location set" %
target_user.nickname)
else:
location = self._user_location(event["user"])
if location == None:
raise utils.EventError("You don't have a location set")
args = {"units": "metric", "APPID": api_key}
if location:
lat, lon = location
args["lat"] = lat
args["lon"] = lon
else:
args["q"] = event["args"]
page = utils.http.request(URL_WEATHER, get_params=args, json=True)
if page:
if "weather" in page.data:
location = "%s, %s" % (page.data["name"],
page.data["sys"]["country"])
celsius = "%dC" % page.data["main"]["temp"]
fahrenheit = "%dF" % ((page.data["main"]["temp"] *
(9 / 5)) + 32)
description = page.data["weather"][0]["description"].title()
humidity = "%s%%" % page.data["main"]["humidity"]
wind_speed = "%sKM/h" % page.data["wind"]["speed"]
event["stdout"].write(
"(%s) %s/%s | %s | Humidity: %s | Wind: %s" %
(location, celsius, fahrenheit, description, humidity,
wind_speed))
else:
event["stderr"].write(
"No weather information for this location")
else:
raise utils.EventsResultsError()
def now_watching(self, event):
"""
:help: Get what you or another user is now watching on trakt.tv
:usage: [username]
"""
if event["args"]:
username = event["args_split"][0]
else:
username = event["user"].get_setting("trakt",
event["user"].nickname)
page = utils.http.request(URL_TRAKT % username,
headers={
"Content-Type":
"application/json",
"trakt-api-version":
"2",
"trakt-api-key":
self.bot.config["trakt-api-key"]
},
json=True,
code=True)
if page:
if page.code == 200:
type = page.data["type"]
if type == "movie":
title = page.data["movie"]["title"]
year = page.data["movie"]["year"]
slug = page.data["movie"]["ids"]["slug"]
event["stdout"].write(
"%s is now watching %s (%s) %s" %
(username, title, year, URL_TRAKTSLUG %
("movie", slug)))
elif type == "episode":
season = page.data["episode"]["season"]
episode_number = page.data["episode"]["number"]
episode_title = page.data["episode"]["title"]
show_title = page.data["show"]["title"]
show_year = page.data["show"]["year"]
slug = page.data["show"]["ids"]["slug"]
event["stdout"].write(
"%s is now watching %s s%se%s - %s %s" %
(username, show_title, str(season).zfill(2),
str(episode_number).zfill(2), episode_title,
URL_TRAKTSLUG % ("shows", slug)))
else:
print("ack! unknown trakt media type!")
else:
event["stderr"].write("%s is not watching anything" % username)
else:
raise utils.EventsResultsError()
def time(self, event):
target_user, location = self._find_setting(event)
if not location == None:
page = utils.http.request(API % location["timezone"], json=True)
if page and page.data and not page.data.get("error", None):
dt = utils.iso8601_parse(page.data["datetime"],
microseconds=True)
human = utils.datetime_human(dt)
event["stdout"].write("Time for %s: %s" %
(target_user.nickname, human))
else:
raise utils.EventsResultsError()
else:
event["stderr"].write(NOLOCATION % target_user.nickname)
def _gallery_info(self, hash):
api_key = self.bot.config["imgur-api-key"]
result = utils.http.request(
URL_GALLERY % hash,
headers={"Authorization": "Client-ID %s" % api_key},
json=True)
if result and result.data["success"]:
data = result.data["data"]
text = self._prefix(data)
text += "(%d views, %d▲▼%d)" % (data["views"], data["ups"],
data["downs"])
if data["title"]:
text += " %s" % data["title"]
return text
else:
raise utils.EventsResultsError()
def _image_info(self, hash):
api_key = self.bot.config["imgur-api-key"]
result = utils.http.request(
URL_IMAGE % hash,
headers={"Authorization": "Client-ID %s" % api_key},
json=True)
if result and result.data["success"]:
data = result.data["data"]
text = self._prefix(data)
text += "(%s %dx%d, %d views)" % (data["type"], data["width"],
data["height"], data["views"])
if data["title"]:
text += " %s" % data["title"]
return text
else:
raise utils.EventsResultsError()
def imgur(self, event):
"""
:help: Get information about a given imgur image URL
:usage: <url>
"""
image_match = REGEX_IMAGE.match(event["args_split"][0])
result = None
if image_match:
result = self._image_info(image_match.group(1))
else:
gallery_match = REGEX_GALLERY.match(event["args_split"][0])
if gallery_match:
result = self._gallery_info(gallery_match.group(1))
if result:
event["stdout"].write(result)
else:
raise utils.EventsResultsError()
def beenpwned(self, event):
"""
:help: Find out if a username, email or similar has appeared in any
hacked databases
:usage: <username/email>
"""
page = utils.http.request(URL_HAVEIBEENPWNEDAPI % event["args"],
json=True,
code=True)
if page:
if page.code == 200:
event["stdout"].write(
"It seems '%s' has been pwned. check on %s." %
(event["args"], URL_HAVEIBEENPWNED))
else:
event["stdout"].write("It seems '%s' has not been pwned" %
(event["args"]))
else:
raise utils.EventsResultsError()
def upc(self, event):
"""
:help: Look up a product by UPC, EAN or GTIN
:usage: <UPC|EAN|GTIN>
"""
arg_len = len(event["args_split"][0])
if not arg_len == 12 and not arg_len == 13:
raise utils.EventError("Invalid UPC/EAN/GTIN provided")
page = utils.http.request(UPCITEMDB_URL,
get_params={"upc": event["args_split"][0]},
json=True)
if page:
if not len(page.data["items"]):
raise utils.EventError("UPC/EAN not found")
item = page.data["items"][0]
brand = item.get("brand", None)
brand = "" if not brand else "%s - " % brand
title = item["title"]
description = item.get("description", None)
description = " " if not description else ": %s " % description
weight = item.get("weight", None)
weight = weight or "unknown"
size = item.get("dimension", None)
size = size or "unknown"
currency = item.get("currency", None)
lowest_price = item.get("lowest_recorded_price", None)
highest_price = item.get("highest_recorded_price", None)
pricing = "price: unknown"
if lowest_price and highest_price and currency:
pricing = "price: %s to %s %s" % (lowest_price, highest_price,
currency)
event["stdout"].write(
"%s%s%s(weight: %s"
", size: %s, price: %s)" %
(brand, title, description, weight, size, pricing))
else:
raise utils.EventsResultsError()
def define(self, event):
"""
:help: Define a provided term
:usage: <phrase>
"""
if event["args"]:
word = event["args"]
else:
word = event["target"].buffer.get(from_self=False)
word = word.replace(" ", "+")
page = self._get_definition(word)
if page:
if len(page.data):
event["stdout"].write(
"%s: %s" % (page.data[0]["word"], page.data[0]["text"]))
else:
event["stderr"].write("No definitions found")
else:
raise utils.EventsResultsError()
def btc(self, event):
"""
:help: Get the exchange rate of bitcoins
:usage: [currency]
"""
currency = (event["args"] or "USD").upper()
page = utils.http.request("https://blockchain.info/ticker", json=True)
if page:
if currency in page.data:
conversion = page.data[currency]
buy, sell = conversion["buy"], conversion["sell"]
event["stdout"].write("1 BTC = %.2f %s (buy) %.2f %s "
"(sell)" %
(buy, currency, sell, currency))
else:
event["stderr"].write("Unknown currency, available "
"currencies: %s" %
", ".join(page.data.keys()))
else:
raise utils.EventsResultsError()
def combo(self, event):
combo = utils.http.request(URL_COMBO,
get_params={
"drugA": event["args_split"][0],
"drugB": event["args_split"][1]
}).json()
if combo:
if not combo["err"] and combo["data"][0]:
data = combo["data"][0]
drug_a = data["interactionCategoryA"]
drug_b = data["interactionCategoryB"]
interaction = data["status"]
event["stdout"].write(
"%s & %s: %s%s" %
(drug_a, drug_b, interaction,
"" if not "note" in data else "; %s" % data["note"]))
else:
event["stderr"].write("Unknown drug provided")
else:
raise utils.EventsResultsError()
def define(self, event):
"""
:help: Define a provided term
:usage: <phrase>
"""
if event["args"]:
word = event["args"]
else:
word = event["target"].buffer.get(from_self=False)
word = word.replace(" ", "+")
success, definition = self._get_definition(word)
if success:
if not definition == None:
text = utils.http.strip_html(definition["text"])
event["stdout"].write("%s: %s" % (definition["word"], text))
else:
event["stderr"].write("No definitions found")
else:
raise utils.EventsResultsError()
