"""Les outils des deux agents : leurs schémas pour l'API, et la Boite qui les exécute sur le poste. Tout outil lance une copie de `API/tools/` par `subprocess`, n'écrit que dans le dossier de la séance (et dans la fabrique Typst `tools/typst/{documents,build}/`), et lève ErreurOutil sur une erreur : l'agent la rend au modèle en `is_error`. """ import base64 import io import os import re import shutil import subprocess from datetime import datetime from pathlib import Path from typing import Callable from PIL import Image API = Path(__file__).resolve().parents[1] PY = str(API / ".venv" / "bin" / "python") TOOLS = API / "tools" TYPST = TOOLS / "typst" KNOWLEDGE = API / "knowledge" LECTURE = {"inventaire", "resume", "plages", "jours", "vignettes", "qualite", "ensemble", "graphique", "metriques", "stations"} AVEC_SORTIE = {"graphique", "ensemble", "jours", "metriques", "vignettes", "qualite", "stations"} # ceux qui écrivent des PNG DELAI = 600 # s VOIR = 1000 # px : les images regardées restent dans l'historique et repartent à chaque appel NOM = re.compile(r"^[A-Za-z0-9_-]+$") INSTANT = re.compile(r"^\d{8}T\d{4}Z$") # AAAAMMJJTHHMMZ, comme le début du nom des images PROCHE = 90 # min : au-delà, pas d'image « à cette heure » class ErreurOutil(Exception): pass def plafonner(texte: str, n: int = 40_000) -> str: return texte if len(texte) <= n else texte[:n] + f"\n[… tronqué : {len(texte)} caractères]" def section(texte: str, titre: str) -> str: """La section d'un markdown dont le titre contient `titre` (sans la casse), jusqu'au titre suivant de même niveau ou plus haut ; lève ErreurOutil avec la liste des titres si aucun ne convient.""" lignes = texte.splitlines() titres = [(i, len(l) - len(l.lstrip("#"))) for i, l in enumerate(lignes) if l.startswith("#")] for k, (i, niveau) in enumerate(titres): if titre.lower() in lignes[i].lstrip("#").strip().lower(): fin = next((j for j, n in titres[k + 1:] if n <= niveau), len(lignes)) return "\n".join(lignes[i:fin]).strip() raise ErreurOutil(f"pas de section « {titre} » ; sections : " + " | ".join(lignes[i].strip() for i, _ in titres)) def bloc_image(chemin: Path, cote: int = 1568) -> dict: """Image -> bloc image de l'API, plus grand côté ≤ cote px (au-delà de 1568, l'API la réduirait de toute façon).""" im = Image.open(chemin) im.thumbnail((cote, cote)) jpeg = Path(chemin).suffix.lower() in (".jpg", ".jpeg") if im.mode not in ("RGB", "L"): im = im.convert("RGB") tampon = io.BytesIO() im.save(tampon, "JPEG" if jpeg else "PNG") return {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg" if jpeg else "image/png", "data": base64.b64encode(tampon.getvalue()).decode()}} def _schema(nom: str, description: str, props: dict) -> dict: return {"name": nom, "description": description, "strict": True, "input_schema": {"type": "object", "properties": props, "required": list(props), "additionalProperties": False}} S, I = {"type": "string"}, {"type": "integer"} LISTE = {"type": "array", "items": {"type": "string"}} OUTILS_ANALYSTE = [ _schema("detecteurs", "Les événements des détecteurs du journal sur une plage : famille, sorte, capteurs, phrase. " "du et au : AAAA-MM-JJ, UTC, au exclu.", {"station": S, "du": S, "au": S}), _schema("stabilite", "La stabilité verticale chiffrée : pour chaque cible, la médiane de corr_y jour par jour et " "l'étendue de ces médianes (de combien elle a varié d'un jour à l'autre), mesures rejetées écartées ; hors : " "plages à écarter, AAAA-MM-JJTHH:MMZ/AAAA-MM-JJTHH:MMZ (les nuits de visibilité réduite). du, au : AAAA-MM-JJ, " "au exclu.", {"station": S, "du": S, "au": S, "hors": LISTE}), _schema("lire_document", "Lit un document de ton savoir (l'index de ton prompt), entier (section vide) ou une seule " "section par son titre (ex. une fiche de la carte des étiquettes : « La pluie »).", {"nom": S, "section": S}), _schema("outil_de_lecture", "Lance un outil de lecture (lire-les-donnees.md) : nom parmi " + ", ".join(sorted(LECTURE)) + ". arguments : la ligne de commande après le nom du script, data/ pour le dossier.", {"nom": S, "arguments": LISTE}), _schema("figure_courbes", "Figure corr_y à plage grisée (figure-y.py) dans le dossier de la séance, .png. " "debut, fin : AAAA-MM-JJTHH:MMZ. options : --cam tilt,pan, --temp, --zone D/F, --ligne T, --hauteur 5…", {"nom": S, "debut": S, "fin": S, "cibles": LISTE, "options": LISTE}), _schema("image_de_la_cause", "Recadrages éclaircis côte à côte autour d'une cible (x, y : pixel dans l'image entière), " ".png. instants : AAAAMMJJTHHMMZ=légende (l'image la plus proche de chaque heure), d'abord un instant " "sans la cause. cibles : les seules cibles dont le nom est écrit, celles dont parle la diapositive.", {"nom": S, "x": I, "y": I, "instants": LISTE, "cibles": LISTE}), _schema("voir_image", "Regarder une image : un fichier du dossier de la séance (ex. bosse.png), ou une image de la " "caméra, images/AAAAMMJJTHHMMZ (la plus proche de cette heure UTC) ou images/.", {"chemin": S}), ] OUTILS_SUPPORT = [ _schema("poser_station", "Fixe la station de la séance (un dossier de données) et le sujet en 2-3 mots " "(ex. courbes-bruitees) ; rend ce que la station a comme données.", {"station": S, "sujet": S}), _schema("demander_analyste", "Envoie un message à l'analyste (station, plage UTC, question ; ou un retour de fond) " "et rend sa réponse.", {"message": S}), _schema("ecrire_presentation", "Écrit le source Typst complet de la présentation dans le dossier de la séance.", {"source_typ": S}), _schema("compiler", "Compile la présentation : rend la version (v1.pdf, v2.pdf…), le nombre de diapositives qui " "débordent et les remarques du lint, ou l'erreur de Typst.", {}), _schema("voir_page", "Regarder la page n (à partir de 1) de la dernière version du PDF.", {"n": I}), ] class Boite: def __init__(self, dossier_seance: Callable[[], Path], station: Callable[[], str | None], donnees: Path, demander_analyste: Callable[[str], str], poser: Callable[[str, str], Path]): self.dossier, self.station, self.donnees = dossier_seance, station, Path(donnees) self.demander_analyste, self.poser = demander_analyste, poser # --- aides def _lancer(self, args: list[str], env: dict | None = None) -> str: try: r = subprocess.run(args, cwd=self.dossier(), capture_output=True, text=True, timeout=DELAI, env={**os.environ, **(env or {})}) except subprocess.TimeoutExpired: raise ErreurOutil(f"délai de {DELAI} s dépassé : {' '.join(args[1:3])}") sortie = (r.stdout + ("\n" + r.stderr if r.stderr.strip() else "")).strip() if r.returncode: raise ErreurOutil(plafonner(sortie or f"code de sortie {r.returncode}")) return plafonner(sortie or "(rien)") def _station(self, station: str | None = None) -> Path: station = station or self.station() if not station: raise ErreurOutil("pas encore de station : le support doit d'abord appeler poser_station") if not NOM.match(station) or not (self.donnees / station).is_dir(): raise ErreurOutil(f"station inconnue : {station} (pas de dossier dans les données)") return self.donnees / station def _nom(self, nom: str) -> str: if not NOM.match(nom): raise ErreurOutil(f"nom de fichier refusé : {nom} (lettres, chiffres, - et _)") return nom def _data(self, a: str) -> str: return str(self.donnees) + a[4:] if a == "data" or a.startswith("data/") else a def _image_proche(self, instant: str) -> Path: """L'image de la station la plus proche de l'instant (les images tombent à :00 ou :01, à un nom près).""" t = datetime.strptime(instant, "%Y%m%dT%H%MZ") ecart = lambda p: abs((datetime.strptime(p.name[:14], "%Y%m%dT%H%MZ") - t).total_seconds()) # noqa: E731 images = [p for p in (self._station() / "images").glob("*.jpg") if INSTANT.match(p.name[:14])] proche = min(images, key=ecart, default=None) if not proche or ecart(proche) > PROCHE * 60: raise ErreurOutil(f"pas d'image à moins de {PROCHE} min de {instant}") return proche def _image(self, chemin: str) -> Path: if chemin.startswith("images/") and INSTANT.match(chemin[7:21]) and not (self._station() / chemin).is_file(): return self._image_proche(chemin[7:21]) if chemin.startswith("images/"): base = self._station() / "images" p = (base / chemin[7:]).resolve() else: base = self.dossier() p = (base / chemin).resolve() if Path(chemin).is_absolute() or not p.is_relative_to(base.resolve()) or not p.is_file(): raise ErreurOutil(f"image refusée ou absente : {chemin}") return p def _versions(self) -> list[Path]: return sorted(self.dossier().glob("v*.pdf"), key=lambda p: int(p.stem[1:])) # --- l'analyste def executer_analyste(self, nom: str, e: dict): if nom == "detecteurs": return self._lancer([PY, str(TOOLS / "journal.py"), str(self._station(e["station"])), "--du", e["du"], "--au", e["au"]]) if nom == "lire_document": p = KNOWLEDGE / "analyste" / e["nom"] if "/" in e["nom"] or not p.is_file(): raise ErreurOutil(f"document inconnu : {e['nom']} ; documents : " + ", ".join(sorted(f.name for f in (KNOWLEDGE / "analyste").iterdir()))) texte = p.read_text() return plafonner(section(texte, e["section"]) if e["section"].strip() else texte) if nom == "stabilite": return self._lancer([PY, str(TOOLS / "stabilite.py"), str(self._station(e["station"])), "--du", e["du"], "--au", e["au"], *(["--hors", *e["hors"]] if e["hors"] else [])]) if nom == "outil_de_lecture": if e["nom"] not in LECTURE: raise ErreurOutil(f"outil inconnu : {e['nom']} (permis : {', '.join(sorted(LECTURE))})") args = [self._data(a) for a in e["arguments"]] if e["nom"] in AVEC_SORTIE: args += ["--sortie", str(self.dossier())] return self._lancer([PY, str(TOOLS / "agent-tools" / f"{e['nom']}.py"), *args]) if nom == "figure_courbes": sortie = self.dossier() / f"{self._nom(e['nom'])}.png" self._lancer([PY, str(TOOLS / "figures" / "figure-y.py"), str(self._station()), str(sortie), e["debut"], e["fin"], "--cibles", ",".join(e["cibles"]), *e["options"]]) return f"{sortie.name} écrite ; la regarder avec voir_image avant de la garder" if nom == "image_de_la_cause": sortie = self.dossier() / f"{self._nom(e['nom'])}.png" instants = [] # chaque instant ramené à l'image la plus proche, sa légende gardée for i in e["instants"]: k, egal, legende = i.partition("=") instants.append(self._image_proche(k).name[:14] + egal + legende) self._lancer([PY, str(TOOLS / "figures" / "image-de-la-cause.py"), str(self._station()), str(e["x"]), str(e["y"]), str(sortie), *instants, *(["--cibles", ",".join(e["cibles"])] if e["cibles"] else [])]) return (f"{sortie.name} écrite, images : {', '.join(i.partition('=')[0] for i in instants)} ; " "la regarder avec voir_image avant de la garder") if nom == "voir_image": return [bloc_image(self._image(e["chemin"]), VOIR)] raise ErreurOutil(f"outil inconnu : {nom}") # --- le support def executer_support(self, nom: str, e: dict): if nom == "poser_station": dossier = self._station(e["station"]) self.poser(e["station"], self._nom(e["sujet"])) sous = ", ".join(f"{d.name} ({sum(1 for _ in d.iterdir())} fichiers)" for d in sorted(dossier.iterdir()) if d.is_dir()) return f"station {e['station']} posée ; données : {sous}" if nom == "demander_analyste": return self.demander_analyste(e["message"]) if nom == "ecrire_presentation": p = self.dossier() / f"{self._station().name.lower()}.typ" p.write_text(e["source_typ"]) return f"{p.name} écrit ({len(e['source_typ'])} caractères)" if nom == "compiler": return self._compiler() if nom == "voir_page": return self._voir_page(int(e["n"])) raise ErreurOutil(f"outil inconnu : {nom}") def _compiler(self) -> str: station = self._station().name.lower() source = self.dossier() / f"{station}.typ" if not source.exists(): raise ErreurOutil("pas de source : appeler ecrire_presentation d'abord") slug = f"{station}-support" doc = TYPST / "documents" / slug shutil.rmtree(doc, ignore_errors=True) doc.mkdir(parents=True) shutil.copy(source, doc / "main.typ") for png in self.dossier().glob("*.png"): shutil.copy(png, doc) env = {"PATH": f"{Path.home() / '.local' / 'bin'}:{os.environ.get('PATH', '')}"} try: r = subprocess.run([PY, "brand/tools/build.py", slug], cwd=TYPST, capture_output=True, text=True, timeout=DELAI, env={**os.environ, **env}) except subprocess.TimeoutExpired: raise ErreurOutil(f"compilation : délai de {DELAI} s dépassé") sortie = (r.stdout + "\n" + r.stderr).strip() pdf = TYPST / "build" / f"{slug}-draft.pdf" if r.returncode or not pdf.exists(): raise ErreurOutil(plafonner(sortie)) version = self.dossier() / f"v{len(self._versions()) + 1}.pdf" shutil.copy(pdf, version) pdf.unlink() # la prochaine compilation ratée ne doit pas trouver l'ancien PDF texte = subprocess.run(["pdftotext", str(version), "-"], capture_output=True, text=True).stdout remarques = "\n".join(l for l in sortie.splitlines() if "warning" in l and "bare-image" not in l) return f"{version.name} : {texte.count('Overflow')} diapositive(s) qui débordent" + ( f"\nremarques du lint :\n{plafonner(remarques, 4000)}" if remarques else "") def _voir_page(self, n: int) -> list[dict]: versions = self._versions() if not versions: raise ErreurOutil("pas encore de PDF : compiler d'abord") prefixe = self.dossier() / f".page-{n}" r = subprocess.run(["pdftoppm", "-f", str(n), "-l", str(n), "-png", "-r", "80", str(versions[-1]), str(prefixe)], capture_output=True, text=True) pages = sorted(self.dossier().glob(f".page-{n}-*.png")) if r.returncode or not pages: raise ErreurOutil(f"page {n} introuvable dans {versions[-1].name}") bloc = bloc_image(pages[0]) for p in pages: p.unlink() return [bloc]