def get_known_words(lang_code):
"""
:param lang_code: only show the words for a given language (e.g. 'de')
:return: Returns all the bookmarks of a given user in the given lang
"""
e = SethiKnowledgeEstimator(flask.g.user, lang_code)
return json_result(e.known_words_list())
def translate_and_bookmark(from_lang_code, to_lang_code):
"""
This expects in the post parameter the following:
- word (to translate)
- context (surrounding paragraph of the original word )
- url (of the origin)
- title (of the origin page)
:param from_lang_code:
:param to_lang_code:
:return:
"""
word_str = unquote_plus(request.form['word'])
url_str = request.form.get('url', '')
title_str = request.form.get('title', '')
context_str = request.form.get('context', '')
# Call the translate API
translation_str, alternative_translations = zeeguu.api.translation_service.translate_from_to(
word_str, from_lang_code, to_lang_code)
translation_str = unquote_plus(translation_str)
id = bookmark_with_context(from_lang_code, to_lang_code, word_str, url_str,
title_str, context_str, translation_str)
return json_result(dict(bookmark_id=id, translation=translation_str))
def get_known_words(lang_code):
"""
:param lang_code: only show the words for a given language (e.g. 'de')
:return: Returns all the bookmarks of a given user in the given lang
"""
e = SethiKnowledgeEstimator(flask.g.user, lang_code)
return json_result(e.known_words_list())
def get_possible_translations(from_lang_code, to_lang_code):
"""
Returns a list of possible translations for this
:param word: word to be translated
:param from_lang_code:
:param to_lang_code:
:return: json array with dictionaries. each of the dictionaries contains at least
one 'translation' and one 'translation_id' key.
In the future we envision that the dict will contain
other types of information, such as relative frequency,
"""
translations_json = []
context = request.form.get('context', '')
url = request.form.get('url', '')
word = request.form['word']
main_translation, alternatives = zeeguu.api.translation_service.translate_from_to(word, from_lang_code, to_lang_code)
lan = Language.find(from_lang_code)
likelihood = 1.0
for translation in alternatives:
wor = UserWord.find(translation, lan)
zeeguu.db.session.add(wor)
zeeguu.db.session.commit()
t_dict = dict(translation_id= wor.id,
translation=translation,
likelihood=likelihood)
translations_json.append(t_dict)
likelihood -= 0.01
return json_result(dict(translations=translations_json))
def get_possible_translations(from_lang_code, to_lang_code):
"""
Returns a list of possible translations for this
:param word: word to be translated
:param from_lang_code:
:param to_lang_code:
:return: json array with dictionaries. each of the dictionaries contains at least
one 'translation' and one 'translation_id' key.
In the future we envision that the dict will contain
other types of information, such as relative frequency,
"""
translations_json = []
context = request.form.get('context', '')
url = request.form.get('url', '')
word = request.form['word']
main_translation, alternatives = zeeguu.api.translation_service.translate_from_to(
word, from_lang_code, to_lang_code)
lan = Language.find(from_lang_code)
likelihood = 1.0
for translation in alternatives:
wor = UserWord.find(translation, lan)
zeeguu.db.session.add(wor)
zeeguu.db.session.commit()
t_dict = dict(translation_id=wor.id,
translation=translation,
likelihood=likelihood)
translations_json.append(t_dict)
likelihood -= 0.01
return json_result(dict(translations=translations_json))
def translate_and_bookmark(from_lang_code, to_lang_code):
"""
This expects in the post parameter the following:
- word (to translate)
- context (surrounding paragraph of the original word )
- url (of the origin)
- title (of the origin page)
:param from_lang_code:
:param to_lang_code:
:return:
"""
word_str = unquote_plus(request.form['word'])
url_str = request.form.get('url', '')
title_str = request.form.get('title', '')
context_str = request.form.get('context', '')
# Call the translate API
translation_str, alternative_translations = zeeguu.api.translation_service.translate_from_to(word_str, from_lang_code, to_lang_code)
translation_str = unquote_plus(translation_str)
id = bookmark_with_context(from_lang_code, to_lang_code, word_str, url_str, title_str, context_str, translation_str)
return json_result(dict(
bookmark_id = id,
translation = translation_str))
def test_upload_user_activity_data():
"""
The user needs to be logged in, so the event
referst to themselves. Thus there is no need
for submitting a user id.
There are four elements that can be submitted for
an user activity event. Within an example they are:
time: '2016-05-05T10:11:12',
event: "User Read Article",
value: "300s",
extra_data: "{article_source: 2, ...}"
All these four elements have to be submitted as POST
arguments
:param self:
:return: OK if all went well
"""
time = request.form['time']
event = request.form['event']
value = request.form['value']
extra_data = request.form['extra_data']
new_entry = UserActivityData(flask.g.user,
time,
event,
value,
extra_data)
db.session.add(new_entry)
db.session.commit()
return json_result(new_entry.data_as_dictionary())
def get_feeds_at_url():
"""
:return: a list of feeds that can be found at the given URL
Empty list if soemething
"""
domain = request.form.get('url', '')
return json_result(list_of_feeds_at_url(domain))
def bookmarks_to_study(bookmark_count):
"""
Returns a number of <bookmark_count> bookmarks that
are recommended for this user to study
"""
return json_result(flask.g.user.bookmarks_to_study(int(bookmark_count)))
def get_user_details():
"""
after the login, this information might be useful to be displayed
by an app
:param lang_code:
:return:
"""
return json_result(flask.g.user.details_as_dictionary())
def learned_and_native_language():
"""
Get the native language of the user in session
:return:
"""
u = flask.g.user
res = dict(native=u.native_language_id, learned=u.learned_language_id)
return json_result(res)
def get_user_details():
"""
after the login, this information might be useful to be displayed
by an app
:param lang_code:
:return:
"""
return json_result(flask.g.user.details_as_dictionary())
def learned_and_native_language():
"""
Get the native language of the user in session
:return:
"""
u = flask.g.user
res = dict( native = u.native_language_id,
learned = u.learned_language_id)
return json_result(res)
def get_interesting_feeds_for_language_id(language_id):
"""
Get a list of feeds for the given language
:return:
"""
feed_data = []
for feed in RSSFeed.find_for_language_id(language_id):
feed_data.append(feed.as_dictionary())
return json_result(feed_data)
def get_bookmarks_by_day(return_context):
"""
Returns the bookmarks of this user organized by date
:param return_context: If "with_context" it also returns the
text where the bookmark was found. If <return_context>
is anything else, the context is not returned.
"""
with_context = return_context == "with_context"
return json_result(flask.g.user.bookmarks_by_day(with_context))
def get_translations_for_bookmark(bookmark_id):
bookmark = Bookmark.query.filter_by(id=bookmark_id).first()
result = [
dict(id=translation.id,
word=translation.word,
language=translation.language.name,
ranked_word=translation.rank)
for translation in bookmark.translations_list]
return json_result(result)
def get_learned_bookmarks(lang):
lang = Language.find(lang)
estimator = SethiKnowledgeEstimator(flask.g.user, lang.id)
bk_list = [
dict(id=bookmark.id,
origin=bookmark.origin.word,
text=bookmark.text.content)
for bookmark in estimator.learned_bookmarks()
]
return json_result(bk_list)
def get_difficulty_for_text(lang_code):
"""
URL parameters:
:param lang_code: the language of the text
Json data:
:param texts: json array that contains the texts to calculate the difficulty for. Each text consists of an array
with the text itself as 'content' and an additional 'id' which gets roundtripped unchanged
:param difficulty_computer (optional): calculate difficulty score using a specific algorithm
:param rank_boundary (deprecated): upper boundary for word frequency rank (between 1 and 10'000)
:param personalized (deprecated): by default we always compute the personalized difficulty
For an example of how the Json data looks like, see
../tests/api_tests.py#test_txt_difficulty(self):
:return difficulties: json array, which contains for each text:
* estimated_difficulty - one of three: "EASY", "MEDIUM", "HARD"
* id - identifies the text
* [deprecated] score_average - average difficulty of the words in the text
* [deprecated] score_median - median difficulty of the words in the text
"""
language = Language.find(lang_code)
if not language:
return 'FAIL'
data = request.get_json()
if not 'texts' in data:
return 'FAIL'
texts = []
for text in data['texts']:
texts.append(text)
difficulty_computer = 'default'
if 'difficulty_computer' in data:
difficulty_computer = data['difficulty_computer'].lower()
user = flask.g.user
known_probabilities = KnownWordProbability.find_all_by_user_cached(user)
difficulties = []
for text in texts:
difficulty = text_difficulty(
text["content"],
language,
known_probabilities,
difficulty_computer
)
difficulty["id"] = text["id"]
difficulties.append(difficulty)
return json_result(dict(difficulties=difficulties))
def get_translations_for_bookmark(bookmark_id):
bookmark = Bookmark.query.filter_by(id=bookmark_id).first()
result = [
dict(id=translation.id,
word=translation.word,
language=translation.language.name,
ranked_word=translation.rank)
for translation in bookmark.translations_list
]
return json_result(result)
def get_learned_bookmarks(lang):
lang = Language.find(lang)
estimator = SethiKnowledgeEstimator(flask.g.user, lang.id)
bk_list = [
dict(
id=bookmark.id,
origin=bookmark.origin.word,
text=bookmark.text.content)
for bookmark in estimator.learned_bookmarks()]
return json_result(bk_list)
def get_exercise_log_for_bookmark(bookmark_id):
bookmark = Bookmark.query.filter_by(id=bookmark_id).first()
exercise_log_dict = []
exercise_log = bookmark.exercise_log
for exercise in exercise_log:
exercise_log_dict.append(dict(id = exercise.id,
outcome = exercise.outcome.outcome,
source = exercise.source.source,
exercise_log_solving_speed = exercise.solving_speed,
time = exercise.time.strftime('%m/%d/%Y')))
return json_result(exercise_log_dict)
def get_exercise_log_for_bookmark(bookmark_id):
bookmark = Bookmark.query.filter_by(id=bookmark_id).first()
exercise_log_dict = []
exercise_log = bookmark.exercise_log
for exercise in exercise_log:
exercise_log_dict.append(
dict(id=exercise.id,
outcome=exercise.outcome.outcome,
source=exercise.source.source,
exercise_log_solving_speed=exercise.solving_speed,
time=exercise.time.strftime('%m/%d/%Y')))
return json_result(exercise_log_dict)
def get_difficulty_for_text(lang_code):
"""
URL parameters:
:param lang_code: the language of the text
Json data:
:param texts: json array that contains the texts to calculate the difficulty for. Each text consists of an array
with the text itself as 'content' and an additional 'id' which gets roundtripped unchanged
:param difficulty_computer (optional): calculate difficulty score using a specific algorithm
:param rank_boundary (deprecated): upper boundary for word frequency rank (between 1 and 10'000)
:param personalized (deprecated): by default we always compute the personalized difficulty
For an example of how the Json data looks like, see
../tests/api_tests.py#test_txt_difficulty(self):
:return difficulties: json array, which contains for each text:
* estimated_difficulty - one of three: "EASY", "MEDIUM", "HARD"
* id - identifies the text
* [deprecated] score_average - average difficulty of the words in the text
* [deprecated] score_median - median difficulty of the words in the text
"""
language = Language.find(lang_code)
if not language:
return 'FAIL'
data = request.get_json()
if not 'texts' in data:
return 'FAIL'
texts = []
for text in data['texts']:
texts.append(text)
difficulty_computer = 'default'
if 'difficulty_computer' in data:
difficulty_computer = data['difficulty_computer'].lower()
user = flask.g.user
known_probabilities = KnownWordProbability.find_all_by_user_cached(user)
difficulties = []
for text in texts:
difficulty = text_difficulty(text["content"], language,
known_probabilities, difficulty_computer)
difficulty["id"] = text["id"]
difficulties.append(difficulty)
return json_result(dict(difficulties=difficulties))
def get_feeds_being_followed():
"""
A user might be following multiple feeds at once.
This endpoint returns them as a list.
:return: a json list with feeds for which the user is registered;
every feed in this list is a dictionary with the following info:
id = unique id of the feed; uniquely identifies feed in other endpoints
title = <unicode string>
url = ...
language = ...
image_url = ...
"""
registrations = RSSFeedRegistration.feeds_for_user(flask.g.user)
return json_result([reg.rss_feed.as_dictionary() for reg in registrations])
def get_smartwatch_events():
"""
Returns an array of entries which are dicts:
dict (
bookmark_id: 1,
time: 'YYYY-MM-DDTHH:MM:SS',
event: "Glance"
}
:return: OK or FAIL
"""
event_objects = WatchInteractionEvent.events_for_user(flask.g.user)
sorted_events = sorted(event_objects, key=lambda event: event.time)
events = [x.data_as_dictionary() for x in sorted_events]
return json_result(events)
def get_smartwatch_events():
"""
Returns an array of entries which are dicts:
dict (
bookmark_id: 1,
time: 'YYYY-MM-DDTHH:MM:SS',
event: "Glance"
}
:return: OK or FAIL
"""
event_objects = WatchInteractionEvent.events_for_user(flask.g.user)
sorted_events = sorted(event_objects, key=lambda event: event.time)
events = [x.data_as_dictionary() for x in sorted_events]
return json_result(events)
def get_feed_items_for(feed_id):
"""
Get a list of feed items for a given feed ID
:return: json list of dicts, with the following info:
title = <unicode string>
url = <unicode string>
content = <list> e.g.:
[{u'base': u'http://www.spiegel.de/schlagzeilen/index.rss',
u'type': u'text/html', u'language': None, u'value': u'\xdcberwachungskameras, die bei Aldi verkauft wurden, haben offenbar ein Sicherheitsproblem: Hat man kein Passwort festgelegt, \xfcbertragen sie ihre Aufnahmen ungesch\xfctzt ins Netz - und verraten au\xdferdem WLAN- und E-Mail-Passw\xf6rter.'}]
summary = <unicode string>
published= <unicode string> e.g.
'Fri, 15 Jan 2016 15:26:51 +0100'
"""
registration = RSSFeedRegistration.with_feed_id(feed_id, flask.g.user)
return json_result(registration.rss_feed.feed_items())
def post_bookmarks_by_day():
"""
Returns the bookmarks of this user organized by date. Based on the
POST arguments, it can return also the context of the bookmark as
well as it can return only the bookmarks after a given date.
:param (POST) with_context: If this parameter is "true", the endpoint
also returns the text where the bookmark was found.
:param (POST) after_date: the date after which to start retrieving
the bookmarks. if no date is specified, all the bookmarks are returned.
The date format is: %Y-%m-%dT%H:%M:%S. E.g. 2001-01-01T01:55:00
"""
with_context = request.form.get("with_context", "false") == "true"
after_date_string = request.form.get("after_date", "1970-01-01T00:00:00")
after_date = datetime.strptime(after_date_string, '%Y-%m-%dT%H:%M:%S')
return json_result(flask.g.user.bookmarks_by_day(with_context, after_date))
def get_learnability_for_text(lang_code):
"""
URL parameters:
:param lang_code: the language of the text
Json data:
:param texts: json array that contains the texts to calculate the learnability for. Each text consists of an array
with the text itself as 'content' and an additional 'id' which gets roundtripped unchanged
For an example of how the Json data looks like, see
../tests/api_tests.py#test_text_learnability(self):
:return learnabilities: json array, contains the learnabilities as arrays with the key 'score' for the learnability
value (percentage of words from the text that the user is currently learning), the 'count' of the learned
words in the text and the 'id' parameter to identify the corresponding text
"""
user = flask.g.user
language = Language.find(lang_code)
if language is None:
return 'FAIL'
data = request.get_json()
texts = []
if 'texts' in data:
for text in data['texts']:
texts.append(text)
else:
return 'FAIL'
learnabilities = []
for text in texts:
e = SethiKnowledgeEstimator(user)
count, learnability = text_learnability(
text, e.words_being_learned(language))
learnabilities.append(
dict(score=learnability, count=count, id=text['id']))
return json_result(dict(learnabilities=learnabilities))
def get_learnability_for_text(lang_code):
"""
URL parameters:
:param lang_code: the language of the text
Json data:
:param texts: json array that contains the texts to calculate the learnability for. Each text consists of an array
with the text itself as 'content' and an additional 'id' which gets roundtripped unchanged
For an example of how the Json data looks like, see
../tests/api_tests.py#test_text_learnability(self):
:return learnabilities: json array, contains the learnabilities as arrays with the key 'score' for the learnability
value (percentage of words from the text that the user is currently learning), the 'count' of the learned
words in the text and the 'id' parameter to identify the corresponding text
"""
user = flask.g.user
language = Language.find(lang_code)
if language is None:
return 'FAIL'
data = request.get_json()
texts = []
if 'texts' in data:
for text in data['texts']:
texts.append(text)
else:
return 'FAIL'
learnabilities = []
for text in texts:
e = SethiKnowledgeEstimator(user)
count, learnability = text_learnability(text, e.words_being_learned(language))
learnabilities.append(dict(score=learnability, count=count, id=text['id']))
return json_result(dict(learnabilities=learnabilities))
def get_probably_known_words(lang_code):
e = SethiKnowledgeEstimator(flask.g.user, lang_code)
return json_result(e.get_probably_known_words())
def studied_words():
"""
Returns a list of the words that the user is currently studying.
"""
return json_result(flask.g.user.user_words())
def get_known_bookmarks(lang_code):
e = SethiKnowledgeEstimator(flask.g.user, lang_code)
return json_result(e.get_known_bookmarks())
def get_not_looked_up_words(lang_code):
e = SethiKnowledgeEstimator(flask.g.user)
return json_result(e.get_not_looked_up_words())
def get_not_encountered_words(lang_code):
return json_result(flask.g.user.get_not_encountered_words(Language.find(lang_code)))
def get_content_from_url():
"""
Json data:
:param urls: json array that contains the urls to get the article content for. Each url consists of an array
with the url itself as 'url' and an additional 'id' which gets roundtripped unchanged.
For an example of how the Json data looks like, see
../tests/api_tests.py#test_content_from_url(self):
:param timeout (optional): maximal time in seconds to wait for the results
:param lang_code (optional): If the user sends along the language, then we compute the difficulty of the texts
:return contents: json array, contains the contents of the urls that responded within the timeout as arrays
with the key 'content' for the article content, the url of the main image as 'image' and the 'id' parameter
to identify the corresponding url
"""
data = request.get_json()
queue = Queue.Queue()
urls = []
if 'urls' in data:
for url in data['urls']:
urls.append(url)
else:
return 'FAIL'
if 'timeout' in data:
timeout = int(data['timeout'])
else:
timeout = 10
# Start worker threads to get url contents
threads = []
for url in urls:
thread = threading.Thread(target=PageExtractor.worker, args=(url['url'], url['id'], queue))
thread.daemon = True
threads.append(thread)
thread.start()
# Wait for workers to finish until timeout
stop = time.time() + timeout
while any(t.isAlive() for t in threads) and time.time() < stop:
time.sleep(0.1)
contents = []
for i in xrange(len(urls)):
try:
contents.append(queue.get_nowait())
except Queue.Empty:
pass
# If the user sends along the language, then we can compute the difficulty
if 'lang_code' in data:
lang_code = data['lang_code']
language = Language.find(lang_code)
if language is not None:
print "got language"
user = flask.g.user
known_probabilities = KnownWordProbability.find_all_by_user_cached(user)
for each_content_dict in contents:
difficulty = text_difficulty(
each_content_dict["content"],
language,
known_probabilities
)
each_content_dict["difficulty"] = difficulty
return json_result(dict(contents=contents))
def get_not_encountered_words(lang_code):
return json_result(
flask.g.user.get_not_encountered_words(Language.find(lang_code)))
def get_not_looked_up_words(lang_code):
e = SethiKnowledgeEstimator(flask.g.user)
return json_result(e.get_not_looked_up_words())
def get_known_bookmarks(lang_code):
e = SethiKnowledgeEstimator(flask.g.user, lang_code)
return json_result(e.get_known_bookmarks())
def get_probably_known_words(lang_code):
e = SethiKnowledgeEstimator(flask.g.user, lang_code)
return json_result(e.get_probably_known_words())