quizforge 0.2.0__py3-none-any.whl

quizforge/__init__.py

@@ -0,0 +1,104 @@
+"""quizforge — generate a deep, mixed-format question bank from source material
+and grade it. Deterministic where it can, LLM where it must. Bring your own
+chat model.
+
+Public API
+----------
+Generate:
+    generate_bank(material, llm, *, targets=..., existing=...) -> list[dict]
+Sample:
+    sample_test(questions, blueprint=..., seen_ids=...) -> list[dict]
+    pick_spread(pool, want, seen_ids) -> list[dict]
+    DEFAULT_BLUEPRINT
+Grade:
+    grade_fill_blank(question, user_answer) -> dict
+    grade_match(question, selections) -> dict
+    grade_open_answer(question, user_answer, llm) -> QuizGrade | None
+    QuizGrade
+Integrity:
+    assess_speed(*, elapsed_seconds, question_types, passed) -> IntegrityFlag
+    expected_min_seconds(question_types) -> float
+    within_time_limit(elapsed_seconds, limit_seconds=...) -> bool
+    IntegrityFlag
+Certificate:
+    make_certificate(*, learner_id, ..., score_pct, awarded_on) -> Certificate
+    verification_code(...) -> str   |   verify(certificate) -> bool
+    Certificate
+Utilities:
+    normalize(text) -> str
+    structured_output(llm, schema) -> chain
+"""
+
+from .bank import Bank
+from .certificate import (
+    Certificate,
+    is_eligible,
+    level_for,
+    make_certificate,
+    verification_code,
+    verify,
+)
+from .generate import (
+    DEFAULT_COVERAGE,
+    DEFAULT_DIFF_SPLIT,
+    DEFAULT_SYSTEM,
+    DEFAULT_TARGETS,
+    generate_bank,
+)
+from .grade import (
+    DEFAULT_GRADE_SYSTEM,
+    QuizGrade,
+    grade_fill_blank,
+    grade_match,
+    grade_open_answer,
+)
+from .integrity import (
+    DEFAULT_MIN_SECONDS_PER_TYPE,
+    DEFAULT_TIME_LIMIT_SECONDS,
+    IntegrityFlag,
+    assess_speed,
+    expected_min_seconds,
+    within_time_limit,
+)
+from .llm import structured_output
+from .sample import DEFAULT_BLUEPRINT, DIFFICULTY_ORDER, pick_spread, sample_test
+from .schemas import DIFFICULTIES, FORMAT_KEYS, FORMATS
+from .text import normalize
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "Bank",
+    "generate_bank",
+    "sample_test",
+    "pick_spread",
+    "grade_fill_blank",
+    "grade_match",
+    "grade_open_answer",
+    "QuizGrade",
+    "assess_speed",
+    "expected_min_seconds",
+    "within_time_limit",
+    "IntegrityFlag",
+    "DEFAULT_MIN_SECONDS_PER_TYPE",
+    "DEFAULT_TIME_LIMIT_SECONDS",
+    "Certificate",
+    "make_certificate",
+    "verification_code",
+    "verify",
+    "is_eligible",
+    "level_for",
+    "normalize",
+    "structured_output",
+    "DEFAULT_BLUEPRINT",
+    "DEFAULT_TARGETS",
+    "DEFAULT_DIFF_SPLIT",
+    "DEFAULT_SYSTEM",
+    "DEFAULT_COVERAGE",
+    "DEFAULT_GRADE_SYSTEM",
+    "DIFFICULTY_ORDER",
+    "DIFFICULTIES",
+    "FORMAT_KEYS",
+    "FORMATS",
+    "__version__",
+]

quizforge/bank.py

@@ -0,0 +1,89 @@
+"""Bank — a YAML-backed question bank with grow/sample/save convenience.
+
+A bank file is YAML with (at least) a ``questions:`` list; any other top-level
+keys are metadata, carried through untouched on save. An optional ``material:``
+key holds the source text used to ground generation (or pass it explicitly).
+
+Comments are NOT preserved on save (clean round-trip via PyYAML). If you keep a
+heavily-commented bank file, generate into memory and write where you control
+the formatting instead of calling ``save``.
+"""
+
+from collections import Counter
+from pathlib import Path
+from typing import List, Optional, Union
+
+import yaml
+
+from .generate import generate_bank
+from .sample import sample_test
+
+PathLike = Union[str, Path]
+
+
+class Bank:
+    """Load, grow, sample, and save a question bank."""
+
+    def __init__(self, questions: Optional[List[dict]] = None, meta: Optional[dict] = None):
+        self.questions: List[dict] = list(questions or [])
+        self.meta: dict = dict(meta or {})
+
+    # ----- construction -----------------------------------------------------
+    @classmethod
+    def load(cls, path: PathLike) -> "Bank":
+        data = yaml.safe_load(Path(path).read_text()) or {}
+        if not isinstance(data, dict):
+            raise ValueError(f"{path}: expected a YAML mapping, got {type(data).__name__}")
+        questions = data.pop("questions", []) or []
+        return cls(questions=questions, meta=data)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Bank":
+        data = dict(data or {})
+        return cls(questions=data.pop("questions", []) or [], meta=data)
+
+    # ----- inspection -------------------------------------------------------
+    @property
+    def material(self) -> str:
+        return self.meta.get("material", "") or ""
+
+    def counts_by_type(self) -> dict:
+        return dict(Counter(q.get("type", "mc") for q in self.questions))
+
+    def counts_by_difficulty(self) -> dict:
+        return dict(Counter(q.get("difficulty", "medium") for q in self.questions))
+
+    def __len__(self) -> int:
+        return len(self.questions)
+
+    # ----- mutation ---------------------------------------------------------
+    def add(self, new_questions: List[dict]) -> "Bank":
+        self.questions.extend(new_questions)
+        return self
+
+    def grow(self, llm, *, targets: Optional[dict] = None,
+             material: Optional[str] = None, **kwargs) -> List[dict]:
+        """Generate the shortfall to reach ``targets`` and append it in place.
+
+        Grounds on ``material`` if given, else the bank's ``material`` metadata.
+        Returns just the newly added questions.
+        """
+        mat = material if material is not None else self.material
+        if not (mat or "").strip():
+            raise ValueError("no material to ground generation — pass material=... "
+                             "or set a 'material:' key in the bank file")
+        new = generate_bank(mat, llm, targets=targets, existing=self.questions, **kwargs)
+        self.add(new)
+        return new
+
+    def sample(self, blueprint: Optional[dict] = None, seen_ids=(), rng=None) -> List[dict]:
+        return sample_test(self.questions, blueprint=blueprint, seen_ids=seen_ids, rng=rng)
+
+    # ----- persistence ------------------------------------------------------
+    def to_dict(self) -> dict:
+        return {**self.meta, "questions": self.questions}
+
+    def save(self, path: PathLike) -> None:
+        with open(path, "w") as f:
+            yaml.safe_dump(self.to_dict(), f, sort_keys=False, allow_unicode=True,
+                           width=100, default_flow_style=False)

quizforge/certificate.py

@@ -0,0 +1,84 @@
+"""Completion certificates — the data + a tamper-evident verification code.
+
+quizforge owns the *facts* of a certificate (who, which topic, what level, when)
+and a deterministic verification code derived from them, so any consumer can
+re-derive the code to confirm a certificate wasn't altered. Rendering — PDF,
+HTML, image — is deliberately left to the consumer, where the branding lives, so
+this module stays dependency-light (pydantic only) and clockless (the caller
+supplies ``awarded_on``, keeping generation reproducible).
+"""
+
+import hashlib
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+PASS = "passed"
+DISTINCTION = "distinction"
+_SEP = "\x1f"  # unit separator — unlikely to appear in any field
+
+
+class Certificate(BaseModel):
+    """An earned completion certificate's facts + its verification code."""
+
+    learner_id: str = Field(description="Stable learner identity (e.g. email).")
+    learner_name: str = Field(description="Display name to print on the certificate.")
+    topic_id: str = Field(description="Topic/lesson identifier.")
+    topic_title: str = Field(description="Human-readable topic title.")
+    score_pct: int = Field(description="Best score as a 0-100 percentage.")
+    level: str = Field(description="'passed' or 'distinction'.")
+    awarded_on: str = Field(description="Award date as the caller's display string.")
+    verification_code: str = Field(description="Deterministic, tamper-evident code.")
+
+
+def verification_code(*, learner_id: str, topic_id: str, awarded_on: str, level: str,
+                      score_pct: int, secret: str = "", prefix: str = "QF") -> str:
+    """Derive a short, stable verification code from a certificate's fields.
+
+    Same fields (+ same ``secret``) always yield the same code; changing any
+    field changes the code, so a printed certificate can be checked against the
+    record. With a non-empty ``secret`` the code is unforgeable without it.
+    """
+    raw = _SEP.join([learner_id.lower().strip(), topic_id, awarded_on, level,
+                     str(score_pct), secret])
+    digest = hashlib.sha256(raw.encode("utf-8")).hexdigest().upper()
+    return f"{prefix}-{digest[:4]}-{digest[4:8]}"
+
+
+def is_eligible(score_pct: int, pass_threshold: float = 0.6) -> bool:
+    """Whether a score earns a certificate at all."""
+    return score_pct / 100.0 >= pass_threshold
+
+
+def level_for(score_pct: int, distinction_threshold: float = 0.8) -> str:
+    """'distinction' at/above the threshold, else 'passed'."""
+    return DISTINCTION if score_pct / 100.0 >= distinction_threshold else PASS
+
+
+def make_certificate(*, learner_id: str, learner_name: str, topic_id: str, topic_title: str,
+                     score_pct: int, awarded_on: str, pass_threshold: float = 0.6,
+                     distinction_threshold: float = 0.8, secret: str = "",
+                     prefix: str = "QF") -> Certificate:
+    """Build a :class:`Certificate` for an eligible score.
+
+    Raises ``ValueError`` if ``score_pct`` is below ``pass_threshold`` — there is
+    no certificate for a non-pass.
+    """
+    if not is_eligible(score_pct, pass_threshold):
+        raise ValueError(f"score {score_pct}% is below the pass threshold "
+                         f"{round(pass_threshold * 100)}% — no certificate")
+    level = level_for(score_pct, distinction_threshold)
+    code = verification_code(learner_id=learner_id, topic_id=topic_id, awarded_on=awarded_on,
+                             level=level, score_pct=score_pct, secret=secret, prefix=prefix)
+    return Certificate(learner_id=learner_id, learner_name=learner_name, topic_id=topic_id,
+                       topic_title=topic_title, score_pct=score_pct, level=level,
+                       awarded_on=awarded_on, verification_code=code)
+
+
+def verify(certificate: Certificate, secret: str = "", prefix: str = "QF") -> bool:
+    """Re-derive the code from the certificate's fields and confirm it matches."""
+    expected = verification_code(
+        learner_id=certificate.learner_id, topic_id=certificate.topic_id,
+        awarded_on=certificate.awarded_on, level=certificate.level,
+        score_pct=certificate.score_pct, secret=secret, prefix=prefix)
+    return expected == certificate.verification_code

quizforge/cli.py

@@ -0,0 +1,134 @@
+"""quizforge command line.
+
+    quizforge grow   BANK [--material-file F] [--mc N ...] [--dry-run] --llm mod:factory
+    quizforge sample BANK [--seed N] [--json]
+    quizforge stats  BANK
+
+`grow` needs a chat model. Because quizforge is provider-neutral, you point it at
+one you construct:
+
+    # a dotted path to a zero-arg callable returning a LangChain-style model
+    quizforge grow bank.yaml --llm myproject.models:make_llm
+
+    # or, if langchain-openai is installed and OPENAI_API_KEY is set
+    quizforge grow bank.yaml --openai-model gpt-4.1
+"""
+
+import argparse
+import importlib
+import json
+import logging
+import random
+import sys
+from collections import Counter
+from typing import Optional
+
+from .bank import Bank
+from .generate import DEFAULT_TARGETS
+from .schemas import FORMAT_KEYS
+
+
+def _resolve_llm(args):
+    """Build the chat model from --llm dotted path or --openai-model."""
+    if args.llm:
+        module_path, _, attr = args.llm.partition(":")
+        if not module_path or not attr:
+            raise SystemExit("--llm must be 'module.path:callable' (a zero-arg factory)")
+        factory = getattr(importlib.import_module(module_path), attr)
+        return factory()
+    if args.openai_model:
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError:
+            raise SystemExit("--openai-model needs 'pip install langchain-openai'")
+        return ChatOpenAI(model=args.openai_model, temperature=args.temperature)
+    raise SystemExit("grow needs a model: pass --llm module:factory or --openai-model NAME")
+
+
+def _cmd_grow(args) -> int:
+    bank = Bank.load(args.bank)
+    targets = {f: getattr(args, f) for f in FORMAT_KEYS if getattr(args, f) is not None}
+    material = None
+    if args.material_file:
+        material = open(args.material_file).read()
+
+    llm = _resolve_llm(args)
+    before = len(bank)
+    new = bank.grow(llm, targets=targets or None, material=material,
+                    batch_size=args.batch, coverage=args.coverage or None)
+    print(f"Generated {len(new)} new questions ({dict(Counter(q['type'] for q in new))}).")
+    if args.dry_run:
+        print(f"--dry-run: not writing. Bank would grow {before} -> {before + len(new)}.")
+        for q in new[:3]:
+            print(f"  [{q['type']}/{q['difficulty']}] {q['prompt'][:90]}")
+        return 0
+    bank.save(args.bank)
+    print(f"Wrote {args.bank}. Bank now {len(bank)} (was {before}).")
+    return 0
+
+
+def _cmd_sample(args) -> int:
+    bank = Bank.load(args.bank)
+    rng = random.Random(args.seed) if args.seed is not None else None
+    test = bank.sample(rng=rng)
+    if args.json:
+        json.dump(test, sys.stdout, indent=2, ensure_ascii=False)
+        print()
+        return 0
+    counts = Counter(q.get("type", "mc") for q in test)
+    print(f"Sampled {len(test)} questions: {dict(counts)}")
+    for i, q in enumerate(test, 1):
+        print(f"  {i:2d}. [{q.get('type')}/{q.get('difficulty')}] {q.get('prompt', '')[:90]}")
+    return 0
+
+
+def _cmd_stats(args) -> int:
+    bank = Bank.load(args.bank)
+    print(f"Bank: {args.bank}")
+    print(f"  total questions : {len(bank)}")
+    print(f"  by format       : {bank.counts_by_type()}")
+    print(f"  by difficulty   : {bank.counts_by_difficulty()}")
+    if bank.material:
+        print(f"  material        : {len(bank.material)} chars")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="quizforge",
+                                description="Generate, sample, and grade mixed-format question banks.")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    g = sub.add_parser("grow", help="generate the shortfall to reach per-format targets")
+    g.add_argument("bank", help="path to the bank YAML file")
+    g.add_argument("--material-file", help="text file to ground generation (overrides bank 'material:')")
+    g.add_argument("--batch", type=int, default=8, help="questions per LLM call (default 8)")
+    g.add_argument("--coverage", default=None, help="coverage steering hint for the generator")
+    g.add_argument("--dry-run", action="store_true", help="generate and summarize, but don't write")
+    g.add_argument("--llm", help="dotted path 'module:callable' to a zero-arg model factory")
+    g.add_argument("--openai-model", help="convenience: build ChatOpenAI with this model name")
+    g.add_argument("--temperature", type=float, default=0.4, help="temperature for --openai-model")
+    for f in FORMAT_KEYS:
+        g.add_argument(f"--{f.replace('_', '-')}", dest=f, type=int, default=None,
+                       help=f"target TOTAL {f} questions (default {DEFAULT_TARGETS[f]})")
+    g.set_defaults(func=_cmd_grow)
+
+    s = sub.add_parser("sample", help="draw one mixed-format test from the bank")
+    s.add_argument("bank")
+    s.add_argument("--seed", type=int, default=None, help="rng seed for a reproducible draw")
+    s.add_argument("--json", action="store_true", help="emit the sampled questions as JSON")
+    s.set_defaults(func=_cmd_sample)
+
+    st = sub.add_parser("stats", help="show bank size and format/difficulty mix")
+    st.add_argument("bank")
+    st.set_defaults(func=_cmd_stats)
+    return p
+
+
+def main(argv: Optional[list] = None) -> int:
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    args = build_parser().parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

quizforge/generate.py

@@ -0,0 +1,193 @@
+"""Generation — grow a question bank from source material with an injected LLM.
+
+``generate_bank`` drafts questions strictly from the material you provide,
+validates each one, dedupes against what's already in the bank (and within the
+run), assigns sequential ids, and returns the NEW questions as plain dicts. It
+never writes files and never duplicates an existing prompt, so it's safe to
+re-run to "top up" a bank to target sizes.
+"""
+
+import logging
+from collections import Counter
+from typing import List, Optional
+
+from .llm import structured_output
+from .schemas import DIFFICULTIES, FORMATS
+from .text import normalize
+
+logger = logging.getLogger("quizforge")
+
+# Default TOTAL bank size per format — comfortably deep for a 20-question test
+# (default blueprint draws mc8/fill4/match2/short4/freetext2) so unseen
+# questions last across many retakes.
+DEFAULT_TARGETS = {"mc": 40, "fill_blank": 20, "match": 12, "short": 16, "freetext": 12}
+DEFAULT_BATCH = 8
+DEFAULT_DIFF_SPLIT = {"easy": 0.30, "medium": 0.45, "hard": 0.25}
+
+DEFAULT_SYSTEM = (
+    "You are an expert quiz-content author. Write questions STRICTLY grounded in the provided "
+    "material — do not invent facts beyond it. Questions must be accurate, unambiguous, and test "
+    "real understanding, not trivia. For multiple choice, exactly one option is correct and the "
+    "distractors are plausible. Vary difficulty as requested. Return strict JSON for the "
+    "requested schema."
+)
+
+# Domain-neutral default. Callers with a specific emphasis (e.g. attack-scenario
+# coverage for security training) pass their own ``coverage`` string.
+DEFAULT_COVERAGE = (
+    "Cover the breadth of the material. Frame at least some questions as realistic applied "
+    "scenarios rather than abstract recall."
+)
+
+
+def _diff_counts(n: int, split: dict) -> dict:
+    """Split a batch of n into easy/medium/hard per ``split`` (sums to n)."""
+    easy = round(n * split.get("easy", 0))
+    hard = round(n * split.get("hard", 0))
+    medium = max(0, n - easy - hard)
+    return {"easy": easy, "medium": medium, "hard": hard}
+
+
+def _valid_difficulty(d: str) -> str:
+    d = (d or "").strip().lower()
+    return d if d in DIFFICULTIES else "medium"
+
+
+def _gen_batch(llm, schema, fmt_desc, material, n, existing_prompts, *,
+               system, coverage, diff_split):
+    counts = _diff_counts(n, diff_split)
+    avoid = "\n".join(f"  - {p}" for p in list(existing_prompts)[-40:]) or "  (none yet)"
+    coverage_line = f"COVERAGE: {coverage}\n" if coverage else ""
+    human = (
+        f"{material}\n\n"
+        f"Write exactly {n} {fmt_desc}.\n"
+        f"Difficulty mix: {counts['easy']} easy, {counts['medium']} medium, {counts['hard']} hard "
+        f"(set each question's difficulty field accordingly).\n"
+        f"{coverage_line}"
+        "Ground every fact in the material above; do not invent details.\n"
+        f"Do NOT duplicate or lightly reword any of these existing questions:\n{avoid}\n"
+    )
+    chain = structured_output(llm, schema)
+    batch = chain.invoke([("system", system), ("human", human)])
+    return batch.questions
+
+
+def _validate(qtype: str, q, seen_norms: set) -> Optional[dict]:
+    """Coerce a generated question to a clean dict, or drop it (return None)."""
+    prompt = (getattr(q, "prompt", "") or "").strip()
+    if not prompt:
+        return None
+    norm = normalize(prompt)
+    if not norm or norm in seen_norms:
+        return None
+
+    out = {"type": qtype, "difficulty": _valid_difficulty(q.difficulty), "prompt": prompt}
+    if qtype == "mc":
+        choices = [c.strip() for c in (q.choices or []) if c.strip()]
+        if len(choices) < 3 or not (0 <= q.answer_idx < len(choices)) or not q.explanation.strip():
+            return None
+        out.update(choices=choices, answer_idx=q.answer_idx, explanation=q.explanation.strip())
+    elif qtype == "fill_blank":
+        accepted = [a.strip() for a in (q.accepted_answers or []) if a.strip()]
+        if not accepted:
+            return None
+        out.update(accepted_answers=accepted, explanation=(q.explanation or "").strip())
+    elif qtype == "match":
+        pairs = [{"left": p.left.strip(), "right": p.right.strip()}
+                 for p in (q.pairs or []) if p.left.strip() and p.right.strip()]
+        rights = [p["right"].lower() for p in pairs]
+        if not (2 <= len(pairs) <= 6) or len(set(rights)) != len(rights):  # distinct rights
+            return None
+        out.update(pairs=pairs, explanation=(q.explanation or "").strip())
+    else:  # short / freetext
+        rubric = [r.strip() for r in (q.rubric or []) if r.strip()]
+        if not q.model_answer.strip() or not rubric:
+            return None
+        out.update(model_answer=q.model_answer.strip(), rubric=rubric)
+
+    seen_norms.add(norm)
+    return out
+
+
+def _next_id_start(existing: List[dict]) -> int:
+    """Highest q<N> id in the existing bank, plus one (1 if none)."""
+    max_idx = 0
+    for q in existing or []:
+        qid = str(q.get("id", ""))
+        if qid.startswith("q") and qid[1:].isdigit():
+            max_idx = max(max_idx, int(qid[1:]))
+    return max_idx + 1
+
+
+def generate_bank(material: str, llm, *, targets: Optional[dict] = None,
+                  existing: Optional[List[dict]] = None, batch_size: int = DEFAULT_BATCH,
+                  diff_split: Optional[dict] = None, system: str = DEFAULT_SYSTEM,
+                  coverage: str = DEFAULT_COVERAGE, max_batches_per_format: int = 6,
+                  id_prefix: str = "q") -> List[dict]:
+    """Generate the shortfall needed to bring a bank up to ``targets``.
+
+    Args:
+        material: the source text to ground questions in.
+        llm: any LangChain-style chat model (sync ``with_structured_output``).
+        targets: desired TOTAL count per format (defaults to ``DEFAULT_TARGETS``).
+        existing: the current bank (counted by type; prompts are not reused).
+        batch_size: questions requested per LLM call.
+        diff_split: easy/medium/hard proportions per batch.
+        system / coverage: prompt steering (override ``coverage`` for a domain).
+        max_batches_per_format: cap on retries when validation rejects items.
+        id_prefix: id scheme; ids continue after the highest existing ``<prefix><N>``.
+
+    Returns:
+        The NEW questions as dicts (with ``id``/``type``/``difficulty`` + fields).
+        Does not mutate ``existing`` and does not include it in the result.
+    """
+    targets = {**DEFAULT_TARGETS, **(targets or {})}
+    diff_split = diff_split or DEFAULT_DIFF_SPLIT
+    existing = existing or []
+
+    existing_by_type: dict = {}
+    seen_norms: set = set()
+    for q in existing:
+        existing_by_type.setdefault(q.get("type", "mc"), []).append(q)
+        seen_norms.add(normalize(q.get("prompt", "")))
+
+    all_new: List[dict] = []
+    for fmt, target in targets.items():
+        if fmt not in FORMATS:
+            logger.warning("Unknown format %r in targets — skipping", fmt)
+            continue
+        have = len(existing_by_type.get(fmt, []))
+        need = max(0, target - have)
+        if need == 0:
+            continue
+        schema, fmt_desc = FORMATS[fmt]
+        prompts_seen = {q["prompt"] for q in existing if q.get("type", "mc") == fmt}
+        made = batches = 0
+        while made < need and batches < max_batches_per_format:
+            batches += 1
+            batch_n = min(batch_size, need - made)
+            try:
+                raw = _gen_batch(llm, schema, fmt_desc, material, batch_n, prompts_seen,
+                                 system=system, coverage=coverage, diff_split=diff_split)
+            except Exception as exc:  # noqa: BLE001 — skip a failed batch, keep going
+                logger.warning("%s batch failed (%s): %s", fmt, type(exc).__name__, str(exc)[:160])
+                continue
+            for q in raw:
+                v = _validate(fmt, q, seen_norms)
+                if v:
+                    all_new.append(v)
+                    prompts_seen.add(v["prompt"])
+                    made += 1
+                    if made >= need:
+                        break
+        logger.info("%-11s have %2d / target %2d -> added %2d", fmt, have, target, made)
+
+    # Assign sequential ids continuing after the existing bank (id first).
+    start = _next_id_start(existing)
+    all_new = [{"id": f"{id_prefix}{i}", **q} for i, q in enumerate(all_new, start=start)]
+
+    if all_new:
+        logger.info("Generated %d new questions: %s | difficulty %s", len(all_new),
+                    dict(Counter(q["type"] for q in all_new)),
+                    dict(Counter(q["difficulty"] for q in all_new)))
+    return all_new

quizforge/grade.py

@@ -0,0 +1,119 @@
+"""Grading — deterministic where we can, LLM where we must.
+
+Multiple-choice is graded by the caller (it's a trivial index compare).
+Fill-in-the-blank and match-the-following are graded deterministically here
+(no LLM, fast and free). Open-ended answers are scored 0..1 with feedback by an
+injected chat model against the question's model answer + rubric.
+"""
+
+import logging
+from typing import List, Optional
+
+from pydantic import BaseModel, Field
+
+from .llm import structured_output
+from .text import normalize
+
+logger = logging.getLogger("quizforge")
+
+
+def grade_fill_blank(question: dict, user_answer: str) -> dict:
+    """Deterministic grade for a fill-in-the-blank against accepted_answers.
+
+    Binary credit: 1.0 if the normalized answer matches any accepted answer.
+    """
+    accepted = question.get("accepted_answers") or []
+    ua = normalize(user_answer)
+    correct = bool(ua) and ua in {normalize(a) for a in accepted}
+    return {"score": 1.0 if correct else 0.0, "correct": correct, "accepted": accepted}
+
+
+def grade_match(question: dict, selections: dict) -> dict:
+    """Deterministic grade for match-the-following with per-pair partial credit.
+
+    ``selections`` maps the stringified left-item index -> the right-side label
+    chosen. Score = fraction of rows matched correctly.
+    """
+    pairs = question.get("pairs") or []
+    total = len(pairs)
+    if not total:
+        return {"score": 0.0, "correct_count": 0, "total": 0, "rows": []}
+    rows = []
+    correct_count = 0
+    for i, pair in enumerate(pairs):
+        chosen = selections.get(str(i), "")
+        is_ok = normalize(chosen) == normalize(pair.get("right", ""))
+        if is_ok:
+            correct_count += 1
+        rows.append({
+            "left": pair.get("left", ""),
+            "right": pair.get("right", ""),
+            "chosen": chosen,
+            "correct": is_ok,
+        })
+    return {"score": correct_count / total, "correct_count": correct_count,
+            "total": total, "rows": rows}
+
+
+class QuizGrade(BaseModel):
+    """The model's read on an open-ended answer."""
+
+    score: float = Field(description="Credit awarded, 0.0 to 1.0. 1.0 = covers the key points "
+                         "correctly; ~0.5 = partially correct or missing a key idea; 0.0 = wrong, "
+                         "empty, or just restates the question.")
+    verdict: str = Field(description="One of: 'correct', 'partial', 'incorrect'")
+    feedback: str = Field(description="2-3 sentences, encouraging coach tone. Say what was right, "
+                          "then the single most important thing to add or fix.")
+    covered: List[str] = Field(description="Key points the answer got right (short phrases). Empty if none.")
+    missed: List[str] = Field(description="Key points the answer missed or got wrong (short phrases). Empty if none.")
+
+
+DEFAULT_GRADE_SYSTEM = (
+    "You are a training assessor grading a learner's open-ended quiz answer. Grade on "
+    "CONCEPTS, not phrasing or grammar — credit the learner when they demonstrate the right "
+    "understanding in their own words. Be fair but rigorous: award partial credit when an "
+    "answer is on the right track but misses a key point, and award 0 when it is wrong, empty, "
+    "evasive ('I don't know'), or merely restates the question. Do not be fooled by "
+    "confident-sounding but incorrect answers. Return strict JSON for the QuizGrade schema."
+)
+
+
+def _open_prompt(question: dict, user_answer: str) -> str:
+    parts = [
+        f"QUESTION:\n{question['prompt']}",
+        "",
+        f"MODEL ANSWER (what a strong response covers):\n"
+        f"{(question.get('model_answer') or '').strip() or '(none provided)'}",
+    ]
+    rubric = question.get("rubric") or []
+    if rubric:
+        parts += ["", "RUBRIC — key points to look for:"]
+        parts += [f"  - {point}" for point in rubric]
+    parts += ["", f"LEARNER'S ANSWER:\n{(user_answer or '').strip()}",
+              "", "Grade the learner's answer. score is fractional 0..1."]
+    return "\n".join(parts)
+
+
+def grade_open_answer(question: dict, user_answer: str, llm,
+                      system: str = DEFAULT_GRADE_SYSTEM) -> Optional[QuizGrade]:
+    """Score an open-ended answer 0..1 with feedback using the injected ``llm``.
+
+    Returns a :class:`QuizGrade`, or ``None`` if automated grading was
+    unavailable (callers should exclude the question from the attempt's max
+    score rather than penalize the learner for an outage).
+    """
+    if not (user_answer or "").strip():
+        return QuizGrade(score=0.0, verdict="incorrect", feedback="No answer was provided.",
+                         covered=[], missed=list(question.get("rubric") or []))
+    try:
+        chain = structured_output(llm, QuizGrade)
+        grade = chain.invoke([
+            ("system", system),
+            ("human", _open_prompt(question, user_answer)),
+        ])
+    except Exception as exc:  # noqa: BLE001 — degrade gracefully, never crash the quiz
+        logger.warning("Open-answer grading failed for %s: %s: %s",
+                       question.get("id", "?"), type(exc).__name__, str(exc)[:200])
+        return None
+    grade.score = max(0.0, min(1.0, float(grade.score)))
+    return grade

quizforge/integrity.py

@@ -0,0 +1,123 @@
+"""Integrity signals — flag attempts that are too fast to be genuine.
+
+A deep, unseen-first bank (see :mod:`quizforge.sample`) already makes
+answer-sharing hard. This adds a cheap, deterministic backstop: an attempt that
+*passed* in less time than it physically takes to read and answer the questions
+is suspicious — it points at a leaked answer key, a shared screenshot, or
+automation, not knowledge.
+
+This is intentionally a dumb arithmetic heuristic, not an LLM call: "is 40s
+plausible for 20 questions including two written answers" is a timing question,
+and an LLM adds nothing to it. The per-format floors and thresholds are tunable
+so a caller can dial sensitivity to their own population.
+"""
+
+from typing import Iterable, List, Optional
+
+from pydantic import BaseModel, Field
+
+# Minimum *realistic* seconds to genuinely read + answer one question of each
+# format — not an absolute physical floor, but the point below which engagement
+# is implausible. Open formats dominate because a passing written answer takes
+# real time to compose. Deliberately generous to keep false positives low.
+DEFAULT_MIN_SECONDS_PER_TYPE = {
+    "mc": 5.0,
+    "fill_blank": 7.0,
+    "match": 10.0,
+    "short": 20.0,
+    "freetext": 40.0,
+}
+# Seconds assumed for a format not in the table (unknown / custom).
+DEFAULT_FALLBACK_SECONDS = 6.0
+
+# Default wall-clock budget for a single timed attempt (30 minutes). A limit is
+# the opposite end of the timing spectrum from :func:`assess_speed`: too *slow*
+# rather than too *fast*. Enforcement (a countdown that auto-submits) is the
+# caller's UI concern; this module just owns the policy value and the check.
+DEFAULT_TIME_LIMIT_SECONDS = 1800
+
+
+def within_time_limit(elapsed_seconds: int,
+                      limit_seconds: int = DEFAULT_TIME_LIMIT_SECONDS) -> bool:
+    """Whether a timed attempt finished inside its allotted budget.
+
+    Untimed attempts (``elapsed_seconds <= 0``, e.g. legacy rows or a disabled
+    timer) are treated as within limit — absence of timing is not a violation.
+    A non-positive ``limit_seconds`` means "no limit" and always returns True.
+    """
+    if elapsed_seconds <= 0 or limit_seconds <= 0:
+        return True
+    return elapsed_seconds <= limit_seconds
+
+
+class IntegrityFlag(BaseModel):
+    """The verdict on a single attempt's timing."""
+
+    suspicious: bool = Field(description="True if the pass was implausibly fast.")
+    severity: str = Field(description="One of: 'none', 'low', 'high'.")
+    elapsed_seconds: int = Field(description="Seconds the learner actually took.")
+    expected_seconds: float = Field(description="Realistic minimum for these questions.")
+    speed_ratio: float = Field(description="elapsed / expected; <1 is faster than realistic.")
+    reasons: List[str] = Field(default_factory=list, description="Human-readable explanation.")
+
+
+def expected_min_seconds(question_types: Iterable[str], per_type: Optional[dict] = None,
+                         fallback: float = DEFAULT_FALLBACK_SECONDS) -> float:
+    """Sum the per-format realistic-minimum seconds for a set of question types."""
+    table = {**DEFAULT_MIN_SECONDS_PER_TYPE, **(per_type or {})}
+    return sum(table.get(t, fallback) for t in question_types)
+
+
+def assess_speed(*, elapsed_seconds: int, question_types: Iterable[str], passed: bool,
+                 per_type: Optional[dict] = None, fallback: float = DEFAULT_FALLBACK_SECONDS,
+                 low_ratio: float = 0.5, high_ratio: float = 0.25) -> IntegrityFlag:
+    """Flag a *passing* attempt completed implausibly fast.
+
+    Only passes are assessed — a fast *fail* is someone giving up, not cheating.
+    Attempts with no recorded timing (``elapsed_seconds <= 0``, e.g. legacy rows)
+    are never flagged: absence of a signal is not evidence.
+
+    Args:
+        elapsed_seconds: wall-clock seconds the attempt took.
+        question_types: the format of each question in the attempt (e.g.
+            ``["mc", "mc", "freetext", ...]``).
+        passed: whether the attempt passed (only passes are flagged).
+        per_type: override realistic-minimum seconds per format.
+        low_ratio / high_ratio: speed_ratio thresholds for 'low' / 'high'
+            severity (lower ratio = faster = more suspicious).
+
+    Returns:
+        An :class:`IntegrityFlag`. ``severity`` is 'high' when
+        ``speed_ratio < high_ratio``, 'low' when ``< low_ratio``, else 'none'.
+    """
+    types = list(question_types)
+    expected = expected_min_seconds(types, per_type, fallback)
+
+    if elapsed_seconds <= 0:
+        return IntegrityFlag(suspicious=False, severity="none", elapsed_seconds=int(elapsed_seconds),
+                             expected_seconds=round(expected, 1), speed_ratio=0.0,
+                             reasons=["No timing was recorded for this attempt."])
+    if not passed:
+        return IntegrityFlag(suspicious=False, severity="none", elapsed_seconds=int(elapsed_seconds),
+                             expected_seconds=round(expected, 1),
+                             speed_ratio=round(elapsed_seconds / expected, 2) if expected else 0.0,
+                             reasons=["Attempt did not pass — timing not assessed."])
+
+    ratio = (elapsed_seconds / expected) if expected > 0 else 1.0
+    if ratio < high_ratio:
+        severity = "high"
+    elif ratio < low_ratio:
+        severity = "low"
+    else:
+        severity = "none"
+
+    reasons: List[str] = []
+    if severity != "none":
+        reasons.append(
+            f"Passed in {int(elapsed_seconds)}s — {round(ratio * 100)}% of the "
+            f"~{round(expected)}s it realistically takes to read and answer "
+            f"{len(types)} questions."
+        )
+    return IntegrityFlag(suspicious=severity != "none", severity=severity,
+                         elapsed_seconds=int(elapsed_seconds), expected_seconds=round(expected, 1),
+                         speed_ratio=round(ratio, 2), reasons=reasons)

quizforge/llm.py

@@ -0,0 +1,42 @@
+"""Provider-neutral structured-output helper.
+
+quizforge never imports a specific LLM SDK. You pass in any object that quacks
+like a LangChain chat model — i.e. it exposes ``with_structured_output(schema)``
+returning something with an ``.invoke(messages)`` method, where ``messages`` is a
+list of ``(role, content)`` tuples. That covers ``langchain-openai``,
+``langchain-anthropic``, community wrappers, and your own shim.
+"""
+
+import logging
+from typing import Any
+
+logger = logging.getLogger("quizforge")
+
+
+class _RetryingStructuredChain:
+    """Binds a schema to the model and retries invoke on transient failures."""
+
+    def __init__(self, llm: Any, schema: type, max_retries: int):
+        self._bound = llm.with_structured_output(schema)
+        self._max_retries = max_retries
+
+    def invoke(self, messages):
+        last_exc = None
+        for attempt in range(self._max_retries + 1):
+            try:
+                return self._bound.invoke(messages)
+            except Exception as exc:  # noqa: BLE001 — surface the last error after retries
+                last_exc = exc
+                if attempt < self._max_retries:
+                    logger.warning("structured_output attempt %d failed (%s); retrying",
+                                   attempt + 1, type(exc).__name__)
+        raise last_exc
+
+
+def structured_output(llm: Any, schema: type, max_retries: int = 1):
+    """Return a chain whose ``.invoke(messages)`` yields a validated ``schema``.
+
+    Uses the model's native structured-output binding and retries once by
+    default so a single flaky response doesn't fail the whole call.
+    """
+    return _RetryingStructuredChain(llm, schema, max_retries)

quizforge/sample.py

@@ -0,0 +1,73 @@
+"""Sampling — draw a fresh, mixed-format test from a deep bank.
+
+A deep bank (far more questions than any one test shows) plus unseen-first
+sampling is what makes two learners rarely see the same test, which defeats
+answer-sharing. No LLM here — pure, deterministic given an rng.
+"""
+
+import random
+from collections import defaultdict
+from typing import Iterable, List, Optional
+
+# How many of each format a single test draws. Sums to 20 by default.
+DEFAULT_BLUEPRINT = {"mc": 8, "fill_blank": 4, "match": 2, "short": 4, "freetext": 2}
+DIFFICULTY_ORDER = ("easy", "medium", "hard")
+
+
+def pick_spread(pool: List[dict], want: int, seen_ids: Iterable[str],
+                rng: Optional[random.Random] = None) -> List[dict]:
+    """Pick ``want`` questions from one format's pool, unseen-first + difficulty-spread.
+
+    Unseen questions are exhausted before reusing seen ones; within that order we
+    round-robin easy/medium/hard so a draw doesn't come back all-hard or all-easy.
+    """
+    rng = rng or random
+    if want <= 0 or not pool:
+        return []
+    seen = set(seen_ids)
+    unseen = [q for q in pool if q.get("id") not in seen]
+    reused = [q for q in pool if q.get("id") in seen]
+    rng.shuffle(unseen)
+    rng.shuffle(reused)
+    ordered = unseen + reused  # exhaust unseen before recycling
+
+    buckets: dict = defaultdict(list)
+    for q in ordered:
+        buckets[q.get("difficulty", "medium")].append(q)
+
+    target = min(want, len(ordered))
+    picked: List[dict] = []
+    while len(picked) < target:
+        progressed = False
+        for level in DIFFICULTY_ORDER:
+            if buckets[level]:
+                picked.append(buckets[level].pop(0))
+                progressed = True
+                if len(picked) >= target:
+                    break
+        if not progressed:  # difficulties outside the canonical order — drain them
+            leftovers = [q for qs in buckets.values() for q in qs]
+            picked.extend(leftovers[: target - len(picked)])
+            break
+    return picked
+
+
+def sample_test(questions: List[dict], blueprint: Optional[dict] = None,
+                seen_ids: Iterable[str] = (), rng: Optional[random.Random] = None) -> List[dict]:
+    """Draw a mixed-format test per ``blueprint``, unseen-first within each format.
+
+    Falls short of the blueprint only when the bank lacks enough of a format; the
+    test still assembles with whatever it can. Final order is shuffled so formats
+    interleave instead of arriving grouped by type.
+    """
+    rng = rng or random
+    blueprint = blueprint or DEFAULT_BLUEPRINT
+    by_type: dict = defaultdict(list)
+    for q in questions:
+        by_type[q.get("type", "mc")].append(q)
+
+    picked: List[dict] = []
+    for qtype, want in blueprint.items():
+        picked.extend(pick_spread(by_type.get(qtype, []), want, seen_ids, rng=rng))
+    rng.shuffle(picked)
+    return picked

quizforge/schemas.py

@@ -0,0 +1,85 @@
+"""Generation schemas — the per-format shapes the LLM must return.
+
+These describe what a freshly *generated* question looks like coming back from
+the model. After validation, questions are stored as plain dicts (YAML-friendly,
+template-friendly) with an added ``id`` and ``type``; see ``generate`` and the
+format-field reference in the README.
+"""
+
+from typing import List
+
+from pydantic import BaseModel, Field
+
+# The five question formats and the difficulty levels the kernel understands.
+FORMAT_KEYS = ("mc", "fill_blank", "match", "short", "freetext")
+DIFFICULTIES = ("easy", "medium", "hard")
+
+
+class GenMC(BaseModel):
+    """A generated multiple-choice question."""
+
+    prompt: str
+    choices: List[str] = Field(description="3-4 options; exactly one correct, others plausible-but-wrong")
+    answer_idx: int = Field(description="0-based index of the correct choice")
+    explanation: str = Field(description="Why the answer is right — a teaching sentence")
+    difficulty: str = Field(description="easy | medium | hard")
+
+
+class GenFill(BaseModel):
+    """A generated fill-in-the-blank question."""
+
+    prompt: str = Field(description="A sentence with a ______ blank where the answer belongs")
+    accepted_answers: List[str] = Field(description="Every acceptable spelling/synonym/abbreviation of the answer")
+    explanation: str
+    difficulty: str
+
+
+class GenPair(BaseModel):
+    left: str
+    right: str
+
+
+class GenMatch(BaseModel):
+    """A generated match-the-following question."""
+
+    prompt: str
+    pairs: List[GenPair] = Field(description="3-4 unambiguous one-to-one pairs; distinct right-side labels")
+    explanation: str
+    difficulty: str
+
+
+class GenOpen(BaseModel):
+    """A generated open-ended (short / free-response) question."""
+
+    prompt: str
+    model_answer: str = Field(description="A strong, concise reference answer")
+    rubric: List[str] = Field(description="3-5 key points a correct answer must cover")
+    difficulty: str
+
+
+class MCBatch(BaseModel):
+    questions: List[GenMC]
+
+
+class FillBatch(BaseModel):
+    questions: List[GenFill]
+
+
+class MatchBatch(BaseModel):
+    questions: List[GenMatch]
+
+
+class OpenBatch(BaseModel):
+    questions: List[GenOpen]
+
+
+# Per-format: the batch schema the model fills, and a human-readable description
+# spliced into the generation prompt. ``short`` and ``freetext`` share the open
+# schema but differ in framing (one-liners vs. walk-me-through scenarios).
+FORMATS = {
+    "mc": (MCBatch, "multiple-choice questions with one best answer and 3 plausible distractors"),
+    "fill_blank": (FillBatch, "fill-in-the-blank questions (a sentence with a ______ blank)"),
+    "match": (MatchBatch, "match-the-following questions with 3-4 unambiguous pairs"),
+    "short": (OpenBatch, "short-answer questions answerable in 1-2 sentences"),
+    "freetext": (OpenBatch, "scenario / free-response questions ('walk me through how you'd…')"),
+}

quizforge/text.py

@@ -0,0 +1,11 @@
+"""Shared text normalization used by the deterministic graders and the
+generator's dedup pass."""
+
+
+def normalize(text: str) -> str:
+    """Casefold + collapse whitespace + strip surrounding punctuation.
+
+    So 'ICA.', ' ica ', and 'ICA' all compare equal without an LLM call.
+    """
+    cleaned = " ".join((text or "").lower().split())
+    return cleaned.strip(" \t\n.,;:!?\"'`()[]")

quizforge-0.2.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: quizforge
+Version: 0.2.0
+Summary: Generate a deep, mixed-format question bank from source material and grade it — deterministic where it can, LLM where it must. Bring your own chat model.
+Project-URL: Homepage, https://github.com/vinayvobbili/quizforge
+Project-URL: Source, https://github.com/vinayvobbili/quizforge
+Author: Vinay Vobbilichetty
+License: MIT
+License-File: LICENSE
+Keywords: assessment,education,grading,llm,question-bank,quiz,training
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Education :: Testing
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2
+Requires-Dist: pyyaml>=6
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: langchain-openai>=0.1; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# quizforge
+
+Generate a deep, **mixed-format** question bank from any source material, then grade it — **deterministic where it can, LLM where it must**. Bring your own chat model.
+
+quizforge is the engine behind a training/readiness feature: it drafts far more questions than any single test shows (multiple choice, fill-in-the-blank, match-the-following, short answer, and free-response scenarios), samples a fresh shuffled test on each attempt — so two learners rarely see the same one — and grades every format. MC/fill/match are graded instantly with no model call; open-ended answers are scored 0–1 with coaching feedback by an LLM you provide.
+
+- **Model-agnostic** — pass any LangChain-style chat model (`with_structured_output`). No SDK is bundled.
+- **Deep bank, anti-sharing sampling** — unseen-first, difficulty-spread draws per a configurable blueprint.
+- **Cheap grading** — only open-ended answers cost a model call; everything else is local and free.
+- **Plain dicts in, plain dicts out** — YAML/JSON-friendly, easy to store and template.
+
+## Install
+
+```bash
+pip install quizforge
+```
+
+Bring a chat model from whichever provider you use, e.g.:
+
+```bash
+pip install langchain-openai   # or langchain-anthropic, etc.
+```
+
+## Quickstart
+
+### Generate a bank
+
+```python
+from quizforge import generate_bank
+from langchain_openai import ChatOpenAI
+
+llm = ChatOpenAI(model="gpt-4.1", temperature=0.4)
+
+material = open("citrix_lesson.md").read()
+new_questions = generate_bank(
+    material, llm,
+    targets={"mc": 40, "fill_blank": 20, "match": 12, "short": 16, "freetext": 12},
+    existing=[],                       # pass your current bank to top it up
+    coverage="At least half should be applied incident-response scenarios.",
+)
+# -> list of dicts with id/type/difficulty + per-format fields. Store as you like.
+```
+
+`generate_bank` only produces the *shortfall* to reach `targets`, validates each
+question, and never duplicates an existing prompt — safe to re-run to grow a bank.
+
+### Sample a test
+
+```python
+from quizforge import sample_test, DEFAULT_BLUEPRINT
+
+test = sample_test(bank, blueprint=DEFAULT_BLUEPRINT, seen_ids=already_seen)
+# DEFAULT_BLUEPRINT draws mc8 / fill4 / match2 / short4 / freetext2 = 20, shuffled.
+```
+
+### Grade
+
+```python
+from quizforge import grade_fill_blank, grade_match, grade_open_answer
+
+grade_fill_blank(q, "ICA")                 # {"score": 1.0, "correct": True, ...}
+grade_match(q, {"0": "RDP", "1": "ICA"})   # per-pair partial credit
+grade_open_answer(q, learner_text, llm)    # QuizGrade(score, verdict, feedback, ...) or None
+```
+
+`grade_open_answer` returns `None` if the model was unavailable — exclude that
+question from the attempt's max score rather than penalizing the learner.
+
+## Question shapes
+
+Each question is a dict with `id`, `type`, `difficulty`, `prompt`, plus:
+
+- `mc` — `choices: [str]`, `answer_idx: int`, `explanation: str`
+- `fill_blank` — `accepted_answers: [str]`, `explanation: str`
+- `match` — `pairs: [{left, right}]`, `explanation: str`
+- `short` / `freetext` — `model_answer: str`, `rubric: [str]`
+
+## License
+
+MIT

quizforge-0.2.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+quizforge/__init__.py,sha256=fgrMRAFDYItRLsSydsFZE2grIpyHnLf5ZfCCkoIGAGU,2666
+quizforge/bank.py,sha256=8IpsET4x4Ulodxam_sGv4Ot65ECLwGsP2VqzAFQs-LM,3612
+quizforge/certificate.py,sha256=iOOtXQGpACd1Us76XIXSBST-Z19FHOIWmYMJSCH-iUA,4247
+quizforge/cli.py,sha256=NgC3ciNc8pdD0PdwwoKBoXoAEujbv8ZNdIXiYDiAW8o,5420
+quizforge/generate.py,sha256=UCqEVvbwRFhrXqveXW21H3_qvUUfzDC4WY5txckXEFo,8638
+quizforge/grade.py,sha256=hZ90Nnuqf1u7WPWJG9fHS9d-kLhzIkP5GxSLcIPSpos,5221
+quizforge/integrity.py,sha256=1_DbL9W8jJkKE7ncRs-ddxrsSllaiLVModyXjwmSQQM,5928
+quizforge/llm.py,sha256=Ycd6RT2yCkZy_4GvUsNJKWRrWwDUooBrKuoJ1Dl1Hxg,1684
+quizforge/sample.py,sha256=2qTaGM2mjVO6yzKRstXZrO59ercWuakD5jbet06lKTk,2888
+quizforge/schemas.py,sha256=4zkq9bl-AmiszF3i0r9iRA7N77Gz_a64j53XOP5buJA,2917
+quizforge/text.py,sha256=jzFeT9DleOUhmRZpCFQIoZNIzqxSI1wc6fBJvl6VBNU,387
+quizforge-0.2.0.dist-info/METADATA,sha256=NohUiaIHbU0Bzkv47Bj55X2iBys69ZdnQNbFDBpA1F4,4096
+quizforge-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+quizforge-0.2.0.dist-info/entry_points.txt,sha256=HL6bvElX7W1gotbUwLyKBVtMkDi_tJlkQXvVzbaX6-4,49
+quizforge-0.2.0.dist-info/licenses/LICENSE,sha256=Q7CXTchzC9hqR2Dr-9cRh3bM2kXTgXGwk-dO0rGvQsE,1076
+quizforge-0.2.0.dist-info/RECORD,,

quizforge-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

quizforge-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+quizforge = quizforge.cli:main

quizforge-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vinay Vobbilichetty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.