108 lines
4.0 KiB
Python
108 lines
4.0 KiB
Python
"""Stufe 1 der Prüfung: alles, was sich zählen lässt, zählt der Code.
|
|
|
|
Das Modell erfand hier Regeln, die im Katalog nicht stehen — „Im" als Füllwort,
|
|
Satzzeichen, wo keins ist. Diese Klasse ist jetzt abschließend hier erledigt, und
|
|
der Prompt verbietet dem Modell, sie noch einmal zu melden.
|
|
|
|
Ein Befund mit Vorschlag geht ohne Anfrage durch. Ein Befund ohne Vorschlag heißt:
|
|
der Code weiß, dass die Stelle falsch ist, aber nicht, was richtig wäre — den
|
|
Auftrag bekommt das Modell.
|
|
"""
|
|
|
|
import re
|
|
|
|
# Höchstzahl Wörter je Zeile, nach (bereich, feld)
|
|
WORTGRENZEN = {
|
|
("feature", "titel"): 3,
|
|
("funktion", "titel"): 5,
|
|
("feature", "regeln"): 10,
|
|
("funktion", "regeln"): 10,
|
|
("funktion", "testen"): 8,
|
|
}
|
|
ZIEL_SAETZE = 2
|
|
ZIEL_WOERTER = 12
|
|
|
|
# Abschließend. Genau diese Wörter, keine sinnverwandten.
|
|
FUELLWOERTER = ("auch", "noch", "einfach", "jeweils", "ggf")
|
|
BADGE = ("kern", "optional")
|
|
ZEILENFELDER = ("regeln", "testen")
|
|
|
|
SATZENDE = ".;"
|
|
_KLAMMER = re.compile(r"[()/]")
|
|
_STRICH = re.compile(r"^[-*]\s*")
|
|
|
|
|
|
def _zeilen(feld: str, text: str) -> list[str]:
|
|
"""regeln und testen sind Listen, alles andere ist ein Block."""
|
|
if feld in ZEILENFELDER:
|
|
return [_STRICH.sub("", z.strip()) for z in text.splitlines() if z.strip()]
|
|
return [text.strip()] if text.strip() else []
|
|
|
|
|
|
def _problem(feld: str, original: str, problem: str, vorschlag: str = "") -> dict:
|
|
return {"feld": feld, "original": original, "problem": problem, "vorschlag": vorschlag}
|
|
|
|
|
|
def _ohne_wort(zeile: str, wort: str) -> str:
|
|
neu = re.sub(rf"\s*\b{re.escape(wort)}\b\.?", "", zeile, flags=re.I).strip()
|
|
return re.sub(r"\s{2,}", " ", neu)
|
|
|
|
|
|
def _reparierbar(zeile: str) -> tuple[list[str], str]:
|
|
"""Verstöße, die sich wegstreichen lassen, samt der bereinigten Zeile."""
|
|
gruende, neu = [], zeile
|
|
if neu[-1] in SATZENDE:
|
|
gruende.append("Satzzeichen am Zeilenende")
|
|
neu = neu[:-1].rstrip()
|
|
for wort in FUELLWOERTER:
|
|
if re.search(rf"\b{wort}\b", neu, re.I):
|
|
gruende.append(f"Füllwort „{wort}“")
|
|
neu = _ohne_wort(neu, wort)
|
|
return gruende, neu
|
|
|
|
|
|
def _umschreiben(bereich: str, feld: str, zeile: str) -> list[str]:
|
|
"""Verstöße, die der Code sieht, aber nicht beheben kann."""
|
|
gruende = []
|
|
if _KLAMMER.search(zeile):
|
|
gruende.append("Klammer oder Schrägstrich")
|
|
grenze = WORTGRENZEN.get((bereich, feld))
|
|
if grenze and len(zeile.split()) > grenze:
|
|
gruende.append(f"Mehr als {grenze} Wörter")
|
|
if feld == "ziel":
|
|
saetze = [s.strip() for s in re.split(r"[.!?]+", zeile) if s.strip()]
|
|
if len(saetze) > ZIEL_SAETZE:
|
|
gruende.append(f"Mehr als {ZIEL_SAETZE} Sätze")
|
|
if any(len(s.split()) > ZIEL_WOERTER for s in saetze):
|
|
gruende.append(f"Satz mit mehr als {ZIEL_WOERTER} Wörtern")
|
|
return gruende
|
|
|
|
|
|
def _zeile(bereich: str, feld: str, zeile: str) -> list[dict]:
|
|
"""Höchstens ein Befund je Zeile. Zwei Vorschläge für dieselbe Zeile wären nicht
|
|
unabhängig — der zweite fände seine Stelle nach dem ersten nicht mehr."""
|
|
gruende, neu = _reparierbar(zeile)
|
|
offen = _umschreiben(bereich, feld, zeile)
|
|
if offen:
|
|
# Muss ohnehin neu geschrieben werden — dann alles in einem Zug, vom Modell
|
|
return [_problem(feld, zeile, ", ".join(gruende + offen))]
|
|
return [_problem(feld, zeile, ", ".join(gruende), neu)] if gruende else []
|
|
|
|
|
|
def befunde(bereich: str, felder: dict) -> list[dict]:
|
|
"""Alle messbaren Verstöße einer Prüfstelle, in Reihenfolge der Felder."""
|
|
raus = []
|
|
for feld, text in felder.items():
|
|
if feld == "badge":
|
|
if text and text not in BADGE:
|
|
raus.append(_problem(feld, text, "Weder kern noch optional", "kern"))
|
|
continue
|
|
for zeile in _zeilen(feld, text or ""):
|
|
raus += _zeile(bereich, feld, zeile)
|
|
return raus
|
|
|
|
|
|
def auftrag(befund: dict) -> str:
|
|
"""Zeile für das Modell: der Code hat gemessen, den Ersatz schreibt das Modell."""
|
|
return f'- {befund["feld"]} „{befund["original"]}“: {befund["problem"]}'
|