564 lines
27 KiB
Python
564 lines
27 KiB
Python
"""Ebene 3: Struktur. Backward Design: Lernziele aus den Atomen je Soll-Punkt
|
||
(Zuordnung im selben Call — Lektion 52), dann wird Struktur RECHENBAR:
|
||
Baustein-Schnitt = Partition der Ziel-Gruppen ins Größenband, Reihenfolge =
|
||
topologische Sortierung des braucht-Graphen. Zyklen bricht ein Judge an der
|
||
schwächsten Kante (deterministischer Fallback)."""
|
||
|
||
import asyncio
|
||
import logging
|
||
from collections import defaultdict
|
||
|
||
import db
|
||
import llm
|
||
from config import (BAUSTEIN_MAX_ATOME, BAUSTEIN_MIN_ATOME, DURCHGANG,
|
||
KAPITEL_BAUSTEINE, LEVEL_RANG, ZIELE_CHUNK_ATOME)
|
||
|
||
log = logging.getLogger("creator2.struktur")
|
||
|
||
EBENE = "struktur"
|
||
|
||
|
||
def _atome(topic: str) -> list[dict]:
|
||
return db.query("SELECT * FROM atome WHERE topic=? AND status NOT IN"
|
||
" ('gemerged','verworfen') ORDER BY id", (topic,))
|
||
|
||
|
||
def _braucht_kanten(topic: str) -> list[dict]:
|
||
return db.query("SELECT * FROM kanten WHERE topic=? AND art='braucht' AND status='aktiv'",
|
||
(topic,))
|
||
|
||
|
||
# ── Lernziele ─────────────────────────────────────────────────────────────────
|
||
|
||
async def _ziele_bilden(ctx: llm.Kontext) -> None:
|
||
atome = [a for a in _atome(ctx.topic) if not a["ziel_id"]]
|
||
gruppen: dict = defaultdict(list)
|
||
for a in atome:
|
||
gruppen[a["soll_id"]].append(a)
|
||
|
||
async def eine_gruppe(soll_id, gruppe: list[dict]) -> None:
|
||
punkt = db.one("SELECT punkt FROM soll WHERE id=?", (soll_id,)) or {"punkt": ctx.topic}
|
||
rest = gruppe
|
||
for runde in ("1", "2"): # Schlussrunde MUSS alles entscheiden (Lektion 23)
|
||
if not rest:
|
||
return
|
||
chunk = rest[:ZIELE_CHUNK_ATOME]
|
||
liste = "\n".join(f"{a['id']}: {a['titel']} — {a['definition']}" for a in chunk)
|
||
res = await llm.call(ctx, stage="ziele", template="Lernziele",
|
||
werte={"punkt": punkt["punkt"], "atome": liste,
|
||
"pflicht": "Jedes Atom MUSS genau einem Ziel"
|
||
" zugeordnet sein." if runde == "2" else ""},
|
||
role="judge", n=len(chunk),
|
||
item=f"s{soll_id}-r{runde}", erwartet=list)
|
||
gueltig = {a["id"] for a in chunk}
|
||
zugeordnet: set[int] = set()
|
||
for z in res or []:
|
||
ids = [i for i in z.get("atome", []) if isinstance(i, int)
|
||
and i in gueltig and i not in zugeordnet]
|
||
text = str(z.get("ziel", "")).strip()
|
||
if not ids or not text:
|
||
continue
|
||
ziel_id = db.insert("lernziele", topic=ctx.topic, text=text,
|
||
titel=str(z.get("titel", "")).strip()[:80],
|
||
soll_id=soll_id, status="aktiv")
|
||
for i in ids:
|
||
db.update("atome", "id", i, ziel_id=ziel_id)
|
||
zugeordnet.update(ids)
|
||
rest = [a for a in gruppe if a["id"] not in zugeordnet
|
||
and not db.one("SELECT ziel_id FROM atome WHERE id=?",
|
||
(a["id"],))["ziel_id"]]
|
||
if rest: # nach der Schlussrunde: deterministisches Sammelziel statt Lücke
|
||
ziel_id = db.insert("lernziele", topic=ctx.topic,
|
||
text=f"Grundlagen: {punkt['punkt']}",
|
||
soll_id=soll_id, status="aktiv")
|
||
for a in rest:
|
||
db.update("atome", "id", a["id"], ziel_id=ziel_id)
|
||
|
||
await llm.alle(eine_gruppe(s, g) for s, g in gruppen.items())
|
||
|
||
|
||
# ── Zyklen brechen ────────────────────────────────────────────────────────────
|
||
|
||
def _finde_zyklus(knoten: list[int], kanten: list[tuple[int, int]]) -> list[tuple[int, int]] | None:
|
||
"""Ein Zyklus als Kantenliste, oder None (iterative DFS mit Farben)."""
|
||
nach = defaultdict(list)
|
||
for v, z in kanten:
|
||
nach[v].append(z)
|
||
farbe = {k: 0 for k in knoten} # 0 weiß, 1 grau, 2 schwarz
|
||
eltern: dict[int, int] = {}
|
||
for start in knoten:
|
||
if farbe[start]:
|
||
continue
|
||
stapel = [(start, iter(nach[start]))]
|
||
farbe[start] = 1
|
||
while stapel:
|
||
v, it = stapel[-1]
|
||
fortschritt = False
|
||
for z in it:
|
||
if z not in farbe:
|
||
continue
|
||
if farbe[z] == 0:
|
||
farbe[z] = 1
|
||
eltern[z] = v
|
||
stapel.append((z, iter(nach[z])))
|
||
fortschritt = True
|
||
break
|
||
if farbe[z] == 1: # Rückkante → Zyklus rekonstruieren
|
||
pfad = [(v, z)]
|
||
k = v
|
||
while k != z:
|
||
pfad.append((eltern[k], k))
|
||
k = eltern[k]
|
||
return pfad
|
||
if not fortschritt:
|
||
farbe[v] = 2
|
||
stapel.pop()
|
||
return None
|
||
|
||
|
||
async def _zyklen_brechen(ctx: llm.Kontext) -> None:
|
||
while True:
|
||
atome = _atome(ctx.topic)
|
||
ids = [a["id"] for a in atome]
|
||
kanten = [(k["von_atom"], k["zu_atom"]) for k in _braucht_kanten(ctx.topic)
|
||
if k["von_atom"] in ids and k["zu_atom"] in ids]
|
||
zyklus = _finde_zyklus(ids, kanten)
|
||
if not zyklus:
|
||
return
|
||
je_id = {a["id"]: a for a in atome}
|
||
liste = "\n".join(f"{v}→{z}: {je_id[v]['titel']} braucht {je_id[z]['titel']}"
|
||
for v, z in zyklus)
|
||
res = await llm.call(ctx, stage="zyklus", template="Kanten-Zyklus",
|
||
werte={"kanten": liste}, role="judge",
|
||
item=f"z{zyklus[0][0]}", erwartet=dict)
|
||
wahl = None
|
||
if res:
|
||
paar = (res.get("von"), res.get("zu"))
|
||
if paar in zyklus:
|
||
wahl = paar
|
||
if wahl is None: # deterministischer Fallback: kleinste Kante
|
||
wahl = min(zyklus)
|
||
db.execute("UPDATE kanten SET status='gebrochen' WHERE topic=? AND von_atom=?"
|
||
" AND zu_atom=? AND art='braucht'", (ctx.topic, wahl[0], wahl[1]))
|
||
log.info("Zyklus gebrochen: %s→%s", wahl[0], wahl[1])
|
||
|
||
|
||
# ── Bausteine schneiden + ordnen ──────────────────────────────────────────────
|
||
|
||
def _topo(knoten: list[int], kanten: list[tuple[int, int]],
|
||
rang: dict[int, tuple]) -> list[int]:
|
||
"""Kahn; kanten (v, z) = v braucht z ⇒ z kommt vor v. Ties nach rang (stabil).
|
||
Kanten STRIKT auf die Knotenmenge filtern — Kanten zu fremden Atomen zogen
|
||
sonst fremde Knoten in die Ausgabe und verdrängten Gruppenmitglieder
|
||
(gemessen aak: 22 Atome ohne Baustein)."""
|
||
kn = set(knoten)
|
||
vorher = defaultdict(set)
|
||
nachher = defaultdict(set)
|
||
for v, z in kanten:
|
||
if v in kn and z in kn:
|
||
vorher[v].add(z)
|
||
nachher[z].add(v)
|
||
offen = sorted([k for k in knoten if not vorher[k]], key=lambda k: rang[k])
|
||
out = []
|
||
erledigt: set[int] = set()
|
||
while offen:
|
||
k = offen.pop(0)
|
||
out.append(k)
|
||
erledigt.add(k)
|
||
neu = []
|
||
for n in nachher[k]:
|
||
if not (vorher[n] - erledigt) and n not in erledigt and n not in offen and n not in neu:
|
||
neu.append(n)
|
||
offen = sorted(offen + neu, key=lambda kk: rang[kk])
|
||
out += sorted([k for k in knoten if k not in erledigt], key=lambda k: rang[k])
|
||
return out
|
||
|
||
|
||
def _anker_rang(topic: str) -> dict[int, tuple]:
|
||
"""Natürliche Quellreihenfolge als Tie-Break: (quelle_id, start) des ersten Ankers."""
|
||
out = {}
|
||
for a in _atome(topic):
|
||
row = db.one("SELECT quelle_id, start FROM anker WHERE atom_id=? AND start>=0"
|
||
" ORDER BY quelle_id, start LIMIT 1", (a["id"],))
|
||
out[a["id"]] = (row["quelle_id"], row["start"]) if row else (999_999, a["id"])
|
||
return out
|
||
|
||
|
||
def _bausteine_schneiden(ctx: llm.Kontext) -> None:
|
||
"""Deterministisch, idempotent: alte Zuordnung verwerfen, neu schneiden.
|
||
Gruppen sind (Ziel, Level) — je Level entstehen GETRENNTE Bausteine
|
||
(E/M/S-Durchgänge). Kleine Gruppen level-intern mergen (das Atom wechselt
|
||
sein Ziel, Baustein bleibt EIN Ziel + EIN Level), große entlang der
|
||
Topo-Reihenfolge splitten ("Teil n")."""
|
||
topic = ctx.topic
|
||
db.execute("DELETE FROM bausteine WHERE topic=?", (topic,))
|
||
atome = _atome(topic)
|
||
rang = _anker_rang(topic)
|
||
kanten = [(k["von_atom"], k["zu_atom"]) for k in _braucht_kanten(topic)]
|
||
|
||
gruppen: dict = defaultdict(list)
|
||
for a in atome:
|
||
gruppen[(a["ziel_id"], a["level"])].append(a)
|
||
|
||
# kleine Gruppen mergen (kleinste zuerst), nur innerhalb des Levels.
|
||
# Partnerwahl thematisch statt per Soll-Punkt — das Soll ist seit der
|
||
# Entkopplung reine Checkliste (152 feine Punkte hätten sonst keine
|
||
# Merge-Partner): meiste braucht-Kanten zwischen den Gruppen, sonst
|
||
# Nachbar in der Quellreihenfolge.
|
||
def kanten_score(g1: list[dict], g2: list[dict]) -> int:
|
||
ids1 = {a["id"] for a in g1}
|
||
ids2 = {a["id"] for a in g2}
|
||
return sum(1 for v, z in kanten
|
||
if (v in ids1 and z in ids2) or (v in ids2 and z in ids1))
|
||
|
||
def gruppen_rang(g: list[dict]) -> tuple:
|
||
return min(rang[a["id"]] for a in g)
|
||
|
||
geaendert = True
|
||
while geaendert:
|
||
geaendert = False
|
||
kleine = sorted([k for k, g in gruppen.items() if len(g) < BAUSTEIN_MIN_ATOME],
|
||
key=lambda k: len(gruppen[k]))
|
||
for k in kleine:
|
||
# nur Level-Gleichheit als Schranke — die MAX-Grenze fiel weg, weil der
|
||
# Split große Gruppen ohnehin bandkonform zerlegt. Sonst blieb eine
|
||
# kleine Gruppe ohne passenden Partner als Unter-Band-Baustein liegen,
|
||
# den messen dann als unreparierbaren band-Befund meldete.
|
||
passende = [p for p in gruppen if p != k and p[1] == k[1]]
|
||
if not passende:
|
||
continue
|
||
eigener = gruppen_rang(gruppen[k])
|
||
|
||
def naehe(pp: tuple) -> tuple:
|
||
r = gruppen_rang(gruppen[pp])
|
||
return (-kanten_score(gruppen[k], gruppen[pp]),
|
||
(abs(r[0] - eigener[0]), abs(r[1] - eigener[1])),
|
||
len(gruppen[pp]))
|
||
|
||
p = min(passende, key=naehe)
|
||
for a in gruppen[k]:
|
||
db.update("atome", "id", a["id"], ziel_id=p[0])
|
||
gruppen[p] += gruppen.pop(k)
|
||
# Ziel erst still legen, wenn KEIN Level mehr darauf zeigt
|
||
if not any(kk[0] == k[0] for kk in gruppen):
|
||
db.update("lernziele", "id", k[0], status="gemerged")
|
||
geaendert = True
|
||
break
|
||
|
||
# Bausteine anlegen (große Gruppen splitten), Atome zuordnen
|
||
ziele = {z["id"]: z for z in db.query("SELECT * FROM lernziele WHERE topic=?", (topic,))}
|
||
for (ziel_id, level), gruppe in gruppen.items():
|
||
ordnung = _topo([a["id"] for a in gruppe], kanten, rang)
|
||
z = ziele.get(ziel_id, {})
|
||
titel = z.get("titel") or z.get("text", "Baustein") # Kurztitel; Zieltext nur Fallback
|
||
n_teile = -(-len(gruppe) // BAUSTEIN_MAX_ATOME)
|
||
# gleichverteilt statt ceil-Scheiben: der letzte Teil war sonst der Rest
|
||
# (43→8,8,8,8,8,3 verletzt das Band). divmod → 43→8,7,7,7,7,7; mit
|
||
# MIN≤MAX/2 liegt jeder Teil bei n_teile≥2 beweisbar im Band.
|
||
basis, rest_teile = divmod(len(gruppe), n_teile)
|
||
start = 0
|
||
for teil in range(n_teile):
|
||
gr = basis + (1 if teil < rest_teile else 0)
|
||
teil_ids = ordnung[start:start + gr]
|
||
start += gr
|
||
if not teil_ids:
|
||
continue
|
||
b_titel = titel if n_teile == 1 else f"{titel} (Teil {teil + 1})"
|
||
b_id = db.insert("bausteine", topic=topic, ziel_id=ziel_id, titel=b_titel,
|
||
status="neu", level=level)
|
||
for pos, atom_id in enumerate(teil_ids):
|
||
db.update("atome", "id", atom_id, baustein_id=b_id, ord=pos)
|
||
|
||
_bausteine_ordnen(topic, kanten, rang)
|
||
|
||
|
||
def _bausteine_ordnen(topic: str, kanten: list[tuple[int, int]], rang: dict) -> None:
|
||
"""Baustein-DAG aus aggregierten Atom-Kanten, JE LEVEL getrennt geordnet;
|
||
ord läuft global fortlaufend E→M→S (eine Achse — Vorwärts-Logik und Kapitel-
|
||
Kontiguität bleiben level-blind korrekt). Cross-Level-Kanten zeigen nach der
|
||
Konfliktlösung immer auf tiefere Level und sind durch die Blockordnung
|
||
automatisch erfüllt. Zyklen deterministisch an der schwächsten Aggregat-Kante
|
||
gebrochen (wenigste Atom-Kanten)."""
|
||
bausteine = db.query("SELECT * FROM bausteine WHERE topic=?", (topic,))
|
||
atome = _atome(topic)
|
||
je_atom = {a["id"]: a["baustein_id"] for a in atome}
|
||
b_level = {b["id"]: b["level"] for b in bausteine}
|
||
gewicht: dict = defaultdict(int)
|
||
for v, z in kanten: # v braucht z ⇒ Baustein(z) vor Baustein(v)
|
||
bv, bz = je_atom.get(v), je_atom.get(z)
|
||
if bv and bz and bv != bz and b_level[bv] == b_level[bz]:
|
||
gewicht[(bv, bz)] += 1
|
||
# Tie-Break: Quellposition des Bausteins (früheste Belegstelle); Kanten gewinnen
|
||
# weiter. Kapitel entstehen erst NACH der Ordnung (Entkopplung vom Soll).
|
||
b_rang = {}
|
||
for b in bausteine:
|
||
b_rang[b["id"]] = min((rang.get(a["id"], (9, 9)) for a in atome
|
||
if a["baustein_id"] == b["id"]), default=(9, 9))
|
||
offset = 0
|
||
for level in LEVEL_RANG:
|
||
b_ids = [b["id"] for b in bausteine if b["level"] == level]
|
||
if not b_ids:
|
||
continue
|
||
b_kanten = {k for k in gewicht if b_level[k[0]] == level}
|
||
while True:
|
||
zyklus = _finde_zyklus(b_ids, list(b_kanten))
|
||
if not zyklus:
|
||
break
|
||
schwach = min(zyklus, key=lambda k: (gewicht[k], k))
|
||
b_kanten.discard(schwach)
|
||
# Die Atom-Kanten hinter der geopferten Aggregat-Kante stilllegen — sonst
|
||
# meldet die QA sie ewig als Vorwärts-Kante (Baustein-Zyklen kann keine
|
||
# Ordnung vollständig rückwärts auflösen).
|
||
bv, bz = schwach
|
||
db.execute("UPDATE kanten SET status='geopfert' WHERE topic=? AND art='braucht'"
|
||
" AND status='aktiv'"
|
||
" AND von_atom IN (SELECT id FROM atome WHERE baustein_id=?)"
|
||
" AND zu_atom IN (SELECT id FROM atome WHERE baustein_id=?)",
|
||
(topic, bv, bz))
|
||
for pos, b_id in enumerate(_topo(b_ids, list(b_kanten), b_rang)):
|
||
db.update("bausteine", "id", b_id, ord=offset + pos)
|
||
offset += len(b_ids)
|
||
|
||
|
||
async def _level_kalibrieren(ctx: llm.Kontext) -> None:
|
||
"""Stufen als Komplexitätsschichten (4C/ID): Die Extraktion sieht nur ihren
|
||
Chunk und stuft absolut (aak: 13 % E → Einstiegs-Durchgang war ein
|
||
Lücken-Gerippe). Hier stuft ein Judge je LERNZIEL relativ nach — VOR dem
|
||
Schnitt, denn je Level entstehen getrennte Bausteine. Die E-Atome eines
|
||
Ziels müssen allein einen kohärenten Kurzdurchgang tragen; rein
|
||
vertiefende Ziele bleiben ohne E."""
|
||
atome = _atome(ctx.topic)
|
||
ziele = {z["id"]: z for z in db.query("SELECT * FROM lernziele WHERE topic=?",
|
||
(ctx.topic,))}
|
||
gruppen: dict = defaultdict(list)
|
||
for a in atome:
|
||
if a["ziel_id"]:
|
||
gruppen[a["ziel_id"]].append(a)
|
||
|
||
async def einer(ziel_id: int, eigene: list[dict]) -> None:
|
||
z = ziele.get(ziel_id, {})
|
||
titel = z.get("titel") or z.get("text") or ctx.topic
|
||
# bewusst OHNE bisheriges Level: der Extraktions-Prior ist verzerrt
|
||
# (Chunk-blind, M-Anchoring) und würde die Neubewertung ankern
|
||
liste = "\n".join(f"{a['id']}: {a['titel']} — {a['definition']}" for a in eigene)
|
||
res = await llm.call(ctx, stage="level", template="Level-Kalibrierung",
|
||
werte={"titel": titel, "atome": liste},
|
||
role="judge", n=len(eigene), item=f"lvz{ziel_id}",
|
||
erwartet=list)
|
||
gueltig = {a["id"]: a["level"] for a in eigene}
|
||
for e in res or []:
|
||
if not isinstance(e, dict):
|
||
continue
|
||
atom_id = e.get("atom")
|
||
level = str(e.get("level", "")).strip().upper()
|
||
if atom_id in gueltig and level in ("E", "M", "S") and level != gueltig[atom_id]:
|
||
db.update("atome", "id", atom_id, level=level)
|
||
|
||
await llm.alle(einer(z, g) for z, g in gruppen.items())
|
||
|
||
|
||
def _level_konflikte_loesen(topic: str) -> None:
|
||
"""Deterministisch: Eine Voraussetzung darf nie über dem Level ihres Nutzers
|
||
liegen — sonst fehlt dem Durchgang sein Fundament. Auflösung durch ABSENKEN
|
||
der Voraussetzung (sie gehört ins Grundgerüst des Abhängigen); Anheben würde
|
||
Kerninhalte aus dem E-Durchgang verdrängen. Fixpunkt: Level fallen monoton,
|
||
terminiert nach max. 2 Stufen je Atom."""
|
||
level = {a["id"]: a["level"] for a in _atome(topic)}
|
||
kanten = [(k["von_atom"], k["zu_atom"]) for k in _braucht_kanten(topic)
|
||
if k["von_atom"] in level and k["zu_atom"] in level]
|
||
gesenkt = 0
|
||
geaendert = True
|
||
while geaendert:
|
||
geaendert = False
|
||
for v, z in kanten: # v braucht z ⇒ level(z) ≤ level(v)
|
||
if LEVEL_RANG[level[z]] > LEVEL_RANG[level[v]]:
|
||
level[z] = level[v]
|
||
db.update("atome", "id", z, level=level[v])
|
||
gesenkt += 1
|
||
geaendert = True
|
||
if gesenkt:
|
||
log.info("Level-Konflikte: %d Voraussetzungen abgesenkt", gesenkt)
|
||
|
||
|
||
async def _kapitel_bilden(ctx: llm.Kontext) -> None:
|
||
"""Kapitel = kontiguierliche Segmente der geordneten Baustein-Folge, JE
|
||
DURCHGANG (Level) geschnitten; kapitel.ord läuft global E→M→S weiter. Das
|
||
Soll ist seit der Entkopplung reine Checkliste — Kapitel sind Struktur. Der
|
||
Judge liefert nur GRENZEN (titel + bis-id) — id-Listen schrieb er
|
||
unvollständig (aak Lauf 17: 516 Tokens für 68 Bausteine → alles verworfen).
|
||
Der Code erzwingt Reihenfolge, Lückenlosigkeit UND Größe (≥2 Bausteine außer
|
||
im letzten, ≤2×Richtwert-Band — Lernen: 68/73 Singleton-Kapitel); ungültig
|
||
bekommt EINEN Retry, danach √n-Fallback mit Befund (kapitel_fallback)."""
|
||
topic = ctx.topic
|
||
alle = db.query("SELECT * FROM bausteine WHERE topic=? ORDER BY ord", (topic,))
|
||
if not alle:
|
||
return
|
||
ziele = {z["id"]: z for z in db.query("SELECT * FROM lernziele WHERE topic=?", (topic,))}
|
||
db.execute("DELETE FROM kapitel WHERE topic=?", (topic,))
|
||
pos_global = 0
|
||
for level in LEVEL_RANG:
|
||
bausteine = [b for b in alle if b["level"] == level]
|
||
if not bausteine:
|
||
continue
|
||
# Positionsnummern statt DB-IDs: nach dem Level-Split sind die IDs
|
||
# nicht mehr monoton entlang der Lesefolge — der Judge verlor die
|
||
# Reihenfolge und lieferte 0 gültige Schnitte (aak Run 46: 15/15 Fallback)
|
||
liste = "\n".join(f"{i + 1}: {b['titel']} — "
|
||
f"{ziele.get(b['ziel_id'], {}).get('text', '')}"
|
||
for i, b in enumerate(bausteine))
|
||
richtwert = max(3, round(len(bausteine) / KAPITEL_BAUSTEINE))
|
||
max_groesse = 2 * KAPITEL_BAUSTEINE
|
||
folge = [b["id"] for b in bausteine]
|
||
pos_von = {i + 1: i for i in range(len(folge))}
|
||
|
||
async def schneiden(hinweis: str, tag: str) -> list[tuple[str, list[int]]] | None:
|
||
res = await llm.call(ctx, stage="kapitel_schnitt", template="Kapitel-Schnitt",
|
||
schritt="kapitel", role="judge", n=len(bausteine),
|
||
item=tag, erwartet=list,
|
||
werte={"bausteine": liste, "richtwert": str(richtwert),
|
||
"durchgang": DURCHGANG[level], "hinweis": hinweis})
|
||
segmente: list[tuple[str, list[int]]] = []
|
||
start = 0
|
||
for gruppe in res or []:
|
||
if not isinstance(gruppe, dict):
|
||
return None
|
||
titel = str(gruppe.get("titel", "")).strip()
|
||
ende = pos_von.get(gruppe.get("bis"))
|
||
if not titel or ende is None or ende < start:
|
||
return None
|
||
segmente.append((titel, folge[start:ende + 1]))
|
||
start = ende + 1
|
||
if not segmente or start != len(folge):
|
||
return None
|
||
for i, (_, ids) in enumerate(segmente): # Größen-Gate
|
||
if len(ids) > max_groesse:
|
||
return None
|
||
if len(ids) < 2 and len(folge) > 1 and i < len(segmente) - 1:
|
||
return None
|
||
return segmente
|
||
|
||
segmente = await schneiden("", f"kapitel-{level}")
|
||
if segmente is None:
|
||
segmente = await schneiden(
|
||
"ACHTUNG: Der letzte Versuch war ungültig. Jede Zeile braucht"
|
||
" \"titel\" und \"bis\" (eine NUMMER aus der Liste, streng"
|
||
" aufsteigend); das letzte \"bis\" MUSS die letzte Nummer der Liste"
|
||
f" sein. Jedes Kapitel bündelt 2–{max_groesse} Bausteine (Richtwert"
|
||
f" {richtwert} Kapitel); nur das letzte darf kleiner sein.",
|
||
f"kapitel-{level}-2")
|
||
art = "judge"
|
||
if segmente is None: # deterministischer Fallback: gleichmäßige √n-Segmente
|
||
art = "fallback"
|
||
je_id = {b["id"]: b for b in bausteine}
|
||
n = max(1, round(len(folge) ** 0.5))
|
||
groesse = -(-len(folge) // n)
|
||
segmente = [(je_id[teil[0]]["titel"], teil)
|
||
for i in range(n) if (teil := folge[i * groesse:(i + 1) * groesse])]
|
||
for titel, ids in segmente:
|
||
k_id = db.insert("kapitel", topic=topic, titel=titel[:120], ord=pos_global,
|
||
art=art, level=level)
|
||
pos_global += 1
|
||
for b_id in ids:
|
||
db.update("bausteine", "id", b_id, kapitel_id=k_id)
|
||
|
||
|
||
async def bauen(ctx: llm.Kontext) -> None:
|
||
ctx.ebene = EBENE
|
||
await _ziele_bilden(ctx)
|
||
await _zyklen_brechen(ctx)
|
||
await _level_kalibrieren(ctx) # VOR dem Schnitt: Level bestimmt die Bausteine
|
||
_level_konflikte_loesen(ctx.topic)
|
||
_bausteine_schneiden(ctx)
|
||
await _kapitel_bilden(ctx)
|
||
|
||
|
||
def messen(ctx: llm.Kontext) -> list[dict]:
|
||
befunde = []
|
||
atome = _atome(ctx.topic)
|
||
for a in atome:
|
||
if not a["ziel_id"] or not a["baustein_id"]:
|
||
befunde.append({"art": "partition", "item": str(a["id"]), "detail": a["titel"]})
|
||
bausteine = db.query("SELECT * FROM bausteine WHERE topic=? ORDER BY ord", (ctx.topic,))
|
||
je_baustein: dict = defaultdict(list)
|
||
for a in atome:
|
||
je_baustein[a["baustein_id"]].append(a)
|
||
# Band-Unterschreitung nur, wo der Schnitt einen Merge-Partner HÄTTE (gleiches
|
||
# Level, anderer Baustein) — der Schnitt mergt jetzt ohne MAX-Schranke und
|
||
# re-splittet bandkonform, also ist genau das die erfüllbare Messlatte. Eine
|
||
# einsame Unter-Band-Gruppe ohne Level-Partner meldet nichts (Lektion 75).
|
||
for b in bausteine:
|
||
n = len(je_baustein[b["id"]])
|
||
partner = any(bb["id"] != b["id"] and bb["level"] == b["level"] for bb in bausteine)
|
||
if n > BAUSTEIN_MAX_ATOME or (n < BAUSTEIN_MIN_ATOME and partner):
|
||
befunde.append({"art": "band", "item": str(b["id"]),
|
||
"detail": f"{b['titel']}: {n} Atome"})
|
||
for a in je_baustein[b["id"]]: # ein Baustein = genau ein Level
|
||
if a["level"] != b["level"]:
|
||
befunde.append({"art": "level_mix", "item": str(a["id"]),
|
||
"detail": f"Atom {a['level']} in Baustein {b['level']}"
|
||
f" ({b['titel']})"})
|
||
level_von = {a["id"]: a["level"] for a in atome}
|
||
for k in _braucht_kanten(ctx.topic): # Voraussetzung nie über dem Nutzer-Level
|
||
lv, lz = level_von.get(k["von_atom"]), level_von.get(k["zu_atom"])
|
||
if lv and lz and LEVEL_RANG[lz] > LEVEL_RANG[lv]:
|
||
befunde.append({"art": "level_konflikt", "item": str(k["id"]),
|
||
"detail": f"Atom {k['von_atom']} ({lv}) braucht"
|
||
f" {k['zu_atom']} ({lz})"})
|
||
kaps = db.query("SELECT * FROM kapitel WHERE topic=?", (ctx.topic,))
|
||
kap_ids = {k["id"] for k in kaps}
|
||
kap_level = {k["id"]: k["level"] for k in kaps}
|
||
for b in bausteine:
|
||
if b["kapitel_id"] not in kap_ids:
|
||
befunde.append({"art": "baustein_ohne_kapitel", "item": str(b["id"]),
|
||
"detail": b["titel"]})
|
||
elif kap_level.get(b["kapitel_id"]) != b["level"]:
|
||
befunde.append({"art": "kapitel_level", "item": str(b["id"]),
|
||
"detail": f"{b['titel']} ({b['level']}) in Kapitel"
|
||
f" {kap_level.get(b['kapitel_id'])}"})
|
||
belegt = {b["kapitel_id"] for b in bausteine}
|
||
je_kapitel: dict = defaultdict(int)
|
||
je_level: dict = defaultdict(int)
|
||
for b in bausteine:
|
||
je_kapitel[b["kapitel_id"]] += 1
|
||
je_level[b["level"]] += 1
|
||
for k in kaps:
|
||
if k["id"] not in belegt:
|
||
befunde.append({"art": "kapitel_leer", "item": str(k["id"]),
|
||
"detail": k["titel"]})
|
||
if k["art"] == "fallback": # stiller Fallback wäre unsichtbarer Qualitätsverlust
|
||
befunde.append({"art": "kapitel_fallback", "item": str(k["id"]),
|
||
"detail": k["titel"]})
|
||
# Singleton-Kapitel zerstückeln die Navigation (Lernen: 68/73) — erlaubt
|
||
# nur, wenn der ganze Durchgang bloß einen Baustein hat.
|
||
if je_kapitel[k["id"]] == 1 and je_level[k["level"]] > 1:
|
||
letzte = max((kk["ord"] for kk in kaps if kk["level"] == k["level"]))
|
||
if k["ord"] != letzte:
|
||
befunde.append({"art": "kapitel_zerstueckelt", "item": str(k["id"]),
|
||
"detail": k["titel"]})
|
||
ord_von = {b["id"]: b["ord"] for b in bausteine}
|
||
for k in _braucht_kanten(ctx.topic):
|
||
bv = next((a["baustein_id"] for a in atome if a["id"] == k["von_atom"]), None)
|
||
bz = next((a["baustein_id"] for a in atome if a["id"] == k["zu_atom"]), None)
|
||
if bv and bz and bv != bz and ord_von.get(bz, 0) > ord_von.get(bv, 0):
|
||
befunde.append({"art": "vorwaerts_kante", "item": str(k["id"]),
|
||
"detail": f"Atom {k['von_atom']} braucht {k['zu_atom']} (später)"})
|
||
ids = [a["id"] for a in atome]
|
||
kanten = [(k["von_atom"], k["zu_atom"]) for k in _braucht_kanten(ctx.topic)
|
||
if k["von_atom"] in ids and k["zu_atom"] in ids]
|
||
if _finde_zyklus(ids, kanten):
|
||
befunde.append({"art": "zyklus", "item": "", "detail": "braucht-Graph hat Zyklus"})
|
||
return befunde
|
||
|
||
|
||
async def reparieren(ctx: llm.Kontext, befunde: list[dict]) -> bool:
|
||
ctx.ebene = EBENE
|
||
if not befunde:
|
||
return False
|
||
await _ziele_bilden(ctx) # fängt Partition-Lücken
|
||
await _zyklen_brechen(ctx) # fängt Zyklen
|
||
await _level_kalibrieren(ctx)
|
||
_level_konflikte_loesen(ctx.topic) # fängt level_konflikt
|
||
_bausteine_schneiden(ctx) # Neu-Schnitt fängt Band, Vorwärts-Kanten, level_mix
|
||
await _kapitel_bilden(ctx) # fängt Kapitel-Befunde
|
||
return True
|