Dédoublonnage : inclusion des graphies, non plus simple comptage

Le critère précédent comparait le NOMBRE de libellés. Deux copies peuvent en
porter autant tout en couvrant des graphies différentes : la copie aurait été
supprimée et ses graphies perdues.

Une copie n'est désormais supprimée que si toutes ses graphies sont déjà
couvertes par la version rattachée à une source. Une seule graphie manquante
suffit à la conserver.

Sur la production, le comptage avait déjà écarté 3 276 copies sur 26 191.
L'inclusion en écartera davantage — et surtout, elle rend la garantie
démontrable plutôt que probable.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: THIOYE97

app/scripts/dedupe_entities.py

@@ -69,29 +69,31 @@ def _sql_candidats(db) -> str:
       FROM entities e
      WHERE NOT ({ref})
 ),
--- Pour chaque nom, le nombre de libellés que porte la version rattachée
--- à une source : c'est lui qui détermine le pouvoir de rapprochement.
+-- Libellés portés par chaque entité, sous forme d'ensemble normalisé.
+-- Compter ne suffit pas : deux copies peuvent porter autant de libellés tout
+-- en couvrant des graphies différentes. Seule l'INCLUSION garantit qu'aucune
+-- graphie ne disparaît.
+libelles AS (
+    SELECT entity_id, ARRAY_AGG(DISTINCT name_normalized) AS jeu
+      FROM entity_names GROUP BY entity_id
+),
 officielles AS (
-    SELECT UPPER(TRIM(e.primary_name)) AS cle, MAX(k.n) AS n_libelles
+    SELECT UPPER(TRIM(e.primary_name)) AS cle,
+           ARRAY_AGG(DISTINCT g) AS jeu
       FROM entities e
       JOIN source_records sr ON sr.entity_id = e.id
-      JOIN (SELECT entity_id, COUNT(*) n FROM entity_names GROUP BY entity_id) k
-        ON k.entity_id = e.id
+      JOIN libelles l ON l.entity_id = e.id
+      CROSS JOIN LATERAL UNNEST(l.jeu) AS g
      GROUP BY UPPER(TRIM(e.primary_name))
-),
-richesse AS (
-    SELECT o.id, COUNT(en.id) AS n_libelles
-      FROM orphelines o LEFT JOIN entity_names en ON en.entity_id = o.id
-     GROUP BY o.id
 )
 SELECT o.id, o.primary_name, o.entity_type
   FROM orphelines o
   JOIN officielles f ON f.cle = o.cle
-  JOIN richesse   r ON r.id = o.id
- -- Une copie qui porte PLUS de libellés que sa jumelle est conservée :
- -- la supprimer ferait cesser de reconnaître des graphies aujourd'hui
- -- couvertes. Un alias perdu, c'est une personne qu'on ne détecte plus.
- WHERE r.n_libelles <= f.n_libelles
+  LEFT JOIN libelles lo ON lo.entity_id = o.id
+ -- La copie n'est supprimée que si TOUTES ses graphies sont déjà couvertes
+ -- par la version rattachée à une source. Une seule graphie manquante suffit
+ -- à la conserver : un alias perdu, c'est une personne qu'on ne détecte plus.
+ WHERE COALESCE(lo.jeu, ARRAY[]::text[]) <@ f.jeu
 """
 
 
@@ -113,30 +115,30 @@ def analyser(db) -> dict:
     # Contrôle de non-régression du filtrage : supprimer une copie qui porte
     # PLUS de libellés que sa jumelle ferait perdre du pouvoir de rapprochement.
     # Un nom d'alias en moins, c'est une personne qu'on cesse de reconnaître.
-    # Copies plus riches que leur jumelle : exclues de la suppression par la
-    # requête ci-dessus, comptées ici pour être signalées.
-    ref2 = ref
+    # Copies conservées parce qu'elles couvrent des graphies absentes de la
+    # version rattachée à une source.
     plus_riches = db.execute(text(f"""
-        WITH orph AS (
-            SELECT e.id, UPPER(TRIM(e.primary_name)) AS cle
-              FROM entities e WHERE NOT ({ref2})
+        WITH libelles AS (
+            SELECT entity_id, ARRAY_AGG(DISTINCT name_normalized) AS jeu
+              FROM entity_names GROUP BY entity_id
         ),
-        n_orph AS (
-            SELECT o.id, o.cle, COUNT(en.id) AS n
-              FROM orph o LEFT JOIN entity_names en ON en.entity_id = o.id
-             GROUP BY o.id, o.cle
+        orph AS (
+            SELECT e.id, UPPER(TRIM(e.primary_name)) AS cle
+              FROM entities e WHERE NOT ({ref})
         ),
-        n_off AS (
-            SELECT UPPER(TRIM(e.primary_name)) AS cle, MAX(k.n) AS n
+        off AS (
+            SELECT UPPER(TRIM(e.primary_name)) AS cle, ARRAY_AGG(DISTINCT g) AS jeu
               FROM entities e
               JOIN source_records sr ON sr.entity_id = e.id
-              JOIN (SELECT entity_id, COUNT(*) n FROM entity_names GROUP BY entity_id) k
-                ON k.entity_id = e.id
+              JOIN libelles l ON l.entity_id = e.id
+              CROSS JOIN LATERAL UNNEST(l.jeu) AS g
              GROUP BY UPPER(TRIM(e.primary_name))
         )
-        SELECT COUNT(*) FROM n_orph o
-          JOIN n_off f ON f.cle = o.cle
-         WHERE o.n > f.n
+        SELECT COUNT(*)
+          FROM orph o
+          JOIN off f ON f.cle = o.cle
+          LEFT JOIN libelles lo ON lo.entity_id = o.id
+         WHERE NOT (COALESCE(lo.jeu, ARRAY[]::text[]) <@ f.jeu)
     """)).scalar()
     return {"total": total, "sans_source": sans_source, "protegees": protegees,
             "candidats": candidats, "plus_riches": plus_riches,
@@ -174,7 +176,7 @@ def main(argv: list[str]) -> int:
         print(f"  sans enregistrement source: {a['sans_source']:>7}")
         print(f"  dont référencées ailleurs : {a['protegees']:>7}  (conservées)")
         print(f"  doublons supprimables     : {a['candidats']:>7}")
-        print(f"  dont plus riches en alias : {a['plus_riches']:>7}"
+        print(f"  dont graphies non couvertes: {a['plus_riches']:>7}"
               + ("  (conservées : elles couvrent des graphies que la version"
                  " rattachée à une source ignore)" if a["plus_riches"] else ""))
         if a["exemples"]:

tests/test_lbcft_modules.py

@@ -1063,3 +1063,31 @@ def test_dedupe_epargne_une_copie_plus_riche_en_alias(db):
     dedupe_entities.supprimer(db)
     assert db.execute(text("SELECT COUNT(*) FROM entities WHERE id = CAST(:i AS uuid)"),
                       {"i": copie}).scalar() == 1
+
+
+@pytest.mark.integration
+def test_dedupe_epargne_une_copie_aux_graphies_differentes(db):
+    """Compter les libellés ne suffit pas : deux copies peuvent en porter
+    autant tout en couvrant des graphies différentes. Seule l'inclusion
+    garantit qu'aucune graphie ne disparaît."""
+    from sqlalchemy import text
+    from app.scripts import dedupe_entities
+    from app.services.matching import normalize_name, tokenize
+
+    def alias(eid, valeur):
+        n = normalize_name(valeur)
+        db.execute(text("""
+            INSERT INTO entity_names (entity_id, name_raw, name_normalized,
+                                      name_tokens, is_primary, name_type)
+            VALUES (CAST(:i AS uuid), :r, :n, :t, false, 'ALIAS')
+        """), {"i": eid, "r": valeur, "n": n, "t": tokenize(n)})
+
+    officielle = _entite(db, "SEKOU TRAORE", avec_source=True)
+    alias(officielle, "SEKOU T")                 # 2 libellés au total
+    copie = _entite(db, "Sekou Traore")
+    alias(copie, "SEIKOU TRAORE")                # 2 aussi, mais AUTRE graphie
+    db.commit()
+
+    dedupe_entities.supprimer(db)
+    assert db.execute(text("SELECT COUNT(*) FROM entities WHERE id = CAST(:i AS uuid)"),
+                      {"i": copie}).scalar() == 1