From 553562622f0eb92afc1785e3d56b2044e0b991dc Mon Sep 17 00:00:00 2001 From: maxime Date: Wed, 18 Nov 2026 15:09:34 +0100 Subject: [PATCH] =?UTF-8?q?Conversations=20:=20pomper.sh=20(.env,=20verrou?= =?UTF-8?q?,=20journal)=20et=20pompage.py,=20appel=C3=A9=20par=20aimsight-?= =?UTF-8?q?app?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- .gitignore | 1 + .vscode/tasks.json | 6 ++++++ README.md | 22 +++++++++++++++++++- conversations/pompage.py | 45 ++++++++++++++++++++++++++++++++++++++++ conversations/pomper.sh | 18 ++++++++++++++++ tests/test_pompage.py | 41 ++++++++++++++++++++++++++++++++++++ 6 files changed, 132 insertions(+), 1 deletion(-) create mode 100644 conversations/pompage.py create mode 100755 conversations/pomper.sh create mode 100644 tests/test_pompage.py diff --git a/.gitignore b/.gitignore index 86bd1a5..2529b70 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,4 @@ cases/ # sauvegardes de draw.io .$*.bkp +out/ diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 56e64f7..8041ce7 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -98,6 +98,12 @@ "type": "shell", "command": "[ \"${input:confirmationProduction}\" = oui ] || { echo annulé; exit 1; } && set -a && . ./.env && set +a && LIBREDESK_URL='${input:urlProduction}' python3 -m snippets.envoyer --ecrire", "problemMatcher": [] + }, + { + "label": "Conversations : pomper", + "type": "shell", + "command": "conversations/pomper.sh --sortie ~/aimsight-labeling/auto/conversations", + "problemMatcher": [] } ], "inputs": [ diff --git a/README.md b/README.md index ffc40f6..5ff3fc9 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,7 @@ Ce dépôt porte tout ce qu'il faut pour cela : - `snippets/` : les textes des snippets, relus (`textes/`, un fichier par snippet), les consignes de rédaction (`consignes_redaction.md`, à coller dans Admin → IA → Providers → Custom instructions) et l'import vers LibreDesk ; - `ollama/` : l'image Ollama avec le modèle d'embeddings `bge-m3:567m` embarqué, qui sert la recherche dans la base depuis le serveur de LibreDesk ; - `acces/` : le service d'accès, appelé par l'outil `get_customer_access` de LibreDesk au clic sur « Generate reply » : les stations que le client de la conversation peut voir sur le dashboard (export d'Auth0 `acces/utilisateurs.json` + ses UserGroup, en lecture seule) ; lancement dans `acces/compose.yml` ; +- `conversations/` : le pompage des conversations, **en lecture seule**, vers `~/aimsight-labeling/auto/conversations/` (le fil, les images, les pièces jointes), pour le support et l'entraînement ; lancé par l'onglet Conversations d'aimsight-app (section ci-dessous) ; - `instance-de-test/` : un LibreDesk v2.9.0 local avec Mailpit (un piège SMTP : rien ne sort), pour tout essayer avant la production ; - `.vscode/tasks.json` : les opérations courantes en un clic (Terminal → Run Task). @@ -15,7 +16,7 @@ Design : `docs/superpowers/specs/2026-11-12-support-libredesk-design.md`. Gestes ## Aucun message ne part au client -- Aucun code de ce dépôt n'écrit dans une conversation de la production. L'import ne parle à LibreDesk que par les routes des extraits (`tests/test_garde_fou_base.py`). +- Aucun code de ce dépôt n'écrit dans une conversation de la production. L'import ne parle à LibreDesk que par les routes des extraits (`tests/test_garde_fou_snippets.py`) ; le pompage des conversations ne fait que des GET (`tests/test_garde_fou_conversations.py`). - Seule l'instance de test crée des conversations, et son SMTP est Mailpit. - Les assistants IA de LibreDesk (qui répondraient seuls) restent désactivés ; aucune règle d'automatisation. @@ -70,3 +71,22 @@ Interface : `http://127.0.0.1:9100` (utilisateur `System`) ; Mailpit : `http://1 ### Retoucher la base de connaissances Modifier le fichier dans `snippets/textes/`, lancer les tests, puis l'import en simulation et en écriture (tâches « Snippets : … »). L'import apparie par titre, met à jour ce qui a changé et **ne supprime jamais** : un extrait retiré du corpus est seulement signalé. En production, il faut une clé admin temporaire (`docs/production.md`, point 4). + +### Pomper les conversations + +`conversations/pomper.py` copie les conversations de LibreDesk, toutes les boîtes et tous les statuts, notes privées comprises, dans un dossier par conversation : `conversation.json`, `messages.json` (les URL des pièces jointes remplacées par leur chemin local), `attachments/` et `transcript.md`, le fil lisible (texte seul, images en ligne). Que des GET ; la clé ne va qu'à LibreDesk. Sans dates, ce qui a changé depuis le dernier pompage complet (`pumped.json` dans le dossier de sortie ; la première fois, tout l'historique, à une heure calme) ; avec `--depuis/--jusqu-a`, une plage de mises à jour. + +La clé : un agent « Lecture conversations » dans LibreDesk, avec un rôle qui n'a que `conversations:read_all` et `messages:read`, et sa clé d'API dans `.env` : + +```bash +export LIBREDESK_LECTURE_KEY=… +export LIBREDESK_LECTURE_SECRET=… +``` + +D'habitude depuis l'onglet **Conversations** d'aimsight-app (qui appelle `conversations/pompage.py`), sinon la tâche « Conversations : pomper », ou : + +```bash +conversations/pomper.sh --sortie ~/aimsight-labeling/auto/conversations +``` + +Un pompage à la fois (`out/conversations.lock`), journal dans `out/conversations.log`. Les conversations se commitent ensuite dans aimsight-labeling, à la main. diff --git a/conversations/pompage.py b/conversations/pompage.py new file mode 100644 index 0000000..1ac84b8 --- /dev/null +++ b/conversations/pompage.py @@ -0,0 +1,45 @@ +"""Ce qu'aimsight-app appelle pour pomper les conversations (son onglet Conversations), le jumeau d'extraction/pumping.py +d'aimsight-data : lancer pomper.sh, savoir s'il tourne, lire la fin de son journal. Importé comme module simple (sys.path = +conversations/) : aucun import du paquet ici.""" +import fcntl +import os +import re +import subprocess +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +JOUR = re.compile(r"\d{4}-\d{2}-\d{2}") +PLAGE = "a range: From and To, YYYY-MM-DD, From before To" # les mots de pumping.py, montrés tels quels par l'app + + +def running() -> bool: + """Un pompage en cours : le verrou de pomper.sh est tenu.""" + try: + with open(ROOT / "out" / "conversations.lock") as verrou: + fcntl.flock(verrou, fcntl.LOCK_EX | fcntl.LOCK_NB) + except FileNotFoundError: + return False + except BlockingIOError: + return True + return False + + +def log(lines: int = 40) -> list[str]: + """Les dernières lignes de out/conversations.log.""" + try: + with open(ROOT / "out" / "conversations.log", "rb") as f: + f.seek(max(0, f.seek(0, os.SEEK_END) - 300 * lines)) + return f.read().decode(errors="replace").splitlines()[-lines:] + except FileNotFoundError: + return [] + + +def start(depuis: str, jusqu_a: str, sortie: str) -> subprocess.Popen: + """pomper.sh en arrière-plan, dans sortie ; avec une plage (AAAA-MM-JJ, jusqu_a exclu) ou sans (ce qui a changé).""" + if bool(depuis) != bool(jusqu_a) or (depuis and not (JOUR.fullmatch(depuis) and JOUR.fullmatch(jusqu_a) and depuis < jusqu_a)): + raise ValueError(PLAGE) + if running(): + raise ValueError("a pumping of the conversations is already running") + plage = ["--depuis", depuis, "--jusqu-a", jusqu_a] if depuis else [] + return subprocess.Popen([str(ROOT / "conversations" / "pomper.sh"), "--sortie", str(sortie), *plage], cwd=ROOT, + stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) diff --git a/conversations/pomper.sh b/conversations/pomper.sh new file mode 100755 index 0000000..3eab227 --- /dev/null +++ b/conversations/pomper.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash +# Pompe les conversations de LibreDesk (conversations/pomper.py), en lecture seule. Lit la clé de lecture dans le .env à la +# racine du dépôt (jamais versionné). Un pompage à la fois (verrou out/conversations.lock), sortie ajoutée à +# out/conversations.log. +# conversations/pomper.sh --sortie ~/aimsight-labeling/auto/conversations [--depuis AAAA-MM-JJ --jusqu-a AAAA-MM-JJ] +set -u +root=$(cd "$(dirname "$0")/.." && pwd) +mkdir -p "$root/out" +cd "$root" + +exec 9>"$root/out/conversations.lock" +flock -n 9 || { echo "Un pompage des conversations tourne déjà." >&2; exit 1; } + +{ + echo "=== $(date -u +%Y-%m-%dT%H:%MZ) pomper $*" + (set -a +u && . "$root/.env" && set +a -u && python3 -m conversations.pomper "$@") + echo "=== $(date -u +%Y-%m-%dT%H:%MZ) fin" +} 2>&1 | tee -a "$root/out/conversations.log" diff --git a/tests/test_pompage.py b/tests/test_pompage.py new file mode 100644 index 0000000..4096740 --- /dev/null +++ b/tests/test_pompage.py @@ -0,0 +1,41 @@ +import shutil +import tempfile +import unittest +from pathlib import Path + +from conversations import pompage + + +class TestPompage(unittest.TestCase): + def setUp(self): + self.racine, avant = Path(tempfile.mkdtemp()), pompage.ROOT + pompage.ROOT = self.racine + self.addCleanup(setattr, pompage, "ROOT", avant) + self.addCleanup(shutil.rmtree, self.racine) + + def test_plage_refusee(self): + for depuis, jusqu_a in (("2026-11-01", ""), ("", "2026-11-01"), ("2026-11-02", "2026-11-01"), ("1.11.2026", "2026-11-02")): + with self.assertRaisesRegex(ValueError, "From and To"): + pompage.start(depuis, jusqu_a, "/tmp/x") + + def test_pas_de_verrou_pas_de_pompage(self): + self.assertFalse(pompage.running()) + + def test_verrou_tenu(self): + import fcntl + (self.racine / "out").mkdir() + with open(self.racine / "out" / "conversations.lock", "w") as verrou: + fcntl.flock(verrou, fcntl.LOCK_EX) + self.assertTrue(pompage.running()) + with self.assertRaisesRegex(ValueError, "already running"): + pompage.start("", "", "/tmp/x") + + def test_journal(self): + (self.racine / "out").mkdir() + (self.racine / "out" / "conversations.log").write_text("".join(f"ligne {i}\n" for i in range(50))) + self.assertEqual(pompage.log(3), ["ligne 47", "ligne 48", "ligne 49"]) + self.assertEqual(pompage.log(), [f"ligne {i}" for i in range(10, 50)]) + + +if __name__ == "__main__": + unittest.main()