- base_connaissances/ → snippets/ (corpus/ → textes/, instructions.md → consignes_redaction.md, decoupage.py → fichiers.py, importer.py → envoyer.py) ; python3 -m snippets.envoyer. - instance-de-test/ : 1_demarrer.sh, 2_creer_boite_et_cle.py, 3_brancher_ia.py, 4_essayer_brouillons.py, voir_empreintes.sh, connexion_admin.py. - ollama/verifier.py → ollama/verifier_ollama.py ; tests, tâches VS Code et docs alignés. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
132 lines
5.5 KiB
Python
132 lines
5.5 KiB
Python
"""Envoie les textes de snippets/textes/ dans LibreDesk : ce sont ses snippets (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 de snippets/textes/ 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 snippets.envoyer [--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 snippets.fichiers import Extrait, lire_textes
|
|
|
|
TEXTES = Path(__file__).resolve().parent / "textes"
|
|
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]}")
|
|
except (urllib.error.URLError, TimeoutError) as err:
|
|
sys.exit(f"LibreDesk injoignable à {self.url} : {getattr(err, 'reason', err)}")
|
|
|
|
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_textes(TEXTES))
|
|
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 snippets/textes/ (non supprimé) : {t}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main(sys.argv[1:])
|