Files
aimsight-libredesk/conversations/pomper.py
T

179 lines
8.9 KiB
Python

"""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 <dossier>
[--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("&", "&amp;"), 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()