diff --git a/base_connaissances/__init__.py b/base_connaissances/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/base_connaissances/decoupage.py b/base_connaissances/decoupage.py new file mode 100644 index 0000000..166bb2e --- /dev/null +++ b/base_connaissances/decoupage.py @@ -0,0 +1,100 @@ +"""Du texte d'un PDF (sortie de `pdftotext`, sans `-layout`) ou d'un Markdown aux extraits de la base de connaissances +de LibreDesk ; écriture et lecture du corpus (un fichier Markdown par extrait).""" +import re +import unicodedata +from dataclasses import dataclass +from pathlib import Path + +ENTREE = re.compile(r"(.+?)\s*(?:\.\s?){3,}\s*(\d+)") # « titre . . . . page » de la table des matières +PUCE = re.compile(r"\s*�\s*") + + +def slug(titre: str) -> str: + sans_accents = unicodedata.normalize("NFKD", titre).encode("ascii", "ignore").decode() + return re.sub(r"-+", "-", re.sub(r"[^a-z0-9]", "-", sans_accents.lower())).strip("-") + + +@dataclass(frozen=True) +class Extrait: + titre: str + contenu: str + source: str + + @property + def cle(self) -> str: + return slug(self.titre) + ".md" + + +def _table_des_matieres(lignes: list[str]) -> tuple[list[str], int]: + """Les titres de la table des matières et l'indice de sa dernière ligne. Un titre peut continuer sur la ligne + suivante, et plusieurs entrées peuvent être collées sur une ligne.""" + titres, debut, fin = [], "", -1 + for i, ligne in enumerate(lignes): + entrees = list(ENTREE.finditer(ligne)) + if not entrees: + if fin >= 0 or titres: + debut = f"{debut} {ligne.strip()}".strip() + continue + for k, m in enumerate(entrees): + titre = m.group(1).strip() + if k == 0 and debut: + titre = f"{debut} {titre}" + titres.append(" ".join(titre.split())) + debut, fin = ligne[entrees[-1].end():].strip(), i + return titres, fin + + +def decouper_pdf(texte: str, parasites: list[str], source: str = "") -> list[Extrait]: + """Un extrait par entrée de la table des matières qui a un corps ; les titres de chapitre (sans corps) n'en donnent + pas.""" + lignes = texte.splitlines() + titres, fin = _table_des_matieres(lignes) + connus = set(titres) + sections: list[tuple[str, list[str]]] = [] + for ligne in lignes[fin + 1:]: + nette = ligne.strip() + if nette in parasites or re.fullmatch(r"\d+", nette): + continue + if nette in connus: + sections.append((nette, [])) + elif sections and nette: + sections[-1][1].append(nette) + extraits = [] + for titre, corps in sections: + contenu = PUCE.sub("\n- ", "\n".join(corps)).strip() + if contenu: + extraits.append(Extrait(titre, contenu, source)) + return extraits + + +def decouper_markdown(texte: str, source: str, max_car: int = 6000) -> list[Extrait]: + """Un extrait par fichier ; au-delà de `max_car`, un par section `## `.""" + lignes = texte.strip().splitlines() + if lignes and lignes[0].startswith("# "): + titre, corps = lignes[0][2:].strip(), "\n".join(lignes[1:]).strip() + else: + titre, corps = Path(source).stem, "\n".join(lignes).strip() + if len(corps) <= max_car: + return [Extrait(titre, corps, source)] + sections: list[tuple[str, list[str]]] = [(titre, [])] + for ligne in corps.splitlines(): + if ligne.startswith("## "): + sections.append((f"{titre} — {ligne[3:].strip()}", [])) + else: + sections[-1][1].append(ligne) + return [Extrait(t, "\n".join(c).strip(), source) for t, c in sections if "\n".join(c).strip()] + + +def ecrire_corpus(extraits: list[Extrait], dossier: Path) -> None: + dossier.mkdir(parents=True, exist_ok=True) + for e in extraits: + (dossier / e.cle).write_text(f"# {e.titre}\n\n{e.contenu}\n\nSource : {e.source}\n") + + +def lire_corpus(dossier: Path) -> list[Extrait]: + extraits = [] + for f in sorted(dossier.glob("*.md")): + tete, reste = f.read_text().rstrip("\n").split("\n\n", 1) + contenu, source = reste.rsplit("\n\nSource : ", 1) + extraits.append(Extrait(tete.removeprefix("# ").strip(), contenu.strip(), source.strip())) + return extraits diff --git a/tests/test_decoupage.py b/tests/test_decoupage.py new file mode 100644 index 0000000..3375a49 --- /dev/null +++ b/tests/test_decoupage.py @@ -0,0 +1,49 @@ +import tempfile +import unittest +from pathlib import Path + +from base_connaissances.decoupage import Extrait, decouper_markdown, decouper_pdf, ecrire_corpus, lire_corpus + +TOC = ("Contents\nInstall . . . . . . 1\n Does it start? . . . . . 1\n How long does the\n battery last? . . . . 2\n" + "Data . . . . 3 Which formats? . . . . 3\n") +CORPS = ("Install\nDoes it start?\nCheck power.\nRevision 1.5\n2\nAIMsight FAQ\nCheck fuse.\n" + "How long does the battery last?\nAbout 3 days: � sun; � mains.\nData\nWhich formats?\nCSV.\n") +PARASITES = ["Revision 1.5", "AIMsight FAQ"] + + +class TestDecouperPdf(unittest.TestCase): + def test_un_extrait_par_question_avec_corps(self): + x = decouper_pdf(TOC + CORPS, PARASITES) + self.assertEqual([e.titre for e in x], ["Does it start?", "How long does the battery last?", "Which formats?"]) + + def test_parasites_et_numeros_de_page_retires(self): + x = decouper_pdf(TOC + CORPS, PARASITES) + self.assertEqual(x[0].contenu, "Check power.\nCheck fuse.") + + def test_puces(self): + self.assertIn("\n- sun;\n- mains.", decouper_pdf(TOC + CORPS, [])[1].contenu) + + +class TestDecouperMarkdown(unittest.TestCase): + def test_markdown_court_un_extrait(self): + x = decouper_markdown("# Le cycle thermique\n\nLe jour, ...\n", "labeling/connaissances/cycle-thermique.md") + self.assertEqual([(e.titre, e.source) for e in x], + [("Le cycle thermique", "labeling/connaissances/cycle-thermique.md")]) + + def test_markdown_long_par_section(self): + texte = "# Doc\n\n## A\n\n" + "a" * 4000 + "\n\n## B\n\n" + "b" * 4000 + "\n" + self.assertEqual([e.titre for e in decouper_markdown(texte, "x.md")], ["Doc — A", "Doc — B"]) + + +class TestCorpus(unittest.TestCase): + def test_aller_retour_du_corpus(self): + with tempfile.TemporaryDirectory() as t: + d = Path(t) + x = [Extrait("Which formats?", "CSV.", "AIMsight FAQ, rév. 1.5")] + ecrire_corpus(x, d) + self.assertEqual(lire_corpus(d), x) + self.assertEqual((d / "which-formats.md").read_text().splitlines()[-1], "Source : AIMsight FAQ, rév. 1.5") + + +if __name__ == "__main__": + unittest.main()