test(core): verrouiller le fallback edsnlp sur drugs.json corrompu (revue qualité)

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

anonymisation_cli_onefile.spec

@@ -29,6 +29,7 @@ datas = []
 for relative_path, target_dir in [
     ("config", "config"),
     ("data/bdpm", "data/bdpm"),
+    ("data/edsnlp", "data/edsnlp"),
     ("data/finess", "data/finess"),
     ("data/insee", "data/insee"),
     ("models/camembert-bio-deid/onnx", "models/camembert-bio-deid/onnx"),

anonymisation_gui_v6_onefile.spec

@@ -26,6 +26,7 @@ datas = []
 for relative_path, target_dir in [
     ("config", "config"),
     ("data/bdpm", "data/bdpm"),
+    ("data/edsnlp", "data/edsnlp"),
     ("data/finess", "data/finess"),
     ("data/insee", "data/insee"),
     ("models/camembert-bio-deid/onnx", "models/camembert-bio-deid/onnx"),

anonymizer_core_refactored_onnx.py

@@ -256,24 +256,62 @@ except ImportError:
 APP_VERSION = "0.11.0-mvp"  # incrémenter avant rebuild release
 
 
+# Gazetteer médicaments extrait de edsnlp/resources/drugs.json et versionné dans
+# le dépôt (data/edsnlp/drugs.json). Lu EN PREMIER au runtime pour rester complet
+# dans le build Windows torch-free (Plan 3), où edsnlp — qui importe torch en dur —
+# n'est pas disponible. En mode frozen, __file__ pointe vers _MEIPASS, donc ce
+# chemin résout le fichier embarqué (cf _load_bdpm_medication_names).
+_EDSNLP_DRUGS_DATA_PATH = Path(__file__).parent / "data" / "edsnlp" / "drugs.json"
+
+
+def _parse_edsnlp_drugs_json(path: Path) -> set:
+    """Parse un drugs.json edsnlp (code ATC → liste de noms).
+
+    Retourne le set des noms mono-mot de longueur >= 4, en minuscules.
+    Parsing IDENTIQUE à l'historique (garantie de non-régression du gazetteer)."""
+    import json as _json
+
+    data = _json.loads(path.read_text(encoding="utf-8"))
+    result = set()
+    for _code, names in data.items():
+        for name in names:
+            if " " not in name and len(name) >= 4:
+                result.add(name.lower())
+    return result
+
+
 def _load_edsnlp_drug_names() -> set:
-    """Charge les noms de médicaments mono-mot depuis edsnlp/resources/drugs.json.
-    Retourne un set lowercase. Fallback silencieux si edsnlp absent."""
+    """Charge les noms de médicaments mono-mot pour la whitelist anti-faux-positif.
+
+    Ordre de résolution (torch-free) :
+      1. data/edsnlp/drugs.json (fichier versionné, 0 dépendance edsnlp/torch) ;
+      2. fallback : package edsnlp (BASE_DIR/resources/drugs.json), comportement
+         historique en mode dev ;
+      3. échec total → log.warning explicite + set() (dégradation rendue visible).
+
+    Retourne un set lowercase."""
+    # 1. Fichier data versionné (disponible aussi en frozen torch-free).
+    try:
+        if _EDSNLP_DRUGS_DATA_PATH.exists():
+            return _parse_edsnlp_drugs_json(_EDSNLP_DRUGS_DATA_PATH)
+    except Exception as exc:  # fichier corrompu → on tente le fallback
+        log.debug("Lecture %s échouée : %s", _EDSNLP_DRUGS_DATA_PATH, exc)
+
+    # 2. Fallback package edsnlp (dev).
     try:
         import edsnlp as _edsnlp
         drugs_path = _edsnlp.BASE_DIR / "resources" / "drugs.json"
-        if not drugs_path.exists():
-            return set()
-        import json as _json
-        data = _json.loads(drugs_path.read_text(encoding="utf-8"))
-        result = set()
-        for _code, names in data.items():
-            for name in names:
-                if " " not in name and len(name) >= 4:
-                    result.add(name.lower())
-        return result
-    except Exception:
-        return set()
+        if drugs_path.exists():
+            return _parse_edsnlp_drugs_json(drugs_path)
+    except Exception as exc:
+        log.debug("Fallback package edsnlp indisponible : %s", exc)
+
+    # 3. Échec total : rendre la dégradation visible (risque de sur-masquage).
+    log.warning(
+        "Gazetteer médicaments edsnlp indisponible (ni data/edsnlp/drugs.json "
+        "ni package edsnlp) — whitelist médicaments réduite, risque de sur-masquage"
+    )
+    return set()
 
 
 def _load_bdpm_medication_names() -> set:

data/edsnlp/README.md

@@ -0,0 +1,32 @@
+# data/edsnlp — Gazetteer médicaments (extrait de edsnlp)
+
+## Contenu
+
+- `drugs.json` : dictionnaire code ATC → liste de noms de médicaments (1968 codes),
+  extrait de **edsnlp 0.20.0**, fichier `edsnlp/resources/drugs.json`.
+
+## Usage
+
+Ce fichier alimente `_load_edsnlp_drug_names()` dans
+`anonymizer_core_refactored_onnx.py`. Les noms mono-mot de longueur ≥ 4 sont
+chargés (en minuscules) comme **gazetteer anti-faux-positif** : ils empêchent
+que des noms de médicaments (ex. « elisor », « kessar », « muse », « sirop »)
+soient pris à tort pour des noms de personnes et sur-masqués.
+
+Il est versionné dans le dépôt (et non lu depuis le package `edsnlp` au
+runtime) afin que la whitelist médicaments reste complète dans le build Windows
+**torch-free** (Plan 3), où `edsnlp` — qui importe `torch` en dur — n'est pas
+disponible.
+
+## Attribution / Licence
+
+`drugs.json` provient du projet **edsnlp**, distribué sous licence
+**BSD-3-Clause**.
+
+> Copyright (c) 2021, Assistance Publique - Hôpitaux de Paris
+>
+> Redistribution and use in source and binary forms, with or without
+> modification, are permitted under the terms of the BSD-3-Clause license.
+
+Source : https://github.com/aphp/edsnlp — `edsnlp/resources/drugs.json`
+(version 0.20.0).

tests/unit/test_edsnlp_drugs_static.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Tests — chargement du gazetteer médicaments edsnlp depuis data/ (torch-free).
+
+Contexte : le build Windows torch-free (Plan 3) retire torch. Or edsnlp importe
+torch en dur → en frozen, `import edsnlp` échoue et l'ancienne
+`_load_edsnlp_drug_names()` retournait silencieusement set() → whitelist
+médicaments amputée de ~4206 noms → sur-masquage de médicaments pris pour des
+personnes.
+
+Correctif (Option A+B) :
+  A. charger d'abord depuis data/edsnlp/drugs.json (versionné, 0 dépendance) ;
+     fallback sur le package edsnlp (dev).
+  B. log.warning explicite si NI le fichier data NI le package ne sont dispo.
+
+Aucun mock du contenu du gazetteer : on utilise le VRAI fichier data extrait.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+import anonymizer_core_refactored_onnx as core
+
+ROOT_DIR = Path(__file__).resolve().parents[2]
+DATA_DRUGS = ROOT_DIR / "data" / "edsnlp" / "drugs.json"
+
+# Nombre exact de noms mono-mot (len>=4, lowercase) issus de drugs.json 0.20.0.
+# C'est aussi le compte historique produit par l'ancienne fonction en dev :
+# la garantie de non-régression est que la whitelist n'est PAS réduite.
+EXPECTED_COUNT = 4206
+
+# Noms de médicaments réellement présents dans le gazetteer extrait et qui
+# entrent en conflit avec des noms/prénoms INSEE (vérifiés, pas inventés).
+CONFLICT_NAMES = ["elisor", "kessar", "panos", "muse", "sirop"]
+
+
+def test_data_file_present_and_parses():
+    """Le fichier data doit exister et contenir 1968 codes ATC."""
+    import json
+
+    assert DATA_DRUGS.exists(), f"fichier data manquant : {DATA_DRUGS}"
+    data = json.loads(DATA_DRUGS.read_text(encoding="utf-8"))
+    assert len(data) == 1968
+
+
+def test_load_from_data_exact_count():
+    """Chargement depuis data/edsnlp/drugs.json → set de 4206 noms exactement."""
+    result = core._load_edsnlp_drug_names()
+    assert isinstance(result, set)
+    assert len(result) == EXPECTED_COUNT
+
+
+def test_load_contains_conflict_names():
+    """Les noms-conflits INSEE vérifiés doivent être dans le set (anti-sur-masquage)."""
+    result = core._load_edsnlp_drug_names()
+    for name in CONFLICT_NAMES:
+        assert name in result, f"{name!r} absent du gazetteer médicaments"
+
+
+def test_fallback_to_package_when_data_absent(monkeypatch, tmp_path):
+    """Si le fichier data est absent mais edsnlp importable → fallback package,
+    même résultat (4206)."""
+    pytest.importorskip("edsnlp")
+    # Pointer la constante de chemin data vers un dossier vide → fichier absent.
+    missing = tmp_path / "drugs.json"
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", missing)
+    assert not missing.exists()
+
+    result = core._load_edsnlp_drug_names()
+    assert len(result) == EXPECTED_COUNT
+    for name in CONFLICT_NAMES:
+        assert name in result
+
+
+def test_warning_when_both_sources_absent(monkeypatch, tmp_path, caplog):
+    """Si le fichier data est absent ET edsnlp non importable → set() + log.warning."""
+    import builtins
+
+    missing = tmp_path / "drugs.json"
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", missing)
+
+    _real_import = builtins.__import__
+
+    def _fake_import(name, *args, **kwargs):
+        if name == "edsnlp" or name.startswith("edsnlp."):
+            raise ImportError("edsnlp indisponible (torch-free)")
+        return _real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", _fake_import)
+
+    with caplog.at_level("WARNING", logger=core.log.name):
+        result = core._load_edsnlp_drug_names()
+
+    assert result == set()
+    assert any(
+        "edsnlp" in rec.message.lower() and rec.levelname == "WARNING"
+        for rec in caplog.records
+    ), "aucun log.warning émis lors de l'échec total"
+
+
+def test_data_source_matches_package_source(monkeypatch, tmp_path):
+    """Le set chargé depuis data doit être IDENTIQUE à celui du fallback package
+    (garantie que l'extraction n'altère pas le gazetteer)."""
+    pytest.importorskip("edsnlp")
+    from_data = core._load_edsnlp_drug_names()
+
+    missing = tmp_path / "drugs.json"
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", missing)
+    from_package = core._load_edsnlp_drug_names()
+
+    assert from_data == from_package
+
+
+def test_corrupted_data_falls_back_to_package(monkeypatch, tmp_path):
+    """Fichier data PRÉSENT mais corrompu + edsnlp DISPONIBLE → fail-safe :
+    retombe sur le package et retourne 4206 (jamais un set partiel/tronqué)."""
+    pytest.importorskip("edsnlp")
+    corrupt = tmp_path / "drugs.json"
+    corrupt.write_text("{ invalide", encoding="utf-8")
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", corrupt)
+
+    result = core._load_edsnlp_drug_names()
+    assert len(result) == EXPECTED_COUNT
+    for name in CONFLICT_NAMES:
+        assert name in result
+
+
+def test_corrupted_data_and_no_package_warns(monkeypatch, tmp_path, caplog):
+    """Fichier data corrompu ET edsnlp INDISPONIBLE → set() vide + log.warning
+    (dégradation rendue visible, pas de silence)."""
+    import builtins
+
+    corrupt = tmp_path / "drugs.json"
+    corrupt.write_text("{ invalide", encoding="utf-8")
+    monkeypatch.setattr(core, "_EDSNLP_DRUGS_DATA_PATH", corrupt)
+
+    _real_import = builtins.__import__
+
+    def _fake_import(name, *args, **kwargs):
+        if name == "edsnlp" or name.startswith("edsnlp."):
+            raise ImportError("edsnlp indisponible (torch-free)")
+        return _real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", _fake_import)
+
+    with caplog.at_level("WARNING", logger=core.log.name):
+        result = core._load_edsnlp_drug_names()
+
+    assert result == set()
+    assert any(
+        "edsnlp" in rec.message.lower() and rec.levelname == "WARNING"
+        for rec in caplog.records
+    ), "aucun log.warning émis lors de l'échec total (data corrompu + pas de package)"