Dédoublonnage : neutraliser la casse dans la comparaison des graphies

L'analyse en production annonçait 0 doublon supprimable — un résultat trop
absolu pour être vrai. Vérification sur un doublon connu : les noms bruts sont
identiques, seule la normalisation diffère. L'ancien agent écrivait en
minuscules (« vladimir putin »), le moteur d'ingestion en majuscules
(« VLADIMIR PUTIN »).

Le critère d'inclusion comparait donc des graphies qui ne pouvaient jamais
coïncider : il était vrai par construction, et le zéro n'avait aucun sens.

Le rapprochement, lui, n'en souffrait pas : pg_trgm ignore la casse.

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

Author: THIOYE97

app/scripts/dedupe_entities.py

@@ -69,12 +69,16 @@ def _sql_candidats(db) -> str:
       FROM entities e
      WHERE NOT ({ref})
 ),
--- Libellés portés par chaque entité, sous forme d'ensemble normalisé.
+-- Libellés portés par chaque entité, sous forme d'ensemble.
+-- La casse est neutralisée : l'ancien agent normalisait en minuscules, le
+-- moteur d'ingestion en majuscules. Comparer sans en tenir compte revenait à
+-- ne jamais rien trouver — le critère était vrai par construction, donc vide
+-- de sens. (Le rapprochement, lui, n'en souffre pas : pg_trgm ignore la casse.)
 -- 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
+    SELECT entity_id, ARRAY_AGG(DISTINCT UPPER(name_normalized)) AS jeu
       FROM entity_names GROUP BY entity_id
 ),
 officielles AS (
@@ -119,7 +123,7 @@ def analyser(db) -> dict:
     # version rattachée à une source.
     plus_riches = db.execute(text(f"""
         WITH libelles AS (
-            SELECT entity_id, ARRAY_AGG(DISTINCT name_normalized) AS jeu
+            SELECT entity_id, ARRAY_AGG(DISTINCT UPPER(name_normalized)) AS jeu
               FROM entity_names GROUP BY entity_id
         ),
         orph AS (

tests/test_lbcft_modules.py

@@ -1091,3 +1091,28 @@ def alias(eid, valeur):
     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_compare_les_graphies_sans_tenir_compte_de_la_casse(db):
+    """L'ancien agent normalisait en minuscules, le moteur d'ingestion en
+    majuscules. Comparer sans neutraliser la casse rendait le critère vrai par
+    construction : AUCUN doublon n'était jamais détecté, alors que les noms
+    bruts étaient identiques."""
+    from sqlalchemy import text
+    from app.scripts import dedupe_entities
+    from app.services.matching import tokenize
+
+    officielle = _entite(db, "IBRAHIMA SOW", avec_source=True)
+    copie = _entite(db, "Ibrahima Sow")
+    # On rejoue l'écart : la copie porte la graphie en minuscules.
+    db.execute(text("UPDATE entity_names SET name_normalized = LOWER(name_normalized) "
+                    "WHERE entity_id = CAST(:i AS uuid)"), {"i": copie})
+    db.commit()
+
+    assert dedupe_entities.analyser(db)["candidats"] >= 1
+    dedupe_entities.supprimer(db)
+    assert db.execute(text("SELECT COUNT(*) FROM entities WHERE id = CAST(:i AS uuid)"),
+                      {"i": copie}).scalar() == 0
+    assert db.execute(text("SELECT COUNT(*) FROM entities WHERE id = CAST(:i AS uuid)"),
+                      {"i": officielle}).scalar() == 1