from queue import Queue
import random

CARDS_PER_CM = 5

BOX = [
    Queue(1  * CARDS_PER_CM),
    Queue(2  * CARDS_PER_CM),
    Queue(5  * CARDS_PER_CM),
    Queue(8  * CARDS_PER_CM),
    Queue(14 * CARDS_PER_CM),
]

def add(card, i):
    BOX[i].put(card)
    if BOX[i].full():
        study()

def review(card):
    return random.choice([True, True, True, False])

def study():
    for index, partition in enumerate(BOX):
        if partition.full():
            # Time to review the cards
            print(f"Time to study partition {index + 1}!")

            cards_to_review = []
            while not partition.empty():
                cards_to_review.append(partition.get())

            for card in cards_to_review:
                answer = review(card)
                new_index = None
                if answer and index + 1 < len(BOX):
                    # Promote
                    new_index = index + 1
                elif not answer and index - 1 > 0:
                    # Demote
                    new_index = 0
                else:
                    # Replace in the same partition
                    new_index = index
                add(card, new_index)

if __name__ == "__main__":

    # Populate the box
    for i in range(140):
        add("New Card", 0)

    # Study
    study()

from queue import Queue
import random
from datetime import datetime, timedelta

A = 0
B = 1
C = 2
SYSTEM = [
    Queue(), # Box A: every day
    Queue(), # Box B: every 2-3 days (ex: Tuesday & Friday)
    Queue(), # Box C: every week (ex: Sunday)
]


def add(card, i):
    """Add a new card in the Leitner system."""
    SYSTEM[i].put(card)

def review(card):
    """Answer a single card."""
    return random.choice([True, True, True, False])

def study_box(number):
    """Review all cards in a box."""
    cards_to_review = []
    while not SYSTEM[number].empty():
        cards_to_review.append(SYSTEM[number].get())

    for card in cards_to_review:
        answer = review(card)
        new_number = None
        if answer and number < C:
            # Promote
            new_number = number + 1
        elif not answer and number > A:
            # Demote
            new_number = number - 1
        else:
            # Replace in the same box
            new_number = number
        add(card, new_number)

def study(day):
    """Study the box according the week day."""
    weekday = day.weekday()
    if weekday == 0: # Monday
        study_box(A)
    elif weekday == 1: # Tuesday
        study_box(A)
        study_box(B)
    elif weekday == 2: # Wednesday
        study_box(A)
    elif weekday == 3: # Thursday
        study_box(A)
    elif weekday == 4: # Friday
        study_box(A)
        study_box(B)
    elif weekday == 5: # Saturday
        study_box(A)
    elif weekday == 6: # Sunday
        study_box(A)
        study_box(C)

if __name__ == "__main__":

    # Populate the box
    for i in range(140):
        add("New Card", 0)

    # Study (over 10 days)
    for i in range(10):
        day = datetime.today() - timedelta(days=10 - i)
        study(day)

import random
from datetime import date, timedelta
from queue import Queue

# The table of repetition intervals determines the number of days between
# two successive reviews.
# SM-0 applies the factor 1.7 between two successive values.
# Ex: 4, 7, 12, 20, ...
TABLE_REPETITION_INTERVALS = [4] # First review after 4 days
for i in range(1, 15): # 15 repetitions max
    prev = TABLE_REPETITION_INTERVALS[i - 1]
    next = int(prev * 1.7)
    TABLE_REPETITION_INTERVALS.append(next)

# The book containing the pages to review
DATABOOK = []
# The book containing the page numbers to review day after day
# NB: We use a sparse dictionary where only dates
# with one or more pages to review are present
SCHEDULE_BOOK = {} # <date, [page numbers]>

# Fake the user in answering the question
def review_question(question, repetitions):
    """
    Randomly answer a question.
    The chance of answering correctly increases with the number of repetitions.
    """
    return random.choice([True] * repetitions * 4 + [False])

# A single page in the data book.
class Page:

    def __init__(self, questions, answers):
        # "Question field" column
        self.questions = questions
        # "Answer field" column
        self.answers = answers
        # "Repetition scores" column
        # => Determined during the review session
        # "Repetitions" column
        self.repetitions = []

    def review(self):
        remaining_questions = Queue(self.questions)

        # Review until there is no more cards wrongly answered
        iteration = 1
        # Memorize the number of wrong answers during the first iteration
        U = 0
        while not remaining_questions.empty():

            questions_to_review = []
            while not remaining_questions.empty():
                questions_to_review.append(remaining_questions.get())

            for question in questions_to_review:
                if not review_question(question, iteration): (1)
                    # Review again
                    remaining_questions.append(question)
                    if iteration == 1:
                        U += 1
            iteration += 1

        self.repetitions.append({
            "No": len(self.repetitions) + 1,
            "Dat": str(date.today()),
            "U": U,
        })


if __name__ == "__main__":
    # Add a new page for illustration purposes
    DATABOOK.append(Page(
        questions=["Question 1", "Question 2", "Question 3"],
        answers=["Answer 1", "Answer 2", "Answer 3"],
    ))
    page_number = len(DATABOOK) - 1

    # Mark the page to review according the table of repetition intervals
    now = date.today()
    for interval in TABLE_REPETITION_INTERVALS:
        review_date = str(now + timedelta(days=interval))
        if review_date not in SCHEDULE_BOOK:
            SCHEDULE_BOOK[review_date] = []
        print(f"Page {page_number} to review on {review_date}")
        SCHEDULE_BOOK[review_date] = [page_number]

    # Review sessions during one year
    for i in range(365):
        day = str(now + timedelta(days=i))
        if not day in SCHEDULE_BOOK:
            # Nothing to review today
            continue
        # Review each planned pages
        for page in SCHEDULE_BOOK[day]:
            print(f"Reviewing page {page} on {day}")
            DATABOOK[page].review()

import random
from datetime import date, timedelta
from queue import Queue

def grade(question, repetitions):
    # Increase the chance of success with the increased number of repetitions
    choices = [0] * 1 * repetitions + [1] * 2 * repetitions + \
              [2] * 3 * repetitions + [3] * 4 * repetitions + \
              [4] * 5 * repetitions + [5] * 6 * repetitions
    return random.choice(choices)

# Settings
I1 = 1
I2 = 6
MIN_EF = 1.3 (1)

class Item:

    def __init__(self, question, answer):
        self.question = question
        self.answer = answer
        self.EF = 2.5 (2)
        self.I = I1
        self.next_review = date.today() + timedelta(days=self.I)
        self.repetitions = 0

    def review(self, day, q):
        self.EF = max(self.EF+(0.1-(5-q)*(0.08+(5-q)*0.02)), MIN_EF) (3)
        if q < 3:
            self.I = I1
        elif self.I == I1:
            self.I = I2
        else:
            self.I = round(self.I * self.EF)
        self.next_review = day + timedelta(days=self.I)
        self.repetitions += 1
        return q < 4

if __name__ == "__main__":
    # Populate items
    items = []
    for i in range(1, 100):
        items.append(Item(f"Q{i}", f"A{i}"))

    # Review one year
    # for i in range(365):
    for i in range(365):
        day = date.today() + timedelta(days=i)

        items_to_review = Queue()
        for item in items:
            if item.next_review == day:
                items_to_review.put(item)

        while not items_to_review.empty():
            item = items_to_review.get()
            q = grade(item.question, item.repetitions + 1)
            if not item.review(day, q): (4)
                items_to_review.put(item)

# Whether new cards should be mixed with reviews, or shown first or last
NEW_CARDS_DISTRIBUTE = 0
NEW_CARDS_LAST = 1
NEW_CARDS_FIRST = 2

# The initial factor when a card gets promoted
STARTING_FACTOR = 2500

# Default collection configuration
colConf = {
    'newSpread': NEW_CARDS_DISTRIBUTE,
    'collapseTime': 1200, (1)
}

# Default deck configuration
deckConf = {
    'new': { (2)
        'delays': [1, 10],
        'ints': [1, 4],
        'initialFactor': STARTING_FACTOR,
        'perDay': 20,
    },
    'rev': { (2)
        'perDay': 200,
        'ease4': 1.3,
        'maxIvl': 36500,
        'hardFactor': 1.2,
    },
    'lapse': { (3)
        'delays': [10],
        'mult': 0,
        'minInt': 1,
        'leechFails': 8,
    },
}

class Collection:

    def __init__(self, id=None):
        d = datetime.datetime.today()
        d = datetime.datetime(d.year, d.month, d.day)
        # Timestamp of the creation date in seconds.
        self.crt = int(time.mktime(d.timetuple()))
        # In-memory list of cards
        self.cards = []
        self.sched = Scheduler(self) (1)

    def addNote(self, note):
        self.cards.append(Card(note))

class Note:

    def __init__(self):
        self.id = intId() (2)
        self.tags = []

    def addTag(self, tag):
        if not tag in self.tags:
            self.tags.append(tag)

class Card:

    def __init__(self, note, id=None):
        self.id = intId() (2)
        self.note = note
        # Timestamp of the creation date in second.
        self.crt = intTime()
        # 0=new, 1=learning, 2=review, 3=relearning
        self.type = 0
        # Queue type:
        #   -1=suspend => leeches (as manual suspension is not supported)
        #    0=new     => new (never shown)
        #    1=lrn     => learning/relearning
        #    2=rev     => review (as for type)
        self.queue = 0
        # The interval. Negative = seconds, positive = days
        self.ivl = 0
        # The ease factor in permille.
        # Ex: 2500 = the interval will be multiplied by 2.5
        # the next time you press "Good".
        self.factor = 0
        # The number of reviews.
        self.reps = 0
        # The number of times the card went from a "was answered correctly"
        # to "was answered incorrectly" state.
        self.lapses = 0
        # Of the form a*1000+b, with:
        #   a => the number of reps left today
        #   b => the number of reps left till graduation
        # Ex: '2004' = 2 reps left today and 4 reps till graduation
        self.left = 0
        # Due is used differently for different card types:
        # - new => note id or random int
        # - lrn => integer timestamp in second
        # - rev => integer day, relative to the collection's creation time
        self.due = self.id

import time

def intId():
    """Returns a unique integer identifier."""
    t = intTime(1000)
    # Make sure the next call to the function returns a different value
    while intTime(1000) == t:
        time.sleep(1)
    return t

def intTime(scale=1):
    "The time in integer seconds. Pass scale=1000 to get milliseconds."
    return int(time.time()*scale)

class Scheduler:

    def __init__(self, col):
        # The collection used to retrieve the cards
        self.col = col
        # An upper limit for new and review cards
        self.queueLimit = 50
        # An upper limit for learning cards
        self.reportLimit = 1000
        # The number of already reviewed cards today
        self.reps = 0
        # The number of days since the collection creation
        self.today = self._daysSinceCreation() (1)
        # The timestamp of the end of day
        self.dayCutoff = self._dayCutoff() (2)
        # The timestamp in seconds to determine the learn ahead limit
        self._lrnCutoff = 0 (3)
        self.reset()

class Scheduler:

    def reset(self):
        self._resetLrn()
        self._resetRev()
        self._resetNew()

    # New cards
    #################################################################

    def _resetNew(self):
        self._newQueue = [] (1)
        self._updateNewCardRatio() (2)

    def _fillNew(self):
        if self._newQueue:
            return True
        lim = min(self.queueLimit, deckConf["new"]["perDay"])
        self._newQueue = list(filter(lambda card: card.queue == 0,
            self.col.cards)) (3)
        self._newQueue.sort(key=lambda card: card.due)
        self._newQueue = self._newQueue[:lim]
        if self._newQueue:
            return True

    def _updateNewCardRatio(self):
        if colConf['newSpread'] == NEW_CARDS_DISTRIBUTE:
            if self._newQueue:
                newCount = len(self._newQueue)
                revCount = len(self._revQueue)
                self.newCardModulus = (
                    (newCount + revCount) // newCount)
                # if there are cards to review, ensure modulo >= 2
                if revCount:
                    self.newCardModulus = max(2, self.newCardModulus)
                return
        self.newCardModulus = 0 # = Do not distribute new cards


    # Learning cards
    #################################################################

    def _resetLrn(self):
        self._updateLrnCutoff(force=True)
        self._lrnQueue = [] (1)

    def _fillLrn(self):
        if self._lrnQueue:
            return True
        cutoff = intTime() + colConf['collapseTime']
        self._lrnQueue = list(filter(lambda card: card.queue == 1 and
            card.due < cutoff, self.col.cards)) (4)
        self._lrnQueue.sort(key=lambda card: card.id)
        self._lrnQueue = self._lrnQueue[:self.reportLimit]
        return self._lrnQueue

    # Review cards
    #################################################################

    def _resetRev(self):
        self._revQueue = [] (1)

    def _fillRev(self):
        if self._revQueue:
            return True
        lim = min(self.queueLimit, self.col.deckConf["rev"]["perDay"])
        self._revQueue = list(filter(lambda card: card.queue == 2 and
            card.due <= self.today, self.col.cards)) (5)
        self._revQueue.sort(key=lambda card: card.due)
        self._revQueue = self._revQueue[:lim]

        if self._revQueue:
            r = random.Random()
            r.seed(self.today)
            r.shuffle(self._revQueue)
            return True

class Scheduler:

    def getCard(self):
        card = self._getCard()
        if card:
            self.reps += 1
            return card

class Scheduler:

    def _getCard(self): (1)
        "Return the next due card or None."

        # learning card due?
        c = self._getLrnCard()
        if c:
            return c

        # new first, or time for one?
        if self._timeForNewCard():
            c = self._getNewCard()
            if c:
                return c

        # card due for review?
        c = self._getRevCard()
        if c:
            return c

        # new cards left?
        c = self._getNewCard()
        if c:
            return c

        # collapse or finish
        return self._getLrnCard(collapse=True)


    # New cards
    ##########################################################################

    def _getNewCard(self):
        if self._fillNew(): (2)
            return self._newQueue.pop()

    def _timeForNewCard(self):
        "True if it's time to display a new card when distributing."
        if not self._newQueue:
            return False
        if colConf['newSpread'] == NEW_CARDS_LAST:
            return False
        elif colConf['newSpread'] == NEW_CARDS_FIRST:
            return True
        elif self.newCardModulus:
            return self.reps and self.reps % self.newCardModulus == 0


    # Learning queues
    ##########################################################################

    def _getLrnCard(self, collapse=False):
        if self._fillLrn(): (2)
            return self._lrnQueue.pop()

    # Reviews
    ##########################################################################

    def _getRevCard(self):
        if self._fillRev(): (2)
            return self._revQueue.pop()

  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  
class Scheduler:

    def reset(self):
        self._updateCutoff() (1)
        self._resetLrn()
        self._resetRev()
        self._resetNew()

    def _updateCutoff(self):
        # days since col created
        self.today = self._daysSinceCreation()
        # end of day cutoff
        self.dayCutoff = self._dayCutoff()
        return stamp

    def _checkDay(self):
        # check if the day has rolled over
        if time.time() > self.dayCutoff:
            self.reset()

    def getCard(self):
        self._checkDay() (2)
        card = self._getCard()
        if card:
            self.reps += 1
            return card

class Scheduler:

    def answerCard(self, card, ease):
        assert 1 <= ease <= 4
        assert 0 <= card.queue <= 4

        card.reps += 1

        if card.queue == 0:
            self._answerNewCard(card, ease)
        elif card.queue in [1, 3]:
            self._answerLrnCard(card, ease)
        elif card.queue == 2:
            self._answerRevCard(card, ease)
        else:
            assert 0

class Scheduler:

    def _answerNewCard(self, card, ease):
        # came from the new queue, move to learning
        card.queue = 1 (1)
        card.type = 1 (2)
        # init reps to graduation
        card.left = self._startingLeft(card) (3)

    def _startingLeft(self, card):
        conf = self._lrnConf(card)
        tot = len(conf['delays'])
        tod = self._leftToday(conf['delays'], tot)
        return tot + tod*1000

    def _leftToday(self, delays, left, now=None):
        "The number of steps that can be completed by the day cutoff."
        if not now:
            now = intTime()
        delays = delays[-left:]
        ok = 0
        for i in range(len(delays)):
            now += delays[i]*60
            if now > self.dayCutoff:
                break
            ok = i
        return ok+1

class Scheduler:

    def _answerLrnCard(self, card, ease):
        conf = self._lrnConf(card) (1)

        # immediate graduate?
        if ease == 4:
            self._rescheduleAsRev(card, conf, True)
        # next step?
        elif ease == 3:
            # graduation time?
            if (card.left%1000)-1 <= 0:
                self._rescheduleAsRev(card, conf, False)
            else:
                self._moveToNextStep(card, conf)
        elif ease == 2:
            self._repeatStep(card, conf)
        else:
            # back to first step
            self._moveToFirstStep(card, conf)

    def _lrnConf(self, card):
        if card.type == 2:
            return self.col.deckConf["lapse"]
        else:
            return self.col.deckConf["new"]

class Scheduler:

   def _answerRevCard(self, card, ease):
        if ease == 1:
            self._rescheduleLapse(card)
        else:
            self._rescheduleRev(card, ease)

# ...

def _resetLrn(self):
    self._lrnQueue = []
    self._lrnDayQueue = [] (1)

# ...

def _rescheduleLrnCard(self, card, conf, delay=None):
    # normal delay for the current step?
    if delay is None:
        delay = self._delayForGrade(conf, card.left)

    card.due = int(time.time() + delay)
    # due today?
    if card.due < self.dayCutoff: (2)
        card.queue = 1
    else:
        # the card is due in one or more days, so we need to use the
        # day learn queue
        ahead = ((card.due - self.dayCutoff) // 86400) + 1
        card.due = self.today + ahead
        card.queue = 3

# ...

def _getCard(self):
    # learning card due?
    c = self._getLrnCard() (3)
    if c:
        return c

    # new first, or time for one?
    if self._timeForNewCard():
        c = self._getNewCard()
        if c:
            return c

    # card due for review?
    c = self._getRevCard()
    if c:
        return c

    # day learning card due?
    c = self._getLrnDayCard() (3)
    if c:
        return c

    # new cards left?
    c = self._getNewCard()
    if c:
        return c

    # collapse or finish
    return self._getLrnCard(collapse=True)

def _fuzzedIvl(self, ivl): (1)
    min, max = self._fuzzIvlRange(ivl)
    return random.randint(min, max)

def _fuzzIvlRange(self, ivl):
    if ivl < 2:
        return [1, 1]
    elif ivl == 2:
        return [2, 3]
    elif ivl < 7: (2)
        fuzz = int(ivl*0.25)
    elif ivl < 30: (2)
        fuzz = max(2, int(ivl*0.15))
    else: (2)
        fuzz = max(4, int(ivl*0.05))
    # fuzz at least a day
    fuzz = max(fuzz, 1)
    return [ivl-fuzz, ivl+fuzz]