"""Propagation document-entier des personnes detectees (analyse §3.1). Le piege n°1 du juridique : le NER trouve "Jean Dupont" phrase 1, mais rate "DUPONT", "M. Dupont" ou "J. Dupont" phrase 12 — et un nom seul qui passe en clair est une fuite. Cette passe deterministe prend les PERSON deja detectees et cherche leurs variantes de surface dans tout le document. Garde-fou : beaucoup de patronymes francais sont des mots communs (Petit, Blanc, Roy). On ne matche JAMAIS en minuscules : uniquement la forme capitalisee exacte ("Dupont"), le tout-majuscules ("DUPONT"), leurs versions sans accents, precedees ou non d'un titre et/ou d'une initiale. Un faux positif sur "M. Petit" en tete de phrase reste du sur-masquage benin. Cette normalisation est le socle du moteur de reversibilite (meme valeur -> meme jeton) : les variantes propagees ici partageront le jeton PERSON_n. """ import re import unicodedata _TITLES = r"(?:M\.|Mme|Mlle|Me|Dr|Monsieur|Madame|Maître|Maitre)" def _strip_accents(s: str) -> str: return "".join(c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn") def _name_parts(value: str) -> tuple[str | None, str | None]: """(prenom, nom) depuis la surface d'un span PERSON, titres exclus.""" tokens = [t for t in re.split(r"[\s]+", value.strip()) if t and not re.fullmatch(_TITLES, t)] tokens = [t for t in tokens if re.fullmatch(r"[^\W\d_].*", t)] if not tokens: return None, None if len(tokens) == 1: return None, tokens[0] return tokens[0], tokens[-1] def _variant_pattern(first: str | None, last: str) -> str: """Regex des variantes plausibles d'une personne, jamais en minuscules.""" last_forms = {re.escape(last), re.escape(last.upper())} stripped = _strip_accents(last) last_forms |= {re.escape(stripped), re.escape(stripped.upper())} lasts = "|".join(sorted(last_forms, key=len, reverse=True)) initial = "" if first: initial = rf"(?:{re.escape(first[0].upper())}\.\s*)?" first_forms = {re.escape(first), re.escape(first.upper())} firsts = "|".join(sorted(first_forms, key=len, reverse=True)) initial = rf"(?:(?:{firsts})\s+|{re.escape(first[0].upper())}\.\s*)?" return rf"(?:{_TITLES}\s+)?{initial}(?:{lasts})\b" def _fold(s: str) -> str: """Repli casse + accents en preservant la LONGUEUR : indispensable pour que les offsets trouves dans la version repliee soient valables dans le texte d'origine.""" out = [] for ch in s: d = unicodedata.normalize("NFD", ch) base = "".join(c for c in d if unicodedata.category(c) != "Mn") out.append((base[0] if base else ch).lower()) return "".join(out) def propagate_exact(text: str, spans: list[dict], types=("COMPANY", "CITY", "ADDRESS")) -> list[dict]: """Coherence intra-document : toute mention d'une valeur deja detectee ailleurs dans le document est masquee aussi. Audit emails reels 2026-07-29 : la meme societe etait prise a sa 1re occurrence et ratee aux suivantes (ou l'inverse) — ~15 fuites COMPANY recuperables sans modele. Residu 2026-07-31 : une meme societe ecrite « Vegetalents » a la ligne 3 et « VEGETALENTS » dans la signature echappait au match exact. On replie donc casse et accents. Garde-fou contre le sur-masquage : la mention retrouvee doit porter au moins une majuscule, sinon un nom propre homographe d'un mot commun ferait masquer le mot commun. """ occupied = set() for s in spans: occupied.update(range(s["start"], s["end"])) values = {} for s in spans: v = s["value"].strip() if s["type"] in types and len(v) >= 4 and not v.isdigit(): values.setdefault(v, s["type"]) folded_text = _fold(text) extra = [] for value, etype in values.items(): needle = _fold(value) start = 0 while True: i = folded_text.find(needle, start) if i < 0: break start = i + 1 j = i + len(value) rng = set(range(i, j)) if rng & occupied: continue # frontieres de mot if i > 0 and text[i - 1].isalnum(): continue if j < len(text) and text[j].isalnum(): continue surface = text[i:j] if surface != value and not any(c.isupper() for c in surface): continue occupied |= rng extra.append({"start": i, "end": j, "type": etype, "value": surface}) return extra def propagate(text: str, spans: list[dict]) -> list[dict]: """Retourne les mentions supplementaires de personnes deja detectees.""" persons = [s for s in spans if s["type"] == "PERSON"] if not persons: return [] occupied = set() for s in spans: occupied.update(range(s["start"], s["end"])) extra = [] seen_patterns = set() for p in persons: first, last = _name_parts(p["value"]) if last is None or len(last) < 3: continue pattern = _variant_pattern(first, last) if pattern in seen_patterns: continue seen_patterns.add(pattern) for m in re.finditer(pattern, text): rng = set(range(m.start(), m.end())) if rng & occupied: continue occupied |= rng extra.append({"start": m.start(), "end": m.end(), "type": "PERSON", "value": m.group(0)}) return extra # --- Enumerations --------------------------------------------------------- # Residu 2026-07-31 : les societes ratees sont des mots uniques sans forme # juridique ni declencheur (EBP, Sage, Pennylane, GoCardless). Le modele en # attrape une sur trois dans « on a compare EBP, Pennylane et Sage » : les # voisins d'une liste partagent le type de leur ancre. _ITEM = r"[A-ZÀ-ÖØ-Þ][\wÀ-ÿ&'’.-]*(?:[ -][A-ZÀ-ÖØ-Þ0-9][\wÀ-ÿ&'’.-]*){0,2}" _LISTE = re.compile( rf"{_ITEM}(?:\s*,\s*{_ITEM})*(?:\s*,\s*|\s+(?:et|ou)\s+){_ITEM}") _SEP = re.compile(r"\s*,\s*|\s+(?:et|ou)\s+") def propagate_enumerations(text: str, spans: list[dict], types=("COMPANY",)) -> list[dict]: """Dans une liste d'elements capitalises, si un element est deja typé, les autres heritent du meme type. Garde-fous : la liste doit compter au moins trois elements (deux suffit a produire des faux positifs sur « Bonjour Marc, Pennylane »), l'ancre doit couvrir un element entier, et un element deja detecte sous un autre type bloque toute la liste (une enumeration de personnes ne doit jamais basculer en societes). """ if not any(s["type"] in types for s in spans): return [] par_pos = {} for s in spans: for k in range(s["start"], s["end"]): par_pos[k] = s["type"] extra = [] for m in _LISTE.finditer(text): items, pos = [], m.start() for part in _SEP.split(m.group(0)): i = text.find(part, pos) if i < 0: continue items.append((i, i + len(part), part)) pos = i + len(part) if len(items) < 3: continue vus = {par_pos.get(k) for i, j, _ in items for k in range(i, j)} ancres = vus & set(types) if not ancres or (vus - {None} - set(types)): continue etype = sorted(ancres)[0] for i, j, part in items: if any(k in par_pos for k in range(i, j)): continue if len(part) < 3 or _norm_common(part): continue for k in range(i, j): par_pos[k] = etype extra.append({"start": i, "end": j, "type": etype, "value": part}) return extra _MOTS_LISTE = { "bonjour", "bonsoir", "merci", "cordialement", "salut", "madame", "monsieur", "oui", "non", "ok", "bien", "donc", "mais", "puis", "ensuite", "enfin", "voila", "aussi", "encore", "toujours", "jamais", } def _norm_common(part: str) -> bool: base = _strip_accents(part).lower().strip(".,;:!?)") return base in _MOTS_LISTE