GitHub/Anki
1
0
Fork 0
mirror of https://github.com/ankitects/anki.git synced 2025-09-19 06:22:22 -04:00
Code Issues Projects Releases Packages 1 Wiki Activity Actions

be consistent in review/rev, etc

Browse source
This commit is contained in:
Damien Elmes 2011-03-18 11:16:50 +09:00
parent 368bdf8d05
commit 308846aa93
1 changed files with 37 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
anki/sched.py
View file

@ -33,9 +33,9 @@ class Scheduler(object):
def reset(self): def reset(self):
self._resetConf() self._resetConf()
t = time.time() t = time.time()
self._resetLearn() self._resetLrn()
#print "lrn %0.2fms" % ((time.time() - t)*1000); t = time.time() #print "lrn %0.2fms" % ((time.time() - t)*1000); t = time.time()
self._resetReview() self._resetRev()
#print "rev %0.2fms" % ((time.time() - t)*1000); t = time.time() #print "rev %0.2fms" % ((time.time() - t)*1000); t = time.time()
self._resetNew() self._resetNew()
#print "new %0.2fms" % ((time.time() - t)*1000); t = time.time() #print "new %0.2fms" % ((time.time() - t)*1000); t = time.time()
@ -45,7 +45,7 @@ class Scheduler(object):
# put it in the learn queue # put it in the learn queue
card.queue = 1 card.queue = 1
if card.queue == 1: if card.queue == 1:
self._answerLearnCard(card, ease) self._answerLrnCard(card, ease)
elif card.queue == 2: elif card.queue == 2:
self._answerRevCard(card, ease) self._answerRevCard(card, ease)
else: else:
@ -55,7 +55,7 @@ class Scheduler(object):
def counts(self): def counts(self):
"Does not include fetched but unanswered." "Does not include fetched but unanswered."
return (self.newCount, self.learnCount, self.revCount) return (self.newCount, self.lrnCount, self.revCount)
def cardQueue(self, card): def cardQueue(self, card):
return card.queue return card.queue
@ -76,14 +76,14 @@ class Scheduler(object):
def _getCardId(self): def _getCardId(self):
"Return the next due card id, or None." "Return the next due card id, or None."
# learning card due? # learning card due?
id = self._getLearnCard() id = self._getLrnCard()
if id: if id:
return id return id
# new first, or time for one? # new first, or time for one?
if self._timeForNewCard(): if self._timeForNewCard():
return self._getNewCard() return self._getNewCard()
# card due for review? # card due for review?
id = self._getReviewCard() id = self._getRevCard()
if id: if id:
return id return id
# new cards left? # new cards left?
@ -91,7 +91,7 @@ class Scheduler(object):
if id: if id:
return id return id
# collapse or finish # collapse or finish
return self._getLearnCard(collapse=True) return self._getLrnCard(collapse=True)
# New cards # New cards
########################################################################## ##########################################################################
@ -156,37 +156,37 @@ queue = 0 %s order by due limit %d""" % (self._groupLimit('new'),
# Learning queue # Learning queue
########################################################################## ##########################################################################
def _resetLearnCount(self): def _resetLrnCount(self):
self.learnCount = self.db.scalar( self.lrnCount = self.db.scalar(
"select count() from cards where queue = 1 and due < ?", "select count() from cards where queue = 1 and due < ?",
intTime() + self.deck.qconf['collapseTime']) intTime() + self.deck.qconf['collapseTime'])
def _resetLearn(self): def _resetLrn(self):
self._resetLearnCount() self._resetLrnCount()
self.learnQueue = self.db.all(""" self.lrnQueue = self.db.all("""
select due, id from cards where select due, id from cards where
queue = 1 and due < :lim order by due queue = 1 and due < :lim order by due
limit %d""" % self.reportLimit, lim=self.dayCutoff) limit %d""" % self.reportLimit, lim=self.dayCutoff)
def _getLearnCard(self, collapse=False): def _getLrnCard(self, collapse=False):
if self.learnQueue: if self.lrnQueue:
cutoff = time.time() cutoff = time.time()
if collapse: if collapse:
cutoff -= self.deck.collapseTime cutoff -= self.deck.collapseTime
if self.learnQueue[0][0] < cutoff: if self.lrnQueue[0][0] < cutoff:
id = heappop(self.learnQueue)[1] id = heappop(self.lrnQueue)[1]
self.learnCount -= 1 self.lrnCount -= 1
return id return id
def _answerLearnCard(self, card, ease): def _answerLrnCard(self, card, ease):
# ease 1=no, 2=yes, 3=remove # ease 1=no, 2=yes, 3=remove
conf = self._learnConf(card) conf = self._lrnConf(card)
leaving = False leaving = False
if ease == 3: if ease == 3:
self._rescheduleAsReview(card, conf, True) self._rescheduleAsRev(card, conf, True)
leaving = True leaving = True
elif ease == 2 and card.grade+1 >= len(conf['delays']): elif ease == 2 and card.grade+1 >= len(conf['delays']):
self._rescheduleAsReview(card, conf, False) self._rescheduleAsRev(card, conf, False)
leaving = True leaving = True
else: else:
card.cycles += 1 card.cycles += 1
@ -196,22 +196,22 @@ limit %d""" % self.reportLimit, lim=self.dayCutoff)
card.grade = 0 card.grade = 0
card.due = time.time() + self._delayForGrade(conf, card.grade) card.due = time.time() + self._delayForGrade(conf, card.grade)
try: try:
self._logLearn(card, ease, conf, leaving) self._logLrn(card, ease, conf, leaving)
except: except:
time.sleep(0.01) time.sleep(0.01)
self._logLearn(card, ease, conf, leaving) self._logLrn(card, ease, conf, leaving)
def _delayForGrade(self, conf, grade): def _delayForGrade(self, conf, grade):
return conf['delays'][grade]*60 return conf['delays'][grade]*60
def _learnConf(self, card): def _lrnConf(self, card):
conf = self._cardConf(card) conf = self._cardConf(card)
if card.type == 2: if card.type == 2:
return conf['lapse'] return conf['lapse']
else: else:
return conf['new'] return conf['new']
def _rescheduleAsReview(self, card, conf, early): def _rescheduleAsRev(self, card, conf, early):
if card.type == 2: if card.type == 2:
# failed; put back entry due # failed; put back entry due
card.due = card.edue card.due = card.edue
@ -236,7 +236,7 @@ limit %d""" % self.reportLimit, lim=self.dayCutoff)
card.due = self.today+card.ivl card.due = self.today+card.ivl
card.factor = conf['initialFactor'] card.factor = conf['initialFactor']
def _logLearn(self, card, ease, conf, leaving): def _logLrn(self, card, ease, conf, leaving):
for i in range(2): for i in range(2):
try: try:
self.deck.db.execute( self.deck.db.execute(
@ -264,15 +264,15 @@ where queue = 1 and type = 2
# Reviews # Reviews
########################################################################## ##########################################################################
def _resetReviewCount(self): def _resetRevCount(self):
self.revCount = self.db.scalar(""" self.revCount = self.db.scalar("""
select count() from (select id from cards where select count() from (select id from cards where
queue = 2 %s and due <= :lim limit %d)""" % ( queue = 2 %s and due <= :lim limit %d)""" % (
self._groupLimit("rev"), self.reportLimit), self._groupLimit("rev"), self.reportLimit),
lim=self.today) lim=self.today)
def _resetReview(self): def _resetRev(self):
self._resetReviewCount() self._resetRevCount()
self.revQueue = self.db.list(""" self.revQueue = self.db.list("""
select id from cards where select id from cards where
queue = 2 %s and due <= :lim order by %s limit %d""" % ( queue = 2 %s and due <= :lim order by %s limit %d""" % (
@ -283,14 +283,14 @@ queue = 2 %s and due <= :lim order by %s limit %d""" % (
else: else:
self.revQueue.reverse() self.revQueue.reverse()
def _getReviewCard(self): def _getRevCard(self):
if self._haveRevCards(): if self._haveRevCards():
return self.revQueue.pop() return self.revQueue.pop()
def _haveRevCards(self): def _haveRevCards(self):
if self.revCount: if self.revCount:
if not self.revQueue: if not self.revQueue:
self._resetReview() self._resetRev()
return self.revQueue return self.revQueue
def _revOrder(self): def _revOrder(self):
@ -307,8 +307,8 @@ queue = 2 %s and due <= :lim order by %s limit %d""" % (
if ease == 1: if ease == 1:
self._rescheduleLapse(card) self._rescheduleLapse(card)
else: else:
self._rescheduleReview(card, ease) self._rescheduleRev(card, ease)
self._logReview(card, ease) self._logRev(card, ease)
def _rescheduleLapse(self, card): def _rescheduleLapse(self, card):
conf = self._cardConf(card)['lapse'] conf = self._cardConf(card)['lapse']
@ -321,14 +321,14 @@ queue = 2 %s and due <= :lim order by %s limit %d""" % (
# put back in the learn queue? # put back in the learn queue?
if conf['relearn']: if conf['relearn']:
card.queue = 1 card.queue = 1
self.learnCount += 1 self.lrnCount += 1
# leech? # leech?
self._checkLeech(card, conf) self._checkLeech(card, conf)
def _nextLapseIvl(self, card, conf): def _nextLapseIvl(self, card, conf):
return int(card.ivl*conf['mult']) + 1 return int(card.ivl*conf['mult']) + 1
def _rescheduleReview(self, card, ease): def _rescheduleRev(self, card, ease):
card.streak += 1 card.streak += 1
# update interval # update interval
card.lastIvl = card.ivl card.lastIvl = card.ivl
@ -337,7 +337,7 @@ queue = 2 %s and due <= :lim order by %s limit %d""" % (
card.factor = max(1300, card.factor+[-150, 0, 150][ease-2]) card.factor = max(1300, card.factor+[-150, 0, 150][ease-2])
card.due = self.today + card.ivl card.due = self.today + card.ivl
def _logReview(self, card, ease): def _logRev(self, card, ease):
for i in range(2): for i in range(2):
try: try:
self.deck.db.execute( self.deck.db.execute(
@ -547,7 +547,7 @@ queue = 2 %s and due <= :lim order by %s limit %d""" % (
# this isn't easily extracted from the learn code # this isn't easily extracted from the learn code
def _nextLrnIvl(self, card, ease): def _nextLrnIvl(self, card, ease):
conf = self._learnConf(card) conf = self._lrnConf(card)
if ease == 1: if ease == 1:
# grade 0 # grade 0
return self._delayForGrade(conf, 0) return self._delayForGrade(conf, 0)