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"
self.log.debug("youtube API request: search.list (B) [snippet]")
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()
if search_page:
if search_page["pageInfo"]["totalResults"] > 0:
url = URL_VIDEO % search_page["items"][0]["id"]["videoId"]
else:
raise utils.EventError("No videos found")
else:
raise utils.EventResultsError()
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.EventResultsError()
else:
event["stderr"].write("No search 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, "prettyPrint": "true", "num": 1, "gl": "gb",
"key": self.bot.config["google-api-key"],
"cx": self.bot.config["google-search-id"],
"safe": safe}).json()
if page:
if "items" in page and len(page["items"]):
item = page["items"][0]
link = item["link"]
title = utils.parse.line_normalise(item["title"])
event["stdout"].write(
"(%s) %s - %s" % (phrase, title, link))
else:
event["stderr"].write("No results found")
else:
raise utils.EventResultsError()
else:
event["stderr"].write("No phrase provided")
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)
if word:
word = word.message
if not word:
raise utils.EventError("No phrase provided")
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.EventResultsError()
def wa(self, event):
"""
:help: Evaluate a given string on Wolfram|Alpha
:usage: <query>
"""
query = event["args"].strip()
try:
page = utils.http.request(URL_WA, timeout=10, get_params={
"input": query, "format": "plaintext",
"output": "JSON", "reinterpret": "true", "units": "metric",
"appid": self.bot.config["wolframalpha-api-key"]}).json()
except utils.http.HTTPTimeoutException:
page = None
if page:
if page["queryresult"]["numpods"]:
input = query
primaries = []
for pod in page["queryresult"]["pods"]:
text = pod["subpods"][0]["plaintext"]
if pod["id"] == "Input" and text:
input = text
elif pod.get("primary", False):
primaries.append(text)
event["stdout"].write("%s: %s" % (input, " | ".join(primaries)))
else:
event["stdout"].write("No results")
else:
raise utils.EventResultsError()
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()
if page:
if len(page["list"]):
if number > 0 and len(page["list"]) > number-1:
definition = page["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.EventResultsError()
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()
if page:
success, definition = self._get_definition(page["word"])
if not success:
raise utils.EventError("Try again in a couple of seconds")
text = utils.http.strip_html(definition["text"])
event["stdout"].write("Random Word: %s - Definition: %s" %
(page["word"], text))
else:
raise utils.EventResultsError()
else:
event["stderr"].write("Try again in a couple of seconds")
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()
if page:
if len(page["tracks"]["items"]):
item = page["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.EventResultsError()
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}
).json()
if page:
# google gives us jsonp, so we need to unwrap it.
page = page.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.EventResultsError()
else:
event["stderr"].write("No phrase provided")
def _get_relays_details(search):
page = utils.http.request(URL_ONIONOO_DETAILS,
get_params={
"search": search
}).json()
if page and "relays" in page:
return page["relays"]
raise utils.EventResultsError()
def acronym(self, event):
query = event["args_split"][0].upper()
response = utils.http.request(API % query)
acronyms = []
for element in response.soup().find_all("acro"):
acronyms.append(element.expan.string)
if acronyms:
event["stdout"].write("%s: %s" % (query, ", ".join(acronyms)))
else:
raise utils.EventResultsError()
def define(self, event):
word = event["spec"][0].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.EventResultsError()
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 = last_soundcloud.match
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()
if page:
if len(page):
page = page[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.EventResultsError()
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"]
})
if page:
if page.code == 200:
page = page.json()
type = page["type"]
if type == "movie":
title = page["movie"]["title"]
year = page["movie"]["year"]
slug = page["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["episode"]["season"]
episode_number = page["episode"]["number"]
episode_title = page["episode"]["title"]
show_title = page["show"]["title"]
show_year = page["show"]["year"]
slug = page["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.EventResultsError()
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.EventResultsError()
def wikipedia(self, event):
page = utils.http.request(URL_WIKIPEDIA, get_params={
"action": "query", "prop": "extracts|info", "inprop": "url",
"titles": event["spec"][0], "exintro": "", "explaintext": "",
"exchars": "500", "redirects": "", "format": "json"}).json()
if page:
pages = page["query"]["pages"]
article = list(pages.items())[0][1]
if not "missing" in article:
title, info = article["title"], article["extract"]
title = article["title"]
info = utils.parse.line_normalise(article["extract"])
url = article["fullurl"]
event["stdout"].write("%s: %s - %s" % (title, info, url))
else:
event["stderr"].write("No results found")
else:
raise utils.EventResultsError()
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()
if page:
if currency in page:
conversion = page[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.keys()))
else:
raise utils.EventResultsError()
def thesaurus(self, event):
"""
:help: Get synonyms/antonyms for a provided phrase
:usage: <word> [type]
"""
phrase = event["args_split"][0]
page = utils.http.request(
URL_THESAURUS %
(self.bot.config["bighugethesaurus-api-key"], phrase))
syn_ant = event["command"][:3]
if page:
if page.code == 404:
raise utils.EventError("Word not found")
page = page.json()
if not len(event["args_split"]) > 1:
word_types = []
for word_type in page.keys():
if syn_ant in page[word_type]:
word_types.append(word_type)
if word_types:
word_types = sorted(word_types)
event["stdout"].write("Available categories for %s: %s" %
(phrase, ", ".join(word_types)))
else:
event["stderr"].write("No categories available")
else:
category = event["args_split"][1].lower()
if category in page:
if syn_ant in page[category]:
event["stdout"].write(
"%ss for %s: %s" %
(event["command"].title(), phrase, ", ".join(
page[category][syn_ant])))
else:
event["stderr"].write("No %ss for %s" %
(event["command"], phrase))
else:
event["stderr"].write("Category not found")
else:
raise utils.EventResultsError()
def geoip(self, event):
"""
:help: Get geoip data on a given IPv4/IPv6 address
:usage: <IP>
:prefix: GeoIP
"""
page = utils.http.request(URL_GEOIP % event["args_split"][0]).json()
if page:
if page["status"] == "success":
data = page["query"]
data += " | Organisation: %s" % page["org"]
data += " | City: %s" % page["city"]
data += " | Region: %s (%s)" % (page["regionName"],
page["countryCode"])
data += " | ISP: %s" % page["isp"]
data += " | Lon/Lat: %s/%s" % (page["lon"], page["lat"])
data += " | Timezone: %s" % page["timezone"]
event["stdout"].write(data)
else:
event["stderr"].write("No geoip data found")
else:
raise utils.EventResultsError()
def imdb(self, event):
"""
:help: Search for a given title on IMDb
:usage: <movie/tv title>
"""
page = utils.http.request(URL_OMDB,
get_params={
"apikey":
self.bot.config["omdbapi-api-key"],
"t": event["args"]
}).json()
if page:
if "Title" in page:
event["stdout"].write(
"%s, %s (%s) %s (%s/10.0) %s" %
(page["Title"], page["Year"], page["Runtime"],
page["Plot"], page["imdbRating"],
URL_IMDBTITLE % page["imdbID"]))
else:
event["stderr"].write("Title not found")
else:
raise utils.EventResultsError()
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
query = None
nickname = None
if event["args"]:
query = 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 not location == None:
nickname = target_user.nickname
else:
location = self._user_location(event["user"])
nickname = event["user"].nickname
if location == None:
raise utils.EventError("You don't have a location set")
args = {"units": "metric", "APPID": api_key}
if location == None and query:
location_info = self.exports.get("get-location")(query)
if not location_info == None:
location = [location_info["lat"], location_info["lon"],
location_info.get("name", None)]
if location == None:
raise utils.EventError("Unknown location")
lat, lon, location_name = location
args["lat"] = lat
args["lon"] = lon
page = utils.http.request(URL_WEATHER, get_params=args).json()
if page:
if "weather" in page:
if location_name:
location_str = location_name
else:
location_parts = [page["name"]]
if "country" in page["sys"]:
location_parts.append(page["sys"]["country"])
location_str = ", ".join(location_parts)
celsius = "%dC" % page["main"]["temp"]
fahrenheit = "%dF" % ((page["main"]["temp"]*(9/5))+32)
description = page["weather"][0]["description"].title()
humidity = "%s%%" % page["main"]["humidity"]
# wind speed is in metres per second - 3.6* for KMh
wind_speed = 3.6*page["wind"]["speed"]
wind_speed_k = "%skm/h" % round(wind_speed, 1)
wind_speed_m = "%smi/h" % round(0.6214*wind_speed, 1)
if not nickname == None:
location_str = "(%s) %s" % (nickname, location_str)
event["stdout"].write(
"%s | %s/%s | %s | Humidity: %s | Wind: %s/%s" % (
location_str, celsius, fahrenheit, description, humidity,
wind_speed_k, wind_speed_m))
else:
event["stderr"].write("No weather information for this location")
else:
raise utils.EventResultsError()
def np(self, event):
"""
:help: Get the last listened to track from a user
:usage: [username]
"""
user = None
lastfm_username = None
shown_username = None
if event["args"]:
arg_username = event["args_split"][0]
if event["server"].has_user_id(arg_username):
user = event["server"].get_user(event["args_split"][0])
else:
lastfm_username = shown_username = arg_username
else:
user = event["user"]
if user:
lastfm_username = user.get_setting("lastfm", user.nickname)
shown_username = user.nickname
page = utils.http.request(URL_SCROBBLER,
get_params={
"method": "user.getrecenttracks",
"user": lastfm_username,
"api_key":
self.bot.config["lastfm-api-key"],
"format": "json",
"limit": "1"
}).json()
if page:
if "recenttracks" in page and len(page["recenttracks"]["track"]):
now_playing = page["recenttracks"]["track"]
if type(now_playing) == list:
now_playing = now_playing[0]
track_name = now_playing["name"]
artist = now_playing["artist"]["#text"]
if '@attr' in now_playing:
np = True
else:
played = int(now_playing["date"]["uts"])
dt = utils.datetime.utcnow()
np = bool((dt.timestamp() - played) < 120)
time_language = "is listening to" if np else "last listened to"
yt_url = self.exports.get_one("search-youtube")(
"%s - %s" % (artist, track_name))
yt_url_str = ""
if yt_url:
yt_url_str = " - %s" % yt_url
info_page = utils.http.request(
URL_SCROBBLER,
get_params={
"method": "track.getInfo",
"artist": artist,
"track": track_name,
"autocorrect": "1",
"api_key": self.bot.config["lastfm-api-key"],
"user": lastfm_username,
"format": "json"
}).json()
track = info_page.get("track", {})
tags_str = ""
if "toptags" in track and track["toptags"]["tag"]:
tags = [t["name"] for t in track["toptags"]["tag"]]
tags_str = " [%s]" % ", ".join(tags)
play_count_str = ""
if "userplaycount" in track:
play_count = int(track["userplaycount"])
if play_count > 0:
play_count_str = " (%d play%s)" % (
play_count, "" if play_count == 1 else "s")
track_name = utils.irc.bold("%s - %s" % (artist, track_name))
event["stdout"].write(
"%s %s: %s%s%s%s" %
(shown_username, time_language, track_name, play_count_str,
tags_str, yt_url_str))
else:
event["stderr"].write(
"The user '%s' has never scrobbled before" %
(shown_username))
else:
raise utils.EventResultsError()
