"""Textnormalisierung und Fuzzy-Vergleich (RapidFuzz). Wichtig: Die Normalisierung wird ausschliesslich fuer Vergleiche und fuer den Suchindex verwendet. Der gespeicherte Originaltext bleibt unveraendert. """ from __future__ import annotations import re import unicodedata from dataclasses import dataclass from rapidfuzz import fuzz # Satzzeichen und Symbole, die beim Vergleich stoeren. Wortzeichen (Buchstaben, # Ziffern, Unterstrich) bleiben erhalten. _PUNCT_RE = re.compile(r"[^\w\s]", re.UNICODE) _WHITESPACE_RE = re.compile(r"\s+", re.UNICODE) # Sehr haeufige deutsche Fuellwoerter. Sie werden beim Vorfilter nicht als # belastbare Uebereinstimmung gewertet, damit "der/die/das" allein keine # Kandidaten erzeugt. STOPWORDS = frozenset( { "der", "die", "das", "den", "dem", "des", "ein", "eine", "einer", "eines", "einem", "einen", "und", "oder", "aber", "als", "auch", "auf", "aus", "bei", "bin", "bis", "da", "dann", "dass", "doch", "dort", "du", "durch", "er", "es", "hat", "ich", "ihm", "ihn", "ihr", "im", "in", "ist", "mit", "nach", "nicht", "noch", "nun", "nur", "ob", "so", "sich", "sie", "sind", "um", "und", "vom", "von", "vor", "war", "was", "wenn", "wie", "wir", "wo", "zu", "zum", "zur", "the", "and", "of", "to", "in", "a", "is", } ) def normalize_text(text: str) -> str: """Normalisiert Text fuer Vergleiche: NFKC, Kleinschreibung, ohne Satzzeichen.""" if not text: return "" normalized = unicodedata.normalize("NFKC", text).casefold() normalized = _PUNCT_RE.sub(" ", normalized) return _WHITESPACE_RE.sub(" ", normalized).strip() def tokenize(text: str) -> list[str]: """Normalisierte Wortliste eines Textes.""" normalized = normalize_text(text) return normalized.split() if normalized else [] def tokenize_original(text: str) -> list[str]: """Wortliste mit Originaltext inklusive anhängender Satzzeichen (fuer die Ausgabe).""" if not text: return [] return [token for token in _WHITESPACE_RE.split(text.strip()) if token] def token_norm(token: str) -> str: """Normalisiert ein einzelnes Originalwort.""" return normalize_text(token) def is_stopword(token: str) -> bool: return token in STOPWORDS @dataclass(frozen=True) class WindowScore: """Ergebnis eines Fenstervergleichs.""" score: float exact: bool def score_window(query_normalized: str, window_normalized: str) -> WindowScore: """Vergleicht Suchanfrage und Textfenster und liefert einen Wert 0-100. Es werden mehrere RapidFuzz-Kennzahlen kombiniert, damit fehlende, zusaetzliche, vertauschte oder falsch erkannte Woerter nicht sofort zum Verlust des Treffers fuehren. """ if not query_normalized or not window_normalized: return WindowScore(0.0, False) if query_normalized == window_normalized: return WindowScore(100.0, True) # Hinweis: Eine reine Teilzeichenketten-Pruefung ist hier absichtlich NICHT # enthalten. Sie wuerde z. B. das Fenster "Leider" fuer die Anfrage # "Leider zu spaet" mit 100 bewerten und den Treffer auf ein Wort # zusammenfallen lassen. Teiluebereinstimmungen werden stattdessen ueber # die gewichteten RapidFuzz-Kennzahlen unten bewertet. ratio = fuzz.ratio(query_normalized, window_normalized) token_set = fuzz.token_set_ratio(query_normalized, window_normalized) weighted = fuzz.WRatio(query_normalized, window_normalized) partial = fuzz.partial_ratio(query_normalized, window_normalized) # partial_ratio neigt bei kurzen Fenstern zu hohen Werten, daher nur # gedämpft einbeziehen. # token_set_ratio/WRatio/partial_ratio bewerten eine Teilmenge der Anfrage # mit 100. Ohne Daempfung wuerde ein einzelnes Wort einer mehrwoertrigen # Anfrage als perfekter Treffer gelten. Daher werden diese Kennzahlen mit # dem Laengenverhaeltnis gewichtet, wenn das Fenster kuerzer ist. length_factor = min(1.0, len(window_normalized) / max(1, len(query_normalized))) score = max( ratio, token_set * length_factor, weighted * length_factor, partial * 0.92 * length_factor, ) return WindowScore(min(100.0, round(score, 2)), False) def token_overlap(query_tokens: list[str], window_tokens: list[str]) -> float: """Anteil der Anfragewoerter, die im Fenster vorkommen (0..1).""" if not query_tokens: return 0.0 window_set = set(window_tokens) hits = sum(1 for token in query_tokens if token in window_set) return hits / len(query_tokens) def significant_overlap(query_tokens: list[str], window_tokens: list[str]) -> float: """Wie :func:`token_overlap`, aber Fuellwoerter zaehlen nur halb.""" if not query_tokens: return 0.0 window_set = set(window_tokens) total = 0.0 hits = 0.0 for token in query_tokens: weight = 0.5 if is_stopword(token) else 1.0 total += weight if token in window_set: hits += weight if total == 0: return 0.0 return hits / total def _escape_fts_token(token: str) -> str: return '"' + token.replace('"', '""') + '"' def build_fts_query(tokens: list[str], prefix_min_length: int = 4) -> str: """Baut eine FTS5-Anfrage aus ODER-verknuepften Woertern. Praefixsuche fuer laengere Woerter faengt deutsche Flexionsformen und Zusammensetzungen ab. Die Anfrage ist bewusst weit gefasst: sie dient nur der Kandidatensuche, die Bewertung erfolgt spaeter per Fuzzy-Vergleich. """ parts: list[str] = [] seen: set[str] = set() for token in tokens: if len(token) < 2 or token in seen: continue seen.add(token) escaped = _escape_fts_token(token) if len(token) >= prefix_min_length: parts.append(f"{escaped}*") else: parts.append(escaped) return " OR ".join(parts) def trigram_terms(tokens: list[str], max_terms: int = 32) -> list[str]: """Sinnvolle Trigramm-Anfragen aus laengeren Anfragewoertern.""" terms: list[str] = [] seen: set[str] = set() for token in tokens: if len(token) < 4 or token in seen: continue seen.add(token) terms.append(token) if len(terms) >= max_terms: break return terms