"""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_-]+") NOM_MAX = 200 # octets : sous la limite de 255 des systèmes de fichiers PERDUE = {403, 404, 410} # une pièce jointe que LibreDesk n'a plus, ou dont il refuse la signature : sautée, notée 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) if urllib.parse.urlsplit(url).scheme not in ("http", "https"): # jamais file: : un fichier local recopié et commité raise ValueError(f"adresse refusée (schéma {urllib.parse.urlsplit(url).scheme or 'absent'})") 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: contenu = self._ouvrir(url) # d'abord : pas de dossier vide pour une pièce refusée chemin.parent.mkdir(parents=True, exist_ok=True) partiel = chemin.with_name(chemin.name + ".part") partiel.write_bytes(contenu) 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 nom = sur(nom) or sur(uuid) or "piece" racine, suffixe = (nom.rsplit(".", 1)[0], "." + nom.rsplit(".", 1)[1]) if "." in nom[1:] else (nom, "") while len((racine + suffixe).encode()) > NOM_MAX: # un nom trop long, raccourci en gardant l'extension racine = racine[:-1] if racine else "" suffixe = suffixe if racine else suffixe[:NOM_MAX // 4] return racine + suffixe def _ecrire(lecteur: Lecteur, sortie: Path, c: dict, journal) -> 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")): try: lecteur.telecharger(url, f) except (urllib.error.HTTPError, ValueError) as e: if isinstance(e, urllib.error.HTTPError): e.close() if e.code not in PERDUE: raise # une erreur passagère : le pompage s'arrête, le suivant reprendra journal(f" pièce jointe {nom} sautée : {getattr(e, 'code', e)}") a["url"], a["absente"] = "", True continue 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, avant = 0, None for c in lecteur.conversations(): t = _date(c["updated_at"]) if avant and t > avant: # l'arrêt incrémental suppose l'ordre de updated_at : sinon des conversations perdues raise ValueError("LibreDesk ne rend pas les conversations dans l'ordre de updated_at : pompage arrêté, repère inchangé") avant = t if haut and t >= haut: continue if bas and t < bas: break nom, n_messages, n_pieces = _ecrire(lecteur, sortie, c, journal) 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)}") except ValueError as e: sys.exit(str(e)) if __name__ == "__main__": main()