"""Pompe les conversations de LibreDesk, en lecture seule, dans un dossier par conversation (labeling/auto/conversations/ d'aimsight-labeling, par l'onglet Conversations d'aimsight-app) : conversation.json, messages.json, attachments/, et transcript.md, le fil lisible. Que des GET : la liste des conversations, leurs messages, et les URL (signées) des pièces jointes que portent les messages ; jamais une adresse trouvée dans le texte d'un message. La clé ne va qu'à LibreDesk ; une pièce jointe ailleurs (un bucket S3) est téléchargée sans elle. Il faut une clé de lecture (un agent dont le rôle n'a que conversations:read_all et messages:read). Sans dates : ce qui a changé depuis le dernier pompage complet (pumped.json, écrit seulement à la fin ; la première fois, tout l'historique). Avec --depuis/--jusqu-a : les conversations mises à jour dans la plage (--jusqu-a exclu), repère inchangé. LIBREDESK_URL=… LIBREDESK_LECTURE_KEY=… LIBREDESK_LECTURE_SECRET=… python3 -m conversations.pomper --sortie [--depuis AAAA-MM-JJ --jusqu-a AAAA-MM-JJ] """ import argparse import json import os import re import sys import urllib.error import urllib.parse import urllib.request from datetime import datetime, timedelta, timezone from pathlib import Path from conversations.transcript import transcript PAGE = 100 MARGE = timedelta(hours=1) # le repère moins une heure : une conversation mise à jour pendant le pompage n'est pas perdue REFERENCE = re.compile(r"[A-Za-z0-9_-]+") class Lecteur: """Le client de LibreDesk, restreint à la lecture des conversations.""" def __init__(self, url: str, cle: str, secret: str): self.url = url.rstrip("/") self._auth = f"token {cle}:{secret}" def _ouvrir(self, url: str) -> bytes: url = urllib.parse.urljoin(self.url + "/", url) r = urllib.request.Request(url) 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) with urllib.request.urlopen(r, timeout=60) as rep: return rep.read() def _pages(self, chemin: str, **params): page = 1 while True: q = urllib.parse.urlencode({"page": page, "page_size": PAGE, **params}) data = json.loads(self._ouvrir(f"{chemin}?{q}"))["data"] yield from data.get("results") or [] if page >= (data.get("total_pages") or 1): return page += 1 def conversations(self): """Toutes les conversations, la plus récemment mise à jour d'abord.""" return self._pages("/api/v1/conversations/all", order_by="updated_at", order="desc") def messages(self, uuid: str) -> list[dict]: """Les messages d'une conversation (notes privées comprises), le plus ancien d'abord.""" uuid = urllib.parse.quote(uuid, safe="") return sorted(self._pages(f"/api/v1/conversations/{uuid}/messages"), key=lambda m: _date(m["created_at"])) def telecharger(self, url: str, chemin: Path) -> None: chemin.parent.mkdir(parents=True, exist_ok=True) partiel = chemin.with_name(chemin.name + ".part") partiel.write_bytes(self._ouvrir(url)) partiel.replace(chemin) def _date(t: str) -> datetime: d = datetime.fromisoformat(t) return (d if d.tzinfo else d.replace(tzinfo=timezone.utc)).astimezone(timezone.utc) def _nom_local(nom: str, uuid: str) -> str: """Un nom de fichier sûr, dans attachments/ seulement ; vide : l'uuid de la pièce jointe.""" sur = lambda s: re.sub(r"[^\w.\- ]", "_", Path(s or "").name).strip(" .") # noqa: E731 return sur(nom) or sur(uuid) or "piece" def _ecrire(lecteur: Lecteur, sortie: Path, c: dict) -> tuple[str, int, int]: ref = str(c.get("reference_number") or "") dossier = sortie / (ref if REFERENCE.fullmatch(ref) else _nom_local(c["uuid"], "conversation")) messages, pris, n_pieces = lecteur.messages(c["uuid"]), set(), 0 for m in messages: for a in m.get("attachments") or []: nom = _nom_local(a.get("name"), a.get("uuid")) if nom in pris: nom = _nom_local(f"{a.get('uuid')}_{nom}", "") pris.add(nom) f, url = dossier / "attachments" / nom, a.get("url") or "" if url and not (f.exists() and f.stat().st_size == a.get("size")): lecteur.telecharger(url, f) if url: # l'URL signée expire : le chemin local, dans la pièce et dans le contenu (images en ligne) m["content"] = (m.get("content") or "").replace(url.replace("&", "&"), url).replace(url, f"attachments/{nom}") a["url"] = f"attachments/{nom}" n_pieces += 1 c = {k: v for k, v in c.items() if k != "previous_conversations"} dossier.mkdir(parents=True, exist_ok=True) for nom, contenu in (("conversation.json", c), ("messages.json", messages)): (dossier / nom).write_text(json.dumps(contenu, ensure_ascii=False, indent=1) + "\n", encoding="utf-8") (dossier / "transcript.md").write_text(transcript(c, messages), encoding="utf-8") return dossier.name, sum(m.get("type") != "activity" for m in messages), n_pieces def pomper(lecteur: Lecteur, sortie: Path, depuis: str | None = None, jusqu_a: str | None = None, journal=print) -> int: debut, repere, haut = datetime.now(timezone.utc), sortie / "pumped.json", None if depuis: bas, haut = _date(depuis), _date(jusqu_a) else: bas = _date(json.loads(repere.read_text())["until"]) - MARGE if repere.exists() else None n = 0 for c in lecteur.conversations(): t = _date(c["updated_at"]) if haut and t >= haut: continue if bas and t < bas: break nom, n_messages, n_pieces = _ecrire(lecteur, sortie, c) journal(f"#{nom} {c.get('subject') or ''} : {n_messages} messages, {n_pieces} pièces jointes") n += 1 if not depuis: # seulement un pompage complet : un pompage interrompu est repris au suivant sortie.mkdir(parents=True, exist_ok=True) repere.write_text(json.dumps({"until": debut.isoformat()}) + "\n") journal(f"{n} conversation(s) pompée(s) dans {sortie}") return n def main(): p = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) p.add_argument("--sortie", required=True, type=Path) p.add_argument("--depuis") p.add_argument("--jusqu-a") a = p.parse_args() if bool(a.depuis) != bool(a.jusqu_a): sys.exit("--depuis et --jusqu-a vont ensemble") cle, secret = os.environ.get("LIBREDESK_LECTURE_KEY"), os.environ.get("LIBREDESK_LECTURE_SECRET") if not (cle and secret): sys.exit("Pas de clé de lecture : LIBREDESK_LECTURE_KEY et LIBREDESK_LECTURE_SECRET dans .env (README)") lecteur = Lecteur(os.environ.get("LIBREDESK_URL", "https://helpdesk.sensima.ch"), cle, secret) try: pomper(lecteur, a.sortie, a.depuis, a.jusqu_a, journal=lambda l: print(l, flush=True)) except urllib.error.HTTPError as e: sys.exit(f"LibreDesk : {e.code} sur {e.url}".split("?")[0]) # sans la signature d'une URL de pièce jointe except (urllib.error.URLError, TimeoutError) as e: sys.exit(f"LibreDesk injoignable : {getattr(e, 'reason', e)}") if __name__ == "__main__": main()