update
This commit is contained in:
team3
@@ -1,4 +1,14 @@
|
||||
"""Bausteine-Pipeline: 4x Recherche (3 nötig) → 2x Auswahl (1) → Prüfung — reines Inventar, unsortiert."""
|
||||
"""Bausteine-Pipeline: Recherche-Konsens + Klärungs-Loop — reines Inventar, unsortiert.
|
||||
|
||||
5x Recherche (min. 3, Grace) → Mapping (Konsens/Rest) → Klärungs-Loop (max.
|
||||
KONSENS_MAX_RUNDEN Runden): 3 Auswahl-Agenten (min. 2, Grace) entscheiden
|
||||
über den strittigen Rest, ein Mapping-Agent sortiert in aufnehmen/verwerfen/
|
||||
weiter strittig. Leerer Rest beendet den Loop; die letzte Runde muss alles
|
||||
entscheiden. Races nutzen ein Grace-Fenster statt „erste N gewinnen": Nach dem
|
||||
ersten gültigen Ergebnis dürfen die übrigen Agenten KONSENS_GRACE Sekunden
|
||||
fertig werden. Der Konsens wird im Code akkumuliert — kein Agent re-emittiert
|
||||
die Gesamtliste.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
@@ -7,15 +17,15 @@ import subprocess
|
||||
from pathlib import Path
|
||||
|
||||
from agents import kill_process
|
||||
from config import DEFAULT_PROVIDER
|
||||
from config import KONSENS_GRACE, KONSENS_MAX_RUNDEN, DEFAULT_PROVIDER
|
||||
from fsutil import atomic_write_text
|
||||
from jsonio import read_json_file as _json_datei
|
||||
from paths import arbeit_dir, bausteine_path, project_dir
|
||||
from pipeline import (
|
||||
CANCELLED, FAILED, GenContext, _extra, _log, _prompt, _race,
|
||||
_semaphore, _timeout, run_single_slot,
|
||||
CANCELLED, FAILED, GenContext, _extra, _log, _prompt, _race, _rest_schema,
|
||||
_runde_schema, _semaphore, _str_liste, _timeout, run_single_slot,
|
||||
)
|
||||
from textkit import _eindeutige_titel, _parse_auswahl, _titel, _titel_aufloesen, _titel_index
|
||||
from textkit import _eindeutige_titel, _parse_auswahl, _titel_aufloesen, _titel_index, _vormerge
|
||||
|
||||
log = logging.getLogger("creator.bausteine")
|
||||
|
||||
@@ -24,11 +34,11 @@ _bausteine_errors: dict[str, str] = {}
|
||||
_bausteine_cancelled: set[str] = set()
|
||||
_bausteine_step: dict[str, int] = {}
|
||||
|
||||
BAUSTEINE_STEPS = ("Recherche", "Auswahl", "Prüfung")
|
||||
BAUSTEINE_STEPS = ("Recherche", "Konsolidierung", "Klärung")
|
||||
|
||||
|
||||
def _bausteine_steps(topic: str) -> tuple:
|
||||
"""Projekte haben einen 4. Schritt: Themenfeld-Ergänzung per Web-Recherche."""
|
||||
"""Projekte haben einen zusätzlichen Schritt: Themenfeld-Ergänzung per Web-Recherche."""
|
||||
if project_dir(topic).is_dir():
|
||||
return BAUSTEINE_STEPS + ("Ergänzung",)
|
||||
return BAUSTEINE_STEPS
|
||||
@@ -36,18 +46,24 @@ def _bausteine_steps(topic: str) -> tuple:
|
||||
|
||||
def _bausteine_files(topic: str) -> dict:
|
||||
arbeit = arbeit_dir(topic)
|
||||
runden = range(1, KONSENS_MAX_RUNDEN + 1)
|
||||
return {
|
||||
"final": bausteine_path(topic),
|
||||
"arbeit": arbeit,
|
||||
"recherche": [arbeit / f"recherche-{i}.md" for i in (1, 2, 3, 4)],
|
||||
"auswahl": [arbeit / f"auswahl-{i}.md" for i in (1, 2)],
|
||||
"auswahl_check": arbeit / "auswahl-check.json",
|
||||
"recherche": [arbeit / f"recherche-{i}.md" for i in (1, 2, 3, 4, 5)],
|
||||
"recherche_mapping": arbeit / "recherche-mapping.json",
|
||||
"auswahl": {n: [arbeit / f"auswahl-r{n}-{i}.json" for i in (1, 2, 3)] for n in runden},
|
||||
"mapping": {n: arbeit / f"auswahl-mapping-r{n}.json" for n in runden},
|
||||
"ergaenzung": arbeit / "ergaenzung.json",
|
||||
}
|
||||
|
||||
|
||||
def _alle_slot_dateien(files: dict) -> list[Path]:
|
||||
return [*files["recherche"], *files["auswahl"], files["auswahl_check"], files["ergaenzung"]]
|
||||
return [
|
||||
*files["recherche"], files["recherche_mapping"],
|
||||
*(p for slots in files["auswahl"].values() for p in slots),
|
||||
*files["mapping"].values(), files["ergaenzung"],
|
||||
]
|
||||
|
||||
|
||||
def cancel_bausteine(topic: str) -> bool:
|
||||
@@ -63,9 +79,14 @@ def _resume_step(topic: str) -> int:
|
||||
files = _bausteine_files(topic)
|
||||
if sum(p.exists() for p in files["recherche"]) < 3:
|
||||
return 0
|
||||
if not any(p.exists() for p in files["auswahl"]):
|
||||
if not files["recherche_mapping"].exists():
|
||||
return 1
|
||||
if not files["auswahl_check"].exists():
|
||||
mapping = _mapping_schema(_json_datei(files["recherche_mapping"]))
|
||||
geklaert = mapping is not None and (
|
||||
not mapping[1] # kein strittiger Rest
|
||||
or any((r := _runde_schema(_json_datei(p))) is not None and not r[1] for p in files["mapping"].values())
|
||||
)
|
||||
if not geklaert:
|
||||
return 2
|
||||
if project_dir(topic).is_dir() and not files["ergaenzung"].exists():
|
||||
return 3
|
||||
@@ -168,25 +189,15 @@ def _file_payload(path: Path):
|
||||
return text if _parse_auswahl(text) else None
|
||||
|
||||
|
||||
def _auswahl_payload(path: Path):
|
||||
if not path.exists():
|
||||
return None
|
||||
text = path.read_text(encoding="utf-8")
|
||||
entries = _parse_auswahl(text)
|
||||
return (text, entries) if entries else None
|
||||
|
||||
|
||||
def _auswahl_check_schema(data):
|
||||
"""{"nachtraege": [...], "streichen": [...]} — None bei Schema-Verstoß."""
|
||||
def _mapping_schema(data):
|
||||
"""{"bausteine": [str, ≥1], "rest": [str]} → (bausteine, rest) · sonst None."""
|
||||
if not isinstance(data, dict):
|
||||
return None
|
||||
nach = data.get("nachtraege", [])
|
||||
streich = data.get("streichen", [])
|
||||
if not isinstance(nach, list) or not isinstance(streich, list):
|
||||
bausteine = _str_liste(data.get("bausteine"))
|
||||
rest = _str_liste(data.get("rest"))
|
||||
if not bausteine or rest is None:
|
||||
return None
|
||||
if not all(isinstance(x, str) for x in [*nach, *streich]):
|
||||
return None
|
||||
return {"nachtraege": nach, "streichen": streich}
|
||||
return bausteine, rest
|
||||
|
||||
|
||||
async def generate_bausteine(topic: str, instructions: str = "", provider: str = DEFAULT_PROVIDER) -> None:
|
||||
@@ -223,17 +234,18 @@ async def generate_bausteine(topic: str, instructions: str = "", provider: str =
|
||||
for p_alt in _alle_slot_dateien(files):
|
||||
p_alt.unlink(missing_ok=True)
|
||||
|
||||
# Schritt 1: 4 Recherche-Agenten, 3 gültige nötig — vorhandene Slot-Dateien zählen
|
||||
# Schritt 1: 5 Recherche-Agenten, min. 3 mit Grace-Fenster — alle gültigen
|
||||
# Slot-Dateien fließen ins Mapping (kein Kappen mehr bei 3)
|
||||
recherchen: list[str] = []
|
||||
offen = []
|
||||
for i, path in enumerate(files["recherche"], 1):
|
||||
text = _file_payload(path)
|
||||
if text is not None and len(recherchen) < 3:
|
||||
if text is not None:
|
||||
recherchen.append(text)
|
||||
else:
|
||||
offen.append((i, path))
|
||||
vorhanden = len(recherchen)
|
||||
set_p(f"Recherche läuft ({vorhanden}/3 gültig)…", step=0)
|
||||
set_p(f"Recherche läuft ({vorhanden} gültig, min. 3)…", step=0)
|
||||
if vorhanden < 3:
|
||||
caps = "files" if project else "full"
|
||||
slots = [
|
||||
@@ -247,80 +259,136 @@ async def generate_bausteine(topic: str, instructions: str = "", provider: str =
|
||||
]
|
||||
neue = await _race(
|
||||
topic, "Recherche", slots, 3 - vorhanden, _timeout("recherche"), provider,
|
||||
on_update=lambda c: set_p(f"Recherche läuft ({vorhanden + c}/3 gültig)…"),
|
||||
cancelled=is_cancelled,
|
||||
on_update=lambda c: set_p(f"Recherche läuft ({vorhanden + c} gültig, min. 3)…"),
|
||||
cancelled=is_cancelled, grace=KONSENS_GRACE,
|
||||
)
|
||||
if is_cancelled():
|
||||
abgebrochen()
|
||||
return
|
||||
if neue is None:
|
||||
_bausteine_errors[topic] = "Recherche fehlgeschlagen (Quorum nicht erreicht)"
|
||||
_bausteine_errors[topic] = "Recherche fehlgeschlagen (Minimum nicht erreicht)"
|
||||
return
|
||||
recherchen += neue
|
||||
|
||||
# Schritt 2: 2 Auswahl-Agenten, der erste gewinnt — vorhandene gültige Datei wird übernommen
|
||||
n_est = max(len(_parse_auswahl(t)) for t in recherchen)
|
||||
bestehende = next((res for p in files["auswahl"] if (res := _auswahl_payload(p)) is not None), None)
|
||||
if bestehende is not None:
|
||||
flat, entries = bestehende
|
||||
else:
|
||||
# Schritt 2: Recherche-Mapping — Code-Vormerge (exakte Titel) + 1 Agent
|
||||
# für semantische Dubletten und Konsens/Rest-Teilung (fatal)
|
||||
mapping = _mapping_schema(_json_datei(files["recherche_mapping"]))
|
||||
if mapping is None:
|
||||
set_p("Konsolidiere Recherche…", step=1)
|
||||
results_block = "\n\n".join(f"### Recherche {i}\n\n{text}" for i, text in enumerate(recherchen, 1))
|
||||
slots = [
|
||||
{
|
||||
"key": f"bausteine-{topic}-auswahl-{i}",
|
||||
"prompt": _prompt("Bausteine-Auswahl", topic=topic, results=results_block, out_path=path),
|
||||
"role": "fast", "capabilities": "files",
|
||||
"payload": (lambda result, p=path: _auswahl_payload(p)),
|
||||
}
|
||||
for i, path in enumerate(files["auswahl"], 1)
|
||||
]
|
||||
auswahl = await _race(topic, "Auswahl", slots, 1, _timeout("auswahl", n_est), provider, cancelled=is_cancelled)
|
||||
if is_cancelled():
|
||||
abgebrochen()
|
||||
return
|
||||
if auswahl is None:
|
||||
_bausteine_errors[topic] = "Auswahl fehlgeschlagen (kein gültiges Ergebnis)"
|
||||
return
|
||||
flat, entries = auswahl[0]
|
||||
|
||||
# Schritt 2b: Auswahl-Prüfung gegen die Recherche-Titel (JSON, nicht fatal)
|
||||
set_p("Prüfe Auswahl…", step=2)
|
||||
check_path = files["auswahl_check"]
|
||||
patch = _auswahl_check_schema(_json_datei(check_path))
|
||||
if patch is None:
|
||||
check_path.unlink(missing_ok=True)
|
||||
titel_listen = "\n\n".join(
|
||||
f"### Recherche {i}\n" + "\n".join(f"- {_titel(t)}" for t in _parse_auswahl(text).values())
|
||||
for i, text in enumerate(recherchen, 1)
|
||||
)
|
||||
status, check = await run_single_slot(
|
||||
ctx, "Auswahl-Check",
|
||||
key=f"bausteine-{topic}-auswahlcheck-1",
|
||||
prompt=_prompt("Bausteine-Auswahl-Check", topic=topic, results=titel_listen, auswahl=flat, out_path=check_path),
|
||||
role="fast", capabilities="files",
|
||||
payload=lambda result: _auswahl_check_schema(_json_datei(check_path)),
|
||||
timeout=_timeout("auswahl_check", len(entries)),
|
||||
files["recherche_mapping"].unlink(missing_ok=True)
|
||||
gemergt = _vormerge([_parse_auswahl(t) for t in recherchen])
|
||||
eintraege = "\n".join(f"{i}. {text} ({n}× genannt)" for i, (text, n) in enumerate(gemergt, 1))
|
||||
status, mapping = await run_single_slot(
|
||||
ctx, "Recherche-Mapping",
|
||||
key=f"bausteine-{topic}-recherche-mapping",
|
||||
prompt=_prompt(
|
||||
"Bausteine-Recherche-Mapping",
|
||||
topic=topic, n=len(recherchen), eintraege=eintraege,
|
||||
out_path=files["recherche_mapping"],
|
||||
),
|
||||
role="judge", capabilities="files",
|
||||
payload=lambda result: _mapping_schema(_json_datei(files["recherche_mapping"])),
|
||||
timeout=_timeout("recherche_mapping", len(gemergt)),
|
||||
)
|
||||
if status == CANCELLED:
|
||||
abgebrochen()
|
||||
return
|
||||
if status == FAILED:
|
||||
_log(topic, "Auswahl-Check fehlgeschlagen — fahre ohne Korrekturen fort")
|
||||
else:
|
||||
patch = check
|
||||
if patch is not None and (patch["streichen"] or patch["nachtraege"]):
|
||||
idx = _titel_index(entries)
|
||||
weg = {num for t in patch["streichen"] if (num := _titel_aufloesen(idx, t)) is not None}
|
||||
if weg:
|
||||
_log(topic, f"Auswahl-Check streicht Duplikate: {sorted(weg)}")
|
||||
entries = {n: t for n, t in entries.items() if n not in weg}
|
||||
if patch["nachtraege"]:
|
||||
_log(topic, f"Auswahl-Check ergänzt {len(patch['nachtraege'])} Bausteine")
|
||||
texts = [t for _, t in sorted(entries.items())] + list(patch["nachtraege"])
|
||||
entries = {i: t for i, t in enumerate(texts, 1)}
|
||||
_bausteine_errors[topic] = "Recherche-Mapping fehlgeschlagen"
|
||||
return
|
||||
konsens, rest = mapping
|
||||
|
||||
# Schritt 4 (nur Projekte): Themenfeld-Ergänzung — Skript/Projekt ist ein Ausschnitt,
|
||||
# Klärungs-Loop: 3 Auswahl-Agenten entscheiden über den Rest, ein
|
||||
# Mapping-Agent sortiert in aufnehmen/verwerfen/weiter strittig.
|
||||
# Leerer Rest beendet den Loop; Runde KONSENS_MAX_RUNDEN muss
|
||||
# alles entscheiden. Der Konsens wächst nur hier im Code.
|
||||
runde = 0
|
||||
while rest and runde < KONSENS_MAX_RUNDEN:
|
||||
runde += 1
|
||||
final_runde = runde == KONSENS_MAX_RUNDEN
|
||||
set_p(f"Klärung läuft (Runde {runde}/{KONSENS_MAX_RUNDEN})…", step=2)
|
||||
mapping_path = files["mapping"][runde]
|
||||
|
||||
# Resume: fertiges Runden-Mapping wird direkt übernommen
|
||||
ergebnis = _runde_schema(_json_datei(mapping_path), final=final_runde)
|
||||
if ergebnis is None:
|
||||
mapping_path.unlink(missing_ok=True)
|
||||
konsens_block = "\n".join(f"- {t}" for t in konsens)
|
||||
rest_block = "\n".join(f"- {t}" for t in rest)
|
||||
|
||||
# 3 Auswahl-Agenten, min. 2 mit Grace-Fenster
|
||||
entscheidungen = []
|
||||
offen = []
|
||||
for i, path in enumerate(files["auswahl"][runde], 1):
|
||||
res = _rest_schema(_json_datei(path))
|
||||
if res is not None:
|
||||
entscheidungen.append(res)
|
||||
else:
|
||||
offen.append((i, path))
|
||||
if len(entscheidungen) < 2:
|
||||
slots = [
|
||||
{
|
||||
"key": f"bausteine-{topic}-auswahl-r{runde}-{i}",
|
||||
"prompt": _prompt(
|
||||
"Bausteine-Auswahl",
|
||||
topic=topic, konsens=konsens_block, rest=rest_block, out_path=path,
|
||||
),
|
||||
"role": "fast", "capabilities": "files",
|
||||
"payload": (lambda result, p=path: _rest_schema(_json_datei(p))),
|
||||
}
|
||||
for i, path in offen
|
||||
]
|
||||
neue = await _race(
|
||||
topic, f"Auswahl r{runde}", slots, 2 - len(entscheidungen),
|
||||
_timeout("auswahl", len(rest)), provider,
|
||||
cancelled=is_cancelled, grace=KONSENS_GRACE,
|
||||
)
|
||||
if is_cancelled():
|
||||
abgebrochen()
|
||||
return
|
||||
if neue is None:
|
||||
_bausteine_errors[topic] = f"Auswahl fehlgeschlagen (Runde {runde}, Minimum nicht erreicht)"
|
||||
return
|
||||
entscheidungen += neue
|
||||
|
||||
# Votum pro Rest-Eintrag deterministisch zählen
|
||||
indizes = [_titel_index(dict(enumerate(e, 1))) for e in entscheidungen]
|
||||
voten = "\n".join(
|
||||
f"{i}. {text} (von {sum(1 for idx in indizes if _titel_aufloesen(idx, text) is not None)}"
|
||||
f"/{len(entscheidungen)} Agenten übernommen)"
|
||||
for i, text in enumerate(rest, 1)
|
||||
)
|
||||
final_zusatz = (
|
||||
"\n- LETZTE RUNDE: Es gibt keine weitere Runde. `rest` MUSS leer sein"
|
||||
" — entscheide JEDEN Eintrag selbst: aufnehmen oder verwerfen."
|
||||
if final_runde else ""
|
||||
)
|
||||
status, ergebnis = await run_single_slot(
|
||||
ctx, f"Auswahl-Mapping r{runde}",
|
||||
key=f"bausteine-{topic}-auswahl-mapping-r{runde}",
|
||||
prompt=_prompt(
|
||||
"Bausteine-Auswahl-Mapping",
|
||||
topic=topic, n=len(entscheidungen), konsens=konsens_block,
|
||||
rest=voten, final=final_zusatz, out_path=mapping_path,
|
||||
),
|
||||
role="judge", capabilities="files",
|
||||
payload=lambda result, p=mapping_path, f=final_runde: _runde_schema(_json_datei(p), final=f),
|
||||
timeout=_timeout("auswahl_mapping", len(rest)),
|
||||
)
|
||||
if status == CANCELLED:
|
||||
abgebrochen()
|
||||
return
|
||||
if status == FAILED:
|
||||
_bausteine_errors[topic] = f"Auswahl-Mapping fehlgeschlagen (Runde {runde})"
|
||||
return
|
||||
|
||||
aufnehmen, rest = ergebnis
|
||||
_log(topic, f"Klärung Runde {runde}: {len(aufnehmen)} aufgenommen, {len(rest)} weiter strittig")
|
||||
konsens = konsens + aufnehmen
|
||||
|
||||
entries = {i: t for i, t in enumerate(konsens, 1)}
|
||||
|
||||
# Nur Projekte: Themenfeld-Ergänzung — Skript/Projekt ist ein Ausschnitt,
|
||||
# ein Web-Agent ergänzt kanonisch fehlende Bausteine, markiert mit [Ergänzung].
|
||||
if project:
|
||||
set_p("Ergänze Themenfeld…", step=3)
|
||||
|
||||
Reference in New Issue
Block a user