155 lines
7.2 KiB
Python
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("&", "&"), 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()
|