def __init__(self): self.word_api = WordApi.WordApi( swagger.ApiClient(wordnik_api_key, wordnik_api)) self.wordoftheday_api = WordsApi.WordsApi( swagger.ApiClient(wordnik_api_key, wordnik_api)) self.urbandictionary_api = urbandictionary_api self.dictionaryCache = LFUCache(maxsize=1000) self.urbandictionaryCache = LFUCache(maxsize=1000) self.wordOfTheDayCache = {} self.session = requests.Session() self.session.mount('http://', requests.adapters.HTTPAdapter(max_retries=5)) self.session.mount('https://', requests.adapters.HTTPAdapter(max_retries=5))
def word_of_the_day(): apiUrl = 'http://api.wordnik.com/v4' apiKey = '***' client = swagger.ApiClient(apiKey, apiUrl) words_api = WordsApi.WordsApi(client) day_word = words_api.getWordOfTheDay() word_api = WordApi.WordApi(client) ''' ugly but sometimes the word of the day wont have IPA pronunciation. Probably I should figure out what type of pron it does have. ''' try: pron = word_api.getTextPronunciations(day_word.word, typeFormat='IPA') except urllib.error.HTTPError: pron = '' # word of the day .definitions returns a list with a custom object (SimpleDefinitions) inside. # index 0 gets us that object, then we use .text to get the definition text. # pron.raw gives us the pronunciation as a string in IPA format per kwarg above. Not sure what pron.raw[0] is, # but it isnt in IPA format, so I'm going to just use [1] if pron: return day_word.word, day_word.definitions[0].text, pron[ 0].raw # error is here b/c according to the try/except # block up there, pron is a string. because of # the if statement, tho, pron wont ever be a str # if we're at this point in the code. else: return day_word.word, day_word.definitions[0].text, pron
def handle(self, *args, **options): from wordnik import swagger, WordApi client = swagger.ApiClient(settings.WORDNIK_KEY, settings.WORDNIK_API) wordApi = WordApi.WordApi(client) definitions = wordApi.getDefinitions( 'child', partOfSpeech='noun', #sourceDictionaries='wiktionary', limit=1) for definition in definitions: print definition.text return total = len(args) word_i = 0 invalid_pos_names = set() skip_to = 0 for word_text in args: word_i += 1 if word_i < skip_to: continue print '=' * 80 print '%s (%i of %i)' % (word_text, word_i, total) utils.import_from_wordnik(word_text, invalid_pos_names=invalid_pos_names) #break dsecs = random.randint(1, 5) print 'Waiting for %i seconds...' % (dsecs, ) time.sleep(dsecs) print '=' * 80 print 'Invalid part-of-speech names:', sorted(invalid_pos_names)
def seekdef(self, word): if not WORDNIK_API: self.chat("WORDNIK_API is not set.") return client = swagger.ApiClient(WORDNIK_API, 'http://api.wordnik.com/v4') wapi = WordApi.WordApi(client) results = wapi.getDefinitions(word.strip()) count = 0 for item in results: try: definition = Words(word=item.word, partofspeech=item.partOfSpeech, definition=item.text, source=item.sourceDictionary) definition.save() if count == 0: tempdef = item.text count += 1 except Exception as e: print e continue if count > 0: self.chat("Wordnik coughed up " + str(count) + " definitions.") self.chat("Definition 1:" + tempdef) else: self.chat("I got nothin.")
def get_wotd(): with open('.context', 'r') as f: gordon_context = json.loads(f.read()) apiUrl = 'http://api.wordnik.com/v4' client = swagger.ApiClient(gordon_context['wordnik_api_key'], apiUrl) wordsApi = WordsApi.WordsApi(client) wotd = wordsApi.getWordOfTheDay() return wotd
def checkConnection(self): try: client = swagger.ApiClient(self.apiKey, self.apiUrl) wordApi = WordApi.WordApi(client) wordApi.getRelatedWords('test') return True except: return False
def defintion(cls, word: str): """ Fetches a definition from Wordnik. :param word: The word to define. :return: The definition from Wordnik. """ client = swagger.ApiClient(cls.WORDNIK_API_KEY, cls.WORDNIK_API_URL) word_api = WordApi.WordApi(client) return word_api.getRelatedWords(word)
def __init__(self, source_language: str, target_language: str, key: str, translator_name: str = 'Wordnik', quality: int = '70', service_name: str = 'Wordnik') -> None: super(WordnikTranslator, self).__init__( source_language, target_language, translator_name, quality, service_name) self.key = key self.api_client = swagger.ApiClient(self.key, API_URL) self.word_api = WordApi.WordApi(self.api_client)
def related_wordnik(w, canonicform=True): client = swagger.ApiClient(wordnik_key, wordnik_url) wordApi = WordApi.WordApi(client) res = wordApi.getRelatedWords( w, useCanonical=canonicform ) #,relationshipTypes=types,limitPerRelationshipType=limit) output = dict() if res != 'null getRelatedWords result': for related in res: output.update({related.relationshipType: related.words}) return output
def __init__(self, api_url=API_URL, api_key=API_KEY, max_api_calls=10, words_per_api_call=10): super(WordnikWordSource, self).__init__() client = swagger.ApiClient(api_key, api_url) self.words_api = WordsApi.WordsApi(client) self.words_per_api_call = words_per_api_call self.max_api_calls = max_api_calls # TODO Hard coded for now, as per https://groups.google.com/d/msg/wordnik-api/pXNsaR7IMac/vvPlR36aAgAJ, # but I'd like a better way self.length = 1500000
def get_synonyms(word): api_url = 'http://api.wordnik.com/v4' api_key = '495685498a8807c1d60070b8cd908c4dd54326674bcc6ddb9' client = swagger.ApiClient(api_key, api_url) word_api = WordApi.WordApi(client) related_words = word_api.getRelatedWords(word, limitPerRelationshipType=100) set_words = Set([word]) # initialize the set of words if isiterable(related_words): for word_group in related_words: if word_group.relationshipType in [ 'equivalent', 'synonym' ]: # just grab in equivalent and synonym set_words = set_words | Set( word_group.words) # union of words to prevent duplicates return list(set_words)
def init_wordnik(yaml, days): global words_api, plural_nouns, pears, trees, verbs, adjectives credentials = load_yaml(yaml) wordnik_client = swagger.ApiClient(credentials["wordnik_api_key"], "http://api.wordnik.com/v4") words_api = WordsApi.WordsApi(wordnik_client) how_many = days - 12 plural_nouns = get_plural_nouns(how_many) how_many = int(days * 0.1) - 1 + 1 pears = get_pears(how_many) trees = get_trees(how_many) # Don't need as many verbs or adjectives # 9 in 10 need verbs, but 11/12 are taken care of, and one for luck how_many = int(days * 0.9) - 11 + 1 verbs = get_verbs(how_many) # 1 in 10 need adjectives, but 1/12 is taken care of, and one for luck how_many = int(days * 0.1) - 1 + 1 adjectives = get_random_words_from_wordnik("adjective", how_many)
import traceback import re import pyfscache from nltk.corpus import wordnet from nltk.stem.snowball import SnowballStemmer import wikipedia from wordnik import swagger, WordApi from vocabulary.vocabulary import Vocabulary as vb if (sys.version_info < (3, 0)): reload(sys) sys.setdefaultencoding('utf8') apiUrl = 'http://api.wordnik.com/v4' apiKey = 'a1b28252f1c2bd049897a03d4e81e85c5d6dbca71cb8dcac8' client = swagger.ApiClient(apiKey, apiUrl) wordApi = WordApi.WordApi(client) stemmer = SnowballStemmer("english") fs_cache = pyfscache.FSCache('data/cache/') wikipedia.set_rate_limiting(True) DEBUG = False PUNC = set(string.punctuation) def clean_str(string): """ Cleans a str by making it all lower case, removing punctuation, and removing any html Args:
def __init__(self, bot): self.bot = bot self.apiUrl = 'http://api.wordnik.com/v4' self.apiKey = config.wordnikToken self.client = swagger.ApiClient(self.apiKey, self.apiUrl) self.wordApi = WordApi.WordApi(self.client)
pronunciation = w pronunciationType = 'none' return pronunciation, pronunciationType # Funcation to remove punctuation from string. def removePunctuation(s): # Remove apostrophies from set of punctuation to be removed (affects the look-up of contractions). sp = string.punctuation.replace('\'', '') return s.translate(str.maketrans('', '', sp)) # Create client and WordApi objects. client = swagger.ApiClient(wordnikKey, wordnikUrl) my_dict = WordApi.WordApi(client) # Input and output filenames. text_filename = './input.txt' output_filename = './output.txt' look_up_filename = './CMU.in.IPA.txt' # Open files for reading and writing. text = open(text_filename, 'r') output_text = open(output_filename, 'wb') look_up_text = open(look_up_filename, 'r') # Pronunciation formats supported acceptable_formats = ['ahd', 'ipa']
# Max tweet length is 140 # Let's naively set an upper limit of 140/3: # one-character word, comma and space top_words = most_frequent_words.most_frequent_words(matched_words, 140 / 3) return top_words # ================= WORDNIK ================== # Wordnik: get API key at http://developer.wordnik.com/ WORDNIK_API_KEY = "3fd3445662c1ac873962d06094f057f39d4711730e1adc28f" WORDNIK_USERNAME = "******" WORDNIK_PASSWORD = "******" WORDNIK_TOKEN = None wordnik_client = swagger.ApiClient(WORDNIK_API_KEY, 'http://api.wordnik.com/v4') wordListApi = WordListApi.WordListApi(wordnik_client) # TODO: Save token to ini file def get_wordnik_token(): import getpass if WORDNIK_USERNAME: my_username = WORDNIK_USERNAME else: my_username = input("Enter your Wordnik username: "******"Enter your Wordnik password: ")
parser.add_argument( "-x", "--test", action="store_true", help="Test mode: go through the motions but don't tweet anything", ) args = parser.parse_args() timecheck() credentials = load_yaml(args.yaml) day = day_of_chistmas() if day > 12: wordnik_client = swagger.ApiClient(credentials["wordnik_api_key"], "http://api.wordnik.com/v4") xdaysofxmas.words_api = WordsApi.WordsApi(wordnik_client) if args.test: # Mock Wordnik def mock_get_random_words_from_wordnik(*args): return ["bleep"] xdaysofxmas.get_random_words_from_wordnik = mock_get_random_words_from_wordnik screen_name = screen_name(day) tweet = giftify(day) print(screen_name) print(tweet) update_screen_name(screen_name, credentials)
# -*- coding: utf-8 -*-` """game.py - Generate target word from wordnik API.""" from wordnik import swagger, WordsApi WORDNIK_API_URL = 'http://api.wordnik.com/v4' WORDNIK_KEY = 'your-wordnik-api-key' client = swagger.ApiClient(WORDNIK_KEY, WORDNIK_API_URL) wordApi = WordsApi.WordsApi(client) def get_target(length): """ Retuns the word for the game """ isValid = False # get a word from Wordnik API # avoid to return a non-valid word (with non alpha characters) while not isValid: word = wordApi.getRandomWord(hasDictionaryDef=True, includePartOfSpeech='noun', minCorpusCount=0, maxCorpusCount=-1, minDictionaryCount=1, maxDictionaryCount=-1, minLength=length, maxLength=length) isValid = word.word.isalpha() print '-------------------------' print word.word.lower() print '-------------------------' return word.word.lower()
def apiCall(self, word, apiLang): client = swagger.ApiClient(self.apiKey, self.apiUrl) wordApi = WordApi.WordApi(client) relatedWords = wordApi.getRelatedWords(word) return relatedWords
import nltk from wordnik import swagger, WordApi, AccountApi client = swagger.ApiClient( 'dd3d32ae6b4709e1150040139c308fb77446e0a8ecc93db31', 'https://api.wordnik.com/v4') word_api = WordApi.WordApi(client) toktok = nltk.ToktokTokenizer() words = ['paint', 'mimic', 'mimics', 'francie', 'frolic', 'funhouse'] for word in words: print('=== {} ==='.format(word)) defs = word_api.getDefinitions(word) if not defs: print("no definitions") continue for def_ in defs: fmt_str = "{} --- {}" tokenized_def = toktok.tokenize(def_.text.lower()) tokenized_def = [s.encode('utf-8') for s in tokenized_def] print(fmt_str.format(def_.sourceDictionary, tokenized_def)) account_api = AccountApi.AccountApi(client) for i in range(5): print("Attempt {}".format(i)) status = account_api.getApiTokenStatus() print("Remaining_calls: {}".format(status.remainingCalls))
import os from wordnik import swagger, WordApi, WordsApi import tweepy import secret TWITTER_CONSUMER_KEY = os.environ['TWITTER_CONSUMER_KEY'] TWITTER_CONSUMER_SECRET = os.environ['TWITTER_CONSUMER_SECRET'] TWITTER_ACCESS_KEY = os.environ['TWITTER_ACCESS_KEY'] TWITTER_ACCESS_SECRET = os.environ['TWITTER_ACCESS_SECRET'] auth = tweepy.OAuthHandler(TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET) auth.set_access_token(TWITTER_ACCESS_KEY, TWITTER_ACCESS_SECRET) api = tweepy.API(auth, wait_on_rate_limit=True) WORDNIK_ACCESS_URL = 'https://api.wordnik.com/v4' WORDNIK_ACCESS_KEY = os.environ['WORDNIK_ACCESS_KEY'] client = swagger.ApiClient(WORDNIK_ACCESS_KEY, WORDNIK_ACCESS_URL) wordAPI = WordApi.WordApi(client) wordsAPI = WordsApi.WordsApi(client)
def __init__(self, bot): """Initialises any APIs and the cog.""" self.__token = bot.get_token('wordnik') self.logger.info(f'Opening API client to {wordnik_endpoint}') self.client = swagger.ApiClient(self.__token, wordnik_endpoint) super().__init__()
def __init__(self): self._token = configfiles.get_config_data(config_file) self.api_client = swagger.ApiClient(self._token, wordnik_endpoint) self.api = WordApi.WordApi(self.api_client)
def definition(word): client = swagger.ApiClient(apiKey, apiUrl) wordApi = WordApi.WordApi(client) res = wordApi.getDefinitions(word, limit=3) return [result.text for result in res]
def relatedwords(word): client = swagger.ApiClient(apiKey, apiUrl) wordApi = WordApi.WordApi(client) res = wordApi.getRelatedWords(word, limit=10) return res
def crawl_wordnik(self, vocab, api_key, corenlp_url, call_quota=15000, crawl_also_lowercase=False, crawl_also_lemma=False): """Download and preprocess definitions from Wordnik. vocab Vocabulary for which the definitions should be found. api_key The API key to use in communications with Wordnik. call_quota Maximum number of calls per hour. crawl_also_lowercase If true will add lowercase version of each word to crawl list crawl_also_lemma If true will also crawl lemma versions of words WARNING: Lemma of Cat is Cat! So if you want to have definition of "cat" you have to also pass crawl_also_lowercase! """ corenlp = StanfordCoreNLP(corenlp_url) self._remaining_calls = call_quota self._last_saved = 0 client = swagger.ApiClient(api_key, 'https://api.wordnik.com/v4') self._word_api = WordApi.WordApi(client) self._account_api = AccountApi.AccountApi(client) words = list(vocab.words) # Note(kudkudak): for SNLI it adds 3k words if crawl_also_lowercase: words_set = set(words) # For efficiency logger.info("Adding lowercase words to crawl") lowercased = [] for w in words: if w.lower() not in words_set: lowercased.append(w.lower()) logger.info("Crawling additional {} words".format(len(lowercased))) words.extend(sorted(lowercased)) # Note(kudkudak): for SNLI it adds 2k words, so we can expect # like sabotage,sabotaging # Note that lemma crawling is *after* lowercasing if crawl_also_lemma: words_set = set(words) # For efficiency logger.info("Adding lemmatized vrsions to crawl") lemmas = [] original = [] lemmatizer = nltk.WordNetLemmatizer() for w in words: if isinstance(w, str): w = w.decode('utf-8') for part_of_speech in ['a', 's', 'r', 'n', 'v']: lemma = lemmatizer.lemmatize(w, part_of_speech) if lemma not in words_set: lemmas.append(lemma) original.append(w) logger.info("Crawling additional {} words".format(len(lemmas))) for id in numpy.random.choice(len(lemmas), 100): logger.info("Example:" + lemmas[id] + "," + original[id]) words.extend(sorted(lemmas)) # Here, for now, we don't do any stemming or lemmatization. # Stemming is useless because the dictionary is not indexed with # lemmas, not stems. Lemmatizers, on the other hand, can not be # fully trusted when it comes to unknown words. for word in words: if isinstance(word, str): word = word.decode('utf-8') if word in self._data: logger.debug(u"a known word {}, skip".format(word)) continue if self._last_saved >= _SAVE_EVERY_CALLS: self.save() self._last_saved = 0 # 100 is a safery margin, I don't want to DDoS Wordnik :) if self._remaining_calls < _MIN_REMAINING_CALLS: self._wait_until_quota_reset() try: if isinstance(word, str): word = word.decode('utf-8') # NOTE(kudkudak): We fetch all dictionaries, but retrieval can filter them based on meta info definitions = self._word_api.getDefinitions(word) except Exception: logger.error(u"error during fetching '{}'".format(word)) logger.error(traceback.format_exc()) continue self._remaining_calls -= 1 self._last_saved += 1 if not definitions: definitions = [] self._data[word] = [] for def_ in definitions: try: # seems like definition text can be both str and unicode text = def_.text if def_.text is None: continue if isinstance(text, str): text = text.decode('utf-8') tokenized_def = corenlp.tokenize(text)[0] self._data[word].append(tokenized_def) # Note(kudkudak): I don't think there is much more useful meta data for us # Note(kudkudak): This might seem strange, but I am afraid this is most robust (least bug prone) # way of storing meta data that doens't require rewriting dict storage format self._meta_data[" ".join(tokenized_def)] = { "sourceDictionary": def_.sourceDictionary } except Exception: logger.error("error during tokenizing '{}'".format(text)) logger.error(traceback.format_exc()) logger.debug(u"definitions for '{}' fetched {} remaining".format( word, self._remaining_calls)) self.save() self._last_saved = 0
session_commands_usage = {} aiml_kernel = aiml.Kernel() aiohttp_session = aiohttp.ClientSession() clarifai_app = clarifai.rest.ClarifaiApp( app_id=credentials.clarifai_api_id, app_secret=credentials.clarifai_api_secret) clarifai_general_model = clarifai_app.models.get("general-v1.3") clarifai_nsfw_model = clarifai_app.models.get("nsfw-v1.0") inflect_engine = inflect.engine() owm_client = pyowm.OWM(credentials.owm_api_key) twitter_auth = tweepy.OAuthHandler(credentials.twitter_consumer_key, credentials.twitter_consumer_secret) twitter_auth.set_access_token(credentials.twitter_access_token, credentials.twitter_access_token_secret) twitter_api = tweepy.API(twitter_auth) wordnik_client = swagger.ApiClient(credentials.wordnik_apikey, "http://api.wordnik.com/v4") wordnik_word_api = WordApi.WordApi(wordnik_client) wordnik_words_api = WordsApi.WordsApi(wordnik_client) wolfram_alpha_client = wolframalpha.Client(credentials.wolframalpha_appid) application_info = None harmonbot_listener = None # TODO: Include owner variable for user object? sys.setrecursionlimit(5000) try: imgur_client = imgurpython.ImgurClient(credentials.imgur_client_id, credentials.imgur_client_secret) except imgurpython.helpers.error.ImgurClientError as e: print("Discord Harmonbot: Failed to load Imgur Client: {}".format(e)) aiml_predicates = {
import wordnik from wordnik import swagger, WordApi api_key = 'befa9e8bb08c1b19b12040c8fae076f87d14cea47688e8ce7' api_url = 'http://api.wordnik.com/v4' client = swagger.ApiClient(api_key, api_url) wordApi = WordApi.WordApi(client) example = wordApi.getTopExample('irony') twitter_api_key = 'azAYHwT3zpaTWh1YkcYrJvSDG'
def _load(self): self.api_key = self.config["apikey"] self.api_client = swagger.ApiClient(self.api_key, "http://api.wordnik.com/v4") self.word_api = WordApi(self.api_client) self.words_api = WordsApi(self.api_client)