class UserWord(db.Model, util.JSONSerializable):
__tablename__ = 'user_words'
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
word = db.Column(db.String(255), nullable=False, unique=True)
language_id = db.Column(db.String(2), db.ForeignKey("language.id"))
language = db.relationship("Language")
rank_id = db.Column(db.Integer,
db.ForeignKey("word_ranks.id"),
nullable=True)
rank = db.relationship("WordRank")
db.UniqueConstraint(word, language_id)
IMPORTANCE_LEVEL_STEP = 1000
IMPOSSIBLE_RANK = 1000000
IMPOSSIBLE_IMPORTANCE_LEVEL = IMPOSSIBLE_RANK / IMPORTANCE_LEVEL_STEP
def __init__(self, word, language, rank=None):
self.word = word
self.language = language
self.rank = rank
def __repr__(self):
return '<UserWord %r>' % (self.word)
def serialize(self):
return self.word
# returns a number between
def importance_level(self):
if self.rank is not None:
return max((10 - self.rank.rank / UserWord.IMPORTANCE_LEVEL_STEP),
0)
else:
return 0
# we use this in the bookmarks.html to show the rank.
# for words in which there is no rank info, we don't display anything
def importance_level_string(self):
if self.rank == None:
return ""
b = "|"
return b * self.importance_level()
@classmethod
def find(cls, word, language, rank=None):
try:
return (cls.query.filter(cls.word == word).filter(
cls.language == language).one())
except sqlalchemy.orm.exc.NoResultFound:
return cls(word, language, rank)
@classmethod
def find_rank(cls, word, language):
return WordRank.find(word, language)
@classmethod
def find_all(cls):
return cls.query.all()
class Url(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(2083))
path = db.Column(db.String(2083))
url = db.Column(db.String(2083))
domain_name_id = db.Column(db.Integer, db.ForeignKey("domain_name.id"))
domain = db.relationship("DomainName")
def __init__(self, url, title):
self.path = Url.get_path(url)
self.domain = DomainName.find(Url.get_domain(url))
self.title = title
def title_if_available(self):
if self.title != "":
return self.title
return self.url
def as_string(self):
return self.domain.domain_name + self.path
def domain_name(self):
return self.domain.domain_name
@classmethod
def get_domain(self, url):
protocol_re = '(.*://)?'
domain_re = '([^/?]*)'
path_re = '(.*)'
domain = re.findall(protocol_re + domain_re, url)[0]
return domain[0] + domain[1]
@classmethod
def get_path(self, url):
protocol_re = '(.*://)?'
domain_re = '([^/?]*)'
path_re = '(.*)'
domain = re.findall(protocol_re + domain_re + path_re, url)[0]
return domain[2]
@classmethod
def find(cls, url, title=""):
try:
d = DomainName.find(Url.get_domain(url))
return (cls.query.filter(cls.path == Url.get_path(url)).filter(
cls.domain == d).one())
except sqlalchemy.orm.exc.NoResultFound:
return cls(url, title)
def render_link(self, link_text):
if self.url != "":
return '<a href="' + self.url + '">' + link_text + '</a>'
else:
return ""
class Card(db.Model):
id = db.Column(db.Integer, primary_key=True)
position = db.Column(db.Integer)
bookmark_id = db.Column(db.Integer, db.ForeignKey('bookmark.id'))
bookmark = db.relationship("Bookmark", backref="card")
last_seen = db.Column(db.DateTime)
def __init__(self, bookmark):
self.bookmark = bookmark
self.position = 0
self.reason = ""
self.seen()
def seen(self):
self.last_seen = datetime.datetime.now()
def set_reason(self, reason):
self.reason = reason
def reason(self):
return self.reason
def is_starred(self):
return self.bookmark.user.has_starred(self.bookmark.origin)
def star(self):
word = self.bookmark.origin
self.bookmark.user.starred_words.append(word)
def unstar(self):
word = self.bookmark.origin
self.bookmark.user.starred_words.remove(word)
class Url(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.String(2083))
title = db.Column(db.String(2083))
def __init__(self, url, title):
self.url = url
self.title = title
def title_if_available(self):
if self.title != "":
return self.title
return self.url
@classmethod
def find(cls, url, title):
try:
return (cls.query.filter(cls.url == url).one())
except sqlalchemy.orm.exc.NoResultFound:
return cls(url, title)
def render_link(self, link_text):
if self.url != "":
return '<a href="' + self.url + '">' + link_text + '</a>'
else:
return ""
class Language(db.Model):
id = db.Column(db.String(2), primary_key=True)
name = db.Column(db.String(255), unique=True)
def __init__(self, id, name):
self.name = name
self.id = id
def __repr__(self):
return '<Language %r>' % (self.id)
@classmethod
def default_learned(cls):
return cls.find("de")
@classmethod
def default_native_language(cls):
return cls.find("en")
@classmethod
def native_languages(cls):
return [cls.find("en"), cls.find("ro")]
@classmethod
def available_languages(cls):
return cls.all()
@classmethod
def find(cls, id_):
return cls.query.filter(Language.id == id_).one()
@classmethod
def all(cls):
return cls.query.filter().all()
class Card(db.Model):
id = db.Column(db.Integer, primary_key=True)
position = db.Column(db.Integer)
contribution_id = db.Column(db.Integer, db.ForeignKey('contribution.id'))
contribution = db.relationship("Contribution", backref="card")
last_seen = db.Column(db.DateTime)
def __init__(self, contribution):
self.contribution = contribution
self.position = 0
self.reason = ""
self.seen()
def seen(self):
self.last_seen = datetime.datetime.now()
def set_reason(self, reason):
self.reason = reason
def reason(self):
return self.reason
def is_starred(self):
return self.contribution.user.has_starred(self.contribution.origin)
def star(self):
word = self.contribution.origin
self.contribution.user.starred_words.append(word)
print "starred the hell out of... " + self.contribution.origin.word
def unstar(self):
word = self.contribution.origin
self.contribution.user.starred_words.remove(word)
print "just unstarred ..." + self.contribution.origin.word
class ExerciseSource(db.Model):
__tablename__ = 'exercise_source'
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
source = db.Column(db.String(255), nullable=False)
def __init__(self, source):
self.source = source
class WatchInteractionEvent(db.Model):
__tablename__ = 'watch_interaction_event'
__table_args__ = dict(mysql_collate='utf8_bin')
id = db.Column(db.Integer, primary_key=True)
time = db.Column(db.DateTime)
bookmark_id = db.Column(db.Integer,
db.ForeignKey('bookmark.id'),
nullable=False)
bookmark = db.relationship("Bookmark")
event_type_id = db.Column(db.Integer,
db.ForeignKey('watch_event_type.id'),
nullable=False)
event_type = db.relationship("WatchEventType")
def __init__(self, event_type, bookmark_id, time):
self.time = time
self.bookmark_id = bookmark_id
self.event_type = event_type
def data_as_dictionary(self):
return dict(user_id=self.bookmark.user_id,
bookmark_id=self.bookmark_id,
time=self.time.strftime("%Y-%m-%dT%H:%M:%S"),
event=self.event_type.name)
def is_learned_event(self):
return self.event_type.name == "learnedIt"
def is_wrong_translation_event(self):
return self.event_type.name == "wrongTranslation"
def prevents_further_study(self):
"""
Some events prevent a bookmark for being good for study
in the future
:return:
"""
return self.is_learned_event() or self.is_wrong_translation_event()
@classmethod
def events_for_bookmark(cls, bookmark):
return cls.query.filter_by(bookmark_id=bookmark.id).all()
@classmethod
def events_for_bookmark_id(cls, bookmark_id):
return cls.query.filter_by(bookmark_id=bookmark_id).all()
@classmethod
def events_for_user(cls, user):
return cls.query.join(Bookmark).filter(
Bookmark.user_id == user.id).all()
class ExerciseSource(db.Model):
__tablename__ = 'exercise_source'
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
source = db.Column(db.String(255), nullable=False)
def __init__(self, source):
self.source = source
@classmethod
def find_by_source(cls, source):
new_source = ExerciseSource.query.filter_by(source=source).first()
return new_source
class RankedWord(db.Model, util.JSONSerializable):
__tablename__ = 'ranked_word'
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
word = db.Column(db.String(255), nullable=False, unique=True, index=True)
language_id = db.Column(db.String(2), db.ForeignKey("language.id"))
language = db.relationship("Language")
rank = db.Column(db.Integer)
db.UniqueConstraint(word, language_id)
def __init__(self, word, language, rank):
self.word = word
self.language = language
self.rank = rank
@classmethod
def find(cls, word, language):
word = word.lower()
try:
return (cls.query.filter(cls.word == word).filter(
cls.language == language).one())
except sqlalchemy.orm.exc.NoResultFound:
return None
@classmethod
def find_all(cls, language):
return cls.query.filter(cls.language == language).all()
@classmethod
def exists(cls, word, language):
word = word.lower()
try:
(cls.query.filter(cls.word == word).filter(
cls.language == language).one())
return True
except sqlalchemy.orm.exc.NoResultFound:
return False
@classmethod
def words_list(cls):
words_list = []
for word in cls.find_all():
words_list.append(word.word)
return words_list
class ExerciseOutcome(db.Model):
__tablename__ = 'exercise_outcome'
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
outcome = db.Column(db.String(255), nullable=False)
IKNOW = 'I know'
NOT_KNOW = 'Do not know'
def __init__(self, outcome):
self.outcome = outcome
@classmethod
def find(cls, outcome):
try:
return cls.query.filter_by(outcome=outcome).first()
except sqlalchemy.orm.exc.NoResultFound:
return cls(outcome)
class Session(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("User")
last_use = db.Column(db.DateTime)
def __init__(self, user, id_):
self.id = id_
self.user = user
self.update_use_date()
def update_use_date(self):
self.last_use = datetime.datetime.now()
@classmethod
def for_user(cls, user):
while True:
id_ = random.randint(0, zeeguu.app.config.get("MAX_SESSION"))
if cls.query.get(id_) is None:
break
return cls(user, id_)
@classmethod
def find_for_id(cls, session_id):
try:
return cls.query.filter(cls.id == session_id).one()
except:
return None
# @classmethod
# def find_for_user(cls, user):
# return cls.query.filter(cls.user == user).order_by(desc(cls.last_use)).first()
@classmethod
def find_for_user(cls, user):
s = cls.query.filter(cls.user == user).\
filter(cls.id < zeeguu.app.config.get("MAX_SESSION")).\
order_by(desc(cls.last_use)).first()
if not s:
s = cls.for_user(user)
return s
class RSSFeedRegistration(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
__tablename__ = 'rss_feed_registration'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("User")
rss_feed_id = db.Column(db.Integer, db.ForeignKey("rss_feed.id"))
rss_feed = relationship("RSSFeed")
def __init__(self, user, feed):
self.user = user
self.rss_feed = feed
@classmethod
def find_or_create(cls, user, feed):
try:
return (cls.query.filter(cls.user == user).filter(
cls.rss_feed == feed).one())
except sqlalchemy.orm.exc.NoResultFound:
return cls(user, feed)
@classmethod
def feeds_for_user(cls, user):
"""
would have been nicer to define a method on the User class get feeds,
but that would pollute the user model, and it's not nice.
:param user:
:return:
"""
return (cls.query.filter(cls.user == user))
@classmethod
def with_id(cls, id):
return (cls.query.filter(cls.id == id)).one()
@classmethod
def with_feed_id(cls, id, user):
return (cls.query.filter(cls.rss_feed_id == id))\
.filter(cls.user_id == user.id).one()
class WatchEventType(db.Model):
__table_args__ = dict(mysql_collate='utf8_bin')
__tablename__ = 'watch_event_type'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
def __init__(self, name):
self.name = name
@classmethod
def find_by_name(cls, name):
"""
:param name:
:return: the desired object, or None if it does not exist
"""
try:
return WatchEventType.query.filter_by(name=name).first()
except:
return None
class Exercise(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
__tablename__ = 'exercise'
id = db.Column(db.Integer, primary_key=True)
outcome_id = db.Column(db.Integer,
db.ForeignKey('exercise_outcome.id'),
nullable=False)
outcome = db.relationship("ExerciseOutcome", backref="exercise")
source_id = db.Column(db.Integer,
db.ForeignKey('exercise_source.id'),
nullable=False)
source = db.relationship("ExerciseSource", backref="exercise")
solving_speed = db.Column(db.Integer)
time = db.Column(db.DateTime, nullable=False)
def __init__(self, outcome, source, solving_speed, time):
self.outcome = outcome
self.source = source
self.solving_speed = solving_speed
self.time = time
class Session(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("User")
last_use = db.Column(db.DateTime)
def __init__(self, user, id_):
self.id = id_
self.user = user
self.update_use_date()
def update_use_date(self):
self.last_use = datetime.datetime.now()
@classmethod
def for_user(cls, user):
while True:
id_ = random.randint(0, 1 << 31)
if cls.query.get(id_) is None:
break
return cls(user, id_)
class ExerciseOutcome(db.Model):
__tablename__ = 'exercise_outcome'
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
outcome = db.Column(db.String(255), nullable=False)
TOO_EASY = 'Too easy'
SHOW_SOLUTION = 'Show solution'
CORRECT = 'Correct'
WRONG = 'Wrong'
def __init__(self, outcome):
self.outcome = outcome
@classmethod
def find(cls, outcome):
try:
return cls.query.filter_by(outcome=outcome).one()
except sqlalchemy.orm.exc.NoResultFound:
return cls(outcome)
class UserActivityData(db.Model):
__table_args__ = dict(mysql_collate="utf8_bin")
__tablename__ = 'user_activity_data'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("User")
time = db.Column(db.DateTime)
event = db.Column(db.String(255))
value = db.Column(db.String(255))
extra_data = db.Column(db.String(4096))
def __init__(self, user, time, event, value, extra_data):
self.user = user
self.time = time
self.event = event
self.value = value
self.extra_data = extra_data
def data_as_dictionary(self):
return dict(user_id=self.user_id,
time=self.time.strftime("%Y-%m-%dT%H:%M:%S"),
event=self.event,
value=self.value,
extra_data=self.extra_data)
class UniqueCode(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(4))
email = db.Column(db.String(255))
time = db.Column(db.DateTime)
def __init__(self, email):
self.code = randint(100,999)
self.email = email
self.time = datetime.now()
def __str__(self):
return str(self.code)
@classmethod
def last_code(cls, email):
return (cls.query.filter(cls.email == email).order_by(cls.time.desc()).first()).code
@classmethod
def all_codes_for(cls, email):
return (cls.query.filter(cls.email == email)).all()
class Language(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.String(2), primary_key=True)
name = db.Column(db.String(255), unique=True)
def __init__(self, id, name):
self.name = name
self.id = id
def __repr__(self):
return '<Language %r>' % (self.id)
@classmethod
def default_learned(cls):
return cls.find("de")
@classmethod
def default_native_language(cls):
return cls.find("en")
@classmethod
def native_languages(cls):
return [cls.find("en")]
@classmethod
def available_languages(cls):
return list(set(cls.all()) - set([Language.find("en")]))
@classmethod
def find(cls, id_):
return cls.query.filter(Language.id == id_).one()
@classmethod
def all(cls):
return cls.query.filter().all()
class DomainName(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
__tablename__ = 'domain_name'
id = db.Column(db.Integer, primary_key=True)
domain_name = db.Column(db.String(2083))
def __init__(self, url):
self.domain_name = self.extract_domain_name(url)
def extract_domain_name(self, url):
protocol_re = '(.*://)?'
domain_re = '([^/?]*)'
domain = re.findall(protocol_re + domain_re, url)[0]
return domain[0] + domain[1]
@classmethod
def find(cls, domain_url):
try:
return (cls.query.filter(cls.domain_name == domain_url).one())
except sqlalchemy.orm.exc.NoResultFound:
# print "tried, but didn't find " + domain_url
return cls(domain_url)
class Impression(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("User", backref="impressions")
word_id = db.Column(db.Integer, db.ForeignKey("word.id"))
word = db.relationship("Word")
text_id = db.Column(db.Integer, db.ForeignKey("text.id"))
text = db.relationship("Text")
count = db.Column(db.Integer)
last_search_id = db.Column(db.Integer, db.ForeignKey("search.id"))
last_search = db.relationship("Search")
def __init__(self, user, word, text=None):
self.user = user
self.word = word
self.text = text
def __repr__(self):
return '<Impression %r>' % (self.word.word)
class Search(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("User", backref="searches")
word_id = db.Column(db.Integer, db.ForeignKey("word.id"))
word = db.relationship("Word")
language_id = db.Column(db.String(2), db.ForeignKey("language.id"))
language = db.relationship("Language")
text_id = db.Column(db.Integer, db.ForeignKey("text.id"))
text = db.relationship("Text")
contribution_id = db.Column(db.Integer, db.ForeignKey("contribution.id"))
contribution = db.relationship("Contribution", backref="search")
def __init__(self, user, word, language, text=None):
self.user = user
self.word = word
self.language = language
self.text = text
def __repr__(self):
return '<Search %r>' % (self.word.word)
class Contribution(db.Model):
id = db.Column(db.Integer, primary_key=True)
origin_id = db.Column(db.Integer, db.ForeignKey('word.id'))
origin = db.relationship("Word", primaryjoin=origin_id == Word.id,
backref="translations")
translation_id = db.Column(db.Integer, db.ForeignKey('word.id'))
translation = db.relationship("Word",
primaryjoin=translation_id == Word.id)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship("User", backref="contributions")
text_id = db.Column(db.Integer, db.ForeignKey('text.id'))
text = db.relationship("Text", backref="contributions")
time = db.Column(db.DateTime)
def __init__(self, origin, translation, user, text, time):
self.origin = origin
self.translation = translation
self.user = user
self.time = time
self.text = text
class Search(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user = db.relationship("User", backref="searches")
word_id = db.Column(db.Integer, db.ForeignKey("user_words.id"))
word = db.relationship("UserWord")
language_id = db.Column(db.String(2), db.ForeignKey("language.id"))
language = db.relationship("Language")
text_id = db.Column(db.Integer, db.ForeignKey("text.id"))
text = db.relationship("Text")
bookmark_id = db.Column(db.Integer, db.ForeignKey("bookmark.id"))
bookmark = db.relationship("Bookmark", backref="search")
def __init__(self, user, word, language, text=None):
self.user = user
self.user_word = word
self.language = language
self.text = text
def __repr__(self):
return '<Search %r>' % (self.user_word.word)
class EncounterBasedProbability(db.Model):
__tablename__ = 'encounter_based_probability'
__table_args__ = {'mysql_collate': 'utf8_bin'}
DEFAULT_PROBABILITY = 0.5
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
user = db.relationship("User")
ranked_word_id = db.Column(db.Integer,
db.ForeignKey("ranked_word.id"),
nullable=False)
ranked_word = db.relationship("RankedWord")
not_looked_up_counter = db.Column(db.Integer, nullable=False)
probability = db.Column(db.DECIMAL(10, 9), nullable=False)
db.UniqueConstraint(user_id, ranked_word_id)
db.CheckConstraint('probability>=0', 'probability<=1')
def __init__(self, user, ranked_word, not_looked_up_counter, probability):
self.user = user
self.ranked_word = ranked_word
self.not_looked_up_counter = not_looked_up_counter
self.probability = probability
@classmethod
def find(cls, user, ranked_word, default_probability=None):
try:
return cls.query.filter_by(user=user,
ranked_word=ranked_word).one()
except sqlalchemy.orm.exc.NoResultFound:
return cls(user, ranked_word, 1, default_probability)
@classmethod
def find_all(cls):
return cls.query.all()
@classmethod
def find_all_by_user(cls, user):
return cls.query.filter_by(user=user).all()
@classmethod
def exists(cls, user, ranked_word):
try:
cls.query.filter_by(user=user, ranked_word=ranked_word).one()
return True
except sqlalchemy.orm.exc.NoResultFound:
return False
@classmethod
def find_or_create(cls, word, user, language):
ranked_word = RankedWord.find(word.lower(), language)
if EncounterBasedProbability.exists(user, ranked_word):
enc_prob = EncounterBasedProbability.find(user, ranked_word)
enc_prob.not_looked_up_counter += 1
enc_prob.boost_prob()
else:
enc_prob = EncounterBasedProbability.find(
user, ranked_word,
EncounterBasedProbability.DEFAULT_PROBABILITY)
return enc_prob
def reset_prob(self):
# Why is this 0.5? Should be lower! I just looked up the word...
# ugh...
self.probability = 0.5
def word_has_just_beek_bookmarked(self):
"""
the user can't know this word very well if he's
bookmarking it again
:return:
"""
self.probability /= 2
# This function controls if prob is already 1.0, else it adds 0.1. It maximum adds 0.1, therefore cannot exceed 1
def boost_prob(self):
if float(self.probability) <> 1.0:
self.probability = float(self.probability) + 0.1
class Text(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(10000))
content_hash = db.Column(db.LargeBinary(32))
language_id = db.Column(db.String(2), db.ForeignKey("language.id"))
language = db.relationship("Language")
url_id = db.Column(db.Integer, db.ForeignKey('url.id'))
url = db.relationship("Url", backref="texts")
def __init__(self, content, language, url):
self.content = content
self.language = language
self.url = url
self.content_hash = util.text_hash(content)
def __repr__(self):
return '<Text %r>' % (self.language.short)
def words(self):
for word in re.split(re.compile(u"[^\\w]+", re.U), self.content):
yield UserWord.find(word, self.language)
def shorten_word_context(self, given_word, max_word_count):
# shorter_text = ""
limited_words = []
words = self.content.split(
) # ==> gives me a list of the words ["these", "types", ",", "the"]
word_count = len(words)
if word_count <= max_word_count:
return self.content
for i in range(0, max_word_count):
limited_words.append(
words[i]) # lista cu primele max_length cuvinte
shorter_text = ' '.join(
limited_words) # string cu primele 'max_word_count' cuv
# sometimes the given_word does not exist in the text.
# in that case return a text containing max_length words
if given_word not in words:
return shorter_text
if words.index(given_word) <= max_word_count:
return shorter_text
for i in range(max_word_count + 1, words.index(given_word) + 1):
limited_words.append(words[i])
shorter_text = ' '.join(limited_words)
return shorter_text
@classmethod
def find(cls, text, language):
try:
query = (cls.query.filter(cls.language == language).filter(
cls.content_hash == util.text_hash(text)))
if query.count() > 0:
query = query.filter(cls.content == text)
try:
return query.one()
except sqlalchemy.orm.exc.NoResultFound:
pass
return cls(text, language)
except:
import traceback
traceback.print_exc()
class Bookmark(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
origin_id = db.Column(db.Integer, db.ForeignKey('user_words.id'))
origin = db.relationship("UserWord",
primaryjoin=origin_id == UserWord.id,
backref="translations")
translations_list = relationship("UserWord",
secondary="bookmark_translation_mapping")
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship("User", backref="bookmarks")
text_id = db.Column(db.Integer, db.ForeignKey('text.id'))
text = db.relationship("Text", backref="bookmarks")
time = db.Column(db.DateTime)
exercise_log = relationship("Exercise",
secondary="bookmark_exercise_mapping")
def __init__(self, origin, translation, user, text, time):
self.origin = origin
self.translations_list.append(translation)
self.user = user
self.time = time
self.text = text
def add_new_exercise(self, exercise):
self.exercise_log.append(exercise)
def translation(self):
return self.translations_list[0]
def translations_rendered_as_text(self):
return ", ".join(self.translation_words_list())
def translation_words_list(self):
translation_words = []
for translation in self.translations_list:
translation_words.append(translation.word)
return translation_words
def add_new_translation(self, translation):
self.translations_list.append(translation)
def remove_translation(self, translation):
if translation in self.translations_list:
self.translations_list.remove(translation)
def add_exercise_outcome(self, exercise_source, exercise_outcome,
exercise_solving_speed):
new_source = ExerciseSource.query.filter_by(
source=exercise_source).first()
new_outcome = ExerciseOutcome.query.filter_by(
outcome=exercise_outcome).first()
exercise = Exercise(new_outcome, new_source, exercise_solving_speed,
datetime.datetime.now())
self.add_new_exercise(exercise)
db.session.add(exercise)
@classmethod
def find_all_filtered_by_user(cls):
return cls.query.filter_by(user=flask.g.user).all()
@classmethod
def find(cls, b_id):
return cls.query.filter_by(id=b_id).first()
@classmethod
def is_sorted_exercise_log_after_date_outcome(cls, outcome, bookmark):
sorted_exercise_log_after_date = sorted(bookmark.exercise_log,
key=lambda x: x.time,
reverse=True)
if sorted_exercise_log_after_date:
if sorted_exercise_log_after_date[0].outcome.outcome == outcome:
return True
return False
class User(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
name = db.Column(db.String(255))
password = db.Column(db.LargeBinary(255))
password_salt = db.Column(db.LargeBinary(255))
learned_language_id = db.Column(db.String(2), db.ForeignKey("language.id"))
learned_language = sqlalchemy.orm.relationship(
"Language", foreign_keys=[learned_language_id])
starred_words = relationship("UserWord",
secondary="starred_words_association")
native_language_id = db.Column(db.String(2), db.ForeignKey("language.id"))
native_language = sqlalchemy.orm.relationship(
"Language", foreign_keys=[native_language_id])
def __init__(self,
email,
username,
password,
learned_language=None,
native_language=None):
self.email = email
self.name = username
self.update_password(password)
self.learned_language = learned_language or Language.default_learned()
self.native_language = native_language or Language.default_native_language(
)
def __repr__(self):
return '<User %r>' % (self.email)
def has_starred(self, word):
return word in self.starred_words
def star(self, word):
self.starred_words.append(word)
print word.word + " is now starred for user " + self.name
# TODO: Does this work without a commit here? To double check.
def set_learned_language(self, code):
self.learned_language = Language.find(code)
def set_native_language(self, code):
self.native_language = Language.find(code)
@classmethod
def find(cls, email):
return User.query.filter(User.email == email).one()
@classmethod
def find_by_id(cls, id):
return User.query.filter(User.id == id).one()
@sqlalchemy.orm.validates("email")
def validate_email(self, col, email):
if "@" not in email:
raise ValueError("Invalid email address")
return email
@sqlalchemy.orm.validates("password")
def validate_password(self, col, password):
if password is None or len(password) == 0:
raise ValueError("Invalid password")
return password
@sqlalchemy.orm.validates("name")
def validate_name(self, col, name):
if name is None or len(name) == 0:
raise ValueError("Invalid username")
return name
def update_password(self, password):
self.password_salt = "".join(
chr(random.randint(0, 255)) for i in range(32))
self.password = util.password_hash(password, self.password_salt)
@classmethod
def authorize(cls, email, password):
try:
user = cls.query.filter(cls.email == email).one()
if user.password == util.password_hash(password,
user.password_salt):
return user
except sqlalchemy.orm.exc.NoResultFound:
return None
def bookmarks_chronologically(self):
return Bookmark.query.filter_by(user_id=self.id).order_by(
Bookmark.time.desc()).all()
def user_words(self):
return map((lambda x: x.origin.word), self.all_bookmarks())
def all_bookmarks(self):
return Bookmark.query.filter_by(user_id=self.id).order_by(
Bookmark.time.desc()).all()
def bookmark_count(self):
return len(self.all_bookmarks())
def word_count(self):
return len(self.user_words())
def bookmarks_by_date(self):
def extract_day_from_date(bookmark):
return (bookmark,
bookmark.time.replace(bookmark.time.year,
bookmark.time.month,
bookmark.time.day, 0, 0, 0, 0))
bookmarks = self.all_bookmarks()
bookmarks_by_date = dict()
for elem in map(extract_day_from_date, bookmarks):
bookmarks_by_date.setdefault(elem[1], []).append(elem[0])
sorted_dates = bookmarks_by_date.keys()
sorted_dates.sort(reverse=True)
return bookmarks_by_date, sorted_dates
def unique_urls(self):
urls = set()
for b in self.all_bookmarks():
urls.add(b.text.url)
return urls
def recommended_urls(self):
urls_to_words = {}
for bookmark in self.all_bookmarks():
if bookmark.text.url.url != "undefined":
urls_to_words.setdefault(bookmark.text.url, 0)
urls_to_words[
bookmark.text.url] += bookmark.origin.importance_level()
return sorted(urls_to_words, key=urls_to_words.get, reverse=True)
def get_known_bookmarks(self):
bookmarks = Bookmark.find_all_filtered_by_user()
i_know_bookmarks = []
for bookmark in bookmarks:
if Bookmark.is_sorted_exercise_log_after_date_outcome(
ExerciseOutcome.IKNOW, bookmark):
i_know_bookmark_dict = {}
i_know_bookmark_dict['id'] = bookmark.id
i_know_bookmark_dict['origin'] = bookmark.origin.word
i_know_bookmark_dict['text'] = bookmark.text.content
i_know_bookmark_dict['time'] = bookmark.time.strftime(
'%m/%d/%Y')
i_know_bookmarks.append(i_know_bookmark_dict.copy())
return i_know_bookmarks
def get_known_bookmarks_count(self):
return len(self.get_known_bookmarks())
def get_estimated_vocabulary(self, lang):
bookmarks = Bookmark.find_all_filtered_by_user()
filtered_words_known_from_user_dict_list = []
marked_words_of_user_in_text = []
words_of_all_bookmarks_content = []
filtered_words_known_from_user = []
for bookmark in bookmarks:
bookmark_content_words = re.sub("[^\w]", " ",
bookmark.text.content).split()
words_of_all_bookmarks_content.extend(bookmark_content_words)
marked_words_of_user_in_text.append(bookmark.origin.word)
words_known_from_user = [
word for word in words_of_all_bookmarks_content
if word not in marked_words_of_user_in_text
]
for word_known in words_known_from_user:
if WordRank.exists(word_known.lower(), lang):
filtered_words_known_from_user.append(word_known)
zeeguu.db.session.commit()
filtered_words_known_from_user = list(
set(filtered_words_known_from_user))
for word in filtered_words_known_from_user:
filtered_word_known_from_user_dict = {}
filtered_word_known_from_user_dict['word'] = word
filtered_words_known_from_user_dict_list.append(
filtered_word_known_from_user_dict.copy())
return filtered_words_known_from_user_dict_list
def get_estimated_vocabulary_for_learned_language(self):
return self.get_estimated_vocabulary(self.learned_language)
def get_estimated_vocabulary_count(self):
return len(self.get_estimated_vocabulary_for_learned_language())
class KnownWordProbability(db.Model):
__table_args__ = {'mysql_collate': 'utf8_bin'}
__tablename__ = 'known_word_probability'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=False)
user = db.relationship("User")
user_word_id = db.Column(db.Integer,
db.ForeignKey('user_word.id'),
nullable=True)
user_word = db.relationship("UserWord")
ranked_word_id = db.Column(db.Integer,
db.ForeignKey("ranked_word.id"),
nullable=True)
ranked_word = db.relationship("RankedWord")
probability = db.Column(db.DECIMAL(10, 9), nullable=False)
db.CheckConstraint('probability>=0', 'probability<=1')
def __init__(self, user, user_word, ranked_word, probability):
self.user = user
self.user_word = user_word
self.ranked_word = ranked_word
self.probability = probability
def word_has_just_beek_bookmarked(self):
self.probability /= 2
@classmethod
def calculateKnownWordProb(cls, exerciseProb, encounterProb):
return 0.8 * float(exerciseProb) + 0.2 * float(encounterProb)
@classmethod
def find(cls, user, user_word, ranked_word, probability=None):
try:
return cls.query.filter_by(user=user,
user_word=user_word,
ranked_word=ranked_word).one()
except sqlalchemy.orm.exc.NoResultFound:
return cls(user, user_word, ranked_word, probability)
@classmethod
def find_all_by_user(cls, user):
return cls.query.filter_by(user=user).all()
@classmethod
def find_all_by_user_cached(cls, user):
known_probabilities_cache = {}
known_probabilities = cls.find_all_by_user(user)
for known_probability in known_probabilities:
user_word = known_probability.user_word
# TODO: Why are there many KnownWordProbabilities with no user word in the database?
if user_word is not None:
known_probabilities_cache[
user_word.word] = known_probability.probability
return known_probabilities_cache
@classmethod
def find_all_by_user_with_rank(cls, user):
known_probs = cls.query.filter_by(user=user).all()
for p in known_probs:
if p.ranked_word is None:
known_probs.remove(p)
return known_probs
@classmethod
def exists(cls, user, user_word, ranked_word):
try:
cls.query.filter_by(user=user,
user_word=user_word,
ranked_word=ranked_word).one()
return True
except sqlalchemy.orm.exc.NoResultFound:
return False
@classmethod
def get_probably_known_words(cls, user):
return cls.query.filter(cls.user == user).filter(
cls.probability >= 0.9).all()
