rahim237cm Claude Opus 5.5 commited on
Commit
911f84f
·
1 Parent(s): 148f7c1

feat(decoupage): les grands tableaux coupes entre leurs lignes, le cachet mieux retire

Browse files

Tableaux. Ils n'etaient jamais coupes : ceux des lois de finances
faisaient des chunks jusqu'a 79 000 caracteres, dont l'embedding ne
lisait que les 10 000 premiers (110 chunks du corpus). Un tableau
markdown se coupe desormais entre deux lignes, jamais au milieu d'une ;
chaque morceau repete l'en-tete du tableau et le debut de l'article. Une
premiere ligne de donnees prise pour un en-tete n'est pas repetee.

Listes nominatives. Le texte de nomination se cherche hors des tableaux :
« PROMOTION DE LA FEMME », intitule de programme d'une loi de reglement,
faisait d'un tableau budgetaire une liste de 35 personnes. Et des que les
tableaux reconnus portent la majorite des lignes, tous les tableaux de
l'article sont de la liste : ceux que la detection manquait restaient dans
le texte vectorise (155 000 caracteres pour 4 229 gardiens de la paix).

Audit sur les 2238 documents : chunks de plus de 10 000 caracteres de 110
a 1 ; plus gros texte vectorise de 136 601 a 15 931 caracteres ; un seul
document sans vecteur, comme avant.

Cachet : seconde releve sur les 13 923 pages (« CORIE CERTIFIEE »,
« GERTIFIED », « SERVICE OU FICHIER », « SERVICE DU ACHIER »), bloc
bilingue reconnu par sa mention anglaise, « PRESIDENCY OF THE REPUBLIC »
seul sur sa ligne. Lignes residuelles : 6 890 a 3 411, aucun texte perdu.

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

app/utils/chunk_refiner.py CHANGED
@@ -607,15 +607,28 @@ def _apply_roster_rule(
607
  # Variante tableau : HTML (LlamaParse) ou markdown a barres (Docling)
608
  tables = [(t, _table_rows(t)) for t in _TABLE_BLOCK.findall(content)]
609
  tables += [(m.group(0), _md_table_rows(m.group(0))) for m in _MD_TABLE_BLOCK.finditer(content)]
610
- for table, rows in tables:
611
- if not _looks_nominative(rows, content):
612
- continue
613
- lignes = _parse_roster_rows(rows, number, start=len(entries))
614
- entries.extend(lignes)
615
- # Un decompte PAR tableau : le total global repete deux fois trompait.
616
- resume = resume.replace(
617
- table.rstrip("\n"), f"[{len(lignes)} personnes — liste nominative]"
618
- )
 
 
 
 
 
 
 
 
 
 
 
 
 
619
 
620
  # Variante texte brut
621
  if not entries:
@@ -632,7 +645,13 @@ def _apply_roster_rule(
632
  # qui n'existait pas. Seul le texte VECTORISE prend la forme resumee : 904
633
  # inspecteurs ne doivent pas faire 904 vecteurs, ni saturer la recherche.
634
  chunk = dict(chunk)
635
- chunk["embed_body"] = resume.strip()
 
 
 
 
 
 
636
  chunk["kind"] = "roster"
637
  chunk["roster_count"] = len(entries)
638
  return chunk, entries
@@ -692,6 +711,104 @@ def _split_roster(
692
  return out
693
 
694
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
695
  def _split_long_article(
696
  chunk: Dict[str, Any], target_max_chars: int = TARGET_MAX_CHARS
697
  ) -> List[Dict[str, Any]]:
@@ -710,19 +827,21 @@ def _split_long_article(
710
  if chunk.get("kind") == "roster":
711
  return _split_roster(chunk, target_max_chars)
712
 
713
- # R5 : un tableau ne se coupe pas. Si le chunk en contient un, on le laisse
714
- # entier meme au-dela de la cible : une ligne isolee ("31 | 180 |
715
- # EDUCATION PRESCOLAIRE | 31 915 303") ne repond a aucune question.
716
  #
717
  # La nature « table » n'etait jamais posee : refine() fixe "article" par
718
  # defaut AVANT cet appel, et `get("kind") or "table"` gardait donc
719
  # "article". Un roster garde sa nature.
720
- if _contains_table(content):
721
  chunk = dict(chunk)
722
  if chunk.get("kind") in (None, "article"):
723
  chunk["kind"] = "table"
724
  chunk["oversized"] = True
725
  return [chunk]
 
 
726
 
727
  parts = [p.strip() for p in _ALINEA.split(content) if p and p.strip()]
728
  if len(parts) < 2:
@@ -967,8 +1086,11 @@ def refine(
967
  chunk["kind"] = "fragment"
968
  chunk["embed"] = False
969
  else:
 
970
  chunk["kind"] = "continuation"
971
  chunk["embed"] = True
 
 
972
  working.append(chunk)
973
  continue
974
 
 
607
  # Variante tableau : HTML (LlamaParse) ou markdown a barres (Docling)
608
  tables = [(t, _table_rows(t)) for t in _TABLE_BLOCK.findall(content)]
609
  tables += [(m.group(0), _md_table_rows(m.group(0))) for m in _MD_TABLE_BLOCK.finditer(content)]
610
+
611
+ # Le texte de nomination se cherche HORS des tableaux : dans une loi de
612
+ # reglement, « PROMOTION DE LA FEMME », intitule de programme, se faisait
613
+ # passer pour lui, et un tableau budgetaire devenait une liste de 35
614
+ # « personnes ».
615
+ hors_tableaux = _MD_TABLE_BLOCK.sub(" ", _TABLE_BLOCK.sub(" ", content))
616
+ nominatives = [_looks_nominative(rows, hors_tableaux) for _, rows in tables]
617
+
618
+ # Une liste nominative s'etale sur un tableau par page, et la detection en
619
+ # manque quelques-uns (matricule « J-057 035 », rang absent). Restes dans
620
+ # le texte vectorise, ils en faisaient 155 000 caracteres. Des que les
621
+ # tableaux reconnus portent la majorite des lignes, l'article est une
622
+ # liste : TOUS ses tableaux en font partie.
623
+ lignes_nominatives = sum(len(rows) for (_, rows), nom in zip(tables, nominatives) if nom)
624
+ if lignes_nominatives and lignes_nominatives >= 0.5 * sum(len(rows) for _, rows in tables):
625
+ for table, rows in tables:
626
+ lignes = _parse_roster_rows(rows, number, start=len(entries))
627
+ entries.extend(lignes)
628
+ # Un decompte PAR tableau : le total global repete deux fois trompait.
629
+ resume = resume.replace(
630
+ table.rstrip("\n"), f"[{len(lignes)} personnes — liste nominative]"
631
+ )
632
 
633
  # Variante texte brut
634
  if not entries:
 
645
  # qui n'existait pas. Seul le texte VECTORISE prend la forme resumee : 904
646
  # inspecteurs ne doivent pas faire 904 vecteurs, ni saturer la recherche.
647
  chunk = dict(chunk)
648
+ resume = resume.strip()
649
+ if len(resume) > TARGET_MAX_CHARS:
650
+ # Garde-fou : le vecteur d'une liste ne lit que son chapeau. Au-dela,
651
+ # l'embedding tronquerait de toute facon.
652
+ coupe = resume.rfind("\n", 0, TARGET_MAX_CHARS)
653
+ resume = resume[:coupe if coupe > TARGET_MAX_CHARS // 2 else TARGET_MAX_CHARS].rstrip()
654
+ chunk["embed_body"] = resume
655
  chunk["kind"] = "roster"
656
  chunk["roster_count"] = len(entries)
657
  return chunk, entries
 
711
  return out
712
 
713
 
714
+ def _ligne_d_en_tete(ligne: str) -> bool:
715
+ """
716
+ La premiere ligne d'un tableau est-elle un en-tete, a repeter ?
717
+
718
+ Docling met en « en-tete » la premiere ligne de DONNEES quand le tableau
719
+ n'en a pas. Un montant ou un rang la trahit : la repeter dans chaque
720
+ morceau dupliquerait une ligne budgetaire.
721
+ """
722
+ return not _MONTANT.search(ligne) and not re.match(r"\s*\|?\s*\d{1,4}\s*[.)|-]", ligne)
723
+
724
+
725
+ def _split_tableaux(
726
+ chunk: Dict[str, Any], target_max_chars: int = TARGET_MAX_CHARS
727
+ ) -> List[Dict[str, Any]]:
728
+ """
729
+ R5 — Decoupe un article qui porte un grand tableau, entre ses lignes.
730
+
731
+ Les tableaux n'etaient jamais coupes : ceux des lois de finances faisaient
732
+ des chunks de 79 000 caracteres, dont l'embedding ne lisait que les 10 000
733
+ premiers — 110 chunks du corpus, dont la fin n'etait jamais cherchable par
734
+ le sens. Ils se coupent desormais entre deux lignes, jamais au milieu
735
+ d'une : « 31 | 180 | EDUCATION PRESCOLAIRE | 31 915 303 » reste entier.
736
+ Chaque morceau repete l'en-tete du tableau, pour que ses colonnes aient un
737
+ nom, et le debut de l'article, pour dire de quel tableau il s'agit.
738
+
739
+ Le texte autour des tableaux se coupe aux paragraphes. Rien n'est perdu
740
+ ni duplique, hors en-tetes repetes.
741
+ """
742
+ content = chunk["content"]
743
+ blocs: List[Tuple[str, str]] = []
744
+ debut = 0
745
+ for m in _MD_TABLE_BLOCK.finditer(content):
746
+ if content[debut:m.start()].strip():
747
+ blocs.append(("texte", content[debut:m.start()]))
748
+ blocs.append(("tableau", m.group(0)))
749
+ debut = m.end()
750
+ if content[debut:].strip():
751
+ blocs.append(("texte", content[debut:]))
752
+
753
+ chapeau = blocs[0][1].strip() if blocs[0][0] == "texte" else ""
754
+ if len(chapeau) > 600:
755
+ chapeau = ""
756
+ prefixe = chapeau[:200].strip()
757
+ place = max(target_max_chars - len(prefixe) - 1, 500)
758
+
759
+ unites: List[Tuple[str, bool]] = []
760
+ for i, (nature, texte) in enumerate(blocs):
761
+ if nature == "texte":
762
+ if i == 0 and chapeau:
763
+ continue
764
+ unites += [(p.strip(), False) for p in re.split(r"\n\s*\n", texte) if p.strip()]
765
+ continue
766
+ lignes = [ln for ln in texte.splitlines() if ln.strip()]
767
+ sep = next((k for k, ln in enumerate(lignes) if _MD_SEPARATOR_ROW.match(ln)), None)
768
+ entete = lignes[:sep + 1] if sep is not None and sep <= 2 and all(
769
+ _ligne_d_en_tete(ln) for ln in lignes[:sep]
770
+ ) else []
771
+ corps = [ln for ln in lignes[len(entete):] if not _MD_SEPARATOR_ROW.match(ln)]
772
+ budget = max(place - sum(len(ln) + 1 for ln in entete), 300)
773
+ groupe: List[str] = []
774
+ taille = 0
775
+ for ligne in corps:
776
+ if groupe and taille + len(ligne) + 1 > budget:
777
+ unites.append(("\n".join(entete + groupe), True))
778
+ groupe, taille = [], 0
779
+ groupe.append(ligne)
780
+ taille += len(ligne) + 1
781
+ if groupe:
782
+ unites.append(("\n".join(entete + groupe), True))
783
+
784
+ morceaux: List[Tuple[str, bool]] = []
785
+ for texte, tableau in unites:
786
+ if morceaux and len(morceaux[-1][0]) + len(texte) + 2 <= place:
787
+ morceaux[-1] = (morceaux[-1][0] + "\n\n" + texte, morceaux[-1][1] or tableau)
788
+ else:
789
+ morceaux.append((texte, tableau))
790
+ if len(morceaux) < 2:
791
+ chunk = dict(chunk)
792
+ if chunk.get("kind") in (None, "article"):
793
+ chunk["kind"] = "table"
794
+ chunk["oversized"] = len(content) > target_max_chars
795
+ return [chunk]
796
+
797
+ out: List[Dict[str, Any]] = []
798
+ for i, (texte, tableau) in enumerate(morceaux):
799
+ piece = dict(chunk)
800
+ tete = chapeau if i == 0 else prefixe
801
+ piece["content"] = (tete + "\n" + texte).strip() if tete else texte
802
+ piece["number"] = f"{chunk['number']}.{i + 1}"
803
+ piece["parent_id"] = str(chunk["number"])
804
+ if tableau and chunk.get("kind") in (None, "article"):
805
+ piece["kind"] = "table"
806
+ piece["char_count"] = len(piece["content"])
807
+ piece["word_count"] = len(piece["content"].split())
808
+ out.append(piece)
809
+ return out
810
+
811
+
812
  def _split_long_article(
813
  chunk: Dict[str, Any], target_max_chars: int = TARGET_MAX_CHARS
814
  ) -> List[Dict[str, Any]]:
 
827
  if chunk.get("kind") == "roster":
828
  return _split_roster(chunk, target_max_chars)
829
 
830
+ # R5 : un tableau markdown se coupe ENTRE ses lignes, son en-tete repete
831
+ # (voir _split_tableaux). Un tableau HTML, forme de l'ancien extracteur,
832
+ # reste entier.
833
  #
834
  # La nature « table » n'etait jamais posee : refine() fixe "article" par
835
  # defaut AVANT cet appel, et `get("kind") or "table"` gardait donc
836
  # "article". Un roster garde sa nature.
837
+ if _TABLE_BLOCK.search(content):
838
  chunk = dict(chunk)
839
  if chunk.get("kind") in (None, "article"):
840
  chunk["kind"] = "table"
841
  chunk["oversized"] = True
842
  return [chunk]
843
+ if _MD_TABLE_BLOCK.search(content):
844
+ return _split_tableaux(chunk, target_max_chars)
845
 
846
  parts = [p.strip() for p in _ALINEA.split(content) if p and p.strip()]
847
  if len(parts) < 2:
 
1086
  chunk["kind"] = "fragment"
1087
  chunk["embed"] = False
1088
  else:
1089
+ # Suite d'une page : du contenu reel, coupe comme un article
1090
  chunk["kind"] = "continuation"
1091
  chunk["embed"] = True
1092
+ working.extend(_split_long_article(chunk, target_max_chars))
1093
+ continue
1094
  working.append(chunk)
1095
  continue
1096
 
app/utils/markdown_cleanup.py CHANGED
@@ -38,15 +38,28 @@ import re
38
  # confond des lettres (« APFAIRS », « CARD IBDEX », « REGLENENTAIRE »,
39
  # « BERVICE ») : avec les anciens motifs, a espaces obligatoires et sans
40
  # confusion admise, le cachet restait dans un tiers des pages.
 
 
 
 
 
 
41
  _STAMP_SPECIFIC_MOTIF = (
42
- r"C[O0]P[IL1T]E\s*C[ET]R[TI1][I1]F[I1][A-ZÉ]{0,3}\s*C[O0]N[FP][A-Z]{1,2}[MN][EF]"
43
- r"|CER[TI1][I1]F[I1][A-Z]{1,2}\s*[TY]R?UE\s*[CGS][O0][PR]Y"
44
- r"|\w{0,3}[VT]ICE\s*D[UO]\s*\w?I[CG][HM]IE[RN]"
45
  r"(?:\s*L[A-ZÉ]{3,6}ATIF)?(?:\s*ET\s*R[EÉ][A-ZÉ]{2,10}AIRE)?"
46
  r"|(?:L[A-Z]{2,6}ATIVE\s*A[A-Z]{2}\s*)?[STB][TY]A[TY]UT[O0C]R[YT]\s*A[FP]{2}AI[RBP]S"
47
  r"|CAR[DOGS]\s*[A-Z]{1,2}[DB]EX\s*[SB]ER[VT]I[CS]E"
48
  )
49
 
 
 
 
 
 
 
 
50
  # Vocabulaire du cachet : ses expressions propres, plus des expressions qui
51
  # sont AUSSI des autorites legitimes (« Présidence de la République »,
52
  # « Secrétariat général ») et ne sont retirees qu'a cote d'une expression
@@ -55,8 +68,8 @@ _STAMP_SPECIFIC_MOTIF = (
55
  _STAMP_VOCAB = re.compile(
56
  rf"(?-i:{_STAMP_SPECIFIC_MOTIF})"
57
  r"|pr[ée][sog]idence\s*de\s*la\s*r[ée]pu\w{4,6}"
58
- r"|pr\w{2}idency\s*o[ef]\s*the\s*repu\w{3,4}"
59
- r"|\w{1,2}cr[ée]tariat[\s-]*\w{1,2}n[ée]ra[il]",
60
  re.IGNORECASE,
61
  )
62
 
@@ -71,12 +84,19 @@ _WATERMARK = re.compile(
71
  # ligne. Une ligne COURTE, en capitales, qui n'est qu'un mot propre au cachet
72
  # ou qui commence par l'une de ses expressions n'est que du cachet.
73
  _FRAGMENT_DE_CACHET = re.compile(
74
- r"^[\W_]*(?:CER[TI1][I1]F[I1]E[ED]|[STB][TY]A[TY]UT[O0C]R[YT]|\w?I[CG][HM]IER)[\W_]*$"
 
75
  r"|^[\W_]*(?:C[O0]P[IL1T]E\W*C[ET]RT|CER[TI1][I1]F[I1][A-Z]{1,2}\W*(?:[TY]|C[O0]N)"
76
  r"|L[A-Z]{2,6}ATIVE\s*A[A-Z]D\s*[STB]|CAR[DS]\s*IN[DB]EX|\w{0,3}[VT]ICE\s*D[UO]\s*\w?I[CG])"
77
  r"[A-Z\W_]{0,40}$"
78
  )
79
 
 
 
 
 
 
 
80
  # Ligne de separation d'un tableau markdown : « |----|---| »
81
  _SEPARATEUR_TABLEAU = re.compile(r"^\s*\|\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)*\|?\s*$")
82
 
@@ -125,7 +145,9 @@ def _oter_le_cachet(ligne: str) -> str:
125
  else:
126
  groupes.append([m])
127
  for groupe in reversed(groupes):
128
- if any(_STAMP_SPECIFIC.search(m.group(0)) for m in groupe):
 
 
129
  ligne = ligne[:groupe[0].start()] + " " + ligne[groupe[-1].end():]
130
  return re.sub(r"[ \t]{2,}", " ", ligne).strip()
131
 
@@ -217,7 +239,11 @@ def _ligne_de_filigrane(ligne: str) -> bool:
217
  donc jamais decoupe.
218
  """
219
  if "|" not in ligne:
220
- return bool(_WATERMARK.match(ligne) or _FRAGMENT_DE_CACHET.match(ligne.strip()))
 
 
 
 
221
  cellules = [c.strip() for c in ligne.strip().strip("|").split("|")]
222
  pleines = [c for c in cellules if c]
223
  return bool(pleines) and all(_WATERMARK.match(c) for c in pleines)
@@ -264,7 +290,13 @@ def strip_stamp_blocks(text: str) -> str:
264
  Markdown nettoye
265
  """
266
  lines = text.splitlines()
267
- a_traiter = [bool(_STAMP_SPECIFIC.search(ln)) for ln in lines]
 
 
 
 
 
 
268
 
269
  i = 0
270
  while i < len(lines):
@@ -279,7 +311,9 @@ def strip_stamp_blocks(text: str) -> str:
279
  stripped = lines[j].strip(" >*|-\t")
280
  if _STAMP_VOCAB.search(lines[j]):
281
  hits += 1
282
- propre = propre or bool(_STAMP_SPECIFIC.search(lines[j]))
 
 
283
  j += 1
284
  elif not stripped:
285
  j += 1
 
38
  # confond des lettres (« APFAIRS », « CARD IBDEX », « REGLENENTAIRE »,
39
  # « BERVICE ») : avec les anciens motifs, a espaces obligatoires et sans
40
  # confusion admise, le cachet restait dans un tiers des pages.
41
+ #
42
+ # Seconde releve, sur les 13 923 pages du corpus : « CORIE CERTIFIEE »,
43
+ # « GOPIE », « COPIF », « GERTIFIED », « CERTTFIED », « SERVICE OU FICHIER »,
44
+ # « SERVICE DU ACHIER ». Le cachet etant toujours en capitales, chaque
45
+ # expression garde sa charpente (COPIE ... CERT... CON..., ... TRUE CO...) :
46
+ # aucun texte juridique en capitales n'y repond.
47
  _STAMP_SPECIFIC_MOTIF = (
48
+ r"[CG][O0][PR][IL1TF]{0,2}[EF]?\s*C[ET]R[TI1]{1,2}[FT]?[I1]?[A-ZÉ]{0,3}\s*C[O0]N[FP][A-Z]{1,2}[MN][EF]"
49
+ r"|[CGE]{0,2}[EF]?R[A-Z1]{3,7}\s*[TY]R?[UV]E\s*[CGS][O0][A-Z]{1,3}\b"
50
+ r"|\w{0,3}[VT]ICE\s*[DO][UO]\s*\w{0,2}[CG][HM]IE[RN]"
51
  r"(?:\s*L[A-ZÉ]{3,6}ATIF)?(?:\s*ET\s*R[EÉ][A-ZÉ]{2,10}AIRE)?"
52
  r"|(?:L[A-Z]{2,6}ATIVE\s*A[A-Z]{2}\s*)?[STB][TY]A[TY]UT[O0C]R[YT]\s*A[FP]{2}AI[RBP]S"
53
  r"|CAR[DOGS]\s*[A-Z]{1,2}[DB]EX\s*[SB]ER[VT]I[CS]E"
54
  )
55
 
56
+ # Le cachet et l'en-tete bilingue portent la mention anglaise : un bloc du
57
+ # vocabulaire qui la contient n'est pas une autorite francaise isolee.
58
+ #
59
+ # En CAPITALES seulement : dans une phrase d'un texte anglais, « the Presidency
60
+ # of the Republic » est du contenu.
61
+ _STAMP_ANGLAIS = re.compile(r"PR\w{2}IDENCY\s*O[EF]\s*THE\s*RE[PBRD]U\w{2,4}")
62
+
63
  # Vocabulaire du cachet : ses expressions propres, plus des expressions qui
64
  # sont AUSSI des autorites legitimes (« Présidence de la République »,
65
  # « Secrétariat général ») et ne sont retirees qu'a cote d'une expression
 
68
  _STAMP_VOCAB = re.compile(
69
  rf"(?-i:{_STAMP_SPECIFIC_MOTIF})"
70
  r"|pr[ée][sog]idence\s*de\s*la\s*r[ée]pu\w{4,6}"
71
+ r"|pr\w{2}idency\s*o[ef]\s*the\s*re[pbrd]u\w{2,4}"
72
+ r"|\w{1,2}cr[ée]tar\w{0,3}[\s-]*\w{1,2}n[ée]ra[il1t]",
73
  re.IGNORECASE,
74
  )
75
 
 
84
  # ligne. Une ligne COURTE, en capitales, qui n'est qu'un mot propre au cachet
85
  # ou qui commence par l'une de ses expressions n'est que du cachet.
86
  _FRAGMENT_DE_CACHET = re.compile(
87
+ r"^[\W_]*(?:CER[TI1][I1]F[I1]\w{0,3}|[STB][TY]A[TY]UT[O0C]R[YT]|\w?I[CG][HM]IER"
88
+ r"|TRUE\s*CO[PR]Y|[LI]\w{3,8}TIF\s*ET\s*R\w{4,10}AIRE)[\W_]*$"
89
  r"|^[\W_]*(?:C[O0]P[IL1T]E\W*C[ET]RT|CER[TI1][I1]F[I1][A-Z]{1,2}\W*(?:[TY]|C[O0]N)"
90
  r"|L[A-Z]{2,6}ATIVE\s*A[A-Z]D\s*[STB]|CAR[DS]\s*IN[DB]EX|\w{0,3}[VT]ICE\s*D[UO]\s*\w?I[CG])"
91
  r"[A-Z\W_]{0,40}$"
92
  )
93
 
94
+ # « PRESIDENCY OF THE REPUBLIC », seul sur sa ligne et en capitales : en-tete
95
+ # ou cachet, jamais une phrase. Releve 850 fois dans les articles indexes.
96
+ _MENTION_ANGLAISE_SEULE = re.compile(
97
+ r"^[\W_]*PR\w{2}IDENCY\s*O[EF]\s*THE\s*RE[PBRD]U\w{0,4}[\W_]*$"
98
+ )
99
+
100
  # Ligne de separation d'un tableau markdown : « |----|---| »
101
  _SEPARATEUR_TABLEAU = re.compile(r"^\s*\|\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)*\|?\s*$")
102
 
 
145
  else:
146
  groupes.append([m])
147
  for groupe in reversed(groupes):
148
+ if any(_STAMP_SPECIFIC.search(m.group(0)) for m in groupe) or (
149
+ len(groupe) >= 2 and any(_STAMP_ANGLAIS.search(m.group(0)) for m in groupe)
150
+ ):
151
  ligne = ligne[:groupe[0].start()] + " " + ligne[groupe[-1].end():]
152
  return re.sub(r"[ \t]{2,}", " ", ligne).strip()
153
 
 
239
  donc jamais decoupe.
240
  """
241
  if "|" not in ligne:
242
+ return bool(
243
+ _WATERMARK.match(ligne)
244
+ or _FRAGMENT_DE_CACHET.match(ligne.strip())
245
+ or _MENTION_ANGLAISE_SEULE.match(ligne)
246
+ )
247
  cellules = [c.strip() for c in ligne.strip().strip("|").split("|")]
248
  pleines = [c for c in cellules if c]
249
  return bool(pleines) and all(_WATERMARK.match(c) for c in pleines)
 
290
  Markdown nettoye
291
  """
292
  lines = text.splitlines()
293
+ a_traiter = [
294
+ bool(_STAMP_SPECIFIC.search(ln))
295
+ # Mention anglaise ET francaise sur la meme ligne : le cachet ou
296
+ # l'en-tete bilingue, mis a plat par l'OCR
297
+ or bool(_STAMP_ANGLAIS.search(ln) and len(_STAMP_VOCAB.findall(ln)) >= 2)
298
+ for ln in lines
299
+ ]
300
 
301
  i = 0
302
  while i < len(lines):
 
311
  stripped = lines[j].strip(" >*|-\t")
312
  if _STAMP_VOCAB.search(lines[j]):
313
  hits += 1
314
+ propre = propre or bool(
315
+ _STAMP_SPECIFIC.search(lines[j]) or _STAMP_ANGLAIS.search(lines[j])
316
+ )
317
  j += 1
318
  elif not stripped:
319
  j += 1
tests/test_utils/test_chunk_refiner.py CHANGED
@@ -286,14 +286,43 @@ class TestTableauxMarkdown:
286
  assert "NOM PRENOM05" not in r.chunks[0]["embed_text"]
287
  assert r.chunks[0]["kind"] == "roster"
288
 
289
- def test_tableau_markdown_jamais_coupe(self, contexte):
 
 
 
 
290
  table = "| ligne | montant |\n| --- | --- |\n" + "".join(
291
  f"| ligne {i} | {i * 1000} |\n" for i in range(200)
292
  )
293
  r = refine([chunk("86", "Les charges sont évaluées ainsi :\n" + table)], contexte)
294
- assert len(r.chunks) == 1
295
- assert r.chunks[0]["oversized"] is True
296
- assert r.chunks[0]["kind"] == "table"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
297
 
298
  def test_tableau_html_trop_long_prend_la_nature_table(self, contexte):
299
  table = "<table>" + "".join(
@@ -734,3 +763,30 @@ class TestArticlePremierIllisible:
734
  def test_ce_qui_suit_decrete_sans_dispositif_reste_dans_les_visas(contexte, reste):
735
  r = refine([chunk("LEGAL_BASIS", "- Vu la Constitution ;\n\nDECRETE :\n\n" + reste)], contexte)
736
  assert [c["number"] for c in r.chunks] == ["LEGAL_BASIS"]
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
286
  assert "NOM PRENOM05" not in r.chunks[0]["embed_text"]
287
  assert r.chunks[0]["kind"] == "roster"
288
 
289
+ def test_grand_tableau_coupe_entre_ses_lignes(self, contexte):
290
+ """
291
+ Entier, un tableau de loi de finances faisait un chunk de 79 000
292
+ caracteres dont l'embedding ne lisait que les 10 000 premiers.
293
+ """
294
  table = "| ligne | montant |\n| --- | --- |\n" + "".join(
295
  f"| ligne {i} | {i * 1000} |\n" for i in range(200)
296
  )
297
  r = refine([chunk("86", "Les charges sont évaluées ainsi :\n" + table)], contexte)
298
+
299
+ assert len(r.chunks) > 1
300
+ assert all(c["kind"] == "table" and c["embed"] for c in r.chunks)
301
+ assert all(len(c["content"]) <= 3000 for c in r.chunks)
302
+ assert [c["number"] for c in r.chunks] == [f"86.{i}" for i in range(1, len(r.chunks) + 1)]
303
+ # Chaque morceau dit de quel tableau il s'agit et nomme ses colonnes
304
+ assert all(c["content"].startswith("Les charges sont évaluées ainsi :") for c in r.chunks)
305
+ assert all("| ligne | montant |" in c["content"] for c in r.chunks)
306
+ # Aucune ligne perdue, aucune dupliquee, aucune coupee
307
+ lignes = [ln for c in r.chunks for ln in c["content"].splitlines() if ln.startswith("| ligne ") and ln[8].isdigit()]
308
+ assert lignes == [f"| ligne {i} | {i * 1000} |" for i in range(200)]
309
+
310
+ def test_premiere_ligne_de_donnees_non_repetee(self, contexte):
311
+ """Sans vrai en-tete, Docling met la premiere ligne de donnees en tete."""
312
+ table = "| 31 | EDUCATION PRESCOLAIRE | 31 915 303 |\n|---|---|---|\n" + "".join(
313
+ f"| {32 + i} | PROGRAMME {i} | 1 000 {i:03d} |\n" for i in range(200)
314
+ )
315
+ r = refine([chunk("12", "Les crédits sont répartis comme suit :\n" + table)], contexte)
316
+
317
+ assert len(r.chunks) > 1
318
+ assert sum(c["content"].count("EDUCATION PRESCOLAIRE") for c in r.chunks) == 1
319
+
320
+ def test_texte_apres_le_tableau_conserve(self, contexte):
321
+ table = "| poste | montant |\n| --- | --- |\n" + "".join(f"| poste {i} | {i} |\n" for i in range(300))
322
+ contenu = "Répartition :\n" + table + "\nLe reliquat est reporté sur l'exercice suivant."
323
+ r = refine([chunk("7", contenu)], contexte)
324
+
325
+ assert "Le reliquat est reporté" in r.chunks[-1]["content"]
326
 
327
  def test_tableau_html_trop_long_prend_la_nature_table(self, contexte):
328
  table = "<table>" + "".join(
 
763
  def test_ce_qui_suit_decrete_sans_dispositif_reste_dans_les_visas(contexte, reste):
764
  r = refine([chunk("LEGAL_BASIS", "- Vu la Constitution ;\n\nDECRETE :\n\n" + reste)], contexte)
765
  assert [c["number"] for c in r.chunks] == ["LEGAL_BASIS"]
766
+
767
+
768
+ class TestListesEtTableauxBudgetaires:
769
+ def test_intitule_de_programme_n_est_pas_un_texte_de_nomination(self, contexte):
770
+ """« PROMOTION DE LA FEMME » dans une cellule ne fait pas une liste."""
771
+ table = "| Programme | Responsable |\n|---|---|\n" + "".join(
772
+ f"| PROMOTION DE LA FEMME {i} | DIRECTION GENERALE {i} |\n" for i in range(8)
773
+ )
774
+ r = refine([chunk("4", "Les programmes se déclinent comme suit :\n" + table)], contexte)
775
+ assert not r.roster
776
+ assert r.chunks[0]["kind"] != "roster"
777
+
778
+ def test_tous_les_tableaux_d_une_liste_sortent_du_vecteur(self, contexte):
779
+ """Un tableau par page ; la detection en manque un : il part quand meme."""
780
+ page1 = "| 1. | NOM PRENOM01 | 701 895-X |\n|---|---|---|\n" + "".join(
781
+ f"| {i}. | NOM PRENOM{i:02d} | 70{i} 89{i}-X |\n" for i in range(2, 9)
782
+ )
783
+ illisible = "| | AKONO AKONO MARTIN | J-057 035 |\n|---|---|---|\n| | ABAH OMGBA | J-057 036 |\n"
784
+ contenu = (
785
+ "Les Gardiens de la Paix dont les noms suivent sont inscrits au tableau d'avancement :\n"
786
+ + page1 + "\n" + illisible
787
+ )
788
+ r = refine([chunk("1", contenu)], contexte)
789
+ assert r.chunks[0]["kind"] == "roster"
790
+ assert "AKONO" in r.chunks[0]["content"], "le contenu garde toute la liste"
791
+ assert "AKONO" not in r.chunks[0]["embed_text"]
792
+ assert "PRENOM05" not in r.chunks[0]["embed_text"]
tests/test_utils/test_markdown_cleanup.py CHANGED
@@ -271,3 +271,41 @@ def test_ligne_sans_marqueur_intacte(ligne):
271
  ])
272
  def test_cachet_ecorche_retire(cachet):
273
  assert strip_stamp_blocks("Article 2.- Texte de l'article.\n\n" + cachet) == "Article 2.- Texte de l'article."
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
271
  ])
272
  def test_cachet_ecorche_retire(cachet):
273
  assert strip_stamp_blocks("Article 2.- Texte de l'article.\n\n" + cachet) == "Article 2.- Texte de l'article."
274
+
275
+
276
+ class TestCachetSecondeReleve:
277
+ """Variantes relevees sur les 13 923 pages du corpus indexe."""
278
+
279
+ @pytest.mark.parametrize("cachet", [
280
+ "CORIECERTIFIEECONFORME",
281
+ "GOPIE CERTIFIEE CONFORME",
282
+ "COPIFCERTIFIEECONFORME",
283
+ "COPILCERTIFIEE CONFORME",
284
+ "GERTIFIED TRUE COPY",
285
+ "CERTTFIED TRUE COPY",
286
+ "EERTIFIED TRUE COPY",
287
+ "TRUECOPY",
288
+ "SERVICE OU FICHIER LEGISLATIF ET REGLEMENTAIRE",
289
+ "SERVICE DU ACHIER LEGISLATIF ET REGLEMENTAIRE",
290
+ "'LEGISLATIF ET REGLEMENTAIRE",
291
+ "PRESIDENCY OF THE REPUBLIC",
292
+ "PRESIDENCYOFTHEREPUBLIC",
293
+ "PRESIDENCE DE LAREPUBLIQUE PRESIDENCY OF THE REPUBLIC SECRETARIAT GENERAL",
294
+ ])
295
+ def test_variante_retiree(self, cachet):
296
+ assert strip_stamp_blocks("Article 2.- Texte de l'article.\n\n" + cachet) == (
297
+ "Article 2.- Texte de l'article."
298
+ )
299
+
300
+ def test_bloc_bilingue_retire_au_milieu_d_une_liste(self):
301
+ md = (
302
+ "- Monsieur ABENA Paul ;\n\n"
303
+ "PRESIDENCE DELA REPUBLIQUE\n\nPRESIDENCY OF THE REPUBLIC\n\nSECRETARLAT GENERAL\n\n"
304
+ "- Monsieur ESSOMBA Jean."
305
+ )
306
+ assert strip_stamp_blocks(md) == "- Monsieur ABENA Paul ;\n\n\n- Monsieur ESSOMBA Jean."
307
+
308
+ def test_mention_anglaise_dans_une_phrase_conservee(self):
309
+ """Un futur texte anglais parle de la Presidence dans ses phrases."""
310
+ md = "The Secretary General of the Presidency of the Republic shall implement this decree."
311
+ assert strip_stamp_blocks(md) == md