The Programming Project (NEA)

procedure record(card, correct, today)
    if correct then
        card.box = min(card.box + 1, 5)
    else
        card.box = 1
    endif
    card.due = today + interval[card.box] days
endprocedure

import sqlite3
from datetime import date, timedelta

BOX_INTERVALS = {1: 1, 2: 2, 3: 4, 4: 8, 5: 16}     # days until a card is due again
MAX_BOX = 5


class DeckError(Exception):
    '''Raised when the user asks the deck to do something it cannot.'''


class Deck:
    '''A set of flashcards stored in a database, using the Leitner system.'''

    def __init__(self):
        self.db = sqlite3.connect(":memory:")
        self.db.execute('''CREATE TABLE card (
            card_id INTEGER PRIMARY KEY,
            question TEXT NOT NULL UNIQUE,
            answer TEXT NOT NULL,
            box INTEGER NOT NULL DEFAULT 1 CHECK (box BETWEEN 1 AND 5),
            due TEXT NOT NULL)''')

    def add(self, question, answer, today):
        '''Add a card, due today. Refuses a blank or duplicate question.'''
        question, answer = question.strip(), answer.strip()
        if not question or not answer:
            raise DeckError("a card needs a question and an answer")
        try:
            self.db.execute("INSERT INTO card (question, answer, due) VALUES (?, ?, ?)",
                            (question, answer, today.isoformat()))
        except sqlite3.IntegrityError:
            raise DeckError("that question is already in the deck")
        self.db.commit()

    def due(self, today):
        '''The cards to be reviewed today, lowest box first.'''
        rows = self.db.execute(
            "SELECT card_id, question, box FROM card WHERE due <= ? ORDER BY box, card_id",
            (today.isoformat(),))
        return rows.fetchall()

    def record(self, card_id, correct, today):
        '''Move a card after it has been answered, and return its new box and due date.'''
        (box,) = self.db.execute("SELECT box FROM card WHERE card_id = ?", (card_id,)).fetchone()
        box = min(box + 1, MAX_BOX) if correct else 1
        due = today + timedelta(days=BOX_INTERVALS[box])
        self.db.execute("UPDATE card SET box = ?, due = ? WHERE card_id = ?",
                        (box, due.isoformat(), card_id))
        self.db.commit()
        return box, due

    def summary(self):
        '''How many cards are in each box.'''
        return self.db.execute("SELECT box, COUNT(*) FROM card GROUP BY box ORDER BY box").fetchall()


day1 = date(2025, 3, 1)
deck = Deck()
deck.add("What does CPU stand for?", "Central processing unit", day1)
deck.add("What is the base of hexadecimal?", "16", day1)
deck.add("Which sort has an O(n log n) worst case?", "Merge sort", day1)

for bad in [("   ", "blank"), ("What is the base of hexadecimal?", "sixteen")]:
    try:
        deck.add(bad[0], bad[1], day1)
    except DeckError as error:
        print("refused:", error)

print("Day 1, due:", len(deck.due(day1)))
deck.record(1, True, day1)
deck.record(2, True, day1)
deck.record(3, False, day1)
print("after day 1:", deck.summary())

day2 = day1 + timedelta(days=1)
print("Day 2, due:", [q for _, q, _ in deck.due(day2)])
box, due = deck.record(3, True, day2)
print("card 3 is now in box", box, "due", due.isoformat())

day3 = day2 + timedelta(days=1)
for card_id, question, box in deck.due(day3):
    deck.record(card_id, True, day3)
print("after day 3:", deck.summary())

import sqlite3
import unittest
from datetime import date, timedelta

BOX_INTERVALS = {1: 1, 2: 2, 3: 4, 4: 8, 5: 16}
MAX_BOX = 5

class DeckError(Exception):
    pass

class Deck:
    def __init__(self):
        self.db = sqlite3.connect(":memory:")
        self.db.execute('''CREATE TABLE card (card_id INTEGER PRIMARY KEY,
            question TEXT NOT NULL UNIQUE, answer TEXT NOT NULL,
            box INTEGER NOT NULL DEFAULT 1 CHECK (box BETWEEN 1 AND 5), due TEXT NOT NULL)''')

    def add(self, question, answer, today):
        question, answer = question.strip(), answer.strip()
        if not question or not answer:
            raise DeckError("a card needs a question and an answer")
        try:
            self.db.execute("INSERT INTO card (question, answer, due) VALUES (?, ?, ?)",
                            (question, answer, today.isoformat()))
        except sqlite3.IntegrityError:
            raise DeckError("that question is already in the deck")
        self.db.commit()

    def due(self, today):
        return self.db.execute("SELECT card_id, question, box FROM card WHERE due <= ? ORDER BY box, card_id",
                               (today.isoformat(),)).fetchall()

    def record(self, card_id, correct, today):
        (box,) = self.db.execute("SELECT box FROM card WHERE card_id = ?", (card_id,)).fetchone()
        box = min(box + 1, MAX_BOX) if correct else 1
        due = today + timedelta(days=BOX_INTERVALS[box])
        self.db.execute("UPDATE card SET box = ?, due = ? WHERE card_id = ?", (box, due.isoformat(), card_id))
        self.db.commit()
        return box, due

TODAY = date(2025, 3, 1)

class TestDeck(unittest.TestCase):
    def setUp(self):
        self.deck = Deck()
        self.deck.add("What is RAM?", "Memory", TODAY)

    def test_t2_blank_question_refused(self):
        with self.assertRaises(DeckError):
            self.deck.add("   ", "anything", TODAY)

    def test_t3_duplicate_refused(self):
        with self.assertRaises(DeckError):
            self.deck.add("What is RAM?", "Random access memory", TODAY)

    def test_t4_correct_in_box_1_moves_to_box_2(self):
        self.assertEqual(self.deck.record(1, True, TODAY), (2, TODAY + timedelta(days=2)))

    def test_t5_correct_in_box_5_stays_in_box_5(self):
        for _ in range(4):
            self.deck.record(1, True, TODAY)
        self.assertEqual(self.deck.record(1, True, TODAY), (5, TODAY + timedelta(days=16)))
        self.assertEqual(self.deck.record(1, True, TODAY)[0], 5)

    def test_t6_wrong_answer_returns_to_box_1(self):
        for _ in range(3):
            self.deck.record(1, True, TODAY)
        self.assertEqual(self.deck.record(1, False, TODAY), (1, TODAY + timedelta(days=1)))

    def test_t7_only_due_cards_offered(self):
        self.deck.add("What is ROM?", "Read only memory", TODAY)
        self.deck.record(2, True, TODAY)
        self.assertEqual([q for _, q, _ in self.deck.due(TODAY)], ["What is RAM?"])

suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestDeck)
result = unittest.TestResult()
suite.run(result)
print(result.testsRun, "tests,", len(result.failures), "failed,", len(result.errors), "errors")
for test, trace in result.failures + result.errors:
    print("  FAILED", test.id().split(".")[-1])