class TwitterListener(StreamListener):
def __init__(self):
self.cache = LFUCache(maxsize=50)
self.cache2 = LFUCache(maxsize=50)
Timer(interval=60, function=self.print_keys)
Timer(interval=30, function=self.check_cached_words)
def on_data(self, data):
data_lst = json.loads(data)
data_lst = data_lst.get('text', '').split()
if self.cache.currsize == self.cache.maxsize:
for key in list(self.cache.keys()):
if self.cache[key] == 0:
del self.cache[key]
for word in data_lst:
if word in self.cache.keys():
self.cache[word] += 1
else:
self.cache[word] = 1
if self.cache[word] < 0:
del self.cache[word]
return True
def print_keys(self):
"""
print recent words and update the second cache every 60 seconds
"""
print(list(self.cache.items()))
self.cache2.update(self.cache)
return True
def check_cached_words(self):
"""
Decrease score of word by 1 if the score does not change within
60 seconds
"""
for word in list(self.cache.keys()):
if self.cache.get(word) == self.cache2.get(word):
self.cache[word] -= 1
return True
class WordBot():
def __init__(self):
self.dictionaryCache = LFUCache(maxsize = 200)
self.urbandictionaryCache = LFUCache(maxsize = 200)
self.wordOfTheDayCache = {}
self.bot = telebot.TeleBot(bot_token)
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 handle_inline(self, query):
try:
query_word = query.get('query')
default_word = self.getWordOfTheDay()
inline_answers = []
if default_word:
default_result = types.InlineQueryResultArticle(
'1',
'Word of the day',
types.InputTextMessageContent(
'*' + default_word['word'] + '*\n' + default_word['definitions'],
parse_mode='markdown'
),
description=default_word['word']
)
inline_answers = [default_result]
if query_word or query_word != '':
reply = self.make_reply('/define ' + query_word)
desc = reply if reply == 'Word not found.' else None
query_result = types.InlineQueryResultArticle('2',
query_word,
types.InputTextMessageContent(
reply,
parse_mode='markdown'
),
description=desc
)
inline_answers = [query_result]
self.bot.answer_inline_query(query.get('id'), inline_answers)
except Exception as e:
pass
#sprint(e)
def handle_message(self, message):
if 'new_chat_participant' in message:
return
query = message.get('text')
if not query:
return
if '@LexicoBot' in query:
query = query.replace('@LexicoBot', '')
reply = self.make_reply(query)
if reply != '':
self.bot.send_chat_action(message['chat']['id'], 'typing')
self.bot.send_message(message['chat']['id'], reply, parse_mode='markdown')
def make_reply(self, query):
if query in ['/start', '/help']:
return start_message
reply_message = ''
if query == '/today':
wordData = self.getWordOfTheDay()
if wordData is None:
return 'Server error.'
query = '/define ' + wordData['word']
query = query.split()
if len(query) > 1:
if query[0] in ['/define', '/synonyms', '/antonyms', '/use', '/all', '/ud']:
word = ' '.join(query[1::])
reply_message = '*' + word + '*\n'
if query[0] != '/ud':
wordData = self.dictionaryCache.get(word)
if wordData is None:
wordData = self.getWord(word)
else:
pass
#print 'Cache hit ' + word
if wordData is None:
return 'Word not found.'
if query[0] in ['/define','/all']:
reply_message += wordData['definitions'] + '\n'
if query[0] in ['/synonyms','/all']:
reply_message += wordData['synonyms'] + '\n'
if query[0] in ['/antonyms','/all']:
reply_message += wordData['antonyms'] + '\n'
if query[0] in ['/use','/all']:
reply_message += wordData['examples'] + '\n'
else:
wordData = self.urbandictionaryCache.get(word)
if wordData is None:
wordData = self.getUrbandictionaryWord(word)
if wordData is None:
return 'Word not found'
reply_message += wordData['definition'] + '\n'
reply_message += wordData['example']
return reply_message
def updateCache(self, word, wordData):
dataDict = {}
definitionText = '*Definitions*' +'\n'
synonymsText = '*Synonyms*' + '\n'
antonymsText = '*Antonyms*' + '\n'
examplesText = '*Examples*' + '\n'
definitions = self.getDefinitions(wordData)
synonyms = self.getSynonyms(wordData)
antonyms = self.getAntonyms(wordData)
examples = self.getExamples(wordData)
if not definitions:
definitionText += 'No definitions found.\n'
if not synonyms:
synonymsText += 'No synonyms found.\n'
if not antonyms:
antonymsText += 'No antonyms found.\n'
if not examples:
examplesText += 'No examples found.\n'
for definition in self.getDefinitions(wordData):
if definition[0]:
definitionText += definition[0] + ': '
definitionText += definition[1] + '\n\n'
definitionText = definitionText[:-1]
for synonym in synonyms[:3]:
synonymsText += synonym + '\n'
for antonym in antonyms[:3]:
antonymsText += antonym + '\n'
for index, example in enumerate(examples[:3]):
examplesText += str(index+1) + '. ' + example + '\n\n'
examplesText = examplesText[:-1]
dataDict['word'] = word
dataDict['definitions'] = definitionText
dataDict['synonyms'] = synonymsText
dataDict['antonyms'] = antonymsText
dataDict['examples'] = examplesText
self.dictionaryCache.update({word:dataDict})
return dataDict
def getDefinitions(self, wordData):
partCounter = Counter()
definitions = []
for definition in wordData:
if 'partOfSpeech' in definition.keys() and partCounter[definition['partOfSpeech']] < 2:
definitions.append(
('_' + definition['partOfSpeech'] + '_ ',
definition['text'])
)
partCounter[definition['partOfSpeech']] += 1
else:
definitions.append(('',definition['text']))
return definitions
def getSynonyms(self, wordData):
synonyms = []
for relatedWords in wordData[0]['relatedWords']:
if relatedWords['relationshipType'] == 'synonym':
for synonym in relatedWords['words']:
synonyms.append(synonym)
for relatedWords in wordData[0]['relatedWords']:
if relatedWords['relationshipType'] == 'cross-reference':
for synonym in relatedWords['words']:
synonyms.append(synonym)
return synonyms
def getAntonyms(self, wordData):
antonyms = []
for relatedWords in wordData[0]['relatedWords']:
if relatedWords['relationshipType'] == 'antonym':
for antonym in relatedWords['words']:
antonyms.append(antonym)
return antonyms
def getExamples(self, wordData):
examples = []
for index,example in enumerate(wordData[0]['examples']):
examples.append(example['text'].replace('\n',''))
return examples
def getEtymology(self, wordData):
etymologies = []
for etymology in wordData[0]['etymologies']:
etymologies.append(etymology)
return etymology
def getWord(self, word):
def_url = wordnik_url + word + '/definitions?limit=15&api_key=' + wordnik_api_key
example_url = wordnik_url + word + '/examples?api_key=' + wordnik_api_key
related_url = wordnik_url + word + '/relatedWords?api_key=' + wordnik_api_key
urls = [def_url, example_url, related_url]
data = []
for url in urls:
try:
response = self.session.get(url, verify=False)
if response.status_code != 200:
return None
data.append(json.loads(response.text.encode('utf-8')))
except ValueError:
return None
if not data[0]:
return None
wordData = data[0]
try:
wordData[0]['examples'] = data[1]['examples']
except KeyError:
wordData[0]['examples'] = []
try:
wordData[0]['relatedWords'] = data[2]
except KeyError:
wordData[0]['relatedWords'] = []
return self.updateCache(word,wordData)
def getUrbandictionaryWord(self, word):
api_url = 'http://api.urbandictionary.com/v0/define?term='
#response = requests.get(api_url+word, verify=False)
response = urllib2.urlopen(api_url + word)
data = json.loads(response.read().decode('utf-8'))
if data['result_type'] == 'no_results' or not data['list']:
return None
wordData = {}
wordData['definition'] = '*Definition*' + '\n'
wordData['example'] = '*Example*' + '\n'
try:
if data['list'][0]['definition']:
wordData['definition'] += data['list'][0]['definition'].strip() + '\n'
else:
return None
except KeyError:
return None
try:
if data['list'][0]['example']:
wordData['example'] += data['list'][0]['example'].strip() + '\n'
else:
wordData['example'] += 'No example found.'
except KeyError:
wordData['example'] += 'No example found.'
self.urbandictionaryCache.update({word:wordData})
return wordData
def getWordOfTheDay(self):
wordOfTheDay = self.wordOfTheDayCache.get(datetime.now().day, None)
if wordOfTheDay is None:
today = datetime.strftime(datetime.now(), '%Y-%m-%d')
url = wordnik_url[:-10] + 'words.json/wordOfTheDay?api_key=' + wordnik_api_key + '&date=' + today
data = []
response = self.session.get(url, verify=False)
try:
data.append(json.loads(response.text.encode('utf-8')))
except ValueError:
return None
wordOfTheDay = data[0]['word']
self.wordOfTheDayCache.clear()
self.wordOfTheDayCache[datetime.now().day] = wordOfTheDay
else:
pass
#print 'Today Cache Hit ' + wordOfTheDay
wordData = self.dictionaryCache.get(wordOfTheDay)
if not wordData:
url = wordnik_url + wordOfTheDay + '/relatedWords?api_key=' + wordnik_api_key
wordData = [definition for definition in data[0]['definitions']]
for definition in wordData:
definition['attributionText'] = ''
wordData[0]['examples'] = data[0]['examples']
response = self.session.get(url, verify = False)
relatedWords = json.loads(response.text)
wordData[0]['relatedWords'] = relatedWords
wordData[0]['word'] = wordOfTheDay
return self.updateCache(wordOfTheDay, wordData)
else:
#print 'Cache hit ' + wordOfTheDay
return wordData
class PoolMetrics(object):
def __init__(self, food_size, history_size):
self.reaction_graph = ReactionGraph()
self.food_size = food_size
self.history = Counter()
self.substrate_count = Counter()
self.recent_history = LFUCache(history_size)
self.pool_str_hist = deque(maxlen=1000)
self.n_reactions = Counter()
self.emergent_substrates = set()
def on_reaction_computed(self, pool, reaction):
#FIXME: move to arguments
self.expressions = pool.expressions
self.pool = pool
self.reaction_graph.add_reaction(reaction)
substrate = reaction.get_substrate()
if substrate is not None:
self.substrate_count[substrate] += 1
for product in reaction.products:
self.history[product] = self.history.get(product, 0) + 1
self.recent_history[product] = self.recent_history.get(product,
0) + 1
self.n_reactions[reaction.type] += 1
def get_current_p_reduce(self):
Z = sum(self.n_reactions.values())
return self.n_reactions['reduce'] / Z if Z > 0 else 0
def get_current_p_break(self):
Z = sum(self.n_reactions.values())
return self.n_reactions['break'] / Z if Z > 0 else 0
def get_current_p_combine(self):
Z = sum(self.n_reactions.values())
return self.n_reactions['combine'] / Z if Z > 0 else 0
def get_current_n_combine(self):
return self.n_reactions['combine']
def get_current_n_reduce(self):
return self.n_reactions['reduce']
def get_current_n_break(self):
return self.n_reactions['break']
@lazy
def raf(self):
food_set = set(
x for x in self.reaction_graph.remove_selfloop().get_expressions()
if len(x) <= self.food_size)
raf = self.reaction_graph.get_raf(food_set)
for r in raf:
count = self.reaction_graph.get_occurrences(r)
logger.info(f'{count} x {r} ') #(' +
#'; '.join(f'{x} = {self.expressions[x]}'
# for x in r.reactives) +
#')')
return raf
def is_valid_raf(self, raf, food_set):
for r in raf:
if any(p not in food_set and not any(p not in r2.products
for r2 in raf)
for p in r.reactives):
return False
return True
@lazy
def reduction_sg(self):
return self.reaction_graph.get_reduction_subgraph().remove_selfloop()
# for reactives, product in raf:
# if term.size(product) > 3:
# print(" + ".join(map(term.to_str, reactives)), '->', term.to_str(product))
def reset_perishable_history(self):
#self.reaction_graph.reset()
lazy.invalidate(self, 'raf')
lazy.invalidate(self, 'reduction_sg')
self.n_reactions.clear()
def get_substrate_count(self):
return self.substrate_count
def get_current_total_size(self):
return self.pool.get_total_size()
def get_current_expressions_top10_length(self):
sizes = list(map(len, self.expressions))
sizes.sort()
return np.mean(sizes[-10:])
def get_current_expressions_reducible_count(self):
reducibles = sum(v for ex, v in self.expressions.items()
if ex.is_reducible(self.pool))
return reducibles
def get_recent_largest_scc_size(self):
if len(self.reaction_graph) > 0:
return len(self.get_largest_strongly_connected_component())
else:
return -1
def get_largest_strongly_connected_component(self):
graph = self.reaction_graph.get_reduction_subgraph()
graph.trim_short_formulae(4)
largest = max(graph.get_all_strongly_connected_components(), key=len)
node_types = nx.get_node_attributes(graph.graph, 'node_type')
sg = self.reaction_graph.graph.subgraph(largest)
#for n in largest:
# if node_types[n] == 'formula':
# print(term.to_str(n))
# self.print_preceding_graph(sg, n)
return largest
def get_current_expressions_count(self):
return sum(v for ex, v in self.expressions.items())
def get_current_expressions_distinct_count(self):
return sum(1 for _ in self.expressions.unique())
def get_current_expressions_recurrence_count(self, threshold=4):
c, n = 0, 0
for f in self.history:
if len(f) > threshold:
c += self.history[f]
n += 1
return c / n if n > 0 else 0
# try:
# m = max((x for x in self.pool.pool if term.size(x) > threshold),
# key=lambda k: self.history.get(k, 0))
# #if self.history[m] > 0:
# # print (term.to_str(m), self.history[m])
# # g = self.reaction_graph.graph
# # if m in g:
# # self.print_preceding_graph(g, m, 1)
# # print('-'*30)
# except ValueError:
# pass
def get_recent_reactions_count(self):
return len(self.reaction_graph.get_all_reducing_reactions())
def get_recent_expressions_recurrence_count(self, threshold=4):
c, n = 0, 0
for f in self.recent_history:
if len(f) > threshold:
c += self.recent_history[f]
n += 1
return c / n if n > 0 else 0
def get_pool_compressed_length(self):
sorted_pool = sorted(self.expressions, key=len)
pool_str = " | ".join(map(str, sorted_pool))
self.pool_str_hist.append(pool_str)
hist_str = "\n".join(self.pool_str_hist)
compressed_hist_str = zlib.compress(hist_str.encode())
return len(compressed_hist_str)
def get_recent_scc_count(self):
n = 0
for scc in self.reduction_sg.get_without_substrates_subgraph(
).get_all_strongly_connected_components():
if len(scc) > 1:
# print("="*20)
# console_tools.print_scc(scc)
for r in sorted((r for r in scc if isinstance(r, Reaction)),
reverse=True):
logger.debug(f'{r} in scc')
# import pickle
# sg_scc = self.reduction_sg.get_subgraph(scc)
# print(len(sg_scc))
# if len(scc)>100:
# pickle.dump(sg_scc.graph, open('scc.pkl', 'wb'))
n += 1
return n
def get_recent_raf_length(self):
return len(self.raf)
def get_recent_raf_cycle_length(self):
raf_graph = ReactionGraph()
for reaction in self.raf:
raf_graph.add_reaction(reaction)
return raf_graph.get_maximal_cycle_length()
def get_recent_raf_substrate_count(self):
raf_graph = ReactionGraph()
for reaction in self.raf:
substrate = reaction.get_substrate()
if substrate is not None:
self.emergent_substrates.add(substrate)
if self.emergent_substrates:
logger.info('Emergent substrates: {}'.format(
self.emergent_substrates))
return len(self.emergent_substrates)
def get_recent_raf_scc_count(self):
raf_subgraph = self.reduction_sg.get_subgraph_from_reactions(self.raf)
n = 0
raf_subgraph.remove_food_edges()
for scc in raf_subgraph.get_all_strongly_connected_components():
if len(scc) > 1:
n += 1
return 1
def get_current_expressions_max_length(self):
return max(map(len, self.expressions.unique()))
def get_current_expressions_max_depth(self):
return max(map(lambda e: e.get_depth(), self.expressions.unique()))
def get_current_expressions_reduction_count(self):
return np.mean(
list(
map(lambda e: len(e.all_reductions()),
self.expressions.unique())))
def get_current_expressions_percent_at_1(self):
return self.get_current_expressions_percent_at(1)
def get_current_expressions_percent_at_2(self):
return self.get_current_expressions_percent_at(2)
def get_current_expressions_percent_at(self, k):
total = 0
at_k = 0
for expr in self.expressions.unique():
n = self.expressions[expr]
total += n
if len(expr) <= k:
at_k += n
return at_k * 100 / total
def get_current_expressions_mean_length(self):
return np.mean(list(map(len, self.expressions.unique())))
def get_recent_raf_product_max_length(self):
return max(map(lambda r: max(len(p) for p in r.products), self.raf),
default=0)
def get_recent_raf_products_count(self):
return sum(
list(self.expressions[p]
for p in set.union(set(), *(set(r.products)
for r in self.raf))))
def get_current_expressions_max_multiplicity(self):
return max(list(v for k, v in self.expressions.items()
if len(k) > self.food_size),
default=0)
def get_current_expressions_mean_multiplicity(self):
current_expressions_multiplicity = list(
v for k, v in self.expressions.items() if len(k) > self.food_size)
return np.mean(current_expressions_multiplicity
) if current_expressions_multiplicity else 0
def get_current_expressions_max_multiplicity_length(self):
multiplicity = self.get_current_expressions_max_multiplicity()
if multiplicity == 1:
return 0 # no trivial solutions
max_multiplicity_lengths = list(
len(k) for k, v in self.expressions.items() if v == multiplicity)
return np.mean(
max_multiplicity_lengths) if max_multiplicity_lengths else 0
def get_recent_raf_products_max_multiplicity(self):
#print(term.to_str(max(set(r.product for r in self.raf if term.size(r.product) > self.food_size), key=lambda k:self.pool.terms_set[k])))
return max(list(self.expressions[p] for p in set.union(
set(),
*(set(r.products) for r in self.raf if any(
len(p) > self.food_size for p in r.products)))),
default=0)
def get_recent_raf_complement_products_max_multiplicity(self):
#print(term.to_str(max(set(r.product for r in self.raf if term.size(r.product) > self.food_size), key=lambda k:self.pool.terms_set[k])))
return max(list(self.expressions[p] for p in self.expressions
if p not in set.union(
set(),
*(set(r.products) for r in self.raf if any(
len(p) > self.food_size
for p in r.products)))),
default=0)
def get_recent_raf_scc_expressions_multiplicity(self):
raf_subgraph = self.reaction_graph.get_subgraph_from_reactions(
self.raf)
all_sccs = list(
scc
for scc in raf_subgraph.get_all_strongly_connected_components()
if len(scc) > 1)
largest_expr_in_sccs = list(max(scc, key=len) for scc in all_sccs)
if all_sccs:
m = max((expr for expr in largest_expr_in_sccs),
key=self.expressions.get_multiplicity)
return self.expressions.get_multiplicity(m)
else:
return 0
def get_recent_recurrent_expression_length(self):
try:
f = max((expr for expr in self.recent_history
if len(expr) > self.food_size),
key=self.recent_history.get)
return len(f)
except ValueError:
return 0
def get_longest_non_trivial_recurring_formula(self):
non_trivial_recurring_formulae = self.get_non_trivial_recurring_formulae(
)
if non_trivial_recurring_formulae:
return max(non_trivial_recurring_formulae, key=len)
else:
return None
def get_non_trivial_recurring_formulae(self):
m = -mode(-np.array(list(self.history.values()))).mode
return [f for f, n_occ in self.history.items() if n_occ > m]
class WordBot():
def __init__(self):
self.offset = ''
self.URL = 'https://api.telegram.org/bot' + bot_token
self.session = requests.Session()
self.session.mount("http://", requests.adapters.HTTPAdapter(max_retries=2))
self.session.mount("https://", requests.adapters.HTTPAdapter(max_retries=2))
self.cache = LFUCache(maxsize = 200)
self.startMessage = start_message
self.keyboard = {"keyboard":[["/define"],["/synonyms"],["/antonyms"],["/examples"],["/all"]]}
def processUpdates(self):
response = self.session.get(self.URL + '/getUpdates?offset=' + str(self.offset),verify=False)
print "Got update"
status = False
updates = json.loads(response.text)
if updates['result']:
self.offset = updates['result'][0]['update_id'] + 1
query = updates['result'][0]['message']['text']
chat_id = updates['result'][0]['message']['chat']['id']
self.session.get(self.URL + '/sendChatAction?chat_id=' + str(chat_id) +'&action=typing',verify=False)
message = self.makeMessage(query)
status = self.sendMessage(message,chat_id)
return status
def makeMessage(self,query):
message = self.startMessage
if query == '/stop':
message = 'Bot disabled.'
elif query == '/today':
wordData = self.getWordOfTheDay()
query = '/define ' + wordData['word']
query = query.split()
if len(query) > 1:
if query[0] not in ['/define','/synonyms','/antonyms','/use','/all']:
return self.startMessage
word = ' '.join(query[1::]).lower()
message = 'Word: ' + word + '\n'
message += '=' * (len(word) + 7) + '\n'
if self.cache.get(word):
print "Fetching from cache"
wordData = self.cache.get(word)
else:
wordData = self.getWord(word)
if wordData is None:
return 'Word not found.'
if query[0] in ['/define','/all']:
message += wordData['definitions'] + '\n'
if query[0] in ['/synonyms','/all']:
message += wordData['synonyms'] + '\n'
if query[0] in ['/antonyms','/all']:
message += wordData['antonyms'] + '\n'
if query[0] in ['/use','/all']:
message += wordData['examples'] + '\n'
return message
def updateCache(self,word,wordData):
dataDict = {}
definitionText = 'Definitions :-' + '\n'
definitionText += '-' * 20 + '\n'
synonymsText = 'Synonyms :-' + '\n'
synonymsText += '-' * 20 + '\n'
antonymsText = 'Antonyms :-' + '\n'
antonymsText += '-' * 20 + '\n'
examplesText = 'Exmaples :-' + '\n'
examplesText += '-' * 20 + '\n'
definitions = self.getDefinitions(wordData)
synonyms = self.getSynonyms(wordData)
antonyms = self.getAntonyms(wordData)
examples = self.getExamples(wordData)
if not definitions:
definitionText += 'No definitions found.\n'
if not synonyms:
synonymsText += 'No synonyms found.\n'
if not antonyms:
antonymsText += 'No antonyms found.\n'
if not examples:
examplesText += 'No examples found.\n'
for definition in self.getDefinitions(wordData):
definitionText += definition[0] + '\n' + definition[1] + ': ' + definition[2] + '\n\n'
for synonym in synonyms[:5]:
synonymsText += synonym + '\n'
for antonym in antonyms[:5]:
antonymsText += antonym + '\n'
for index,example in enumerate(examples[:5]):
examplesText += str(index+1) + ". " + example + '\n\n'
dataDict['word'] = word
dataDict['definitions'] = definitionText
dataDict['synonyms'] = synonymsText
dataDict['antonyms'] = antonymsText
dataDict['examples'] = examplesText
self.cache.update({word:dataDict})
return dataDict
def getDefinitions(self,wordData):
partCounter = Counter()
definitions = []
for definition in wordData:
if partCounter[definition['partOfSpeech']] < 2:
definitions.append((definition['attributionText'],definition['partOfSpeech'],definition['text']))
partCounter[definition['partOfSpeech']] += 1
return definitions
def getSynonyms(self,wordData):
synonyms = []
for relatedWords in wordData[0]['relatedWords']:
if relatedWords['relationshipType'] == 'synonym':
for synonym in relatedWords['words']:
synonyms.append(synonym)
for relatedWords in wordData[0]['relatedWords']:
if relatedWords['relationshipType'] == 'cross-reference':
for synonym in relatedWords['words']:
synonyms.append(synonym)
return synonyms
def getAntonyms(self,wordData):
antonyms = []
for relatedWords in wordData[0]['relatedWords']:
if relatedWords['relationshipType'] == 'antonym':
for antonym in relatedWords['words']:
antonyms.append(antonym)
return antonyms
def getExamples(self,wordData):
examples = []
for index,example in enumerate(wordData[0]['examples']):
examples.append(example['text'].replace('\n',''))
return examples
def getEtymology(self,wordData):
etymologies = []
for etymology in wordData[0]['etymologies']:
etymologies.append(etymology)
return etymology
def getWord(self,word):
url1 = wordnik_url + word + '/definitions?api_key=' + wordnik_api_key
url2 = wordnik_url + word + '/examples?api_key=' + wordnik_api_key
url3 = wordnik_url + word + '/relatedWords?api_key=' + wordnik_api_key
urls = [url1,url2,url3]
data = []
for url in urls:
try:
response = self.session.get(url,verify=False)
data.append(json.loads(response.text.encode('utf-8')))
except ValueError:
return None
if not data[0]:
return None
wordData = data[0]
try:
wordData[0]['examples'] = data[1]['examples']
except KeyError:
wordData[0]['examples'] = []
try:
wordData[0]['relatedWords'] = data[2]
except KeyError:
wordData[0]['relatedWords'] = []
return self.updateCache(word,wordData)
def getWordOfTheDay(self):
today = datetime.datetime.strftime(datetime.datetime.now(), '%Y-%m-%d')
url = wordnik_url[:-10] + 'words.json/wordOfTheDay?api_key=' + wordnik_api_key + '&date=' + today
wordData = []
data = []
response = self.session.get(url,verify = False)
data.append(json.loads(response.text.encode('utf-8')))
word = data[0]['word']
if self.cache.get(word):
wordData = self.cache.get(word)
return wordData
url = wordnik_url + word + '/relatedWords?api_key=' + wordnik_api_key
wordData = [definition for definition in data[0]['definitions']]
for definition in wordData:
definition['attributionText'] = ''
wordData[0]['examples'] = data[0]['examples']
response = self.session.get(url,verify = False)
relatedWords = json.loads(response.text)
wordData[0]['relatedWords'] = relatedWords
wordData[0]['word'] = word
return self.updateCache(word,wordData)
def sendMessage(self,message,chat_id):
dataDict = {'chat_id':str(chat_id),
'text':message.encode('utf-8'),
'reply_markup':self.keyboard}
response = self.session.post(self.URL + '/sendMessage',data = dataDict)
if response.status_code == 200:
return True
else:
return False
class Dictionary(object):
def __init__(self):
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 updateCache(self, word, wordData):
dataDict = {}
definitionText = '*Definitions*' + '\n'
synonymsText = '*Synonyms*' + '\n'
antonymsText = '*Antonyms*' + '\n'
examplesText = '*Examples*' + '\n'
definitions = self.getDefinitions(wordData)
synonyms = self.getSynonyms(wordData)
antonyms = self.getAntonyms(wordData)
examples = self.getExamples(wordData)
if not definitions:
definitionText += 'No definitions found.\n'
if not synonyms:
synonymsText += 'No synonyms found.\n'
if not antonyms:
antonymsText += 'No antonyms found.\n'
if not examples:
examplesText += 'No examples found.\n'
for definition in definitions:
if definition[0]:
definitionText += definition[0] + ': '
definitionText += definition[1] + '\n\n'
definitionText = definitionText[:-1]
for synonym in synonyms[:3]:
synonymsText += synonym + '\n'
for antonym in antonyms[:3]:
antonymsText += antonym + '\n'
for index, example in enumerate(examples[:3]):
examplesText += str(index + 1) + '. ' + example + '\n\n'
examplesText = examplesText[:-1]
dataDict['word'] = word
dataDict['definitions'] = definitionText
dataDict['synonyms'] = synonymsText
dataDict['antonyms'] = antonymsText
dataDict['examples'] = examplesText
self.dictionaryCache.update({word: dataDict})
return dataDict
def getDefinitions(self, wordData):
partCounter = Counter()
definitions = []
for definition in wordData:
if 'partOfSpeech' in definition.keys(
) and partCounter[definition['partOfSpeech']] < 2:
definitions.append(('_' + definition['partOfSpeech'] + '_ ',
definition['text']))
partCounter[definition['partOfSpeech']] += 1
else:
definitions.append(('', definition['text']))
return definitions
def getSynonyms(self, wordData):
synonyms = []
for relatedWords in wordData[0]['relatedWords']:
if relatedWords['relationshipType'] == 'synonym':
for synonym in relatedWords['words']:
synonyms.append(synonym)
for relatedWords in wordData[0]['relatedWords']:
if relatedWords['relationshipType'] == 'cross-reference':
for synonym in relatedWords['words']:
synonyms.append(synonym)
return synonyms
def getAntonyms(self, wordData):
antonyms = []
for relatedWords in wordData[0]['relatedWords']:
if relatedWords['relationshipType'] == 'antonym':
for antonym in relatedWords['words']:
antonyms.append(antonym)
return antonyms
def getExamples(self, wordData):
examples = []
for index, example in enumerate(wordData[0]['examples']):
examples.append(example['text'].replace('\n', ''))
return examples
def getEtymology(self, wordData):
etymologies = []
for etymology in wordData[0]['etymologies']:
etymologies.append(etymology)
return etymology
def getWord(self, word):
if '#' in word:
return None
def_url = wordnik_url + word + '/definitions?limit=15&api_key=' + wordnik_api_key
example_url = wordnik_url + word + '/examples?api_key=' + wordnik_api_key
related_url = wordnik_url + word + '/relatedWords?api_key=' + wordnik_api_key
urls = [def_url, example_url, related_url]
data = []
for url in urls:
try:
response = self.session.get(url, verify=False)
if response.status_code != 200:
return None
data.append(json.loads(response.text.encode('utf-8')))
except ValueError:
return None
if not data[0]:
return None
wordData = data[0]
try:
wordData[0]['examples'] = data[1]['examples']
except KeyError:
wordData[0]['examples'] = []
try:
wordData[0]['relatedWords'] = data[2]
except KeyError:
wordData[0]['relatedWords'] = []
return self.updateCache(word, wordData)
def getUrbandictionaryWord(self, word):
api_url = 'http://api.urbandictionary.com/v0/define?term='
#response = requests.get(api_url+word, verify=False)
response = urllib2.urlopen(api_url + word)
data = json.loads(response.read().decode('utf-8'))
if data['result_type'] == 'no_results' or not data['list']:
return None
wordData = {}
wordData['definition'] = '*Definition*' + '\n'
wordData['example'] = '*Example*' + '\n'
try:
if data['list'][0]['definition']:
wordData['definition'] += data['list'][0]['definition'].strip(
) + '\n'
else:
return None
except KeyError:
return None
try:
if data['list'][0]['example']:
wordData['example'] += data['list'][0]['example'].strip(
) + '\n'
else:
wordData['example'] += 'No example found.'
except KeyError:
wordData['example'] += 'No example found.'
self.urbandictionaryCache.update({word: wordData})
return wordData
def getWordOfTheDay(self):
wordOfTheDay = self.wordOfTheDayCache.get(datetime.now().day, None)
if wordOfTheDay is None:
today = datetime.strftime(datetime.now(), '%Y-%m-%d')
url = wordnik_url[:
-10] + 'words.json/wordOfTheDay?api_key=' + wordnik_api_key + '&date=' + today
data = []
response = self.session.get(url, verify=False)
try:
data.append(json.loads(response.text.encode('utf-8')))
except ValueError:
return None
wordOfTheDay = data[0]['word']
self.wordOfTheDayCache.clear()
self.wordOfTheDayCache[datetime.now().day] = wordOfTheDay
else:
pass
wordData = self.dictionaryCache.get(wordOfTheDay)
if not wordData:
url = wordnik_url + wordOfTheDay + '/relatedWords?api_key=' + wordnik_api_key
wordData = [definition for definition in data[0]['definitions']]
for definition in wordData:
definition['attributionText'] = ''
wordData[0]['examples'] = data[0]['examples']
response = self.session.get(url, verify=False)
relatedWords = json.loads(response.text)
wordData[0]['relatedWords'] = relatedWords
wordData[0]['word'] = wordOfTheDay
return self.updateCache(wordOfTheDay, wordData)
else:
return wordData
