329 lines
14 KiB
Python
329 lines
14 KiB
Python
"""Deterministische Text-Helfer: Normalisierung, Verbatim-Zitatsuche mit Offset-
|
||
Mapping, Abschnitts-Split. Lektionen 27 (Casefold+NFKC), 31 (Negations-Guard),
|
||
43 (Dash-Toleranz), 47 (Abschnitte)."""
|
||
|
||
import re
|
||
import unicodedata
|
||
|
||
from config import ABSCHNITT_CHARS, FUZZY_FEHLERQUOTE, FUZZY_MIN_ZEICHEN
|
||
|
||
_WS = re.compile(r"\s+")
|
||
_WORT = re.compile(r"[a-zäöüß0-9]+")
|
||
|
||
|
||
def norm(text: str) -> str:
|
||
"""NFKC + casefold + Whitespace-Faltung — für jeden Ähnlichkeits-/Gleichheitsvergleich."""
|
||
return _WS.sub(" ", unicodedata.normalize("NFKC", text).casefold()).strip()
|
||
|
||
|
||
def tokens(text: str) -> set[str]:
|
||
return set(_WORT.findall(norm(text)))
|
||
|
||
|
||
_NEGATION = {"nicht", "kein", "keine", "keinen", "keiner", "nie", "niemals", "ohne", "un"}
|
||
|
||
|
||
def negations_menge(text: str) -> frozenset[str]:
|
||
"""Antonyme messen 0.91–0.95 Cosinus — gleiche Negationsmenge ist harte
|
||
Merge-Vorbedingung."""
|
||
return frozenset(t for t in tokens(text) if t in _NEGATION or t.startswith("nicht"))
|
||
|
||
|
||
def _normiert_mit_map(text: str) -> tuple[str, list[int]]:
|
||
"""Whitespace-gefaltete Kopie + Map: Position in Kopie → Position im Original."""
|
||
out: list[str] = []
|
||
mapping: list[int] = []
|
||
in_ws = False
|
||
for i, c in enumerate(text):
|
||
if c.isspace():
|
||
if not in_ws and out:
|
||
out.append(" ")
|
||
mapping.append(i)
|
||
in_ws = True
|
||
else:
|
||
out.append(c)
|
||
mapping.append(i)
|
||
in_ws = False
|
||
return "".join(out), mapping
|
||
|
||
|
||
# LaTeX-Kontrollwörter für den Vergleich neutralisieren: das Modell zitiert die
|
||
# GERENDERTE Lesart („k ∈ ℕ"), die tex-Quelle enthält Markup ($k \in \mathbb{N}$)
|
||
# — Anker-Identität muss unter diesem Rendering invariant sein (aak: 57/146 Atome
|
||
# ohne Anker). Griechische Befehle → Unicode-Buchstabe (überlebt die alnum-Faltung
|
||
# auf beiden Seiten wie das σ im Zitat); alle anderen Befehle fallen weg — ihre
|
||
# gerenderten Symbole (∈, ⊆, ≥) verwirft die alnum-Faltung ebenfalls.
|
||
# \begin{itemize} usw. KOMPLETT schlucken (erste Alternative) — sonst bleibt der
|
||
# Umgebungsname als Residuum in der Faltung („itemize") und Zitate über
|
||
# Listenstarts scheitern; danach normale Befehlswörter
|
||
_LATEX_WORT = re.compile(r"\\(?:begin|end)\{[^}]*\}|\\[a-zA-Z]+")
|
||
_GRIECHISCH = {g: chr(c) for g, c in (
|
||
("alpha", 0x3B1), ("beta", 0x3B2), ("gamma", 0x3B3), ("delta", 0x3B4),
|
||
("epsilon", 0x3B5), ("varepsilon", 0x3B5), ("zeta", 0x3B6), ("eta", 0x3B7),
|
||
("theta", 0x3B8), ("iota", 0x3B9), ("kappa", 0x3BA), ("lambda", 0x3BB),
|
||
("mu", 0x3BC), ("nu", 0x3BD), ("xi", 0x3BE), ("pi", 0x3C0), ("rho", 0x3C1),
|
||
("sigma", 0x3C3), ("tau", 0x3C4), ("phi", 0x3C6), ("varphi", 0x3C6),
|
||
("chi", 0x3C7), ("psi", 0x3C8), ("omega", 0x3C9),
|
||
("Gamma", 0x393), ("Delta", 0x394), ("Theta", 0x398), ("Lambda", 0x39B),
|
||
("Xi", 0x39E), ("Pi", 0x3A0), ("Sigma", 0x3A3), ("Phi", 0x3A6),
|
||
("Psi", 0x3A8), ("Omega", 0x3A9))}
|
||
|
||
|
||
def _latex_falten(text: str) -> list[tuple[str, int]]:
|
||
"""→ (Zeichen, Original-Position)-Paare mit neutralisierten LaTeX-Befehlen."""
|
||
paare: list[tuple[str, int]] = []
|
||
pos = 0
|
||
for m in _LATEX_WORT.finditer(text):
|
||
for i in range(pos, m.start()):
|
||
paare.append((text[i], i))
|
||
if "{" not in m.group(0): # Umgebungen komplett schlucken
|
||
for ch in _GRIECHISCH.get(m.group(0)[1:], ""):
|
||
paare.append((ch, m.start()))
|
||
pos = m.end()
|
||
for i in range(pos, len(text)):
|
||
paare.append((text[i], i))
|
||
return paare
|
||
|
||
|
||
def _locker_mit_map(text: str) -> tuple[str, list[int]]:
|
||
"""Nur Buchstaben/Ziffern (NFKD + casefold, Kombinationszeichen raus) + Map auf
|
||
Original-Positionen, LaTeX-Befehle neutralisiert (s. o.). Für die dritte
|
||
Matching-Stufe: PDF-Extrakte und Reader variieren
|
||
Interpunktion, Anführungszeichen, Dash-Typen und Trennungen — der Wortlaut bleibt
|
||
gleich. NFKD statt NFKC (Lektion 82): pdftotext liefert DEKOMPONIERTE Umlaute
|
||
(„a"+Kombinationspunkt), das LLM-Zitat präkomponierte („ä") — pro Einzelzeichen
|
||
komponiert NFKC nie. Also BEIDE Seiten auf den Basisbuchstaben falten (ä→a);
|
||
ohne das scheiterte fast jedes deutsche Zitat (aak: 59/96 Atome ohne Anker)."""
|
||
out: list[str] = []
|
||
mapping: list[int] = []
|
||
for c, i in _latex_falten(text):
|
||
for cn in unicodedata.normalize("NFKD", c).casefold():
|
||
if cn.isalnum() and not unicodedata.combining(cn):
|
||
out.append(cn)
|
||
mapping.append(i)
|
||
return "".join(out), mapping
|
||
|
||
|
||
def _casefold_mit_map(text: str) -> tuple[str, list[int]]:
|
||
"""Gefaltete Kopie + Map auf die Original-Positionen. casefold() kann ein
|
||
Zeichen zu mehreren expandieren (ß→ss) — die Map hält den Rückweg eindeutig."""
|
||
out: list[str] = []
|
||
mapping: list[int] = []
|
||
for i, c in enumerate(text):
|
||
for cn in c.casefold():
|
||
out.append(cn)
|
||
mapping.append(i)
|
||
return "".join(out), mapping
|
||
|
||
|
||
_LOCKER_MIN_ZEICHEN = 20 # darunter: nur bei EINDEUTIGEM Vorkommen matchen
|
||
_LOCKER_MIN_EINDEUTIG = 10 # darunter: nie (zu wenig Signal, auch wenn einmalig)
|
||
|
||
|
||
def finde_zitat(text: str, zitat: str) -> tuple[int, int] | None:
|
||
"""Zitat im Quelltext finden. Vier Stufen (Hypothes.is-Muster, Lektion 83):
|
||
1. exakt (nur Whitespace-tolerant), 2. + casefold (PDF-Small-Caps),
|
||
3. alnum-gefaltet (Interpunktion/Dashes/Quotes egal, Wortlaut identisch),
|
||
4. fuzzy auf der Faltung (fuzzysearch, harte Fehlerquote + Eindeutigkeits-Guard) —
|
||
fängt Reader-„Verschönerungen": weggelassene Listing-Zeilennummern, rekonstruierte
|
||
Glyphen, geglättete Formeln. → (start, ende) im Original oder None.
|
||
Paraphrasen bleiben draußen (Distanzschranke, keine Wort-Umstellungen)."""
|
||
if not zitat.strip():
|
||
return None
|
||
haystack, mapping = _normiert_mit_map(text)
|
||
needle = _WS.sub(" ", zitat).strip()
|
||
pos = haystack.find(needle)
|
||
if pos >= 0:
|
||
return mapping[pos], mapping[min(pos + len(needle) - 1, len(mapping) - 1)] + 1
|
||
# Stufe 2: casefold — eigene Map, weil casefold die Länge ändert (ß→ss, fi→fi).
|
||
# Direkt in `mapping` zu indizieren verschob den Span um jede Expansion vor dem
|
||
# Treffer und lief am Textende in einen IndexError.
|
||
hay_cf, sub = _casefold_mit_map(haystack)
|
||
ndl_cf = needle.casefold()
|
||
pos = hay_cf.find(ndl_cf)
|
||
if pos >= 0:
|
||
start = mapping[sub[pos]]
|
||
ende = mapping[sub[min(pos + len(ndl_cf) - 1, len(sub) - 1)]] + 1
|
||
return start, ende
|
||
hay_l, map_l = _locker_mit_map(text)
|
||
ndl_l, _ = _locker_mit_map(zitat)
|
||
if len(ndl_l) < _LOCKER_MIN_EINDEUTIG:
|
||
return None
|
||
if len(ndl_l) < _LOCKER_MIN_ZEICHEN:
|
||
# Eindeutigkeit war der eigentliche Grund des Längen-Gates — direkt
|
||
# prüfen statt Proxy-Länge: kurze Formel-Zitate ($LPT(I)=\OPT(I)$)
|
||
# sind oft einmalig und damit sichere Anker. Kein Fuzzy für Kurze.
|
||
if hay_l.count(ndl_l) != 1:
|
||
return None
|
||
pos = hay_l.find(ndl_l)
|
||
return map_l[pos], map_l[min(pos + len(ndl_l) - 1, len(map_l) - 1)] + 1
|
||
pos = hay_l.find(ndl_l)
|
||
if pos < 0:
|
||
span = _fuzzy_span(hay_l, map_l, ndl_l)
|
||
# Negations-Guard auch für Stufe 4: eine eingefügte Negation ist nur
|
||
# ~5 Zeichen Distanz — semantisch aber das Gegenteil (nie ankern)
|
||
if span and negations_menge(text[span[0]:span[1]]) != negations_menge(zitat):
|
||
span = None
|
||
return span or _wort_span(text, zitat)
|
||
return map_l[pos], map_l[min(pos + len(ndl_l) - 1, len(map_l) - 1)] + 1
|
||
|
||
|
||
def _fuzzy_span(hay_l: str, map_l: list[int], ndl_l: str) -> tuple[int, int] | None:
|
||
"""Stufe 4: Levenshtein-Substring auf der alnum-Faltung. Nur ab FUZZY_MIN_ZEICHEN,
|
||
Distanz ≤ FUZZY_FEHLERQUOTE·Länge. Eindeutigkeits-Guard (Falsch-Anker >> fehlender
|
||
Anker): gibt es einen NICHT überlappenden Zweittreffer fast gleicher Distanz → None
|
||
(Realfall: SubSetSum- und Partition-Definition teilen den Satzanfang)."""
|
||
if len(ndl_l) < FUZZY_MIN_ZEICHEN:
|
||
return None
|
||
try:
|
||
from fuzzysearch import find_near_matches
|
||
except ImportError:
|
||
return None
|
||
max_dist = max(2, int(len(ndl_l) * FUZZY_FEHLERQUOTE))
|
||
treffer = find_near_matches(ndl_l, hay_l, max_l_dist=max_dist)
|
||
if not treffer:
|
||
return None
|
||
best = min(treffer, key=lambda m: (m.dist, m.start))
|
||
schranke = best.dist + max(3, int(len(ndl_l) * 0.05))
|
||
for m in treffer:
|
||
if (m.end <= best.start or m.start >= best.end) and m.dist <= schranke:
|
||
return None # mehrdeutig — zwei getrennte, fast gleich gute Stellen
|
||
return map_l[best.start], map_l[min(best.end - 1, len(map_l) - 1)] + 1
|
||
|
||
|
||
# ── Stufe 5: Wort-Alignment ──────────────────────────────────────────────────
|
||
# Modelle zitieren semantisch, nie byte-treu: \cdot → „mal", \sqrt{} → „sqrt()",
|
||
# kleine Auslassungen. Auf Zeichen-Ebene sprengt jede dieser Abweichungen die
|
||
# 8-%-Schranke — auf WORT-Ebene ist es je 1 Edit. Echte Paraphrasen bleiben
|
||
# draußen: dort sind die Wörter selbst anders (Wort-Distanz > Schranke).
|
||
|
||
WORT_MIN = 8 # kürzere Zitate: Wort-Matching nicht mehr eindeutig genug
|
||
WORT_FEHLERQUOTE = 0.25 # max. Wort-Edits als Anteil der Zitat-Wortzahl
|
||
|
||
|
||
def _wort_folge(text: str) -> tuple[list[str], list[tuple[int, int]]]:
|
||
"""Gefaltete Wörter + (start, ende)-Spans im Original. Gleiche Faltung wie
|
||
Stufe 3 (LaTeX neutralisiert, NFKD-alnum), aber mit Wortgrenzen."""
|
||
woerter: list[str] = []
|
||
spans: list[tuple[int, int]] = []
|
||
aktuell: list[str] = []
|
||
w_start = w_ende = -1
|
||
for c, i in _latex_falten(text):
|
||
emittiert = False
|
||
for cn in unicodedata.normalize("NFKD", c).casefold():
|
||
if cn.isalnum() and not unicodedata.combining(cn):
|
||
if not aktuell:
|
||
w_start = i
|
||
aktuell.append(cn)
|
||
w_ende = i
|
||
emittiert = True
|
||
if not emittiert and aktuell:
|
||
woerter.append("".join(aktuell))
|
||
spans.append((w_start, w_ende + 1))
|
||
aktuell = []
|
||
if aktuell:
|
||
woerter.append("".join(aktuell))
|
||
spans.append((w_start, w_ende + 1))
|
||
return woerter, spans
|
||
|
||
|
||
def _wort_distanz(a: list[str], b: list[str], limit: int) -> int:
|
||
"""Levenshtein über Wortfolgen, mit Abbruch oberhalb von limit."""
|
||
if abs(len(a) - len(b)) > limit:
|
||
return limit + 1
|
||
vorher = list(range(len(b) + 1))
|
||
for i, wa in enumerate(a, 1):
|
||
zeile = [i]
|
||
minimum = i
|
||
for j, wb in enumerate(b, 1):
|
||
d = min(vorher[j] + 1, zeile[j - 1] + 1, vorher[j - 1] + (wa != wb))
|
||
zeile.append(d)
|
||
minimum = min(minimum, d)
|
||
if minimum > limit:
|
||
return limit + 1
|
||
vorher = zeile
|
||
return vorher[-1]
|
||
|
||
|
||
def _negationen(woerter: list[str]) -> frozenset[str]:
|
||
return frozenset(w for w in woerter if w in _NEGATION or w.startswith("nicht"))
|
||
|
||
|
||
def _wort_span(text: str, zitat: str) -> tuple[int, int] | None:
|
||
"""Bestes Fenster im Text mit minimaler WORT-Edit-Distanz zum Zitat.
|
||
Kandidaten über die seltensten Zitat-Wörter (kein Voll-Scan); Schranken:
|
||
Fehlerquote, Eindeutigkeits-Guard, Negations-Gleichheit
|
||
(Falsch-Anker >> fehlender Anker)."""
|
||
ndl, _ = _wort_folge(zitat)
|
||
if len(ndl) < WORT_MIN:
|
||
return None
|
||
hay, spans = _wort_folge(text)
|
||
limit = max(2, int(len(ndl) * WORT_FEHLERQUOTE))
|
||
vorkommen: dict[str, list[int]] = {}
|
||
for i, w in enumerate(hay):
|
||
vorkommen.setdefault(w, []).append(i)
|
||
# seltenste Zitat-Wörter als Kandidaten-Anker (bis 3 Wörter, je ≤ 50 Stellen)
|
||
selten = sorted(((len(vorkommen.get(w, [])), idx, w) for idx, w in enumerate(ndl)
|
||
if 0 < len(vorkommen.get(w, [])) <= 50))[:3]
|
||
starts: set[int] = set()
|
||
for _, idx, w in selten:
|
||
for p in vorkommen[w]:
|
||
for versatz in (-2, -1, 0, 1, 2):
|
||
s = p - idx + versatz
|
||
if 0 <= s < len(hay):
|
||
starts.add(s)
|
||
treffer: list[tuple[int, int, int]] = [] # (dist, start, ende)
|
||
for s in starts:
|
||
for laenge in range(max(WORT_MIN, len(ndl) - 2), len(ndl) + 4):
|
||
fenster = hay[s:s + laenge]
|
||
if len(fenster) < WORT_MIN:
|
||
continue
|
||
d = _wort_distanz(ndl, fenster, limit)
|
||
if d <= limit:
|
||
treffer.append((d, s, s + len(fenster)))
|
||
if not treffer:
|
||
return None
|
||
best = min(treffer)
|
||
schranke = best[0] + max(1, int(len(ndl) * 0.08))
|
||
for d, s, e in treffer:
|
||
if (e <= best[1] or s >= best[2]) and d <= schranke:
|
||
return None # mehrdeutig — zwei getrennte, fast gleich gute Stellen
|
||
if _negationen(ndl) != _negationen(hay[best[1]:best[2]]):
|
||
return None # Negations-Guard: nie „regulär" auf „nicht regulär" ankern
|
||
return spans[best[1]][0], spans[best[2] - 1][1]
|
||
|
||
|
||
def titel_kern(titel: str) -> str:
|
||
"""Alnum-gefalteter Titel (NFKC + casefold) — gleicher Kern über
|
||
Schreibvarianten hinweg (U+2011-Dashes, Spacing, Groß/Klein). Dient als
|
||
deterministischer Dubletten-Kandidaten-Generator neben dem Embedding."""
|
||
kern, _ = _locker_mit_map(titel)
|
||
return kern
|
||
|
||
|
||
def abschnitte(text: str, max_chars: int = ABSCHNITT_CHARS) -> list[tuple[int, str]]:
|
||
"""Text an Absatzgrenzen in ≤max_chars-Abschnitte splitten (lost in the middle).
|
||
→ [(offset, abschnitt)]."""
|
||
if len(text) <= max_chars:
|
||
return [(0, text)]
|
||
out: list[tuple[int, str]] = []
|
||
start = 0
|
||
while start < len(text):
|
||
ende = min(start + max_chars, len(text))
|
||
if ende < len(text):
|
||
brk = text.rfind("\n\n", start, ende)
|
||
if brk <= start:
|
||
brk = text.rfind("\n", start, ende)
|
||
if brk > start:
|
||
ende = brk
|
||
out.append((start, text[start:ende]))
|
||
start = ende
|
||
return out
|
||
|
||
|
||
def ueberlappung(a: tuple[int, int], b: tuple[int, int]) -> float:
|
||
"""Span-Überlappung relativ zum kürzeren Span [0..1]."""
|
||
schnitt = max(0, min(a[1], b[1]) - max(a[0], b[0]))
|
||
kuerzer = min(a[1] - a[0], b[1] - b[0])
|
||
return schnitt / kuerzer if kuerzer > 0 else 0.0
|