Base de connaissances : import idempotent des extraits, sans suppression

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-11 14:12:27 +01:00
1 parent 4d75fb6172
commit 4d8d61cb71
3 files changed
+236

No files matched your search

+129
View File
@@ -0,0 +1,129 @@
"""Pousse le corpus dans la base de connaissances de LibreDesk (les « extraits », privés, lus par l'IA seulement).
Idempotent : apparie par titre, crée l'absent, met à jour ce qui a changé, ne touche pas le reste. Ne supprime jamais :
un extrait de LibreDesk absent du corpus est seulement signalé. Ne parle qu'aux routes des extraits. Simulation par
défaut : rien n'est écrit sans --ecrire. Il faut une clé d'administrateur (les routes exigent ai:manage).
LIBREDESK_URL=… LIBREDESK_ADMIN_KEY=… LIBREDESK_ADMIN_SECRET=… python -m base_connaissances.importer [--ecrire]
"""
import html as html_lib
import json
import os
import re
import sys
import urllib.error
import urllib.parse
import urllib.request
from dataclasses import dataclass, field
from pathlib import Path
from base_connaissances.decoupage import Extrait, lire_corpus
CORPUS = Path(__file__).resolve().parent / "corpus"
PUCE = re.compile(r"^\s*- ")
def html(e: Extrait) -> str:
"""Paragraphes séparés par une ligne vide → <p> (lignes jointes par <br>), lignes « - » → <ul><li>, texte échappé,
puis la source."""
morceaux = []
for paragraphe in e.contenu.split("\n\n"):
lignes = [ligne for ligne in paragraphe.splitlines() if ligne.strip()]
i = 0
while i < len(lignes):
liste = PUCE.match(lignes[i]) is not None
j = i
while j < len(lignes) and (PUCE.match(lignes[j]) is not None) == liste:
j += 1
bloc = [html_lib.escape(PUCE.sub("", ligne).strip() if liste else ligne.strip(), quote=False)
for ligne in lignes[i:j]]
morceaux.append("<ul>" + "".join(f"<li>{b}</li>" for b in bloc) + "</ul>" if liste
else "<p>" + "<br>".join(bloc) + "</p>")
i = j
morceaux.append(f"<p>Source : {html_lib.escape(e.source, quote=False)}</p>")
return "".join(morceaux)
def _texte(contenu_html: str) -> str:
"""Le texte sans balises, entités décodées, espaces réduits : LibreDesk peut reformater le HTML qu'il garde."""
return " ".join(html_lib.unescape(re.sub(r"<[^>]+>", " ", contenu_html or "")).split())
class Extraits:
"""Le client restreint aux extraits de la base de connaissances."""
def __init__(self, url: str, cle: str, secret: str, ecrire: bool):
self.url, self.ecrire = url.rstrip("/"), ecrire
self._auth = f"token {cle}:{secret}"
def _requete(self, methode: str, chemin: str, corps: dict | None = None):
url = urllib.parse.urljoin(self.url + "/", chemin.lstrip("/"))
r = urllib.request.Request(url, method=methode, data=json.dumps(corps).encode() if corps is not None else None,
headers={"Content-Type": "application/json"})
if urllib.parse.urlsplit(url)[:2] == urllib.parse.urlsplit(self.url)[:2]: # la clé ne va qu'à LibreDesk
r.add_unredirected_header("Authorization", self._auth)
try:
with urllib.request.urlopen(r, timeout=30) as rep:
return json.loads(rep.read() or b"{}").get("data")
except urllib.error.HTTPError as err:
with err:
sys.exit(f"{methode} {chemin} : {err.code} {err.read().decode(errors='replace')[:300]}")
def lister(self) -> list[dict]:
return self._requete("GET", "/api/v1/ai/snippets") or []
def _corps(self, e: Extrait) -> dict:
return {"title": e.titre, "content": html(e), "enabled": True}
def creer(self, e: Extrait) -> None:
if not self.ecrire:
print(f"[simulation] créer : {e.titre}")
return
self._requete("POST", "/api/v1/ai/snippets", self._corps(e))
def modifier(self, id: int, e: Extrait) -> None: # noqa: A002 (le nom de l'interface du plan)
if not self.ecrire:
print(f"[simulation] modifier ({id}) : {e.titre}")
return
self._requete("PUT", f"/api/v1/ai/snippets/{id}", self._corps(e))
@dataclass
class Bilan:
crees: list[str] = field(default_factory=list)
modifies: list[str] = field(default_factory=list)
inchanges: list[str] = field(default_factory=list)
inconnus: list[str] = field(default_factory=list)
def synchroniser(api: Extraits, extraits: list[Extrait]) -> Bilan:
existants = {s["title"]: s for s in api.lister()}
bilan = Bilan()
for e in extraits:
s = existants.get(e.titre)
if s is None:
api.creer(e)
bilan.crees.append(e.titre)
elif _texte(s.get("content")) != _texte(html(e)):
api.modifier(s["id"], e)
bilan.modifies.append(e.titre)
else:
bilan.inchanges.append(e.titre)
titres = {e.titre for e in extraits}
bilan.inconnus = [t for t, s in existants.items() if s.get("source") == "manual" and t not in titres]
return bilan
def main(argv: list[str]) -> None:
ecrire = "--ecrire" in argv
api = Extraits(os.environ["LIBREDESK_URL"], os.environ["LIBREDESK_ADMIN_KEY"], os.environ["LIBREDESK_ADMIN_SECRET"],
ecrire=ecrire)
b = synchroniser(api, lire_corpus(CORPUS))
print(f"créés {len(b.crees)}, modifiés {len(b.modifies)}, inchangés {len(b.inchanges)}"
+ ("" if ecrire else " (simulation : rien n'a été écrit)"))
for t in b.inconnus:
print(f"dans LibreDesk mais pas dans le corpus (non supprimé) : {t}")
if __name__ == "__main__":
main(sys.argv[1:])
+23
View File
@@ -0,0 +1,23 @@
"""Le paquet base_connaissances ne parle à LibreDesk que par les routes des extraits (spec §3, plan Global Constraints)."""
import re
import unittest
from pathlib import Path
PAQUET = Path(__file__).resolve().parents[1] / "base_connaissances"
AUTORISEES = {"/api/v1/ai/snippets", "/api/v1/ai/snippets/{id}"} # la route PUT s'écrit f"/api/v1/ai/snippets/{id}"
class TestGardeFouBase(unittest.TestCase):
def test_seules_les_routes_des_extraits(self):
for f in PAQUET.glob("*.py"):
texte = f.read_text()
self.assertEqual(set(re.findall(r"/api/v1/[a-z0-9_/{}-]+", texte)) - AUTORISEES, set(), f.name)
for interdit in ("/messages", "/conversations", "DELETE", "automations", "assistants"):
self.assertNotIn(interdit, texte, f"{interdit} dans {f.name}")
def test_le_paquet_a_bien_un_client(self): # sans importer.py, le test ci-dessus passerait à vide
self.assertTrue((PAQUET / "importer.py").exists())
if __name__ == "__main__":
unittest.main()
+84
View File
@@ -0,0 +1,84 @@
import unittest
from base_connaissances.decoupage import Extrait
from base_connaissances.importer import Extraits, html, synchroniser
from faux_libredesk import FauxLibreDesk
LISTE = ("GET", "/api/v1/ai/snippets")
E1 = Extrait("Which formats?", "CSV < 2 Mo.\n\n- csv\n- json", "AIMsight FAQ, rév. 1.5")
E2 = Extrait("Which timezone?", "UTC.", "AIMsight FAQ, rév. 1.5")
def snippet(id_, titre, contenu, source="manual"):
return {"id": id_, "title": titre, "content": contenu, "enabled": True, "source": source}
class TestImporter(unittest.TestCase):
def setUp(self):
self.faux = FauxLibreDesk()
self.addCleanup(self.faux.arreter)
def api(self, ecrire=True):
return Extraits(self.faux.url, "k", "s", ecrire=ecrire)
def test_cree_les_absents(self):
self.faux.reponses[LISTE] = []
b = synchroniser(self.api(), [E1, E2])
self.assertEqual(b.crees, [E1.titre, E2.titre])
self.assertEqual([(m, c["title"]) for m, _, c in self.faux.ecritures()], [("POST", E1.titre), ("POST", E2.titre)])
self.assertEqual(self.faux.ecritures()[0][2], {"title": E1.titre, "content": html(E1), "enabled": True})
def test_rejouer_ne_cree_pas_de_doublon(self):
self.faux.reponses[LISTE] = [snippet(7, E1.titre, html(E1))]
self.assertEqual(synchroniser(self.api(), [E1]).inchanges, [E1.titre])
self.assertEqual(self.faux.ecritures(), [])
def test_html_reformate_reste_inchange(self):
reformate = html(E1).replace("><", ">\n<").replace("&lt;", "&#60;")
self.faux.reponses[LISTE] = [snippet(7, E1.titre, reformate)]
self.assertEqual(synchroniser(self.api(), [E1]).inchanges, [E1.titre])
def test_contenu_change_met_a_jour(self):
self.faux.reponses[LISTE] = [snippet(7, E1.titre, "<p>ancien</p>")]
b = synchroniser(self.api(), [E1])
self.assertEqual(b.modifies, [E1.titre])
self.assertEqual(self.faux.ecritures()[0][:2], ("PUT", "/api/v1/ai/snippets/7"))
def test_extrait_inconnu_signale_pas_supprime(self):
self.faux.reponses[LISTE] = [snippet(9, "Ancien titre", "x")]
b = synchroniser(self.api(), [E1])
self.assertEqual(b.inconnus, ["Ancien titre"])
self.assertNotIn("DELETE", [m for m, _, _ in self.faux.requetes])
def test_extrait_appris_ignore(self): # source « conversation » : appris par LibreDesk, pas à nous
self.faux.reponses[LISTE] = [snippet(9, "Appris", "x", source="conversation")]
self.assertEqual(synchroniser(self.api(), [E1]).inconnus, [])
def test_simulation_n_ecrit_rien(self):
self.faux.reponses[LISTE] = [snippet(7, E2.titre, "<p>ancien</p>")]
b = synchroniser(self.api(ecrire=False), [E1, E2])
self.assertEqual((b.crees, b.modifies), ([E1.titre], [E2.titre]))
self.assertEqual(self.faux.ecritures(), [])
def test_cle_envoyee(self):
self.faux.reponses[LISTE] = []
self.api().lister()
self.assertEqual(self.faux.entetes[-1]["Authorization"], "token k:s")
def test_erreur_http_arrete(self):
self.faux.reponses[LISTE] = 403
with self.assertRaises(SystemExit):
synchroniser(self.api(), [E1])
class TestHtml(unittest.TestCase):
def test_html_echappe_et_listes(self):
h = html(Extrait("T", "a < b\n\n- un\n- deux", "S"))
self.assertEqual(h, "<p>a &lt; b</p><ul><li>un</li><li>deux</li></ul><p>Source : S</p>")
def test_lignes_d_un_paragraphe_gardees(self):
self.assertEqual(html(Extrait("T", "ligne 1\nligne 2", "S")), "<p>ligne 1<br>ligne 2</p><p>Source : S</p>")
if __name__ == "__main__":
unittest.main()