173 lines
7.8 KiB
Python
173 lines
7.8 KiB
Python
"""Ebene 2: Artefakte. Pro Atom 2 Flashcards + 1 Worked Example, generiert in
|
|
Soll-Punkt-Gruppen (Kontext teilen spart Tokens — Lektion 52), verifiziert von einem
|
|
2er-Panel GEGEN DIE ANKER-ZITATE (inline, Lektion 48). Einstimmig ok → verifiziert;
|
|
sonst ein Fix + Re-Verify durch einen Judge; danach verifiziert oder verworfen."""
|
|
|
|
import asyncio
|
|
import logging
|
|
import re
|
|
|
|
import db
|
|
import llm
|
|
from config import ARTEFAKT_CHUNK_ATOME, VERIFY_PANEL
|
|
|
|
log = logging.getLogger("creator2.artefakte")
|
|
|
|
EBENE = "artefakte"
|
|
|
|
# Karten müssen ohne den Quelltext funktionieren (aak Lauf 8: 17 verifizierte
|
|
# Karten fragten „was steht im Beleg"). Eng gefasst, damit Fachwörter nicht
|
|
# matchen: „Belegung" (Aussagenlogik), „Quelle" (Flussnetzwerke), „belegen".
|
|
_QUELLEN_REFERENZ = re.compile(
|
|
r"\bbeleg(e|s)?\b|musterlösung|quelltext|laut (quelle|text|skript)"
|
|
r"|(aus|in) de[rm] (quelle|text|skript)|aufgabenkontext|hausaufgabe"
|
|
r"|präsenzaufgabe|klausur\w*|\baufgabe \d|\bserie \d|\bblatt \d",
|
|
re.IGNORECASE)
|
|
|
|
|
|
def _referenziert_quelle(inhalt: dict) -> bool:
|
|
return _QUELLEN_REFERENZ.search(" ".join(str(v) for v in inhalt.values())) is not None
|
|
|
|
|
|
def _zitate(atom_id: int) -> str:
|
|
rows = db.query("SELECT zitat FROM anker WHERE atom_id=? AND start>=0", (atom_id,))
|
|
return "\n".join(f"> {r['zitat']}" for r in rows) or "(kein Anker)"
|
|
|
|
|
|
def _atom_block(a: dict) -> str:
|
|
return (f"ATOM {a['id']}: {a['titel']} [{a['typ']}]\n"
|
|
f"Definition: {a['definition']}\nBelege:\n{_zitate(a['id'])}")
|
|
|
|
|
|
def _chunks(topic: str, nur_ohne: bool) -> list[list[dict]]:
|
|
"""Atome je Soll-Punkt gruppiert, gestückelt. nur_ohne: nur Atome ohne Artefakte."""
|
|
atome = db.query("SELECT * FROM atome WHERE topic=? AND status NOT IN"
|
|
" ('gemerged','verworfen') ORDER BY soll_id, id", (topic,))
|
|
if nur_ohne:
|
|
# verworfene zählen nicht — sonst kann der Repair nach Verwurf nie
|
|
# nachgenerieren (Lauf 8: 5 Atome blieben dauerhaft ohne Flashcard)
|
|
atome = [a for a in atome if not db.one(
|
|
"SELECT id FROM artefakte WHERE atom_id=? AND status!='verworfen'"
|
|
" LIMIT 1", (a["id"],))]
|
|
gruppen: dict = {}
|
|
for a in atome:
|
|
gruppen.setdefault(a["soll_id"], []).append(a)
|
|
out = []
|
|
for gruppe in gruppen.values():
|
|
out += [gruppe[i:i + ARTEFAKT_CHUNK_ATOME]
|
|
for i in range(0, len(gruppe), ARTEFAKT_CHUNK_ATOME)]
|
|
return out
|
|
|
|
|
|
async def _generieren(ctx: llm.Kontext, chunk: list[dict]) -> None:
|
|
bloecke = "\n\n".join(_atom_block(a) for a in chunk)
|
|
res = await llm.call(ctx, stage="artefakt", template="Artefakt-Generate",
|
|
werte={"atome": bloecke}, role="guide",
|
|
n=len(chunk), item=f"g{chunk[0]['id']}", erwartet=list)
|
|
gueltig = {a["id"] for a in chunk}
|
|
for e in res or []:
|
|
atom_id = e.get("atom")
|
|
typ = str(e.get("typ", "")).strip()
|
|
if atom_id not in gueltig or typ not in ("flashcard", "beispiel"):
|
|
continue
|
|
inhalt = {k: str(e.get(k, "")) for k in ("frage", "antwort", "text")}
|
|
if _referenziert_quelle(inhalt):
|
|
log.info("Artefakt zu Atom %s nicht übernommen: referenziert die Quelle", atom_id)
|
|
continue
|
|
db.insert("artefakte", atom_id=atom_id, typ=typ, inhalt=db.j(inhalt), status="kandidat")
|
|
|
|
|
|
async def _verifizieren(ctx: llm.Kontext, chunk: list[dict]) -> None:
|
|
"""Panel prüft alle Kandidaten des Chunks gegen die Belege. Verwerfen ist
|
|
destruktiv → nur nach Fix + Re-Verify (im Zweifel behalten, Lektion 67)."""
|
|
kandidaten = []
|
|
for a in chunk:
|
|
for k in db.query("SELECT * FROM artefakte WHERE atom_id=? AND status='kandidat'",
|
|
(a["id"],)):
|
|
if _referenziert_quelle(db.uj(k["inhalt"])): # deterministisch, vor dem Panel
|
|
db.update("artefakte", "id", k["id"], status="verworfen")
|
|
else:
|
|
kandidaten.append(k)
|
|
if not kandidaten:
|
|
return
|
|
je_atom = {a["id"]: a for a in chunk}
|
|
liste = "\n\n".join(
|
|
f"ARTEFAKT {k['id']} (Atom {k['atom_id']}, {k['typ']}): {k['inhalt']}\n"
|
|
f"Belege:\n{_zitate(k['atom_id'])}" for k in kandidaten)
|
|
stimmen = await llm.panel(ctx, VERIFY_PANEL, stage="verify", template="Artefakt-Verify",
|
|
werte={"artefakte": liste}, role="judge",
|
|
n=len(kandidaten), item=f"v{chunk[0]['id']}", erwartet=list)
|
|
for k in kandidaten:
|
|
urteile = []
|
|
maengel = []
|
|
for stimme in stimmen:
|
|
for e in stimme:
|
|
if isinstance(e, dict) and e.get("artefakt") == k["id"]:
|
|
urteile.append(bool(e.get("ok")))
|
|
if e.get("mangel"):
|
|
maengel.append(str(e["mangel"]))
|
|
break
|
|
if len(urteile) >= VERIFY_PANEL and all(urteile):
|
|
db.update("artefakte", "id", k["id"], status="verifiziert")
|
|
elif urteile:
|
|
await _fixen(ctx, k, maengel, je_atom.get(k["atom_id"], {}))
|
|
# keine gültige Stimme (Panel-Ausfall) → Kandidat bleibt, nächste Runde prüft
|
|
|
|
|
|
async def _fixen(ctx: llm.Kontext, k: dict, maengel: list[str], atom: dict) -> None:
|
|
res = await llm.call(ctx, stage="artefakt_fix", template="Artefakt-Fix",
|
|
schritt="fix", role="guide", item=f"f{k['id']}",
|
|
werte={"artefakt": k["inhalt"], "typ": k["typ"],
|
|
"maengel": "\n".join(f"- {m}" for m in maengel) or "-",
|
|
"belege": _zitate(k["atom_id"])},
|
|
erwartet=dict)
|
|
if res:
|
|
inhalt = {kk: str(res.get(kk, "")) for kk in ("frage", "antwort", "text")}
|
|
if _referenziert_quelle(inhalt):
|
|
db.update("artefakte", "id", k["id"], status="verworfen")
|
|
return
|
|
db.update("artefakte", "id", k["id"], inhalt=db.j(inhalt))
|
|
urteil = await llm.call(ctx, stage="reverify", template="Artefakt-Verify",
|
|
schritt="verify", role="judge", item=f"rv{k['id']}",
|
|
werte={"artefakte": f"ARTEFAKT {k['id']} (Atom {k['atom_id']},"
|
|
f" {k['typ']}): {db.j(res) if res else k['inhalt']}\n"
|
|
f"Belege:\n{_zitate(k['atom_id'])}"},
|
|
erwartet=list)
|
|
ok = any(isinstance(e, dict) and e.get("artefakt") == k["id"] and e.get("ok")
|
|
for e in urteil or [])
|
|
db.update("artefakte", "id", k["id"], status="verifiziert" if ok else "verworfen")
|
|
|
|
|
|
async def bauen(ctx: llm.Kontext) -> None:
|
|
ctx.ebene = EBENE
|
|
neu = _chunks(ctx.topic, nur_ohne=True)
|
|
await asyncio.gather(*(_generieren(ctx, c) for c in neu))
|
|
alle = _chunks(ctx.topic, nur_ohne=False)
|
|
await asyncio.gather(*(_verifizieren(ctx, c) for c in alle))
|
|
|
|
|
|
def messen(ctx: llm.Kontext) -> list[dict]:
|
|
befunde = []
|
|
atome = db.query("SELECT * FROM atome WHERE topic=? AND status NOT IN"
|
|
" ('gemerged','verworfen')", (ctx.topic,))
|
|
for a in atome:
|
|
karten = db.query("SELECT status FROM artefakte WHERE atom_id=? AND typ='flashcard'",
|
|
(a["id"],))
|
|
if not any(k["status"] == "verifiziert" for k in karten):
|
|
befunde.append({"art": "atom_ohne_flashcard", "item": str(a["id"]),
|
|
"detail": a["titel"]})
|
|
offen = db.query("SELECT id FROM artefakte WHERE atom_id=? AND status='kandidat'",
|
|
(a["id"],))
|
|
for k in offen:
|
|
befunde.append({"art": "artefakt_unentschieden", "item": str(k["id"]),
|
|
"detail": a["titel"]})
|
|
return befunde
|
|
|
|
|
|
async def reparieren(ctx: llm.Kontext, befunde: list[dict]) -> bool:
|
|
ctx.ebene = EBENE
|
|
if not befunde:
|
|
return False
|
|
await bauen(ctx) # idempotent: generiert Fehlendes nach, prüft Offenes
|
|
return True
|