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