| """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 |
| |
| 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 |
|
|
|
|
| |
| |
| |
| |
| |
|
|
| _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 |
|
|
