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()