quizlib 0.1.0__tar.gz

quizlib-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.3
+Name: quizlib
+Version: 0.1.0
+Summary: Generate quizzes from Python code.
+Keywords: quiz,moodle,education,testing,markdown
+Author: Hannes Knoll
+Author-email: Hannes Knoll <git@hannesknoll.de>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Education :: Testing
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: typst>=0.14.7
+Requires-Python: >=3.13
+Project-URL: Repository, https://gitlab.com/hhoegl-tha/snp-rs/quizlib
+Description-Content-Type: text/markdown
+
+# quizlib
+
+Generate quizzes from Python code.
+
+## Features
+
+- **Supported Question Types**: Essay (ES), Multiple Choice (MC), True/False (TF), Cloze (CZ).
+- **Renderers**: Moodle XML, Markdown
+- **Python-centric**: Define quiz structure and content using native Python classes.
+
+## Installation
+
+Install using uv:
+
+```sh
+uv add quizlib
+```
+
+
+**For development run**
+```sh
+uv pip install -e .
+```
+
+## Usage
+
+```python
+from quizlib import Quiz, Essay, MultipleChoice, TrueFalse, Cloze
+from quizlib.renderers import MoodleXMLRenderer
+
+# Initialize quiz
+quiz = Quiz(category="Example", info="Sample quiz")
+
+# Add questions
+quiz.add(Essay(name="q1", defgrade=5, text="Explain the concept of recursion."))
+
+quiz.add(MultipleChoice(
+    name="q2",
+    text="Which of these is a Python keyword?",
+    answers=[(1, "yield"), (0, "function"), (0, "define")],
+))
+
+# Render to Moodle XML
+renderer = MoodleXMLRenderer()
+xml_output = renderer.render(quiz)
+print(xml_output)
+```

quizlib-0.1.0/README.md

@@ -0,0 +1,47 @@
+# quizlib
+
+Generate quizzes from Python code.
+
+## Features
+
+- **Supported Question Types**: Essay (ES), Multiple Choice (MC), True/False (TF), Cloze (CZ).
+- **Renderers**: Moodle XML, Markdown
+- **Python-centric**: Define quiz structure and content using native Python classes.
+
+## Installation
+
+Install using uv:
+
+```sh
+uv add quizlib
+```
+
+
+**For development run**
+```sh
+uv pip install -e .
+```
+
+## Usage
+
+```python
+from quizlib import Quiz, Essay, MultipleChoice, TrueFalse, Cloze
+from quizlib.renderers import MoodleXMLRenderer
+
+# Initialize quiz
+quiz = Quiz(category="Example", info="Sample quiz")
+
+# Add questions
+quiz.add(Essay(name="q1", defgrade=5, text="Explain the concept of recursion."))
+
+quiz.add(MultipleChoice(
+    name="q2",
+    text="Which of these is a Python keyword?",
+    answers=[(1, "yield"), (0, "function"), (0, "define")],
+))
+
+# Render to Moodle XML
+renderer = MoodleXMLRenderer()
+xml_output = renderer.render(quiz)
+print(xml_output)
+```

quizlib-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "quizlib"
+version = "0.1.0"
+description = "Generate quizzes from Python code."
+readme = "README.md"
+authors = [
+    { name = "Hannes Knoll", email = "git@hannesknoll.de" }
+]
+keywords = ["quiz", "moodle", "education", "testing", "markdown"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Education",
+    "Topic :: Education :: Testing",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+]
+requires-python = ">=3.13"
+dependencies = [
+    "typst>=0.14.7",
+]
+
+[project.urls]
+Repository = "https://gitlab.com/hhoegl-tha/snp-rs/quizlib"
+
+[project.scripts]
+quizlib = "quizlib.__main__:main"
+
+[build-system]
+requires = ["uv_build>=0.9.25,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "rich>=14.2.0",
+    "ruff>=0.14.13",
+    "ty>=0.0.12",
+]

quizlib-0.1.0/src/quizlib/__init__.py

@@ -0,0 +1,51 @@
+"""
+quizlib - Generate quizzes from Python.
+
+Example usage:
+
+>>> from quizlib import Quiz, Essay, MultipleChoice, TrueFalse, Cloze
+>>> from quizlib.renderers import MoodleXMLRenderer
+>>>
+>>> quiz = Quiz(category="MyQuiz", info="A sample quiz")
+>>> quiz.add(Essay(name="q1", defgrade=5, text="Explain X..."))
+>>> quiz.add(MultipleChoice(
+>>>     name="q2",
+>>>     text="Which is correct?",
+>>>     answers=[(1, "Correct"), (0, "Wrong A"), (0, "Wrong B")],
+>>> ))
+>>>
+>>> renderer = MoodleXMLRenderer()
+>>> print(renderer.render(quiz))
+"""
+
+from quizlib.questions import (
+    CZ,
+    ES,
+    MC,
+    TF,
+    Cloze,
+    Essay,
+    MultipleChoice,
+    Question,
+    TrueFalse,
+)
+from quizlib.quiz import Quiz
+from quizlib.types import QuestionType, Qtype
+
+__all__ = [
+    # Core
+    "Quiz",
+    "Question",
+    "QuestionType",
+    "Qtype",
+    # Question types (full names)
+    "Essay",
+    "MultipleChoice",
+    "TrueFalse",
+    "Cloze",
+    # Question types (aliases)
+    "ES",
+    "MC",
+    "TF",
+    "CZ",
+]

quizlib-0.1.0/src/quizlib/questions/__init__.py

@@ -0,0 +1,24 @@
+"""
+quizlib question type implementations
+"""
+
+from quizlib.questions.base import Question
+from quizlib.questions.cloze import CZ, Cloze
+from quizlib.questions.essay import ES, Essay
+from quizlib.questions.multiple_choice import MC, MultipleChoice
+from quizlib.questions.true_false import TF, TrueFalse
+
+__all__ = [
+    # Protocol
+    "Question",
+    # Full names
+    "Essay",
+    "MultipleChoice",
+    "TrueFalse",
+    "Cloze",
+    # Short aliases
+    "ES",
+    "MC",
+    "TF",
+    "CZ",
+]

quizlib-0.1.0/src/quizlib/questions/base.py

@@ -0,0 +1,16 @@
+"""
+quizlib base protocol for questions
+"""
+
+from typing import Protocol, runtime_checkable
+
+from quizlib.types import QuestionType
+
+
+@runtime_checkable
+class Question(Protocol):
+    """Protocol that all question types must implement."""
+
+    name: str
+    text: str
+    typ: QuestionType

quizlib-0.1.0/src/quizlib/questions/cloze.py

@@ -0,0 +1,29 @@
+"""
+quizlib cloze question type
+"""
+
+from dataclasses import dataclass, field
+
+from quizlib.types import QuestionType
+
+
+@dataclass
+class Cloze:
+    """Cloze (fill-in-the-blank) question.
+
+    The text contains special Moodle cloze syntax for blanks, e.g.:
+    - {:MRH:=Ja#correct~Nein#incorrect} for multiple choice
+    - {:NUMERICAL:=42:0} for numeric answers
+
+    Attributes:
+        name: Question identifier/title.
+        text: Question text with embedded cloze syntax.
+    """
+
+    name: str
+    text: str
+    typ: QuestionType = field(default=QuestionType.CLOZE, init=False)
+
+
+# Backwards-compatible alias
+CZ = Cloze

quizlib-0.1.0/src/quizlib/questions/essay.py

@@ -0,0 +1,32 @@
+"""
+quizlib essay question type
+"""
+
+from dataclasses import dataclass, field
+
+from quizlib.types import QuestionType
+from quizlib.utils import DEFAULT_ESSAY_LINES
+
+
+@dataclass
+class Essay:
+    """Essay (free-text) question.
+
+    Attributes:
+        name: Question identifier/title.
+        defgrade: Points for this question.
+        text: Question text in Markdown format.
+        lines: Number of lines for the response box.
+        graderinfo: Information for the grader (not shown to students).
+    """
+
+    name: str
+    defgrade: int | float
+    text: str
+    lines: int = DEFAULT_ESSAY_LINES
+    graderinfo: str = ""
+    typ: QuestionType = field(default=QuestionType.ESSAY, init=False)
+
+
+# Backwards-compatible alias
+ES = Essay

quizlib-0.1.0/src/quizlib/questions/multiple_choice.py

@@ -0,0 +1,50 @@
+"""
+quizlib multiple choice question type
+"""
+
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+
+from quizlib.types import MCAnswer, QuestionType
+
+
+@dataclass
+class MultipleChoice:
+    """Multiple choice question.
+
+    Supports single answer (radio buttons) or multiple answers (checkboxes).
+    The mode is automatically determined by the number of correct answers.
+
+    Attributes:
+        name: Question identifier/title.
+        text: Question text in Markdown format.
+        answers: Sequence of (is_correct, answer_text) tuples.
+                 Accepts list or tuple. is_correct is 1 for correct, 0 for incorrect.
+        defgrade: Points for this question. Defaults to number of correct answers.
+    """
+
+    name: str
+    text: str
+    answers: Sequence[MCAnswer]
+    defgrade: int | float | None = None
+    typ: QuestionType = field(default=QuestionType.MULTIPLE_CHOICE, init=False)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.answers, list):
+            object.__setattr__(self, "answers", list(self.answers))
+        if self.defgrade is None:
+            self.defgrade = self.n_correct
+
+    @property
+    def n_correct(self) -> int:
+        """Number of correct answers."""
+        return sum(1 for is_correct, _ in self.answers if is_correct == 1)
+
+    @property
+    def is_single(self) -> bool:
+        """True if only one answer is correct (radio button mode)."""
+        return self.n_correct == 1
+
+
+# Backwards-compatible alias
+MC = MultipleChoice

quizlib-0.1.0/src/quizlib/questions/true_false.py

@@ -0,0 +1,27 @@
+"""
+quizlib True/False question type
+"""
+
+from dataclasses import dataclass, field
+
+from quizlib.types import QuestionType
+
+
+@dataclass
+class TrueFalse:
+    """True/False question.
+
+    Attributes:
+        name: Question identifier/title.
+        text: Question text in Markdown format.
+        correct_answer: True if the correct answer is "true", False otherwise.
+    """
+
+    name: str
+    text: str
+    correct_answer: bool
+    typ: QuestionType = field(default=QuestionType.TRUE_FALSE, init=False)
+
+
+# Backwards-compatible alias
+TF = TrueFalse

quizlib-0.1.0/src/quizlib/quiz.py

@@ -0,0 +1,71 @@
+"""
+quizli quiz container class
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Iterable, Iterator
+from dataclasses import dataclass, field
+from typing import Any
+
+from quizlib.questions.base import Question
+
+
+@dataclass
+class Quiz:
+    """A collection of quiz questions with builder pattern support."""
+
+    category: str
+    info: str = ""
+    questions: list[Question] = field(default_factory=list)
+
+    def add(self, question: Question) -> Quiz:
+        """Add a question. Returns self for chaining."""
+        self.questions.append(question)
+        return self
+
+    def add_all(self, questions: Iterable[Question]) -> Quiz:
+        """Add multiple questions. Returns self for chaining."""
+        self.questions.extend(questions)
+        return self
+
+    def sort(
+        self,
+        *,
+        key: Callable[[Question], Any] | None = None,
+        reverse: bool = False,
+    ) -> Quiz:
+        """Sort questions in place. Default key is name. Returns self for chaining."""
+        self.questions.sort(key=key or (lambda q: q.name), reverse=reverse)
+        return self
+
+    def filter(self, pattern: str) -> Quiz:
+        """Return a NEW Quiz with only questions matching the regex pattern."""
+        regex = re.compile(pattern)
+        filtered = [q for q in self.questions if regex.search(q.name)]
+        return Quiz(
+            category=self.category,
+            info=self.info,
+            questions=filtered,
+        )
+
+    def to_xml(self) -> str:
+        """Render the quiz to Moodle XML format."""
+        from quizlib.renderers import MoodleXMLRenderer
+
+        return MoodleXMLRenderer().render(self)
+
+    def to_markdown(self) -> str:
+        """Render the quiz to Markdown format."""
+        from quizlib.renderers import MarkdownRenderer
+
+        return MarkdownRenderer().render(self)
+
+    def __len__(self) -> int:
+        """Number of questions in the quiz."""
+        return len(self.questions)
+
+    def __iter__(self) -> Iterator[Question]:
+        """Iterate over questions."""
+        return iter(self.questions)

quizlib-0.1.0/src/quizlib/renderers/__init__.py

@@ -0,0 +1,13 @@
+"""
+quizlib renderer implementations
+"""
+
+from quizlib.renderers.base import Renderer
+from quizlib.renderers.moodle_xml import MoodleXMLRenderer
+from quizlib.renderers.markdown import MarkdownRenderer
+
+__all__ = [
+    "Renderer",
+    "MoodleXMLRenderer",
+    "MarkdownRenderer",
+]

quizlib-0.1.0/src/quizlib/renderers/base.py

@@ -0,0 +1,16 @@
+"""
+quizlib base protocol for renderers
+"""
+
+from typing import TYPE_CHECKING, Protocol
+
+if TYPE_CHECKING:
+    from quizlib.quiz import Quiz
+
+
+class Renderer(Protocol):
+    """Protocol that all renderers must implement."""
+
+    def render(self, quiz: "Quiz") -> str:
+        """Render a quiz to the target format."""
+        ...

quizlib-0.1.0/src/quizlib/renderers/markdown.py

@@ -0,0 +1,97 @@
+"""
+quizlib markdown renderer
+"""
+
+from typing import TYPE_CHECKING
+import re
+
+from quizlib.questions.cloze import Cloze
+from quizlib.questions.essay import Essay
+from quizlib.questions.multiple_choice import MultipleChoice
+from quizlib.questions.true_false import TrueFalse
+
+if TYPE_CHECKING:
+    from quizlib.questions.base import Question
+    from quizlib.quiz import Quiz
+
+
+class MarkdownRenderer:
+    """Renders quizzes to Markdown format."""
+
+    def render(self, quiz: "Quiz") -> str:
+        """Render a quiz to Markdown."""
+        parts: list[str] = []
+
+        parts.append(f"# Quiz: {quiz.category}")
+        if quiz.info:
+            parts.append(f"\n{quiz.info}")
+
+        parts.append("\n---\n")
+
+        for i, question in enumerate(quiz.questions, 1):
+            parts.append(self._render_question(question, i))
+            parts.append("\n---\n")
+
+        return "\n".join(parts)
+
+    def _render_question(self, question: "Question", index: int) -> str:
+        """Render a single question."""
+        match question:
+            case Essay():
+                return self._render_essay(question, index)
+            case MultipleChoice():
+                return self._render_mc(question, index)
+            case TrueFalse():
+                return self._render_tf(question, index)
+            case Cloze():
+                return self._render_cloze(question, index)
+            case _:
+                raise TypeError(f"Unknown question type: {type(question)}")
+
+    def _render_header(
+        self, index: int, name: str, points: float | int | None = None
+    ) -> str:
+        """Render question header."""
+        header = f"## {index}. {name}"
+        if points is not None:
+            header += f" ({points} Punkte)"
+        return header + "\n"
+
+    def _render_essay(self, q: Essay, index: int) -> str:
+        parts = [self._render_header(index, q.name, q.defgrade)]
+        parts.append(q.name)
+        parts.append("\n\n> Antwort:\n")
+
+        for _ in range(q.lines):
+            parts.append("> " + "_" * 79 + "\\")
+        return "\n".join(parts)
+
+    def _render_mc(self, q: MultipleChoice, index: int) -> str:
+        symbol = "( )" if q.is_single else "[ ]"
+
+        lines = [self._render_header(index, q.name, q.defgrade), q.text]
+        for _, text in q.answers:
+            if text.startswith("```"):
+                text = f" \n\n{text}"
+
+            lines.append(f"- {symbol} {text}")
+
+        return "\n".join(lines)
+
+    def _render_tf(self, q: TrueFalse, index: int) -> str:
+        parts = [self._render_header(index, q.name)]
+        parts.append(q.name + "\n")
+
+        parts.append("- [ ] True")
+        parts.append("- [ ] False")
+
+        return "\n".join(parts)
+
+    def _render_cloze(self, q: Cloze, index: int) -> str:
+        parts = [self._render_header(index, q.name)]
+
+        # Simplify Cloze syntax: replace {...} with [__________]
+        simplified_text = re.sub(r"\{[^}]+\}", "[__________]", q.name)
+
+        parts.append(simplified_text)
+        return "\n".join(parts)

quizlib-0.1.0/src/quizlib/renderers/moodle_xml.py

@@ -0,0 +1,194 @@
+"""
+quizlib Moodle XML format renderer
+"""
+
+import re
+import html
+from typing import TYPE_CHECKING
+import xml.etree.ElementTree as ET
+
+from quizlib.questions.cloze import Cloze
+from quizlib.questions.essay import Essay
+from quizlib.questions.multiple_choice import MultipleChoice
+from quizlib.questions.true_false import TrueFalse
+
+if TYPE_CHECKING:
+    from quizlib.questions.base import Question
+    from quizlib.quiz import Quiz
+
+
+class MoodleXMLRenderer:
+    """Renders quizzes to Moodle XML format."""
+
+    def render(self, quiz: "Quiz") -> str:
+        """Render a complete quiz to Moodle XML."""
+        root = ET.Element("quiz")
+
+        q_cat = ET.SubElement(root, "question", type="category")
+        cat = ET.SubElement(q_cat, "category")
+        ET.SubElement(cat, "text").text = f"$course$/top/{quiz.category}"
+
+        info = ET.SubElement(q_cat, "info", format="moodle_auto_format")
+        ET.SubElement(info, "text").text = quiz.info
+        ET.SubElement(q_cat, "idnumber")
+
+        for question in quiz.questions:
+            self._render_question(root, question)
+
+        ET.indent(root, space="  ", level=0)
+        xml_str = ET.tostring(root, encoding="unicode", xml_declaration=True)
+        return self._post_process_cdata(xml_str)
+
+    def _post_process_cdata(self, xml_str: str) -> str:
+        """Wrap code blocks in answers with CDATA."""
+        pattern = re.compile(r"(<answer[^>]*>\s*<text>)(.*?)(</text>)", re.DOTALL)
+
+        def replacement(match):
+            prefix = match.group(1)
+            body = match.group(2)
+            suffix = match.group(3)
+
+            if "```" in body:
+                unescaped_body = html.unescape(body)
+                return f"{prefix}<![CDATA[{unescaped_body}]]>{suffix}"
+            return match.group(0)
+
+        return pattern.sub(replacement, xml_str)
+
+    def _render_question(self, parent: ET.Element, question: "Question") -> None:
+        """Render a single question."""
+        match question:
+            case Essay():
+                self._render_essay(parent, question)
+            case MultipleChoice():
+                self._render_mc(parent, question)
+            case TrueFalse():
+                self._render_tf(parent, question)
+            case Cloze():
+                self._render_cloze(parent, question)
+            case _:
+                raise TypeError(f"Unknown question type: {type(question)}")
+
+    def _render_essay(self, parent: ET.Element, q: Essay) -> None:
+        q_elem = ET.SubElement(parent, "question", type="essay")
+
+        name = ET.SubElement(q_elem, "name")
+        ET.SubElement(name, "text").text = q.name
+
+        qtext = ET.SubElement(q_elem, "questiontext", format="markdown")
+        ET.SubElement(qtext, "text").text = q.text
+
+        gen_feedback = ET.SubElement(q_elem, "generalfeedback", format="markdown")
+        ET.SubElement(gen_feedback, "text")
+
+        ET.SubElement(q_elem, "defaultgrade").text = str(q.defgrade)
+        ET.SubElement(q_elem, "penalty").text = "0.0000000"
+        ET.SubElement(q_elem, "hidden").text = "0"
+        ET.SubElement(q_elem, "idnumber")
+        ET.SubElement(q_elem, "responseformat").text = "monospaced"
+        ET.SubElement(q_elem, "responserequired").text = "1"
+        ET.SubElement(q_elem, "responsefieldlines").text = str(q.lines)
+        ET.SubElement(q_elem, "attachments").text = "0"
+        ET.SubElement(q_elem, "attachmentsrequired").text = "0"
+        ET.SubElement(q_elem, "maxbytes").text = "0"
+        ET.SubElement(q_elem, "filetypeslist")
+
+        graderinfo = ET.SubElement(q_elem, "graderinfo", format="markdown")
+        ET.SubElement(graderinfo, "text").text = q.graderinfo
+
+        resp_template = ET.SubElement(q_elem, "responsetemplate", format="markdown")
+        ET.SubElement(resp_template, "text")
+
+    def _render_mc(self, parent: ET.Element, q: MultipleChoice) -> None:
+        q_elem = ET.SubElement(parent, "question", type="multichoice")
+
+        name = ET.SubElement(q_elem, "name")
+        ET.SubElement(name, "text").text = q.name
+
+        qtext = ET.SubElement(q_elem, "questiontext", format="markdown")
+        ET.SubElement(qtext, "text").text = q.text
+
+        gen_feedback = ET.SubElement(
+            q_elem, "generalfeedback", format="moodle_auto_format"
+        )
+        ET.SubElement(gen_feedback, "text")
+
+        ET.SubElement(q_elem, "defaultgrade").text = str(q.defgrade)
+        ET.SubElement(q_elem, "penalty").text = "0.0000000"
+        ET.SubElement(q_elem, "hidden").text = "0"
+        ET.SubElement(q_elem, "idnumber")
+        ET.SubElement(q_elem, "single").text = "true" if q.is_single else "false"
+        ET.SubElement(q_elem, "shuffleanswers").text = "true"
+        ET.SubElement(q_elem, "answernumbering").text = "abc"
+        ET.SubElement(q_elem, "showstandardinstruction").text = "0"
+
+        for tag, text in [
+            ("correctfeedback", "Die Antwort ist richtig."),
+            ("partiallycorrectfeedback", "Die Antwort ist teilweise richtig."),
+            ("incorrectfeedback", "Die Antwort ist falsch."),
+        ]:
+            fb = ET.SubElement(q_elem, tag, format="markdown")
+            ET.SubElement(fb, "text").text = text
+
+        ET.SubElement(q_elem, "shownumcorrect")
+
+        for is_correct, answer_text in q.answers:
+            fraction = f"{100 / q.n_correct:8.6f}" if is_correct == 1 else "0"
+            answer = ET.SubElement(
+                q_elem, "answer", fraction=fraction, format="markdown"
+            )
+            ET.SubElement(answer, "text").text = answer_text
+            feedback = ET.SubElement(answer, "feedback", format="markdown")
+            ET.SubElement(feedback, "text")
+
+    def _render_tf(self, parent: ET.Element, q: TrueFalse) -> None:
+        q_elem = ET.SubElement(parent, "question", type="truefalse")
+
+        name = ET.SubElement(q_elem, "name")
+        ET.SubElement(name, "text").text = q.name
+
+        qtext = ET.SubElement(q_elem, "questiontext", format="markdown")
+        ET.SubElement(qtext, "text").text = q.text
+
+        gen_feedback = ET.SubElement(q_elem, "generalfeedback", format="markdown")
+        ET.SubElement(gen_feedback, "text")
+
+        ET.SubElement(q_elem, "defaultgrade").text = "1.0000000"
+        ET.SubElement(q_elem, "penalty").text = "1.0000000"
+        ET.SubElement(q_elem, "hidden").text = "0"
+        ET.SubElement(q_elem, "idnumber")
+
+        if q.correct_answer:
+            correct, wrong = "true", "false"
+        else:
+            correct, wrong = "false", "true"
+
+        # Wrong answer (fraction 0)
+        ans_wrong = ET.SubElement(
+            q_elem, "answer", fraction="0", format="moodle_auto_format"
+        )
+        ET.SubElement(ans_wrong, "text").text = wrong
+        feed_wrong = ET.SubElement(ans_wrong, "feedback", format="markdown")
+        ET.SubElement(feed_wrong, "text")
+
+        # Correct answer (fraction 100)
+        ans_correct = ET.SubElement(q_elem, "answer", fraction="100", format="markdown")
+        ET.SubElement(ans_correct, "text").text = correct
+        feed_correct = ET.SubElement(ans_correct, "feedback", format="markdown")
+        ET.SubElement(feed_correct, "text")
+
+    def _render_cloze(self, parent: ET.Element, q: Cloze) -> None:
+        q_elem = ET.SubElement(parent, "question", type="cloze")
+
+        name = ET.SubElement(q_elem, "name")
+        ET.SubElement(name, "text").text = q.name
+
+        qtext = ET.SubElement(q_elem, "questiontext", format="markdown")
+        ET.SubElement(qtext, "text").text = q.text
+
+        gen_feedback = ET.SubElement(q_elem, "generalfeedback", format="markdown")
+        ET.SubElement(gen_feedback, "text")
+
+        ET.SubElement(q_elem, "penalty").text = "0.3333333"
+        ET.SubElement(q_elem, "hidden").text = "0"
+        ET.SubElement(q_elem, "idnumber")

quizlib-0.1.0/src/quizlib/types.py

@@ -0,0 +1,21 @@
+"""
+quizlib type definitions
+"""
+
+from enum import Enum, auto
+
+
+class QuestionType(Enum):
+    """Question type enumeration."""
+
+    MULTIPLE_CHOICE = auto()
+    ESSAY = auto()
+    TRUE_FALSE = auto()
+    CLOZE = auto()
+
+
+# Backwards-compatible alias
+Qtype = QuestionType
+
+# Type alias for MC answers: (is_correct: bool, answer_text: str)
+type MCAnswer = tuple[bool, str]

quizlib-0.1.0/src/quizlib/utils.py

@@ -0,0 +1,6 @@
+"""
+quizlib utility functions and constants
+"""
+
+DEFAULT_MC_GRADE: int | None = None
+DEFAULT_ESSAY_LINES: int = 5