84 lines
4.0 KiB
Python
84 lines
4.0 KiB
Python
"""Rückwärts-Redundanz-Check (Kernziel Länge minimieren, R11): Satzpaare aus
|
|
VERSCHIEDENEN Kapiteln mit Jaccard ≥0.6 → 2er-Panel entscheidet „redundant vs.
|
|
didaktisch gewollt" (Recap ist keine Dopplung). Befunde behebt der Fix-Knoten
|
|
per Ein-Satz-Refresher + Anker-Link."""
|
|
from . import config, db, engine, llm, panels, textkit
|
|
|
|
|
|
def kandidaten_paare(topic: str) -> list[dict]:
|
|
saetze = []
|
|
for row in db.query(
|
|
"SELECT s.baustein_id bid, s.text, b.ord bord, k.ord kord FROM "
|
|
"sections s JOIN bausteine b ON b.id=s.baustein_id "
|
|
"JOIN kapitel k ON k.id=b.kapitel_id WHERE b.topic=? AND s.text!=''",
|
|
topic):
|
|
for satz in textkit.satz_split(row["text"]):
|
|
toks = textkit.stamm_tokens(satz)
|
|
if len(toks) >= config.REDUNDANZ_SATZ_MIN_TOKEN:
|
|
saetze.append({"satz": satz, "toks": toks, "bid": row["bid"],
|
|
"pos": (row["kord"], row["bord"])})
|
|
def shingles(satz: str) -> set:
|
|
woerter = textkit.norm(satz).split()
|
|
n = config.REDUNDANZ_SHINGLE
|
|
return {" ".join(woerter[i:i + n]) for i in range(len(woerter) - n + 1)}
|
|
|
|
paare = []
|
|
for i, a in enumerate(saetze):
|
|
for b in saetze[i + 1:]:
|
|
if a["bid"] == b["bid"]:
|
|
continue # innerhalb einer Section: Sache des Prüfers, nicht hier
|
|
schnitt = len(a["toks"] & b["toks"])
|
|
jaccard_treffer = schnitt and schnitt / len(a["toks"] | b["toks"]) \
|
|
>= config.REDUNDANZ_JACCARD
|
|
# Shingle-Kanal: identische Wort-Folge in längeren Sätzen —
|
|
# Jaccard übersieht sie, wenn der Restsatz verschieden ist
|
|
if jaccard_treffer or (shingles(a["satz"]) & shingles(b["satz"])):
|
|
paare.append({"a": a, "b": b})
|
|
return paare
|
|
|
|
|
|
@engine.worker("redundanz.pruefen")
|
|
async def pruefen(task: dict) -> engine.Ergebnis:
|
|
paare = kandidaten_paare(task["topic"])
|
|
befunde = 0
|
|
for i in range(0, len(paare), config.DEDUP_PAARE_PRO_CALL):
|
|
chunk = paare[i:i + config.DEDUP_PAARE_PRO_CALL]
|
|
liste = "\n\n".join(
|
|
f"PAAR {j + 1}:\nKapitel A: {p['a']['satz']}\nKapitel B: {p['b']['satz']}"
|
|
for j, p in enumerate(chunk))
|
|
|
|
async def ruf(p, liste=liste, n=len(chunk)):
|
|
text = await llm.call(
|
|
run_id=task["run_id"], stufe="guide", knoten="redundanz",
|
|
item=f"{task['item']}:c{i}:p{p}", role="judge", n=n,
|
|
skill_namen=["richter", "deutsch-praezise", "redundanz-urteil"],
|
|
werte={"paare": liste})
|
|
if text is None:
|
|
return None
|
|
return {int(b["paar"]): b.get("urteil", "UNSICHER")
|
|
for b in textkit.bloecke(text, "URTEIL")
|
|
if b.get("paar", "").isdigit()}
|
|
|
|
stimmen = await panels.panel(ruf, config.PRUEF_PANEL)
|
|
for j, p in enumerate(chunk):
|
|
def urteil(s, j=j):
|
|
if s is None or (j + 1) not in s:
|
|
return None
|
|
u = s[j + 1]
|
|
return True if u == "redundant" else (
|
|
False if u == "didaktisch_gewollt" else None)
|
|
if panels.einstimmig(stimmen, config.PRUEF_PANEL, urteil):
|
|
# Der SPÄTERE Baustein trägt den Befund (dort wird verwiesen)
|
|
spaeter = max(p["a"], p["b"], key=lambda x: x["pos"])
|
|
schon = db.one(
|
|
"SELECT id FROM befunde WHERE item=? AND art='redundanz' AND "
|
|
"detail=? AND status IN ('offen','eskaliert','freispruch')",
|
|
f"baustein:{spaeter['bid']}", spaeter["satz"][:400])
|
|
if not schon:
|
|
db.insert("befunde", run_id=task["run_id"], stufe="guide",
|
|
knoten="redundanz", art="redundanz",
|
|
item=f"baustein:{spaeter['bid']}",
|
|
detail=spaeter["satz"][:400], runde=task["runde"])
|
|
befunde += 1
|
|
return engine.Ergebnis(daten={"paare": len(paare), "befunde": befunde})
|