rahim237cm Claude Opus 5.5 commited on
Commit
baaafb1
·
1 Parent(s): 6e91d61

fix(recherche): la passe floue compare les titres mot par mot

Browse files

« peine de mort au cameroun » rendait en tete des decrets de pret, a
egalite (0,959), devant les 11 articles du Code penal sur la peine de
mort. La passe floue sur les titres, faite pour rattraper les fautes de
frappe, comparait la requete ENTIERE : « de », « au » et « cameroun »
font plus de la moitie de ses trigrammes, et tout titre en « ... de ...
au Cameroun » passait le seuil (0,516 pour 0,5). Etiquetes correspondance
de titre, ces decrets passaient devant toute correspondance d'article.

- Chaque mot significatif (sans mots vides, ni « cameroun », « loi »,
« decret »...) doit se retrouver dans le titre, meme mal orthographie.
Les fautes de frappe (« nominaton », « code miner ») restent rattrapees.
- Le mode entre dans la cle du cache : une recherche texte et une
recherche hybride de la meme requete se servaient l'une l'autre.
- scripts/eval/evaluer_recherche.py rejoue la requete de la page sur les
102 questions relues et 10 requetes temoins.

Mesure (102 questions), mode hybride : hit@1 0,402 -> 0,441, hit@10
0,824 -> 0,863, 9 questions ameliorees, aucune degradee. Mode texte :
hit@1 0,098 -> 0,137 ; une question degradee (rang 13 -> absente).

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

app/services/postgres_search_service.py CHANGED
@@ -25,6 +25,8 @@ Version: 3.0.0 (PostgreSQL native)
25
  import hashlib
26
  import json
27
  import logging
 
 
28
  from datetime import datetime, timedelta, timezone
29
  from typing import Any, Dict, List, Optional, Sequence
30
 
@@ -67,11 +69,18 @@ MAX_CHUNKS_PER_LAW = 3
67
  CACHE_SCHEMA_VERSION = "v4"
68
 
69
 
70
- def _make_cache_key(query: str, filters: Optional[SearchFilters], limit: int, offset: int) -> str:
71
- """Génère une clé de cache SHA-256 déterministe."""
 
 
 
 
 
 
 
72
  filters_dict = filters.model_dump() if filters else {}
73
  raw = (
74
- f"{CACHE_SCHEMA_VERSION}|{query}|"
75
  f"{json.dumps(filters_dict, sort_keys=True)}|{limit}|{offset}"
76
  )
77
  return hashlib.sha256(raw.encode()).hexdigest()[:64]
@@ -697,6 +706,34 @@ def _rows_to_chunks(rows: Sequence[Any], source: str) -> List[ChunkResult]:
697
  return chunks
698
 
699
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
700
  async def search_titles_trgm_pg(
701
  db: AsyncSession,
702
  query: str,
@@ -722,8 +759,29 @@ async def search_titles_trgm_pg(
722
  `apply_trigram_threshold`) : l'operateur `%>` filtre sur le reglage de
723
  session, si bien qu'un predicat `word_similarity(...) >= 0.5` ajoute ici
724
  serait du code mort — rien sous le defaut de 0,6 ne lui parviendrait.
725
- """
 
 
 
 
 
 
 
 
 
 
 
 
 
 
726
  params: Dict[str, Any] = {"query": query, "limit": limit}
 
 
 
 
 
 
 
727
  where_extra = _law_filter_clauses(filters, params)
728
 
729
  sql = text(f"""
@@ -745,13 +803,13 @@ async def search_titles_trgm_pg(
745
  c.name AS category_name,
746
  TRUE AS title_match,
747
  GREATEST(
748
- word_similarity(immutable_unaccent(:query), immutable_unaccent(l.title)),
749
  word_similarity(immutable_unaccent(:query), immutable_unaccent(l.reference))
750
  ) AS rank
751
  FROM laws l
752
  LEFT JOIN categories c ON c.id = l.category_id
753
  WHERE (
754
- immutable_unaccent(l.title) %> immutable_unaccent(:query)
755
  OR immutable_unaccent(l.reference) %> immutable_unaccent(:query)
756
  )
757
  {where_extra}
 
25
  import hashlib
26
  import json
27
  import logging
28
+ import re
29
+ import unicodedata
30
  from datetime import datetime, timedelta, timezone
31
  from typing import Any, Dict, List, Optional, Sequence
32
 
 
69
  CACHE_SCHEMA_VERSION = "v4"
70
 
71
 
72
+ def _make_cache_key(
73
+ query: str, filters: Optional[SearchFilters], limit: int, offset: int, mode: str
74
+ ) -> str:
75
+ """
76
+ Génère une clé de cache SHA-256 déterministe.
77
+
78
+ Le mode en fait partie : sans lui, une recherche « text » et une recherche
79
+ « hybrid » de la meme requete se servaient l'une l'autre pendant tout le TTL.
80
+ """
81
  filters_dict = filters.model_dump() if filters else {}
82
  raw = (
83
+ f"{CACHE_SCHEMA_VERSION}|{mode}|{query}|"
84
  f"{json.dumps(filters_dict, sort_keys=True)}|{limit}|{offset}"
85
  )
86
  return hashlib.sha256(raw.encode()).hexdigest()[:64]
 
706
  return chunks
707
 
708
 
709
+ # Mots ignores par la passe floue sur les titres : les mots vides, et ceux que
710
+ # presque tous les titres du corpus contiennent. Ils ne designent aucun texte.
711
+ MOTS_SANS_POIDS_TITRE = frozenset({
712
+ "les", "des", "aux", "une", "par", "pour", "sur", "dans", "avec", "sans",
713
+ "que", "qui", "quoi", "est", "sont", "son", "ses", "leur", "leurs", "entre",
714
+ "cameroun", "camerounais", "camerounaise", "republique",
715
+ "loi", "lois", "decret", "decrets", "ordonnance", "arrete", "portant",
716
+ "relatif", "relative", "the", "and", "law",
717
+ })
718
+
719
+
720
+ def mots_significatifs(query: str) -> List[str]:
721
+ """
722
+ Les mots de la requete qui doivent se retrouver dans un titre : sans
723
+ accents, en minuscules, d'au moins trois caracteres, hors
724
+ MOTS_SANS_POIDS_TITRE, sans doublon.
725
+ """
726
+ sans_accents = "".join(
727
+ c for c in unicodedata.normalize("NFD", query.lower())
728
+ if unicodedata.category(c) != "Mn"
729
+ )
730
+ mots: List[str] = []
731
+ for mot in re.findall(r"[a-z0-9]+", sans_accents):
732
+ if len(mot) >= 3 and mot not in MOTS_SANS_POIDS_TITRE and mot not in mots:
733
+ mots.append(mot)
734
+ return mots
735
+
736
+
737
  async def search_titles_trgm_pg(
738
  db: AsyncSession,
739
  query: str,
 
759
  `apply_trigram_threshold`) : l'operateur `%>` filtre sur le reglage de
760
  session, si bien qu'un predicat `word_similarity(...) >= 0.5` ajoute ici
761
  serait du code mort — rien sous le defaut de 0,6 ne lui parviendrait.
762
+
763
+ MOT PAR MOT, ET NON LA REQUETE ENTIERE. Comparee d'un bloc, une requete de
764
+ plusieurs mots passait le seuil sur ses mots les plus banals : dans
765
+ « peine de mort au cameroun », « de », « au » et « cameroun » font plus de
766
+ la moitie des trigrammes, et tout titre en « ... de ... au Cameroun »
767
+ sortait a 0,516 — des decrets de pret, classes en tete comme
768
+ correspondances de titre, devant les 11 articles du Code penal sur la
769
+ peine de mort. Chaque mot significatif (`mots_significatifs`) doit
770
+ desormais se retrouver, meme mal orthographie, dans le titre. Sans mot
771
+ significatif, la passe ne rend rien. La reference, elle, garde la
772
+ comparaison d'un bloc : c'est un identifiant, pas une phrase.
773
+ """
774
+ mots = mots_significatifs(query)
775
+ if not mots:
776
+ return []
777
  params: Dict[str, Any] = {"query": query, "limit": limit}
778
+ for i, mot in enumerate(mots):
779
+ params[f"mot_{i}"] = mot
780
+ titre = "immutable_unaccent(l.title)"
781
+ chaque_mot = " AND ".join(f"{titre} %> :mot_{i}" for i in range(len(mots)))
782
+ similarite_titre = " + ".join(
783
+ f"word_similarity(:mot_{i}, {titre})" for i in range(len(mots))
784
+ )
785
  where_extra = _law_filter_clauses(filters, params)
786
 
787
  sql = text(f"""
 
803
  c.name AS category_name,
804
  TRUE AS title_match,
805
  GREATEST(
806
+ ({similarite_titre}) / {len(mots)},
807
  word_similarity(immutable_unaccent(:query), immutable_unaccent(l.reference))
808
  ) AS rank
809
  FROM laws l
810
  LEFT JOIN categories c ON c.id = l.category_id
811
  WHERE (
812
+ ({chaque_mot})
813
  OR immutable_unaccent(l.reference) %> immutable_unaccent(:query)
814
  )
815
  {where_extra}
app/services/search_service.py CHANGED
@@ -277,7 +277,8 @@ class SearchService:
277
  # Check PostgreSQL cache
278
  if self.use_cache:
279
  cache_key = _make_cache_key(
280
- request.query, request.filters, request.limit, request.offset
 
281
  )
282
  # Le cache est une optimisation, pas une dependance : si query_cache
283
  # est absente ou injoignable, on doit degrader, pas renvoyer 500.
 
277
  # Check PostgreSQL cache
278
  if self.use_cache:
279
  cache_key = _make_cache_key(
280
+ request.query, request.filters, request.limit, request.offset,
281
+ request.mode,
282
  )
283
  # Le cache est une optimisation, pas une dependance : si query_cache
284
  # est absente ou injoignable, on doit degrader, pas renvoyer 500.
scripts/eval/evaluer_recherche.py ADDED
@@ -0,0 +1,184 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ Mesure le classement de la PAGE DE RECHERCHE, document par document.
3
+
4
+ La page /search envoie une recherche en mode « text », filtree sur
5
+ status=published, 20 resultats par page. Ce script rejoue exactement cette
6
+ requete, sans cache et sans journaliser d'evenement de recherche (lecture
7
+ seule), et mesure le rang de la loi attendue :
8
+
9
+ - les 102 questions relues de tests/fixtures/eval/retrieval_eval_v1.json
10
+ (loi attendue : expected_law_id) : hit@1, hit@3, hit@10, MRR@20 ;
11
+ - des requetes TEMOINS, chacune avec ce qu'on attend d'elle : la requete qui
12
+ a revele le defaut (« peine de mort au cameroun »), et celles qui fondent la
13
+ passe floue sur les titres (fautes de frappe : « nominaton », « code miner »).
14
+
15
+ Usage:
16
+ python -m scripts.eval.evaluer_recherche
17
+ python -m scripts.eval.evaluer_recherche --modes text hybrid --sortie data/eval_runs/recherche.json
18
+ """
19
+
20
+ import argparse
21
+ import asyncio
22
+ import json
23
+ import sys
24
+ import unicodedata
25
+ from pathlib import Path
26
+ from typing import Any, Callable, Dict, List, Optional, Sequence
27
+
28
+ RACINE = Path(__file__).resolve().parents[2]
29
+ sys.path.insert(0, str(RACINE))
30
+
31
+ from app.core.database import AsyncSessionLocal
32
+ from app.schemas.search import SearchFilters, SearchRequest
33
+ from app.services.search_service import SearchService
34
+
35
+ JEU = RACINE / "tests" / "fixtures" / "eval" / "retrieval_eval_v1.json"
36
+ TAILLE_PAGE = 20 # TAILLE_PAGE_RECHERCHE du front (src/lib/pagination.ts)
37
+
38
+ CODE_PENAL, JUSTICE_MILITAIRE = 2236, 2085
39
+ CODES_MINIERS = {2210, 2228}
40
+
41
+
42
+ def _sans_accents(texte: str) -> str:
43
+ return "".join(c for c in unicodedata.normalize("NFD", texte.lower())
44
+ if unicodedata.category(c) != "Mn")
45
+
46
+
47
+ def _titres_contiennent(mot: str, n: int) -> Callable[[Dict[str, Any]], bool]:
48
+ """Les n premiers titres contiennent tous `mot` (sans accents)."""
49
+ def verifier(reponse: Dict[str, Any]) -> bool:
50
+ titres = [_sans_accents(r["title"]) for r in reponse["results"][:n]]
51
+ return len(titres) == n and all(mot in t for t in titres)
52
+ return verifier
53
+
54
+
55
+ def _rang_parmi(ids: set, n: int) -> Callable[[Dict[str, Any]], bool]:
56
+ """Une des lois `ids` figure dans les n premiers resultats."""
57
+ def verifier(reponse: Dict[str, Any]) -> bool:
58
+ return any(r["law_id"] in ids for r in reponse["results"][:n])
59
+ return verifier
60
+
61
+
62
+ def _navigation_directe(ids: set) -> Callable[[Dict[str, Any]], bool]:
63
+ def verifier(reponse: Dict[str, Any]) -> bool:
64
+ return bool(reponse["direct_navigation"]) and reponse["target_law_id"] in ids
65
+ return verifier
66
+
67
+
68
+ # (requete, attente lisible, verification)
69
+ TEMOINS: List[tuple] = [
70
+ ("peine de mort au cameroun", "Code penal ou justice militaire dans le top 3",
71
+ _rang_parmi({CODE_PENAL, JUSTICE_MILITAIRE}, 3)),
72
+ ("peine de mort", "Code penal ou justice militaire dans le top 3",
73
+ _rang_parmi({CODE_PENAL, JUSTICE_MILITAIRE}, 3)),
74
+ ("justice militaire", "Code de justice militaire premier",
75
+ _rang_parmi({JUSTICE_MILITAIRE}, 1)),
76
+ ("code pénal", "Code penal (loi 2236 ou decret 1769) dans le top 2",
77
+ _rang_parmi({CODE_PENAL, 1769}, 2)),
78
+ ("code minier", "un code minier dans le top 2", _rang_parmi(CODES_MINIERS, 2)),
79
+ ("code miner", "faute de frappe : un code minier dans le top 3", _rang_parmi(CODES_MINIERS, 3)),
80
+ ("cod minier", "faute de frappe : un code minier dans le top 3", _rang_parmi(CODES_MINIERS, 3)),
81
+ ("nominaton", "faute de frappe : les 5 premiers titres parlent de nomination",
82
+ _titres_contiennent("nomination", 5)),
83
+ ("avancment", "faute de frappe : les 3 premiers titres parlent d'avancement",
84
+ _titres_contiennent("avancement", 3)),
85
+ ("article 35 du code minier", "navigation directe vers un code minier",
86
+ _navigation_directe(CODES_MINIERS)),
87
+ ]
88
+
89
+
90
+ async def rejouer(service: SearchService, requete: str, mode: str) -> Dict[str, Any]:
91
+ """La requete de la page, sans cache ni journal d'evenement."""
92
+ demande = SearchRequest(
93
+ query=requete, mode=mode, limit=TAILLE_PAGE, offset=0,
94
+ filters=SearchFilters(status="published"),
95
+ )
96
+ chunks = await service._execute_search_by_mode(demande)
97
+ reponse = await service._build_search_response(demande, chunks, 0)
98
+ return {
99
+ "results": [{"law_id": r.law_id, "title": r.title, "score": round(r.relevance_score, 3),
100
+ "portee": r.match_scope} for r in reponse.results],
101
+ "total": reponse.total,
102
+ "direct_navigation": reponse.direct_navigation,
103
+ "target_law_id": reponse.target_law_id,
104
+ }
105
+
106
+
107
+ def _rang(reponse: Dict[str, Any], law_id: int) -> Optional[int]:
108
+ for position, r in enumerate(reponse["results"], start=1):
109
+ if r["law_id"] == law_id:
110
+ return position
111
+ return None
112
+
113
+
114
+ def synthese(rangs: Sequence[Optional[int]]) -> Dict[str, Any]:
115
+ n = len(rangs) or 1
116
+ return {
117
+ "n": len(rangs),
118
+ "hit@1": round(sum(1 for r in rangs if r and r <= 1) / n, 3),
119
+ "hit@3": round(sum(1 for r in rangs if r and r <= 3) / n, 3),
120
+ "hit@10": round(sum(1 for r in rangs if r and r <= 10) / n, 3),
121
+ "mrr@20": round(sum(1 / r for r in rangs if r) / n, 3),
122
+ "aucun_resultat": None,
123
+ }
124
+
125
+
126
+ async def evaluer(modes: Sequence[str]) -> Dict[str, Any]:
127
+ items = json.loads(JEU.read_text(encoding="utf-8"))["items"]
128
+ sortie: Dict[str, Any] = {"modes": {}}
129
+ async with AsyncSessionLocal() as session:
130
+ service = SearchService(session, use_cache=False)
131
+ for mode in modes:
132
+ par_item, rangs, vides = [], {"keyword": [], "paraphrase": [], "tous": []}, 0
133
+ for item in items:
134
+ reponse = await rejouer(service, item["question"], mode)
135
+ rang = _rang(reponse, item["expected_law_id"])
136
+ vides += not reponse["results"]
137
+ rangs["tous"].append(rang)
138
+ rangs.setdefault(item.get("difficulty", "?"), []).append(rang)
139
+ par_item.append({"question": item["question"], "attendu": item["expected_law_id"],
140
+ "rang": rang, "total": reponse["total"]})
141
+ temoins = []
142
+ for requete, attente, verifier in TEMOINS:
143
+ reponse = await rejouer(service, requete, mode)
144
+ temoins.append({"requete": requete, "attente": attente, "ok": verifier(reponse),
145
+ "top5": [f"{r['law_id']} {r['portee']} {r['score']} {r['title'][:70]}"
146
+ for r in reponse["results"][:5]]})
147
+ resume = {cle: synthese(valeurs) for cle, valeurs in rangs.items() if valeurs}
148
+ resume["tous"]["aucun_resultat"] = vides
149
+ sortie["modes"][mode] = {"synthese": resume, "temoins": temoins, "items": par_item}
150
+ return sortie
151
+
152
+
153
+ def afficher(sortie: Dict[str, Any]) -> None:
154
+ for mode, donnees in sortie["modes"].items():
155
+ print(f"\n=== mode {mode}")
156
+ for cle, s in donnees["synthese"].items():
157
+ print(f" {cle:10} n={s['n']:3} hit@1 {s['hit@1']:.3f} hit@3 {s['hit@3']:.3f} "
158
+ f"hit@10 {s['hit@10']:.3f} mrr@20 {s['mrr@20']:.3f}"
159
+ + (f" sans resultat {s['aucun_resultat']}" if s["aucun_resultat"] is not None else ""))
160
+ ok = sum(t["ok"] for t in donnees["temoins"])
161
+ print(f" temoins : {ok}/{len(donnees['temoins'])}")
162
+ for t in donnees["temoins"]:
163
+ print(f" [{'ok' if t['ok'] else 'KO'}] {t['requete']!r} : {t['attente']}")
164
+ if not t["ok"]:
165
+ for ligne in t["top5"]:
166
+ print(f" {ligne}")
167
+
168
+
169
+ def main(argv: Optional[Sequence[str]] = None) -> int:
170
+ parseur = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
171
+ parseur.add_argument("--modes", nargs="+", default=["text"], choices=["text", "semantic", "hybrid"])
172
+ parseur.add_argument("--sortie", type=Path, help="Ecrit le detail en JSON")
173
+ args = parseur.parse_args(argv)
174
+ sortie = asyncio.run(evaluer(args.modes))
175
+ afficher(sortie)
176
+ if args.sortie:
177
+ args.sortie.parent.mkdir(parents=True, exist_ok=True)
178
+ args.sortie.write_text(json.dumps(sortie, ensure_ascii=False, indent=1), encoding="utf-8")
179
+ print(f"\nDetail : {args.sortie}")
180
+ return 0
181
+
182
+
183
+ if __name__ == "__main__":
184
+ sys.exit(main())
tests/test_services/test_search_service.py CHANGED
@@ -778,6 +778,21 @@ class TestCaching:
778
  rows = await db_session.execute(sa_text("SELECT count(*) FROM query_cache"))
779
  assert rows.scalar() == 0
780
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
781
 
782
  # ============================================================================
783
  # Test Edge Cases
 
778
  rows = await db_session.execute(sa_text("SELECT count(*) FROM query_cache"))
779
  assert rows.scalar() == 0
780
 
781
+ def test_the_mode_is_part_of_the_key(self):
782
+ """
783
+ Sans le mode dans la cle, une recherche « text » et une recherche
784
+ « hybrid » de la meme requete se servaient l'une l'autre pendant tout le
785
+ TTL : la page (text) et le chat (hybrid) se renvoyaient leurs resultats.
786
+ """
787
+ from app.services.postgres_search_service import _make_cache_key
788
+
789
+ cles = {
790
+ _make_cache_key("peine de mort", None, 20, 0, mode)
791
+ for mode in ("text", "semantic", "hybrid")
792
+ }
793
+
794
+ assert len(cles) == 3
795
+
796
 
797
  # ============================================================================
798
  # Test Edge Cases
tests/test_services/test_title_priority.py CHANGED
@@ -32,6 +32,7 @@ from app.schemas.search import SearchRequest
32
  from app.services.legal_domain_classifier import AFFAIRES
33
  from app.services.postgres_search_service import (
34
  MAX_CHUNKS_PER_LAW,
 
35
  search_articles_pg,
36
  )
37
  from app.services.search_service import SearchService
@@ -195,6 +196,83 @@ class TestTypoTolerance:
195
  assert results[0].relevance_score >= max(r.relevance_score for r in results)
196
 
197
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
198
  class TestPerLawCap:
199
  @pytest.mark.asyncio
200
  async def test_one_law_cannot_take_the_whole_budget(self, db_session, ranking_corpus):
 
32
  from app.services.legal_domain_classifier import AFFAIRES
33
  from app.services.postgres_search_service import (
34
  MAX_CHUNKS_PER_LAW,
35
+ mots_significatifs,
36
  search_articles_pg,
37
  )
38
  from app.services.search_service import SearchService
 
196
  assert results[0].relevance_score >= max(r.relevance_score for r in results)
197
 
198
 
199
+ class TestMotsSignificatifs:
200
+ """La passe floue compare chaque mot qui designe quelque chose, et eux seuls."""
201
+
202
+ @pytest.mark.parametrize("requete, attendus", [
203
+ ("peine de mort au cameroun", ["peine", "mort"]),
204
+ ("Loi portant Code Minier du Cameroun", ["code", "minier"]),
205
+ ("nominaton", ["nominaton"]),
206
+ ("Fonction Publique : statut général", ["fonction", "publique", "statut", "general"]),
207
+ ("code code minier", ["code", "minier"]),
208
+ ("de la République du Cameroun", []),
209
+ ("", []),
210
+ ])
211
+ def test_mots_retenus(self, requete, attendus):
212
+ assert mots_significatifs(requete) == attendus
213
+
214
+
215
+ # Loi 300 : titre en « ... de Base au Cameroun », sans rapport avec la requete.
216
+ # Loi 301 : les articles parlent de la peine de mort.
217
+ DECRET_DE_PRET, CODE_PENAL = 300, 301
218
+
219
+
220
+ @pytest.fixture
221
+ async def peine_corpus(db_session, category_ids):
222
+ from sqlalchemy import text as sql_text
223
+
224
+ db_session.add_all([
225
+ Law(
226
+ id=DECRET_DE_PRET, reference="PRC-10703",
227
+ # Titre reel du corpus : word_similarity avec la requete entiere,
228
+ # 0,516, au-dessus du seuil de 0,5.
229
+ title=("Décret N°2026/176 du 4 mai 2026 ratifiant l'Accord de Prêt pour le "
230
+ "financement du Projet d'Appui à l'Education de Base au Cameroun (PAEBC)"),
231
+ content="Est ratifié l'Accord de Prêt conclu entre la République du Cameroun et la Banque.",
232
+ type="décret", language="fr", status="published",
233
+ category_id=category_ids["Fonction Publique"], publication_date=date(2026, 5, 4),
234
+ ),
235
+ Law(
236
+ id=CODE_PENAL, reference="LOI-2016-007",
237
+ title="Loi N° 2016/007 du 12 juillet 2016 portant Code Pénal",
238
+ content="Au Cameroun, la peine de mort est exécutée par les armes.",
239
+ type="loi", language="fr", status="published",
240
+ category_id=category_ids[AFFAIRES], publication_date=date(2016, 7, 12),
241
+ ),
242
+ ])
243
+ await db_session.flush()
244
+ db_session.add(Article(
245
+ law_id=CODE_PENAL, number="22", order=1, kind="article", embed=True,
246
+ content="Au Cameroun, la peine de mort est exécutée par les armes ou par pendaison.",
247
+ ))
248
+ await db_session.commit()
249
+ await db_session.execute(sql_text(REINDEX_LAWS_SQL))
250
+ await db_session.execute(sql_text(REINDEX_ARTICLES_SQL))
251
+ await db_session.commit()
252
+
253
+
254
+ class TestPhraseRequest:
255
+ @pytest.mark.asyncio
256
+ async def test_common_words_do_not_make_a_title_match(self, service, peine_corpus):
257
+ """
258
+ Requete reelle. Comparee d'un bloc, elle passait le seuil sur « de »,
259
+ « au » et « cameroun » : le decret de pret sortait PREMIER, comme
260
+ correspondance de titre, devant le Code penal.
261
+ """
262
+ results = await service.text_search("peine de mort au cameroun", limit=20)
263
+
264
+ assert results, "aucun resultat"
265
+ assert results[0].law_id == CODE_PENAL
266
+ assert DECRET_DE_PRET not in {r.law_id for r in results}
267
+
268
+ @pytest.mark.asyncio
269
+ async def test_a_typo_in_a_phrase_is_still_caught(self, service, peine_corpus):
270
+ """Mot par mot, la tolerance aux fautes reste : « penal » mal ecrit."""
271
+ results = await service.text_search("code penall", limit=20)
272
+
273
+ assert results and results[0].law_id == CODE_PENAL
274
+
275
+
276
  class TestPerLawCap:
277
  @pytest.mark.asyncio
278
  async def test_one_law_cannot_take_the_whole_budget(self, db_session, ranking_corpus):