class ConceptList(db.Model):
""" Represents a list of concepts """
__tablename__ = 'concept_lists'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode())
isWords = db.Column(db.Boolean)
concepts = db.relationship("Concept", secondary=concept_list_concepts)
def getConceptPairs(self, conceptManager):
""" Return the concept pairs """
return conceptManager.getConceptPairs(
[concept.id for concept in self.concepts])
@hybrid_method
def averageRatingFor(self, language, conceptFormCache, masteryCache):
""" Return the rating for the given user """
ratings = []
for concept in self.concepts:
form = conceptFormCache.get(conceptId=concept.id,
languageId=language.id)
ratings.append(masteryCache[form.id].rating)
return round(sum(ratings, 0.0) / len(ratings), 1)
@averageRatingFor.expression
def averageRatingFor(self, user, language):
""" Return the rating for the given user """
return func.avg(
self.entry_model.ratingFor(user)).over(partition_by=self.id)
class Language(db.Model):
""" Represents a language """
__tablename__ = 'languages'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
def __repr__(self):
""" Return the String Representation of the Language Context """
return repr(self.name)
class LanguageEnrollment(db.Model):
""" Represents a user's enrollment in a language """
__tablename__ = 'language_enrollments'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
language_id = db.Column(db.Integer,
db.ForeignKey('languages.id', ondelete="CASCADE"))
language = db.relationship("Language")
user_id = db.Column(db.Integer,
db.ForeignKey('users.id', ondelete="CASCADE"))
user = db.relationship("User", backref="languageEnrollments")
default = db.Column(db.Boolean, default=False)
class StalenessPeriod(db.Model):
""" Represents a staleness period """
__tablename__ = 'staleness_periods'
id = db.Column(db.Integer, primary_key=True)
days = db.Column(db.Integer)
first = db.Column(db.Boolean, default=False)
next_id = db.Column(db.Integer, db.ForeignKey('staleness_periods.id'))
next = db.relationship("StalenessPeriod", remote_side=[id])
@classmethod
def getFirstStalenessPeriod(cls):
""" Return the first staleness period """
return cls.query.filter_by(first=True).first()
class AmbiguityGroup(db.Model):
""" Represents a group of words or symbols that are ambiguous with each other """
__tablename__ = 'ambiguity_groups'
id = db.Column(db.Integer, primary_key=True)
language_id = db.Column(db.Integer,
db.ForeignKey(Language.id),
nullable=False)
language = db.relationship(Language, backref="ambiguity_groups")
def __repr__(self):
""" Return the String Representation of the Ambiguity Group """
return "<AmbiguityGroup(id={})>".format(self.id)
class Word(db.Model):
""" Represents a word from a particular language """
__tablename__ = 'words'
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.UnicodeText())
concept_id = db.Column(db.Integer, db.ForeignKey('concepts.id', ondelete="CASCADE"))
concept = db.relationship("Concept")
language_id = db.Column(db.Integer, db.ForeignKey('languages.id', ondelete="CASCADE"))
language = db.relationship("Language")
@hybrid_method
def ratingFor(self, masteryCache):
""" Return the rating for the given user """
return masteryCache[self.id].rating
@ratingFor.expression
def ratingFor(self, user):
""" Return the expression to use when querying for a word's rating """
return Mastery.rating
@property
def needsClarification(self):
""" Return if this Symbol needs Clarification """
return False
def ambiguousWith(self, other):
""" Return if this Symbol is ambiguous with the other Symbol """
return self.text == other.text
def __unicode__(self):
""" Return the string representation of the Word """
return unicode(self.text)
def __repr__(self):
""" Return the string representation of the Word """
return repr(self.text)
class Symbol(db.Model):
""" Represents a symbol used in a language """
__tablename__ = 'symbols'
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.UnicodeText())
concept_id = db.Column(db.Integer,
db.ForeignKey('concepts.id', ondelete="CASCADE"))
language_id = db.Column(db.Integer,
db.ForeignKey('languages.id', ondelete="CASCADE"))
ambiguity_group_id = db.Column(
db.Integer, db.ForeignKey(AmbiguityGroup.id, ondelete="SET NULL"))
clarification = db.Column(db.UnicodeText())
concept = db.relationship("Concept")
language = db.relationship("Language")
ambiguity_group = db.relationship(AmbiguityGroup, backref="symbols")
@hybrid_method
def ratingFor(self, masteryCache):
""" Return the rating for the given user """
return masteryCache[self.id].rating
@ratingFor.expression
def ratingFor(self, user):
""" Return the expression to use when querying for a word's rating """
return Mastery.rating
@property
def needsClarification(self):
""" Return if this Symbol needs Clarification """
return self.ambiguity_group_id is not None
def ambiguousWith(self, other):
""" Return if this Symbol is ambiguous with the other Symbol """
return self.text == other.text or self.matchingAmbiguityGroup(other)
def matchingAmbiguityGroup(self, other):
""" Return whether this Symbol matches the other Symbol's Ambiguity Group """
if self.ambiguity_group_id is not None:
return self.ambiguity_group_id == other.ambiguity_group_id
else:
return False
def __unicode__(self):
""" Return the string representation of the Word """
return unicode(self.text)
def __repr__(self):
""" Return the String representation of the Symbol """
return "<Symbol({0}, {1})>".format(self.id, self.language.name)
class User(db.Model):
""" Represents a user """
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.Text(), nullable=False, unique=True, index=True)
password = db.Column(db.String(128), nullable=False)
is_admin = db.Column(db.Boolean, default=False)
givenName = db.Column(db.UnicodeText())
lastName = db.Column(db.UnicodeText())
native_language_id = db.Column(db.Integer, db.ForeignKey('languages.id'))
nativeLanguage = db.relationship("Language")
learnedSymbols = db.relationship("Symbol", secondary=learned_symbols, lazy='dynamic')
learnedWords = db.relationship("Word", secondary=learned_words, lazy='dynamic')
def getLearnedFor(self, formInfo, language):
""" Return the learned forms for the given Form Info """
helper = self.helperFor(formInfo)
return helper.formsFor(language)
def tryToLearn(self, form, formInfo, learnedCache):
""" Learn the form unless it has already been learned """
helper = self.helperFor(formInfo)
helper.tryToLearn(form, learnedCache)
def save(self):
""" Save the Underlying User Data Object """
db.session.add(self)
db.session.commit()
def helperFor(self, formInfo):
""" Return the Learn Helper for the given Form Info """
return self.learnedSymbolsHelper if formInfo is SymbolInfo else self.learnedWordsHelper
@lazy_property
def learnedSymbolsHelper(self):
""" Helper to manage Learned Symbols """
return LearnHelper(self, SymbolInfo)
@lazy_property
def learnedWordsHelper(self):
""" Helper to manage Learned Words """
return LearnHelper(self, WordInfo)
class Mastery(db.Model):
""" Represents the mastery of some skill """
__tablename__ = 'masteries'
MAX_RATING = 5
CORRECT_CHANGE = 1
WRONG_CHANGE = -1
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship("User")
word_id = db.Column(db.Integer,
db.ForeignKey('words.id', ondelete="CASCADE"))
word = db.relationship("Word")
symbol_id = db.Column(db.Integer,
db.ForeignKey('symbols.id', ondelete="CASCADE"))
symbol = db.relationship("Symbol")
answerRating = db.Column(db.Integer,
server_default=text('0'),
nullable=False)
lastCorrectAnswer = db.Column(db.DateTime)
staleness_period_id = db.Column(db.Integer,
db.ForeignKey('staleness_periods.id'))
stalenessPeriod = db.relationship("StalenessPeriod", lazy='subquery')
def __init__(self, *args, **kwargs):
""" Initialize the mastery """
if 'user' in kwargs and hasattr(kwargs['user'], 'user'):
kwargs['user'] = kwargs['user'].user
if 'stalenessPeriod' not in kwargs:
kwargs[
'stalenessPeriod'] = StalenessPeriod.getFirstStalenessPeriod()
db.Model.__init__(self, *args, **kwargs)
def addAnswer(self, correct):
""" Add an answer to this mastery """
self.updateStalenessPeriod(correct)
self.updateAnswerDate(correct)
self.updateRating(correct)
db.session.add(self)
db.session.commit()
def updateRating(self, correct):
""" Update the answer rating """
ratingChange = self.CORRECT_CHANGE if correct else self.WRONG_CHANGE
newRating = self.answerRating + ratingChange
newRating = min(newRating, self.MAX_RATING)
newRating = max(newRating, 0)
self.answerRating = newRating
def updateAnswerDate(self, correct):
""" Update the answer date """
if correct:
self.lastCorrectAnswer = datetime.now()
def updateStalenessPeriod(self, correct):
""" Update the staleness period based on whether the answer is correct """
if correct and self.answerRating == self.MAX_RATING and self.isStale:
self.moveToNextStalenessPeriod()
elif not correct:
self.revertToFirstStalenessPeriod()
def moveToNextStalenessPeriod(self):
""" Move the mastery to the next staleness period """
if self.stalenessPeriod.next:
self.stalenessPeriod = self.stalenessPeriod.next
def revertToFirstStalenessPeriod(self):
""" Revert the staleness period to the first staleness period """
self.stalenessPeriod = StalenessPeriod.getFirstStalenessPeriod()
@property
def form(self):
""" Return the Concept Form associated with the Mastery """
return self.word if self.word_id is not None else self.symbol
@hybrid_property
def rating(self):
""" Return the rating of the mastery """
return max(0, self.answerRating - self.stalenessRating)
@rating.expression
def rating(self):
""" Return the Queryable rating of the mastery """
return func.greatest(0, self.answerRating - self.stalenessRating)
@hybrid_property
def stalenessRating(self):
""" Return the staleness rating of the mastery """
mostRecentCorrectAnswer = self.lastCorrectAnswer
if mostRecentCorrectAnswer is None:
return 0
else:
return int((datetime.now() - mostRecentCorrectAnswer).days /
self.stalenessPeriod.days)
@stalenessRating.expression
def stalenessRating(self):
""" Return the Queryable staleness rating of the mastery """
return func.coalesce(
cast(
func.floor(
func.extract('epoch',
func.now() - self.lastCorrectAnswer) / 86400),
db.Integer) / StalenessPeriod.days, 0)
@hybrid_property
def isStale(self):
""" Return if the mastery has outlived the staleness period """
return self.stalenessRating > 0
from ..Concept import Concept
from ..filtered_query import FilteredQuery
from ..Mastery import Mastery, StalenessPeriod
from kao_flask.ext.sqlalchemy import db
from sqlalchemy import func
from sqlalchemy.ext.hybrid import hybrid_method
concept_list_concepts = db.Table(
'concept_list_concepts', db.Model.metadata,
db.Column('concept_list_id', db.Integer,
db.ForeignKey('concept_lists.id', ondelete="CASCADE")),
db.Column('concept_id', db.Integer,
db.ForeignKey('concepts.id', ondelete="CASCADE")))
class ConceptList(db.Model):
""" Represents a list of concepts """
__tablename__ = 'concept_lists'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode())
isWords = db.Column(db.Boolean)
concepts = db.relationship("Concept", secondary=concept_list_concepts)
def getConceptPairs(self, conceptManager):
""" Return the concept pairs """
return conceptManager.getConceptPairs(
[concept.id for concept in self.concepts])
@hybrid_method
class Concept(db.Model):
""" Represents a concept """
__tablename__ = 'concepts'
id = db.Column(db.Integer, primary_key=True)
from kao_flask.ext.sqlalchemy import db
learned_symbols = db.Table('learned_symbols', db.Model.metadata,
db.Column('user_id', db.Integer, db.ForeignKey('users.id', ondelete="CASCADE")),
db.Column('symbol_id', db.Integer, db.ForeignKey('symbols.id', ondelete="CASCADE")))
learned_words = db.Table('learned_words', db.Model.metadata,
db.Column('user_id', db.Integer, db.ForeignKey('users.id', ondelete="CASCADE")),
db.Column('word_id', db.Integer, db.ForeignKey('words.id', ondelete="CASCADE")))