Files
aimsight-libredesk/conversations/pomper.py
T

155 lines
7.2 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_-]+")
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("&", "&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 = 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()