detect/propagation.py

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