L'app de diagnostic, ses agents et ce dont ils ont besoin, copiés de Support-Agent ; sans la page Support

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-13 11:32:43 +01:00
1 parent 8d5dc4a31c
commit 56f0c902d7
112 files changed
+13047

No files matched your search

+3
View File
@@ -0,0 +1,3 @@
web/node_modules/
web/dist/
__pycache__/
+46
View File
@@ -0,0 +1,46 @@
# La web app AIMsight
L'outil du diagnostic manuel : la page Data (la page Images, retirée, vit dans Data ; la page Support est retirée).
- **Data** (D-139) : le visualiseur de courbes, et l'étiquetage de `labeling/labeling.py` : un plot au départ (déplacements, caméra, qualité, métriques système), « Ajouter un plot » pour en voir plusieurs, alignés sur le temps, la croix pour en enlever un, un clic sur une courbe cale les images sur l'image la plus proche de son instant ; sous eux le choix des étiquettes, Detectors (les événements des détecteurs du journal, `detectors/categories.py`, en lecture seule, D-140), LLM (`labeling/auto/`, en lecture seule) ou Analysis (les mêmes étiquettes de `labeling/auto/`, à modifier, supprimer), et leur barre ; avec Detectors et LLM, y glisser zoome dans le temps ; avec Analysis, y glisser sélectionne une plage, puis des indices facultatifs, « Analyser la plage » : `serveur/analyse.py` lance l'étiqueteur par `claude -p` (non interactif) sur la plage ; il écrit dans `labeling/auto/analyses/<STATION>_<début>_<fin>/` ses étiquettes et un rapport de diagnostic (`rapport.md`, ses figures ; son travail et le journal de claude dans `travail/`, hors de git) ; la page suit son avancement, puis montre le rapport, et le serveur verse ses étiquettes dans `labeling/auto/<STATION>.jsonl` (champ `analyse`, sans `revue` : à relire par `/review-auto-labels`) ; « Voir le rapport » sur une étiquette ainsi faite le rouvre. La barre latérale range toutes les analyses de `labeling/auto/analyses/` en dossiers, un par station (ouvert d'office s'il en a une en cours), et dedans une analyse par plage, la plus récente en tête, avec son état ; un clic ouvre Data sur elle. Une analyse s'arrête avec le serveur (« interrompue ») : sa session gardée, « continue » dans le champ de message la reprend. Sur une analyse finie, « Optimiser les détecteurs » lance `/detector-learner <analyse>` par `claude -p` (D-148) : les détecteurs, puis les outils de lecture, améliorés depuis l'analyse, commités sur `main` ; la page suit le fil de la séance (`travail/optimisation.jsonl`), puis montre son bilan (`detector-learner/<séance>_<analyse>/bilan.md`) sous le rapport. Une optimisation à la fois ; pendant, ni analyse ni message à l'analyste ; une optimisation coupée par l'arrêt du serveur se relance par le bouton. Un clic met une étiquette en évidence sur les plots et la barre, cale les images sur son début, et l'ouvre (avec Analysis : bornes, famille, texte, Enregistrer, Supprimer) ; un clic ailleurs sur la barre la referme. Les zones des étiquettes sur les plots sont à peine visibles (opacité 0,05, 0,07 en sombre). Écrit dans `labeling/auto/<STATION>.jsonl` ; `labeling/manual/` ne s'écrit plus que par `labeling/labeling.py`. À droite, les images de la caméra, comme `view/view.py` (glisseur, ◀ ▶ et flèches du clavier ; molette pour zoomer, glisser pour se déplacer, double clic pour l'image entière ; case Noms ; une plage sur la barre sous le glisseur dessine la flèche de déplacement de chaque capteur), sur la même station et la même plage (D-140) ; une flèche en haut à gauche de l'image l'agrandit et pousse les plots vers la gauche (les colonnes glissent, les plots se recalent à la fin du glissement), la flèche inverse la ramène. Les événements des détecteurs ne portent que leur famille dans la barre ; la bulle donne leurs cibles ; au clic, leurs dates, leurs capteurs (cibles et références), le message (la première phrase du journal) et l'action (la colonne « Pour le client » de `labeling/familles.md`, précisée par sorte, `station.ACTION_SORTE`). Sous l'image, les paramètres du diagnostic : « Focus on event curves » (un événement ouvert, les plots ne montrent que ses capteurs : ceux des détecteurs, ou ceux que nomme le texte d'une étiquette), les familles montrées (filtre immédiat de la page) et, pour Detectors seulement, les cibles considérées, les autres écartées avant les détecteurs (« Relancer les détecteurs », paramètre `cibles` de `/api/detecteurs`). Sans dates dans l'adresse, la sélection prend les 5 derniers jours UTC, aujourd'hui compris. Detectors est la source par défaut.
Data garde la station et la plage (UTC, Au exclue) dans l'adresse : `#/data?station=NIEDERHORN&du=2026-09-25&au=2026-10-08`.
## Lancer
En une commande : la tâche VS Code `run app` (`.vscode/tasks.json` : construit le front, puis lance le serveur). Ou à la main :
Une fois, et après chaque changement de la page : construire le front (Node 22).
```bash
cd app/web && npm install && npm run build
```
Puis le serveur, avec l'environnement Python du dépôt (`.venv`, voir le README à la racine) :
```bash
.venv/bin/python app/serveur/serveur.py
```
La page s'ouvre sur `http://127.0.0.1:8770`. Réglages par variables : `AIMSIGHT_DATA` (données, défaut `data/`), `AIMSIGHT_LABELS` (étiquettes, défaut `labeling/`), `AIMSIGHT_PORT` (8770). Pour travailler sur la page : `npm run dev` dans `app/web/` (http://localhost:5173), le serveur Python lancé à côté.
## Les dossiers
- `serveur/serveur.py` : FastAPI ; sert la page construite et l'API sous `/api` (stations, images, courbes, détecteurs, étiquettes, analyses) ; ne répond qu'aux pages du poste (Host local, JSON déclaré).
- `serveur/station.py` : les données de la page Data ; lecture seule sur `data/`, écrit seulement dans `labeling/{auto,manual}/`.
- `serveur/analyse.py` : l'onglet Analysis ; lance `claude` (Claude Code, connecté) avec l'agent `etiqueteur`, outils Read, Write, Bash autorisés sans demande ; et l'optimisation, `/detector-learner <analyse>`, outils Read, Write, Edit, Bash, Agent autorisés sans demande.
- `serveur/check.py` : vérifications, sans appel à claude : `.venv/bin/python app/serveur/check.py`.
- `web/` : React (Vite) et Mantine ; `src/App.jsx` (en-tête, barre latérale, adresse), `src/pages/` (une page par fichier), `src/commun.jsx` (requêtes, cartes, sélecteur), `src/main.jsx` (thème). Plotly, habillé aux couleurs de Mantine (D-139), ne se charge qu'avec Data. `dist/` et `node_modules/` hors de git.
## Copies
Le calcul de la page Data reprend des outils du dépôt Support-Agent ; ce qui en est copié dans `serveur/station.py` vieillit avec eux.
| Source | Copie | Commit | Date | Adaptation |
|---|---|---|---|---|
| `view/view.py` : `page()` (images, corr à l'heure de chaque image) | `images()` | 6e9f69a | 2026-11-05 | rend du JSON, pas une page |
| `labeling/labeling.py` : `metriques()`, `plots()`, `ajouter()`, `modifier()`, `supprimer()`, `remplace()` | `metriques()`, `courbes()`, et les fonctions des étiquettes | 6e9f69a | 2026-11-05 | rend du JSON ; métriques lues sans `common.stations` |
| `detectors-view/detecteurs.py` : `positions()`, `references()`, `COULEURS`, `POSE`, `MARGE_PX` | idem | 6e9f69a | 2026-11-05 | aucune |
| `labeling/ids.py` : `attribuer()`, `en_tete()` | `attribuer()` | 6e9f69a | 2026-11-05 | sans `retires` (inutile à l'ajout) |
La lecture des données est celle des agents, `agent-tools/donnees.py` ; les événements des détecteurs, ceux du journal, `detectors/categories.py`, lus tels quels (pas une copie : la page montre les détecteurs du jour ; il garde leurs résultats, et les oublie à la fin d'une optimisation ; relancer le serveur après une séance de `/detector-learner` lancée hors de l'app).
+3
View File
@@ -0,0 +1,3 @@
fastapi
uvicorn
markdown
+296
View File
@@ -0,0 +1,296 @@
"""L'onglet Analysis de la page Data : un analyste (l'étiqueteur, .claude/agents/etiqueteur.md) lancé par `claude -p`, non
interactif, sur une plage choisie dans la page, avec les indices facultatifs de l'utilisateur. Il écrit dans
labeling/auto/analyses/<STATION>_<début>_<fin>/ ses étiquettes (etiquettes.jsonl) et un rapport de diagnostic (rapport.md, ses
figures à côté) ; à la fin, le serveur verse ses étiquettes dans labeling/auto/<STATION>.jsonl, marquées de leur analyse
(champ `analyse`, sans `revue` : à relire par /review-auto-labels). Puis l'utilisateur peut lui écrire : la même
session reprend (`claude -p --resume`), et ses étiquettes, si elles changent, remplacent celles qu'il avait versées.
Sur une analyse finie, « Optimiser » lance `/detector-learner <analyse>` par `claude -p` (D-148) : les détecteurs, puis les outils de
lecture, améliorés depuis l'analyse ; une optimisation à la fois, ni analyse ni message pendant ; son bilan,
detector-learner/<séance>_<analyse>/bilan.md, s'affiche sous le rapport.
"""
import html
import json
import os
import subprocess
import threading
from datetime import datetime, timezone
import markdown
import station
DOSSIER = station.ETIQUETTES / "auto" / "analyses"
SEANCES = station.RACINE / "detector-learner" # les séances de /detector-learner, <séance>_<analyse>/
CONSIGNE = """Tu travailles pour la page Data de la web app : l'utilisateur a sélectionné une plage et te demande de la \
diagnostiquer. Ce n'est pas un lot ordinaire : il y a vu une anomalie que les détecteurs captent mal, ou il veut une analyse \
plus poussée.
- Station : data/{station}/
- Lot : {debut} → {fin} (UTC)
- Dossier de sortie : {sortie}/ (tes figures de travail et les sorties des outils dans {sortie}/travail/)
- Indices de l'utilisateur : {indices}
Fais ton travail d'étiqueteur sur ce lot, à ces différences près :
1. Tes étiquettes vont dans {sortie}/etiquettes.jsonl ; c'est le serveur qui les versera dans labeling/auto/{station}.jsonl. \
Celles qui y sont déjà sur la plage (lis-les) restent : ne refais pas une étiquette juste ; une étiquette que tu crois fausse, \
dis-le dans le rapport.
2. En plus de {sortie}/analyse.md, écris {sortie}/rapport.md, le rapport de diagnostic que l'utilisateur lira dans la page, \
en français, comme l'analyse d'un cas du support :
- `# {station} : <le sujet en quelques mots>`, puis la question (sa sélection, ses indices) en une ou deux phrases ;
- « Ce que montrent les données » : chaque événement daté (UTC), les capteurs touchés et ceux qui ne bougent pas, la \
cause et son niveau de preuve (confirmed / strongly supported / consistent with / possible / insufficient evidence / not \
observed), la commande qui fonde chaque fait ;
- les figures qui prouvent, chacune insérée par `![légende](chemin relatif à {sortie}/)` et suivie d'une ligne qui dit ce \
qu'on y voit : courbes (graphique.py), vignettes, images entières de la caméra (copie-les dans {sortie}/ avec cp) ; \
quelques-unes, choisies, pas toutes celles de travail ;
- « Ce qui reste non établi » ; « Étiquettes » : celles que tu proposes, en une ligne chacune.
Réponds en 2 lignes : le nombre d'étiquettes, le chemin du rapport."""
# nom -> {"etat": "en cours" | "fini" | "erreur", "lignes": [...], "versees": n} ; une analyse à la fois par plage
analyses, verrou = {}, threading.Lock()
# nom de l'analyse -> {"etat": "en cours" | "fini" | "erreur", "lignes": [...]} ; une optimisation à la fois, toutes analyses
optimisations = {}
OCCUPE = "une optimisation des détecteurs est en cours"
def _optimise():
return any(o["etat"] == "en cours" for o in optimisations.values())
def lancer(corps):
st, debut, fin = corps.get("station"), corps.get("debut"), corps.get("fin")
station._valide({"description": "-"}, debut, fin)
station.dossier(st)
nom = f"{st}_{debut[:16].replace(':', '')}_{fin[:16].replace(':', '')}"
with verrou:
if _optimise():
raise station.Refus(OCCUPE)
if analyses.get(nom, {}).get("etat") == "en cours":
raise station.Refus("cette plage est déjà en cours d'analyse")
sortie = DOSSIER / nom
if sortie.exists(): # une nouvelle analyse de la même plage : l'ancienne reste, à côté
nom += datetime.now(timezone.utc).strftime("_%H%M%S")
sortie = DOSSIER / nom
indices = (corps.get("indices") or "").strip()
demande = {"station": st, "debut": debut, "fin": fin, "indices": indices}
analyses[nom] = {"etat": "en cours", "lignes": [], "versees": 0, "station": st, "demande": demande}
(sortie / "travail").mkdir(parents=True)
(sortie / "demande.json").write_text(json.dumps(demande, ensure_ascii=False, indent=1), encoding="utf-8")
prompt = CONSIGNE.format(station=st, debut=debut, fin=fin, sortie=sortie.relative_to(station.RACINE),
indices=indices or "aucun")
threading.Thread(target=travailler, args=(nom, sortie, prompt), daemon=True).start()
return {"nom": nom}
def travailler(nom, sortie, prompt, reprise=None):
"""Un tour de l'analyste : la demande, ou un message de l'utilisateur dans la même session (reprise : son id)."""
a = analyses[nom]
try:
p = subprocess.Popen(["claude", "-p", prompt, "--agent", "etiqueteur", "--output-format", "stream-json", "--verbose",
"--allowedTools", "Read,Write,Bash", "--permission-mode", "acceptEdits"]
+ (["--resume", reprise] if reprise else []),
cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
with open(sortie / "travail" / "journal.jsonl", "a", encoding="utf-8") as journal:
for ligne in p.stdout:
journal.write(ligne)
a["lignes"] += resume(ligne)
if '"subtype":"init"' in ligne: # la session, pour les messages suivants
(sortie / "travail" / "session").write_text(json.loads(ligne)["session_id"])
if p.wait():
raise RuntimeError(f"claude a fini avec le code {p.returncode}")
a["versees"] = verser(a["station"], nom, sortie)
a["etat"] = "fini"
except Exception as e: # noqa: BLE001 — l'erreur s'affiche dans la page, le serveur continue
a["lignes"].append(f"Erreur : {e}")
a["etat"] = "erreur"
def message(nom, corps):
"""Un message de l'utilisateur à l'analyste, après son rapport : la même session reprend (claude -p --resume)."""
texte, sortie = (corps.get("texte") or "").strip(), DOSSIER / nom
etat(nom) # le nom vérifié, l'état relu après un redémarrage
a, session = analyses[nom], sortie / "travail" / "session"
if not texte or not session.exists():
raise station.Refus("message vide, ou l'analyse n'a pas de session à reprendre")
with verrou:
if _optimise():
raise station.Refus(OCCUPE)
if a["etat"] == "en cours":
raise station.Refus("l'analyste travaille encore")
a["etat"] = "en cours"
ligne = json.dumps({"type": "page", "texte": texte}, ensure_ascii=False) + "\n"
with open(sortie / "travail" / "journal.jsonl", "a", encoding="utf-8") as journal:
journal.write(ligne)
a["lignes"] += resume(ligne)
prompt = (f"{texte}\n\n(Si tu changes tes étiquettes, réécris {sortie.relative_to(station.RACINE)}/etiquettes.jsonl en "
"entier, le serveur les reversera ; si le diagnostic change, mets rapport.md à jour.)")
threading.Thread(target=travailler, args=(nom, sortie, prompt, session.read_text()), daemon=True).start()
return {}
def resume(ligne):
"""Une ligne du journal -> ce que la page en montre : les messages de l'utilisateur (« › »), les textes de l'analyste, ses
outils et leur commande, en une ligne chacun."""
try:
m = json.loads(ligne)
except json.JSONDecodeError:
return [ligne.strip()[:200]] if ligne.strip() else []
if m.get("type") == "page":
return [f"› {m['texte']}"]
if m.get("type") != "assistant":
return []
out = []
for c in m["message"].get("content", []):
if c.get("type") == "text" and c["text"].strip():
out.append(c["text"].strip()[:300])
elif c.get("type") == "tool_use":
i = c.get("input", {})
out.append(f"{c['name']} : {i.get('command') or i.get('file_path') or ''}"[:200])
return out
def verser(st, nom, sortie):
"""Les étiquettes de l'analyse dans labeling/auto/<STATION>.jsonl, avec leur id et le nom de l'analyse ; si l'analyste les
a changées depuis le dernier versement, elles remplacent celles qu'il y avait versées -> leur nombre."""
fichier, copie = sortie / "etiquettes.jsonl", sortie / "travail" / "versees.jsonl"
texte = fichier.read_text(encoding="utf-8") if fichier.exists() else ""
nouvelles = []
for l in texte.split("\n"):
if l.strip():
e = json.loads(l)
station._valide(e, e.get("debut"), e.get("fin"))
nouvelles.append({k: e[k] for k in ("debut", "fin", "categorie", "description") if k in e} | {"analyse": nom})
if copie.exists() and copie.read_text(encoding="utf-8") == texte:
return len(nouvelles)
# ponytail: retirées puis remises, les étiquettes de l'analyse perdent les retouches faites dans la page ; les garder
# demanderait de les apparier une à une
with verrou:
f = station.fichier(st, "auto") # les autres lignes restent telles quelles
gardees = [l for l in (f.read_text(encoding="utf-8").split("\n") if f.exists() else [])
if l.strip() and json.loads(l).get("analyse") != nom]
station.attribuer(st, [json.loads(l) for l in gardees] + nouvelles)
provisoire = f.with_name(f.name + ".tmp")
provisoire.write_text("".join(l + "\n" for l in gardees + [json.dumps(e, ensure_ascii=False) for e in nouvelles]),
encoding="utf-8")
os.replace(provisoire, f)
copie.write_text(texte, encoding="utf-8")
return len(nouvelles)
def etat(nom):
sortie = DOSSIER / nom
if "/" in nom or nom.startswith(".") or not sortie.is_dir():
raise station.Refus("analyse inconnue")
if nom not in analyses: # après un redémarrage du serveur, il ne reste que le dossier : le fil se relit dans le journal
journal = sortie / "travail" / "journal.jsonl"
lignes = [r for l in open(journal, encoding="utf-8") for r in resume(l)] if journal.exists() else []
demande = json.loads((sortie / "demande.json").read_text(encoding="utf-8"))
analyses[nom] = {"etat": "fini" if (sortie / "rapport.md").exists() else "interrompue", "lignes": lignes,
"versees": None, "station": demande["station"], "demande": demande}
a, r = analyses[nom], sortie / "rapport.md"
return {"nom": nom, "etat": a["etat"], "lignes": a["lignes"], "versees": a["versees"],
"rapport": int(r.stat().st_mtime) if r.exists() else None,
"dialogue": (sortie / "travail" / "session").exists(), "demande": a["demande"], "optimisation": optimisation(nom)}
def liste():
"""L'historique des analyses (la barre latérale), la plus récente en tête : celles du serveur avec leur état, les autres
lues sur le disque (fini avec un rapport, sinon interrompue : une analyse s'arrête avec le serveur)."""
out = []
for d in sorted(DOSSIER.glob("*/demande.json"), key=lambda f: f.parent.stat().st_mtime, reverse=True):
nom = d.parent.name
a = analyses.get(nom) or {"etat": "fini" if (d.parent / "rapport.md").exists() else "interrompue",
"demande": json.loads(d.read_text(encoding="utf-8"))}
out.append({"nom": nom, "etat": a["etat"]} | a["demande"])
return out
def fichier(nom, chemin):
"""Un fichier du dossier de l'analyse (le rapport, ses figures), jamais au-dehors."""
f = (DOSSIER / nom / chemin).resolve()
if not f.is_file() or not f.is_relative_to(DOSSIER.resolve()):
raise station.Refus("fichier inconnu")
return f
STYLE = """body{font:14px/1.55 Roboto,sans-serif;margin:0;padding:4px 2px;color:#212529;background:transparent}
h1{font-size:20px}h2{font-size:16px;margin-top:22px}img{max-width:100%;border:1px solid #dee2e6;border-radius:4px}
code{font-size:12px;background:#f1f3f5;padding:1px 4px;border-radius:3px}pre{overflow-x:auto}
table{border-collapse:collapse}td,th{border:1px solid #dee2e6;padding:3px 8px;text-align:left}
body.sombre{color:#c9c9c9}body.sombre code{background:#2e2e2e}body.sombre td,body.sombre th,body.sombre img{border-color:#424242}"""
def _page(chemin, titre, sombre):
"""Un markdown en HTML, au style de la page ; ses images relatives se résolvent dans le dossier de l'adresse."""
corps = markdown.markdown(chemin.read_text(encoding="utf-8"), extensions=["tables", "fenced_code"])
return (f"<!doctype html><meta charset=utf-8><title>{html.escape(titre)}</title><style>{STYLE}</style>"
f"<body class='{'sombre' if sombre else ''}'>{corps}</body>")
def rapport(nom, sombre):
"""rapport.md en HTML, servi dans le dossier de l'analyse : ses images relatives s'y retrouvent."""
return _page(fichier(nom, "rapport.md"), nom, sombre)
# --- « Optimiser » : /detector-learner <analyse> par claude -p (D-148)
def _bilan(nom):
"""Le bilan de la dernière séance de cette analyse, ou None."""
bilans = sorted(SEANCES.glob(f"*_{nom}/bilan.md")) # <séance> en tête du nom : l'ordre du nom est celui du temps
return bilans[-1] if bilans else None
def optimisation(nom):
"""-> None (jamais optimisée) ou {etat, lignes, bilan : mtime du dernier bilan}. Après un redémarrage, l'état se relit sur
le disque : fini si un bilan est plus récent que le flux, sinon interrompue."""
flux, b = DOSSIER / nom / "travail" / "optimisation.jsonl", _bilan(nom)
o = optimisations.get(nom)
if o is None:
if not flux.exists():
return None if b is None else {"etat": "fini", "lignes": [], "bilan": int(b.stat().st_mtime)}
o = {"etat": "fini" if b and b.stat().st_mtime >= flux.stat().st_mtime else "interrompue",
"lignes": [r for l in open(flux, encoding="utf-8") for r in resume(l)]}
optimisations[nom] = o
return {"etat": o["etat"], "lignes": o["lignes"], "bilan": int(b.stat().st_mtime) if b else None}
def optimiser(nom):
"""Le bouton « Optimiser » sur une analyse finie : la séance dans un fil ; refusée si une optimisation ou une analyse tourne."""
if etat(nom)["etat"] != "fini":
raise station.Refus("seule une analyse finie s'optimise")
with verrou:
if _optimise():
raise station.Refus(OCCUPE)
if any(a["etat"] == "en cours" for a in analyses.values()):
raise station.Refus("une analyse est en cours : l'optimisation attend sa fin")
optimisations[nom] = {"etat": "en cours", "lignes": []}
threading.Thread(target=optimiser_fil, args=(nom,), daemon=True).start()
return {}
def optimiser_fil(nom):
o = optimisations[nom]
try:
p = subprocess.Popen(["claude", "-p", f"/detector-learner {nom}", "--output-format", "stream-json", "--verbose",
"--allowedTools", "Read,Write,Edit,Bash,Agent", "--permission-mode", "acceptEdits"],
cwd=station.RACINE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
(DOSSIER / nom / "travail").mkdir(exist_ok=True)
with open(DOSSIER / nom / "travail" / "optimisation.jsonl", "a", encoding="utf-8") as flux:
for ligne in p.stdout:
flux.write(ligne)
o["lignes"] += resume(ligne)
if p.wait():
raise RuntimeError(f"claude a fini avec le code {p.returncode}")
o["etat"] = "fini"
except Exception as e: # noqa: BLE001 — l'erreur s'affiche dans la page, le serveur continue
o["lignes"].append(f"Erreur : {e}")
o["etat"] = "erreur"
finally:
station.detecteurs.cache_clear() # les détecteurs ont pu changer : la page Data les recalcule
def bilan(nom, sombre):
b = _bilan(nom)
if b is None:
raise station.Refus("aucun bilan pour cette analyse")
return _page(b, nom, sombre)
+168
View File
@@ -0,0 +1,168 @@
"""Vérifications de la web app, sans appel à claude : .venv/bin/python app/serveur/check.py [nom]"""
import json
import shutil
import socket
import sys
import tempfile
import threading
import time
import urllib.request
from pathlib import Path
from urllib.error import HTTPError
ICI = Path(__file__).resolve().parent
sys.path.insert(0, str(ICI))
import uvicorn # noqa: E402
import serveur # noqa: E402
import station # noqa: E402
def seance_temporaire():
return Path(tempfile.mkdtemp())
def check_serveur():
# le vrai serveur sur un port libre : la garde (Host, JSON déclaré), une lecture
with socket.socket() as so:
so.bind(("127.0.0.1", 0))
port = so.getsockname()[1]
srv = uvicorn.Server(uvicorn.Config(serveur.app, host="127.0.0.1", port=port, log_level="error"))
threading.Thread(target=srv.run, daemon=True).start()
while not srv.started:
time.sleep(0.05)
base = f"http://127.0.0.1:{port}"
def appel(chemin, corps=None, entetes=None, methode=None):
r = urllib.request.Request(base + chemin, json.dumps(corps).encode() if corps is not None else None,
{"Content-Type": "application/json", **(entetes or {})}, method=methode)
try:
with urllib.request.urlopen(r) as rep:
return rep.status
except HTTPError as e:
return e.code
try:
assert appel("/api/stations", entetes={"Host": "evil.example:80"}) == 403
assert appel("/api/etiquettes", {"station": "x"}, {"Content-Type": "text/plain"}) == 403
assert appel("/api/stations") == 200
assert appel("/api/analyses") == 200
assert appel("/api/analyses/INCONNUE/optimiser", {}) == 400
finally:
srv.should_exit = True
def leve(f, *a):
try:
f(*a)
except station.Refus as e:
return str(e)
raise AssertionError(f"{f.__name__}{a} n'a pas refusé")
def check_station():
# les données de la page Data, sur les vraies données ; les étiquettes dans un dossier temporaire
assert "NIEDERHORN" in station.stations()
im = station.images("NIEDERHORN", "2026-09-25", "2026-09-26")
assert im["images"] and im["positions"] and set(im["corr"]) == set(im["positions"]), list(im)
assert all(len(c) == len(im["images"]) for c in im["corr"].values())
assert station.image("NIEDERHORN", im["images"][0]["nom"]).is_file()
leve(station.image, "NIEDERHORN", "../../../.env")
leve(station.images, "../API", "", "")
assert station.images("LENZSPITZE", "2026-10-26", "2026-10-27")["images"]
c = station.courbes("LENZSPITZE", "2026-10-26", "2026-10-27")
titres = [p["titre"] for p in c["plots"]]
assert "Relative Corrected Vertical Shift" in titres and any(t.startswith("System: ") for t in titres), titres
ev = station.detecteurs("LENZSPITZE", "2026-10-26", "2026-10-27") # les détecteurs du journal, ~10 s
assert ev and {"debut", "fin", "categorie", "description", "capteurs"} <= set(ev[0]), ev[:1]
assert all(e["message"] and e["action"] and set(e["cibles"] + e["references"]) == set(e["capteurs"]) for e in ev), ev[:1]
assert station.message("A moved; nothing to do. The jump of 2 targets in this period has the same cause.") \
== "A moved. The jump of 2 targets in this period has the same cause."
assert all(e["fin"] >= "2026-10-26T00:00Z" and e["debut"] < "2026-10-27T00:00Z" for e in ev), [(e["debut"], e["fin"]) for e in ev]
assert not any("SIM_CCID" in t or t.startswith("System: ip") for t in titres)
assert all(len(c["T"][tr["t"]]) == len(tr["y"]) for p in c["plots"] for tr in p["traces"])
avant, station.ETIQUETTES = station.ETIQUETTES, seance_temporaire()
try:
e = station.ajouter({"station": "NIEDERHORN", "dossier": "auto", "debut": "2026-09-25T01:00Z",
"fin": "2026-09-25T02:00Z", "categorie": "Visibility", "description": "brouillard"})
assert e["id"] == "NIEDERHORN-1" and next(iter(e)) == "id", e
e2 = station.modifier({"station": "NIEDERHORN", "dossier": "auto", "avant": e,
"debut": e["debut"], "fin": e["fin"], "categorie": "", "description": "pluie"})
assert e2 == {"id": "NIEDERHORN-1", "debut": e["debut"], "fin": e["fin"], "description": "pluie"}, e2
assert station.lire("NIEDERHORN", "auto") == [e2]
assert "plus dans le fichier" in leve(station.supprimer, {"station": "NIEDERHORN", "dossier": "auto", "avant": e})
station.supprimer({"station": "NIEDERHORN", "dossier": "auto", "avant": e2})
assert station.lire("NIEDERHORN", "auto") == []
leve(station.ajouter, {"station": "NIEDERHORN", "dossier": "../x", "debut": "a", "fin": "b", "description": "x"})
leve(station.ajouter, {"station": "NIEDERHORN", "debut": "2026-09-25T02:00Z", "fin": "2026-09-25T01:00Z", "description": "x"})
finally:
shutil.rmtree(station.ETIQUETTES)
station.ETIQUETTES = avant
def check_optimisation():
# le bouton Optimiser (analyse.optimiser), sans claude : un faux processus qui ne finit que sur signal, une analyse finie
# copiée dans un dossier temporaire ; le verrou (une optimisation à la fois, ni analyse ni message pendant), l'état
# relu après un redémarrage
import analyse
fin = threading.Event()
class FauxProcessus:
returncode = 0
stdout = iter(lambda: fin.wait() and "", "") # rien, jusqu'au signal
def __init__(self, *a, **k):
pass
def wait(self):
return 0
avant = analyse.DOSSIER, analyse.SEANCES, analyse.subprocess.Popen
analyse.DOSSIER, analyse.SEANCES = seance_temporaire(), seance_temporaire()
analyse.subprocess.Popen = FauxProcessus
try:
for nom in ("NORDEND_a", "NORDEND_b"):
(analyse.DOSSIER / nom / "travail").mkdir(parents=True)
(analyse.DOSSIER / nom / "demande.json").write_text(json.dumps(
{"station": "NORDEND", "debut": "2026-11-04T21:12Z", "fin": "2026-11-07T14:12Z", "indices": ""}))
(analyse.DOSSIER / nom / "rapport.md").write_text("# rapport")
assert analyse.etat("NORDEND_a")["optimisation"] is None
assert analyse.optimiser("NORDEND_a") == {}
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "en cours"
leve(analyse.optimiser, "NORDEND_a")
leve(analyse.optimiser, "NORDEND_b")
leve(analyse.lancer, {"station": "NORDEND", "debut": "2026-11-04T00:00Z", "fin": "2026-11-05T00:00Z"})
leve(analyse.message, "NORDEND_b", {"texte": "continue"})
fin.set()
while analyse.etat("NORDEND_a")["optimisation"]["etat"] == "en cours":
time.sleep(0.05)
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "fini"
analyse.analyses["NORDEND_b"]["etat"] = "en cours" # une analyse qui tourne bloque l'optimisation
leve(analyse.optimiser, "NORDEND_a")
# après un redémarrage : un flux sans bilan plus récent -> interrompue ; un bilan plus récent -> fini, rendu en HTML
analyse.analyses.clear()
analyse.optimisations.clear()
assert analyse.etat("NORDEND_a")["optimisation"]["etat"] == "interrompue"
time.sleep(0.01)
(analyse.SEANCES / "2026-11-13T1000Z_NORDEND_a").mkdir()
(analyse.SEANCES / "2026-11-13T1000Z_NORDEND_a" / "bilan.md").write_text("# Optimisation\n\n**Résultat** : aucune")
analyse.optimisations.clear()
o = analyse.etat("NORDEND_a")["optimisation"]
assert o["etat"] == "fini" and o["bilan"], o
assert "<strong>Résultat</strong>" in analyse.bilan("NORDEND_a", False)
assert analyse.etat("NORDEND_b")["optimisation"] is None
finally:
fin.set()
shutil.rmtree(analyse.DOSSIER)
shutil.rmtree(analyse.SEANCES)
analyse.DOSSIER, analyse.SEANCES, analyse.subprocess.Popen = avant
analyse.analyses.clear()
analyse.optimisations.clear()
CHECKS = [check_serveur, check_station, check_optimisation]
if __name__ == "__main__":
nom = sys.argv[1] if len(sys.argv) > 1 else None
for f in CHECKS:
if nom in (None, f.__name__):
f()
print("ok", f.__name__)
+165
View File
@@ -0,0 +1,165 @@
"""La web app : .venv/bin/python app/serveur/serveur.py → http://127.0.0.1:8770
Le serveur FastAPI sert la page React construite (app/web/dist, `npm run build` dans app/web) et l'API sous /api.
La page Data lit data/ et les étiquettes de labeling/ (station.py) ; son onglet Analysis lance l'étiqueteur, et l'optimisation
des détecteurs (analyse.py).
Réglages : AIMSIGHT_DATA (données), AIMSIGHT_LABELS (étiquettes), AIMSIGHT_PORT (port, 8770).
"""
import json
import os
import platform
import subprocess
import sys
import threading
import webbrowser
from pathlib import Path
import uvicorn
from fastapi import FastAPI, Query, Request
from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
import analyse
import station
from fastapi.staticfiles import StaticFiles
APP = Path(__file__).resolve().parents[1]
PORT = int(os.environ.get("AIMSIGHT_PORT", 8770))
HOTES = {"127.0.0.1", "localhost"} # contre le DNS rebinding : un autre site ne lit pas les données
PAGE = APP / "web" / "dist"
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
def erreur(code: int, texte: str) -> JSONResponse:
return JSONResponse({"erreur": texte}, code)
@app.middleware("http")
async def garde(request: Request, suite):
"""Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne
peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
hote = request.headers.get("host", "").rsplit(":", 1)[0]
if hote not in HOTES or (request.method in ("POST", "PUT", "DELETE")
and not request.headers.get("content-type", "").startswith("application/json")):
return erreur(403, "requête refusée")
return await suite(request)
# --- la page Data (station.py)
@app.exception_handler(station.Refus)
def refus(_, e):
return erreur(400, str(e))
@app.get("/api/stations")
def stations():
return station.stations()
@app.get("/api/images")
def images(station_: str = Query(alias="station"), du: str = "", au: str = ""):
return station.images(station_, du, au)
@app.get("/api/image/{station_}/{nom}")
def image(station_: str, nom: str):
return FileResponse(station.image(station_, nom), headers={"Cache-Control": "max-age=86400"})
@app.get("/api/courbes")
def courbes(station_: str = Query(alias="station"), du: str = "", au: str = ""):
return station.courbes(station_, du, au)
@app.get("/api/detecteurs")
def detecteurs(station_: str = Query(alias="station"), du: str = "", au: str = "", cibles: str = ""):
return station.detecteurs(station_, du, au, cibles)
@app.get("/api/etiquettes")
def etiquettes(station_: str = Query(alias="station"), dossier: str = "manual"):
try:
return station.lire(station_, dossier)
except json.JSONDecodeError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier
return erreur(500, f"labeling/{dossier}/{station_}.jsonl illisible : {e}")
@app.post("/api/etiquettes")
def ajouter(corps: dict):
return station.ajouter(corps)
@app.put("/api/etiquettes")
def modifier(corps: dict):
return station.modifier(corps)
@app.delete("/api/etiquettes")
def supprimer(corps: dict):
return station.supprimer(corps)
# --- l'onglet Analysis de la page Data (analyse.py) : l'étiqueteur lancé par claude -p sur une plage
@app.post("/api/analyses")
def lancer_analyse(corps: dict):
return analyse.lancer(corps)
@app.get("/api/analyses")
def analyses():
return analyse.liste()
@app.get("/api/analyses/{nom}")
def etat_analyse(nom: str):
return analyse.etat(nom)
@app.post("/api/analyses/{nom}/message")
def message_analyse(nom: str, corps: dict):
return analyse.message(nom, corps)
@app.get("/api/analyses/{nom}/rapport.html")
def rapport_analyse(nom: str, sombre: bool = False):
return HTMLResponse(analyse.rapport(nom, sombre))
@app.post("/api/analyses/{nom}/optimiser")
def optimiser_analyse(nom: str):
return analyse.optimiser(nom)
@app.get("/api/analyses/{nom}/bilan.html")
def bilan_analyse(nom: str, sombre: bool = False):
return HTMLResponse(analyse.bilan(nom, sombre))
@app.get("/api/analyses/{nom}/{chemin:path}")
def fichier_analyse(nom: str, chemin: str):
return FileResponse(analyse.fichier(nom, chemin))
if PAGE.is_dir():
app.mount("/", StaticFiles(directory=PAGE, html=True), name="page")
else:
@app.get("/")
def sans_page():
return erreur(503, "la page n'est pas construite : cd app/web && npm install && npm run build")
def ouvrir(url: str) -> None:
if "microsoft" in platform.uname().release.lower(): # WSL : le navigateur Windows
subprocess.Popen(["explorer.exe", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
else:
webbrowser.open(url)
if __name__ == "__main__":
url = f"http://127.0.0.1:{PORT}"
print(f"Diagnostic AIMsight : {url}")
if "--sans-navigateur" not in sys.argv:
threading.Timer(1, ouvrir, [url]).start()
uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)
+331
View File
@@ -0,0 +1,331 @@
"""Les données de la page Data : les images d'une station, ses courbes, ses étiquettes.
Repris de view/view.py et labeling/labeling.py (le calcul, pas les pages) ; positions, references, COULEURS, POSE et
attribuer sont copiés de detectors-view/detecteurs.py et labeling/ids.py (app/README.md, « Copies »). La lecture des données est
celle des agents, agent-tools/donnees.py ; les événements des détecteurs, ceux du journal,
detectors/categories.py (D-140). Lecture seule sur data/ ; écrit seulement dans labeling/{auto,manual}/.
"""
import bisect
import functools
import csv
import glob
import json
import os
import re
import statistics
import sys
from datetime import datetime, timedelta
from pathlib import Path
RACINE = Path(__file__).resolve().parents[2]
sys.path[:0] = [str(RACINE / "agent-tools"), str(RACINE / "detectors")]
import donnees # noqa: E402
from categories import evenements # noqa: E402
DONNEES = Path(os.environ.get("AIMSIGHT_DATA", RACINE / "data")).resolve()
ETIQUETTES = Path(os.environ.get("AIMSIGHT_LABELS", RACINE / "labeling")).resolve()
DOSSIERS = ("auto", "manual") # celles de l'étiqueteur (D-105), celles de Marc (D-102)
FAMILLES = ("Visibility", "Obstruction", "Thermal displacement", "Displacement", "Target issue", "No data", "None") # D-109
FORMAT = "%Y-%m-%dT%H:%MZ"
MARGE_PX = 150 # detecteurs.MARGE_PX : x, y ne sont des positions dans l'image que loin du coin
COULEURS = ["#2a78d6", "#eb6834", "#1baf7a", "#8a5cd6", "#d6a12a", "#d63b8a", "#3bb3d6", "#6b6b66"] # un capteur chacun
POSE = (("pan", "#1a1a19"), ("tilt", "#8a8a85"), ("rotation", "#b5651d"))
# Le menu Advanced d'Explore, dans son ordre (labeling.PLOTS, QUALITE)
PLOTS = (("error_value", "Error value"), ("x", "X [px]"), ("y", "Y [px]"),
("relative_x", "Relative Horizontal Shift"), ("relative_y", "Relative Vertical Shift"),
("corr_x", "Relative Corrected Horizontal Shift"), ("corr_y", "Relative Corrected Vertical Shift"),
("reproj_err", "References (reproj. error)"))
QUALITE = (("peak", "Quality: Peak"), ("flux", "Quality: Flux"), ("sharpness", "Quality: Sharpness"),
("fwhm", "Quality: FWHM [px]"), ("dominance", "Quality: Dominance"), ("snr", "Quality: SNR"))
IDENTIFIANT = re.compile(r"(SIM_CCID|ip(_.*)?)$") # jamais lus (CLAUDE.md, « data/ »)
METRIQUE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
class Refus(ValueError):
"""Une demande à refuser (400), avec sa raison."""
def stations():
return sorted(d.name for d in DONNEES.iterdir() if d.is_dir())
def dossier(station):
if station not in stations(): # le nom devient un chemin : un dossier de data/, rien d'autre
raise Refus(f"station inconnue : {station}")
return DONNEES / station
def bornes(du, au):
return donnees.instant(du or "0001-01-01"), donnees.instant(au or "9999-01-01")
# --- detectors-view/detecteurs.py
def positions(mesures, a, b):
"""La position médiane de chaque capteur dans l'image sur [a, b) ({} si x, y n'y sont pas des positions)."""
maisons = {s: (statistics.median(xs), statistics.median(ys)) for s, ms in mesures.items()
if (xs := [m["x"] for m in ms if a <= m["t"] < b and m["x"] is not None])
and (ys := [m["y"] for m in ms if a <= m["t"] < b and m["y"] is not None])}
return maisons if any(abs(x) > MARGE_PX or abs(y) > MARGE_PX for x, y in maisons.values()) else {}
def references(mesures, a, b):
"""Capteurs de la compensation sur la plage : ceux qui ont un reproj_err (références seulement)."""
return {s for s, ms in mesures.items() if any(m["reproj_err"] is not None for m in ms if a <= m["t"] < b)}
# --- les images de la page Data (view/view.py)
def images(station, du, au):
"""Les images de [du, au), les positions médianes des capteurs, les références, et par capteur entouré son corr_x,
corr_y à l'heure de chaque image : la mesure valide la plus proche, à 30 min près, sinon 0."""
d, (a, b) = dossier(station), bornes(du, au)
vues = [(t, im) for im in sorted(glob.glob(str(d / "images" / "*"))) if (t := donnees.heure_image(im)) and a <= t < b]
if not vues:
raise Refus(f"aucune image de {station} sur cette plage")
mesures = donnees.charger(d)
maisons, refs = positions(mesures, a, b), references(mesures, a, b)
# ponytail: une seule mesure à chaque borne, bruitée ; une médiane sur une fenêtre si les flèches tremblent trop
marge, corr = timedelta(minutes=30), {}
for s in maisons:
serie = [(m["t"], m["corr_x"], m["corr_y"]) for m in mesures[s] if m["corr_x"] is not None and m["corr_y"] is not None]
temps, corr[s] = [m[0] for m in serie], []
for t, _ in vues:
k = bisect.bisect_left(temps, t)
k = min((n for n in (k - 1, k) if 0 <= n < len(serie)), key=lambda n: abs(temps[n] - t), default=None)
corr[s].append([round(serie[k][1], 4), round(serie[k][2], 4)] if k is not None and abs(temps[k] - t) <= marge else 0)
return {"images": [{"t": donnees.iso(t).replace("T", " ").rstrip("Z"), "nom": os.path.basename(im)} for t, im in vues],
"positions": {s: [round(x, 1), round(y, 1)] for s, (x, y) in sorted(maisons.items())},
"references": sorted(refs), "corr": corr}
def image(station, nom):
f = (dossier(station) / "images" / nom).resolve()
if f.parent != (DONNEES / station / "images").resolve() or not f.is_file():
raise Refus("image inconnue")
return f
# --- la page Data (labeling/labeling.py)
def metriques(d, a, b):
"""Les métriques système numériques de metrics/ sur [a, b) -> {nom: {t: valeur ou None}} (une valeur vide : None, le
trou se voit), sans les métriques texte, les identifiants, ni celles qui n'ont aucune valeur."""
station, series, texte = d.name + "_", {}, set()
for p in sorted(glob.glob(str(d / "metrics" / "*.csv"))):
if not (m := METRIQUE.match(os.path.basename(p))) or IDENTIFIANT.match(nom := m.group(1).removeprefix(station)):
continue
with open(p, newline="") as f:
for r in csv.DictReader(f):
t, v = donnees.instant(r["time_utc"]), (r.get("metric") or "").strip("[]'\" ")
if not a <= t < b:
continue
try:
series.setdefault(nom, {})[t] = float(v) if v else None
except ValueError:
texte.add(nom) # link, mode… : pas de courbe
return {n: dict(sorted(s.items())) for n, s in series.items()
if n not in texte and any(v is not None for v in s.values())}
def plage(mesures, du, au):
"""La plage lue : de du à au (exclu), sinon de la première mesure à la dernière, plus un pas."""
tous = sorted({m["t"] for ms in mesures.values() for m in ms})
a = donnees.instant(du) if du else tous[0]
b = donnees.instant(au) if au else tous[-1] + (tous[-1] - tous[-2] if len(tous) > 1 else timedelta(hours=1))
return a, b
def courbes(station, du, au):
"""-> {A, B, T, plots} : T, les heures de chaque série, une fois (clé : le capteur, "" pour la caméra, « system: »
et son nom pour une métrique) ; plot : titre et traces (name, t, y, line, mode), sans plots ni capteurs vides."""
d = dossier(station)
mesures = donnees.charger(d)
if not mesures:
raise Refus(f"aucun export « advanced » pour {station}")
a, b = plage(mesures, du, au)
poses = [p for p in donnees.charger_camera(d) if a <= p["t"] < b]
heure = lambda t: t.strftime("%Y-%m-%d %H:%M") # noqa: E731 (UTC, sans fuseau : comme l'affiche Plotly)
valeurs = lambda s, c: [None if m[c] is None else round(m[c], 5) for m in s] # noqa: E731
dans = {s: [m for m in mesures[s] if a <= m["t"] < b] for s in sorted(mesures)}
refs, out = references(mesures, a, b), []
def par_capteur(colonnes):
for col, titre in colonnes:
traces = [{"name": s + " (ref.)" * (s in refs), "t": s, "y": y,
"line": {"width": 1.2, "color": COULEURS[i % len(COULEURS)], "dash": "dot" if s in refs else "solid"}}
for i, (s, y) in enumerate((s, valeurs(ms, col)) for s, ms in dans.items()) if any(v is not None for v in y)]
if traces:
out.append({"titre": titre, "traces": traces})
par_capteur(PLOTS)
if poses:
out.append({"titre": "Camera movement (deg)", "traces": [{"name": c, "t": "", "y": valeurs(poses, c),
"line": {"width": 1.2, "color": col}} for c, col in POSE]})
par_capteur(QUALITE)
T = {"": [heure(p["t"]) for p in poses], **{s: [heure(m["t"]) for m in ms] for s, ms in dans.items()}}
systeme = metriques(d, a, b)
for nom in sorted(systeme, key=str.lower):
T["system:" + nom] = [heure(t) for t in systeme[nom]]
out.append({"titre": "System: " + nom, "traces": [{"name": nom, "t": "system:" + nom, "mode": "lines+markers",
"y": [None if v is None else round(v, 5) for v in systeme[nom].values()],
"line": {"width": 1.2, "color": COULEURS[0]}}]})
if not out:
raise Refus(f"aucune mesure de {station} sur cette plage")
return {"A": donnees.iso(a), "B": donnees.iso(b), "T": T, "plots": out}
# --- la page Data, étiquettes « Detectors » : les événements du journal, en lecture seule
HISTORIQUE = timedelta(days=3) # jours d'avant donnés aux détecteurs, comme categories.py (règle du 2026-10-24)
# ponytail: gardés jusqu'au redémarrage du serveur (une minute ou plus par plage) ; relancer après une séance de /detector-learner
@functools.lru_cache(maxsize=32)
def detecteurs(station, du, au, cibles=""):
"""-> les événements des détecteurs sur la plage, au format des étiquettes (debut, fin, categorie, description) ;
plus sorte, capteurs, ignore (zone grisée du journal). cibles : les capteurs gardés, séparés par des virgules (vide :
tous) ; les autres sont écartés avant les détecteurs, comme s'ils n'existaient pas."""
d = dossier(station)
tout = donnees.charger(d)
if cibles:
garde = set(cibles.split(","))
tout = {s: ms for s, ms in tout.items() if s in garde}
if not tout:
raise Refus(f"aucun export « advanced » pour {station}" + " avec ces cibles" * bool(cibles))
a, b = plage(tout, du, au)
mesures = {s: k for s, ms in tout.items() if (k := [m for m in ms if a - HISTORIQUE <= m["t"] < b])}
evs = [v for v in evenements(mesures, b, str(d)) if v["end"] >= donnees.iso(a)] if mesures else []
refs = {s for s, ms in mesures.items() if ms[0]["pattern_type"] == "global_ref"}
return [{"id": f"D-{i + 1}", "debut": v["start"], "fin": v["end"], "categorie": v["category"], "sorte": v["episodes"][0]["label"],
"description": f"{v['episodes'][0]['label']}. {v['text']}", "capteurs": v["sensors"], "ignore": v["ignore"],
"cibles": [s for s in v["sensors"] if s not in refs], "references": [s for s in v["sensors"] if s in refs],
"message": message(v["text"]), "action": action(v)}
for i, v in enumerate(evs)]
def message(texte):
"""Ce qui arrive : la première phrase du journal (detectors/categories.py, phrase), jusqu'à son « ; » ; la suite y dit quoi
en faire, sauf la phrase des sauts absorbés, gardée. ". " seulement : « 1.5× » ou « 0.30 px » ne coupent pas."""
meme = re.search(r" (The jumps? of .* same cause\.)$", texte)
return re.split(r"\. |; ", texte, maxsplit=1)[0].rstrip(".") + "." + (" " + meme.group(1) if meme else "")
# Quoi en faire : la colonne « Pour le client » de labeling/familles.md, par famille ; précisée par sorte (le label de l'épisode
# principal, avec son niveau) d'après les phrases du journal validées le 2026-10-24 (detectors/categories.py, phrase)
ACTION_FAMILLE = {
"Visibility": "Do not trust the curves in this period: this is not a movement.",
"Obstruction": "Ignore the curves of the hidden targets in this period.",
"Thermal displacement": "Normal, nothing to do.",
"Displacement": "To check: look at the images, then keep watching.",
"Target issue": "Act on the target (prism, mount); ignore its curve in the meantime.",
"No data": "The curves are missing in this period; its cause tells whether to act.",
}
ACTION_SORTE = {
"Poor visibility reduced": "Use the data in this period with care: they are less precise.",
"Heat shimmer": "Nothing to do: the small fast wiggles are not movement.",
"Camera thermal movement": "Nothing to do: this is not a movement of the structure.",
"Brief obstruction": "Ignore this single point on the curves.",
"Sudden jump, back to normal": "Look at the images: the cause is not established.",
"Lasting shift": "Check whether the structure moved: look at the images.",
"Jump, not back yet": "Check whether the structure moved: look at the images.",
"Large shift": "Check whether the structure moved: look at the images.",
"Slow drift": "Keep watching it.",
}
def action(v):
ep = v["episodes"][0]
return ACTION_SORTE.get(f"{ep['label']} {ep.get('level') or ''}".strip(), ACTION_SORTE.get(ep["label"])) \
or ACTION_FAMILLE.get(v["category"], "")
# --- les étiquettes (labeling/labeling.py, labeling/ids.py)
def fichier(station, source):
if source not in DOSSIERS:
raise Refus("dossier d'étiquettes inconnu")
dossier(station)
return ETIQUETTES / source / f"{station}.jsonl"
def lire(station, source):
f = fichier(station, source)
# split et non splitlines : celui-ci couperait aussi sur les séparateurs Unicode que le texte peut contenir
return [json.loads(l) for l in f.read_text(encoding="utf-8").split("\n") if l.strip()] if f.exists() else []
def attribuer(station, etiquettes):
"""labeling/ids.attribuer (D-131) : un id aux étiquettes qui n'en ont pas, le suivant de la station, en premier champ."""
n = max((int(e["id"].rsplit("-", 1)[1]) for e in etiquettes if "id" in e), default=0)
for e in etiquettes:
if "id" not in e:
n += 1
e["id"] = f"{station}-{n}"
if next(iter(e)) != "id":
reste = {k: v for k, v in e.items() if k != "id"}
ident = e["id"]
e.clear()
e.update({"id": ident}, **reste)
def _valide(corps, debut, fin):
description = (corps.get("description") or "").strip()
try:
vide = datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT)
except (TypeError, ValueError):
raise Refus("bornes illisibles (AAAA-MM-JJTHH:MMZ)") from None
if not description or vide:
raise Refus("texte vide ou plage vide")
c = corps.get("categorie") or ""
if c and c not in FAMILLES:
raise Refus("famille inconnue")
return description, c
def ajouter(corps):
station, source = corps.get("station"), corps.get("dossier", "manual")
f = fichier(station, source)
description, c = _valide(corps, corps.get("debut"), corps.get("fin"))
label = {"debut": corps["debut"], "fin": corps["fin"]} | ({"categorie": c} if c else {}) | {"description": description}
if source == "auto": # une étiquette automatique porte un id stable, le suivant de sa station (D-131)
attribuer(station, lire(station, "auto") + [label])
f.parent.mkdir(parents=True, exist_ok=True)
avant = f.read_bytes() if f.exists() else b"" # une ligne retirée à la main peut laisser le fichier sans fin de ligne
with open(f, "ab") as sortie:
sortie.write(b"\n" * bool(avant and not avant.endswith(b"\n")) + json.dumps(label, ensure_ascii=False).encode() + b"\n")
return label
def modifier(corps):
avant = corps.get("avant") or {}
debut, fin = corps.get("debut", avant.get("debut")), corps.get("fin", avant.get("fin"))
description, c = _valide(corps, debut, fin)
label = dict.fromkeys(("id", "debut", "fin", "categorie")) | avant | {"debut": debut, "fin": fin, "categorie": c,
"description": description}
if label["id"] is None:
del label["id"]
if not c:
del label["categorie"]
label.pop("revue", None) # changée : à revoir par /review-labels (D-103)
return remplace(corps.get("station"), corps.get("dossier", "manual"), avant, label)
def supprimer(corps):
remplace(corps.get("station"), corps.get("dossier", "manual"), corps.get("avant"), None)
return corps.get("avant")
def remplace(station, source, avant, label):
"""Remplace l'étiquette avant par label (None : la retire), retrouvée par son contenu, pas par son rang : le fichier
a pu changer depuis le chargement de la page. Écrit à côté puis remplace : une coupure n'abîme pas le fichier."""
f = fichier(station, source)
lignes = f.read_text(encoding="utf-8").split("\n") if f.exists() else []
for i, ligne in enumerate(lignes):
if ligne.strip() and json.loads(ligne) == avant:
lignes[i:i + 1] = [] if label is None else [json.dumps(label, ensure_ascii=False)]
provisoire = f.with_name(f.name + ".tmp")
provisoire.write_text("\n".join(lignes), encoding="utf-8")
os.replace(provisoire, f)
return label
raise Refus("cette étiquette n'est plus dans le fichier : recharger la page")
+14
View File
@@ -0,0 +1,14 @@
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Diagnostic AIMsight</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap" rel="stylesheet">
</head>
<body>
<div id="racine"></div>
<script type="module" src="/src/main.jsx"></script>
</body>
</html>
+1192
View File
File diff suppressed because it is too large. Load diff
+22
View File
@@ -0,0 +1,22 @@
{
"name": "support-aimsight",
"private": true,
"type": "module",
"scripts": {
"dev": "vite",
"build": "vite build"
},
"dependencies": {
"@mantine/core": "^9.7.5",
"@mantine/hooks": "^9.7.5",
"@mantine/notifications": "^9.7.5",
"@tabler/icons-react": "^3.50.0",
"plotly.js-dist-min": "^4.2.0",
"react": "^19.3.1",
"react-dom": "^19.3.1"
},
"devDependencies": {
"@vitejs/plugin-react": "^6.2.1",
"vite": "^8.3.6"
}
}
+134
View File
@@ -0,0 +1,134 @@
import { lazy, Suspense, useEffect, useState } from "react";
import {
ActionIcon, AppShell, Burger, ColorSwatch, Group, Loader, NavLink, ScrollArea, Text, Tooltip, useComputedColorScheme, useMantineColorScheme,
} from "@mantine/core";
import { useDisclosure } from "@mantine/hooks";
import { IconChartLine, IconFolder, IconMoon, IconSun } from "@tabler/icons-react";
const Data = lazy(() => import("./pages/Data.jsx")); // Plotly, chargé seulement ici
const PAGES = [["data", "Data", IconChartLine]];
// L'adresse : #/<page>?station=…&du=…&au=… ; recharger garde la page et la sélection, Retour marche ; sans dates, les 5 derniers
// jours UTC, aujourd'hui compris (au exclu : demain)
const jour = n => new Date(Date.now() + n * 864e5).toISOString().slice(0, 10);
function lireAdresse() {
const [page, q = ""] = location.hash.replace(/^#\/?/, "").split("?");
const p = new URLSearchParams(q);
return { page: PAGES.some(([n]) => n === page) ? page : "data",
selection: { station: p.get("station") || "", du: p.get("du") || jour(-4), au: p.get("au") || jour(1) } };
}
function adresse(page, s) {
const q = new URLSearchParams(Object.entries(s).filter(([, v]) => v)).toString();
return `#/${page}${q ? "?" + q : ""}`;
}
function Entete({ mobile, bureau, basculer }) {
const { setColorScheme } = useMantineColorScheme(), schema = useComputedColorScheme("light");
return (
<AppShell.Header className="entete">
<Group h="100%" px="md" justify="space-between" wrap="nowrap">
<Group gap="sm" wrap="nowrap">
<Burger opened={mobile} onClick={basculer.mobile} hiddenFrom="sm" size="sm" color="white" aria-label="Menu" />
<Burger opened={bureau} onClick={basculer.bureau} visibleFrom="sm" size="sm" color="white" aria-label="Barre latérale" />
<Text fw={700} size="lg">AIMsight</Text>
<Text size="sm" opacity={0.6}>Diagnostic</Text>
</Group>
<Group gap="sm" wrap="nowrap">
<Tooltip label={schema === "dark" ? "Mode clair" : "Mode sombre"}>
<ActionIcon variant="subtle" color="white" size="lg" aria-label="Changer de thème"
onClick={() => setColorScheme(schema === "dark" ? "light" : "dark")}>
{schema === "dark" ? <IconSun size={20} /> : <IconMoon size={20} />}
</ActionIcon>
</Tooltip>
</Group>
</Group>
</AppShell.Header>
);
}
// Les analyses de la page Data (labeling/auto/analyses/), relues toutes les 3 s : un dossier par station, ouvert d'office s'il en
// a une en cours, et dedans une analyse par plage ; un clic ouvre Data sur sa station et ses jours, et y montre son rapport
// La plage d'une analyse sur une ligne : « 01.11 · 10:30–11:40 » dans le jour, sinon « 04.11 21:12 – 07.11 14:12 » (UTC)
const jourMois = t => `${t.slice(8, 10)}.${t.slice(5, 7)}`, heure = t => t.slice(11, 16);
const plage = a => (a.debut.slice(0, 10) === a.fin.slice(0, 10)
? `${jourMois(a.debut)} · ${heure(a.debut)}–${heure(a.fin)}` : `${jourMois(a.debut)} ${heure(a.debut)} – ${jourMois(a.fin)} ${heure(a.fin)}`);
const COULEUR_ETAT = { fini: "teal", erreur: "red", interrompue: "gray" };
// L'état : une roue qui tourne en cours, sinon une pastille de couleur (son nom dans la bulle)
const Pastille = ({ etat }) => (etat === "en cours" ? <Loader size={10} color="orange" />
: <Tooltip label={etat}><ColorSwatch size={8} color={`var(--mantine-color-${COULEUR_ETAT[etat] || "gray"}-6)`} withShadow={false} /></Tooltip>);
function Analyses({ ouvrir }) {
const [liste, setListe] = useState([]);
useEffect(() => {
const lire = () => fetch("/api/analyses").then(r => r.ok && r.json()).then(l => l && setListe(l)).catch(() => {}); // en silence : toutes les 3 s
lire();
const minuterie = setInterval(lire, 3000);
return () => clearInterval(minuterie);
}, []);
if (!liste.length) return null;
const stations = [...new Set(liste.map(a => a.station))].sort();
return <>
<Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="lg" pb="xs">Analyses (UTC)</Text>
{stations.map(st => {
const siennes = liste.filter(a => a.station === st), occupee = siennes.some(a => a.etat === "en cours");
// le chevron du dossier reste celui de Mantine : un rightSection prendrait sa place, et tournerait avec lui
return (
<NavLink key={st} defaultOpened={occupee} childrenOffset={22} leftSection={<IconFolder size={16} />}
label={<Group gap={6} wrap="nowrap">{st}<Text span size="xs" c="dimmed">{siennes.length}</Text>{occupee && <Loader size={10} color="orange" />}</Group>}>
{siennes.map(a => (
<NavLink key={a.nom} py={4} onClick={() => ouvrir(a)} leftSection={<Pastille etat={a.etat} />}
label={<Text size="xs" ff="monospace" style={{ whiteSpace: "nowrap" }}>{plage(a)}</Text>} />
))}
</NavLink>
);
})}
</>;
}
function Barre({ page, selection, fermer, ouvrir }) {
const titre = t => <Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="lg" pb="xs">{t}</Text>;
return (
<AppShell.Navbar p="xs">
<ScrollArea type="scroll">
{titre("Pages")}
{PAGES.map(([n, nom, Icone]) => (
<NavLink key={n} label={nom} leftSection={<Icone size={18} />} active={page === n} onClick={fermer}
href={adresse(n, selection)} />
))}
<Analyses ouvrir={a => { fermer(); ouvrir(a); }} />
</ScrollArea>
</AppShell.Navbar>
);
}
export default function App() {
const [{ page, selection }, setLieu] = useState(lireAdresse);
const [mobile, { toggle: basculerMobile, close: fermerMobile }] = useDisclosure(false);
const [bureau, { toggle: basculerBureau }] = useDisclosure(true);
const [analyse, setAnalyse] = useState(null); // l'analyse dont Data montre le rapport
useEffect(() => {
const suivre = () => setLieu(lireAdresse());
addEventListener("hashchange", suivre);
return () => removeEventListener("hashchange", suivre);
}, []);
const choisir = s => { location.hash = adresse(page, s); };
// Une analyse de la barre : Data sur sa station, des jours qui couvrent sa plage (sauf si la plage affichée les couvre déjà)
function ouvrirAnalyse(a) {
const s = selection, couvre = s.station === a.station && s.du <= a.debut.slice(0, 10) && a.fin < s.au;
const au = new Date(Date.parse(a.fin.slice(0, 10)) + 864e5).toISOString().slice(0, 10);
setAnalyse(a.nom);
location.hash = adresse("data", couvre ? s : { station: a.station, du: a.debut.slice(0, 10), au });
}
return (
<AppShell header={{ height: 64 }} padding="lg"
navbar={{ width: 260, breakpoint: "sm", collapsed: { mobile: !mobile, desktop: !bureau } }}>
<Entete mobile={mobile} bureau={bureau} basculer={{ mobile: basculerMobile, bureau: basculerBureau }} />
<Barre page={page} selection={selection} fermer={fermerMobile} ouvrir={ouvrirAnalyse} />
<AppShell.Main bg="var(--mantine-color-default-hover)">
<Suspense fallback={<Loader m="xl" />}><Data selection={selection} choisir={choisir} analyse={analyse} setAnalyse={setAnalyse} /></Suspense>
</AppShell.Main>
</AppShell>
);
}
+52
View File
@@ -0,0 +1,52 @@
import { useEffect, useState } from "react";
import { Button, Card, Group, Select, Text, TextInput } from "@mantine/core";
import { notifications } from "@mantine/notifications";
// Une requête à l'API ; un refus du serveur s'affiche en notification -> le JSON rendu, ou null
export async function appel(chemin, methode = "GET", corps) {
try {
const r = await fetch(chemin, corps === undefined ? { method: methode }
: { method: methode, headers: { "Content-Type": "application/json" }, body: JSON.stringify(corps) });
const json = await r.json().catch(() => ({ erreur: r.statusText }));
if (r.ok) return json;
notifications.show({ color: "red", title: "Refusé", message: json.erreur || r.statusText });
} catch (e) {
notifications.show({ color: "red", title: "Serveur injoignable", message: e.message });
}
return null;
}
export const poster = async (chemin, corps) => (await appel(chemin, "POST", corps)) !== null;
export function Carte({ surtitre, titre, action, children, ...reste }) {
return (
<Card shadow="sm" padding={0} withBorder {...reste}>
<Group px="lg" py="md" justify="space-between" wrap="nowrap" style={{ borderBottom: "1px solid var(--mantine-color-default-border)" }}>
<div>
<Text size="xs" fw={700} tt="uppercase" c="dimmed">{surtitre}</Text>
<Text fw={500}>{titre}</Text>
</div>
{action}
</Group>
{children}
</Card>
);
}
// La station et la plage (UTC, Au exclue ; vides : toute la période), partagées par les pages via l'adresse
export function Selecteur({ selection, choisir }) {
const [stations, setStations] = useState([]), [s, setS] = useState(selection);
useEffect(() => { appel("/api/stations").then(l => l && setStations(l)); }, []);
useEffect(() => setS(selection), [selection.station, selection.du, selection.au]);
return (
<Card shadow="sm" withBorder>
<Group align="flex-end" gap="md">
<Select label="Station" placeholder="Choisir" data={stations} value={s.station || null} searchable w={200}
onChange={v => setS({ ...s, station: v || "" })} />
<TextInput label="Du (UTC)" type="date" value={s.du} onChange={e => setS({ ...s, du: e.currentTarget.value })} />
<TextInput label="Au (exclu)" type="date" value={s.au} onChange={e => setS({ ...s, au: e.currentTarget.value })} />
<Button onClick={() => choisir(s)} disabled={!s.station}>Charger</Button>
</Group>
</Card>
);
}
+24
View File
@@ -0,0 +1,24 @@
import { createRoot } from "react-dom/client";
import { MantineProvider, createTheme } from "@mantine/core";
import { Notifications } from "@mantine/notifications";
import "@mantine/core/styles.css";
import "@mantine/notifications/styles.css";
import "./style.css";
import App from "./App.jsx";
// Bleu primaire #5383ff (shade 5), la palette retenue pour la page
const theme = createTheme({
primaryColor: "aimsight",
primaryShade: 5,
colors: { aimsight: ["#eef3ff", "#dce5ff", "#b8c9ff", "#91abff", "#6f92ff", "#5383ff", "#4574f5", "#3863dc", "#2c55c4", "#1d45ab"] },
fontFamily: "Roboto, Helvetica, Arial, sans-serif",
headings: { fontFamily: "Roboto, Helvetica, Arial, sans-serif" },
defaultRadius: "md",
});
createRoot(document.getElementById("racine")).render(
<MantineProvider theme={theme} defaultColorScheme="auto">
<Notifications position="top-right" />
<App />
</MantineProvider>,
);
+562
View File
@@ -0,0 +1,562 @@
import { useEffect, useMemo, useRef, useState } from "react";
import {
ActionIcon, Badge, Button, Card, Checkbox, Grid, Group, Loader, NativeSelect, SegmentedControl, SimpleGrid, Stack, Switch, Text, Textarea, TextInput, Title, Tooltip,
useComputedColorScheme,
} from "@mantine/core";
import { IconPlus, IconX } from "@tabler/icons-react";
import { appel, Selecteur } from "../commun.jsx";
import { ImagesDe } from "./Images.jsx";
// Data, le visualiseur de courbes (et l'étiquetage de labeling/labeling.py) : un plot au départ, d'autres à ajouter ou enlever,
// tous alignés sur le temps ; sous eux les étiquettes : Detectors (les événements du journal), LLM (labeling/auto/, en lecture)
// ou Analysis (les mêmes, à modifier, supprimer ; glisser sur la barre sélectionne une plage, que l'analyste diagnostique et
// étiquette ; ailleurs, glisser zoome) ; un clic ouvre une
// étiquette et la met en évidence. À droite, les images de la station, et sous elles les paramètres du diagnostic.
const FAMILLES = { "Visibility": "#8ec5e8", "Obstruction": "#f0b072", "Thermal displacement": "#f08a7e", "Displacement": "#b39ddb",
"Target issue": "#e6d46a", "No data": "#c4c4be", "None": "#a8d5a2" };
const NOM_FAMILLE = f => (f === "None" ? "None (courbes intactes)" : f);
const CHOIX_FAMILLE = [{ value: "", label: "(sans famille)" }, ...Object.keys(FAMILLES).map(f => ({ value: f, label: NOM_FAMILLE(f) }))];
// LLM et Analysis : les mêmes étiquettes, labeling/auto/ ; LLM les lit, Analysis les modifie, supprime, et en fait faire par
// l'analyste sur une plage (app/serveur/analyse.py)
const SOURCES = [{ value: "detecteurs", label: "Detectors" }, { value: "auto", label: "LLM" }, { value: "analysis", label: "Analysis" }];
const GRIS = "#b0b0aa", BLEU = "#2a78d6", VOIE = 26, HAUT = 330; // VOIE : px par rangée d'étiquettes ; HAUT : d'un plot
const couleur = l => FAMILLES[l.categorie] || GRIS;
const lisible = s => s.slice(0, 16).replace("T", " ");
const marge = () => ({ l: 60, r: 20, t: 10, b: 30 });
// L'habillage, aux couleurs de Mantine (dark.0 à dark.7 en sombre, gray en clair)
const COULEURS = { clair: { texte: "#495057", faible: "#868e96", grille: "#eef0f2", axe: "#dee2e6", fond: "#f1f3f5", bulle: "#ffffff", zone: 0.05 },
sombre: { texte: "#c9c9c9", faible: "#828282", grille: "#2e2e2e", axe: "#424242", fond: "#3b3b3b", bulle: "#242424", zone: 0.07 } };
const POLICE = "Roboto, sans-serif";
const habillage = c => ({ paper_bgcolor: "rgba(0,0,0,0)", plot_bgcolor: "rgba(0,0,0,0)", font: { family: POLICE, size: 11, color: c.texte },
hoverlabel: { bgcolor: c.bulle, bordercolor: c.axe, align: "left", font: { family: POLICE, size: 12, color: c.texte } },
modebar: { bgcolor: "rgba(0,0,0,0)", color: c.faible, activecolor: "#5383ff" } });
const axe = c => ({ gridcolor: c.grille, linecolor: c.axe, showline: true, zeroline: false, ticks: "" });
const OUTILS = { responsive: true, doubleClick: "reset", displaylogo: false, showTips: false,
modeBarButtonsToRemove: ["lasso2d", "select2d", "autoScale2d", "zoomIn2d", "zoomOut2d", "hoverClosestCartesian", "hoverCompareCartesian", "toggleSpikelines"] };
const date = v => Date.parse(String(v).replace(" ", "T").replace(/Z?$/, "Z")); // une date Plotly ou d'étiquette -> ms UTC
const coupe = s => s.replace(/(.{1,80})(\s|$)/g, "$1<br>"); // la bulle : des lignes de 80 caractères au plus
const DETECTEES = Object.keys(FAMILLES).filter(f => f !== "None"); // les familles des détecteurs (categories.py)
export default function Data({ selection, choisir, analyse, setAnalyse }) {
const [donnees, setDonnees] = useState(null), [charge, setCharge] = useState(false), [large, setLarge] = useState(false);
const gauche = useRef(), [instant, setInstant] = useState(null); // instant : où caler les images (le début de l'événement cliqué)
// Les paramètres du diagnostic, sous l'image (Detectors et LLM) : familles montrées (filtre de la page) ; cibles gardées ("" :
// toutes ; sinon les détecteurs retournent sans les autres)
const [source, setSource] = useState("detecteurs"), [familles, setFamilles] = useState(DETECTEES), [cibles, setCibles] = useState("");
const [focus, setFocus] = useState(false); // un événement ouvert : les plots ne montrent que ses capteurs
const { station, du, au } = selection;
useEffect(() => {
setDonnees(null); setCibles("");
if (!station) return;
setCharge(true);
appel(`/api/courbes?${new URLSearchParams({ station, du, au })}`).then(d => { setDonnees(d); setCharge(false); });
}, [station, du, au]);
// Les colonnes glissent (style.css) ; Plotly ne suit que la fenêtre : à la fin du glissement, les plots se recalent sur leur
// nouvelle largeur (les redessiner à chaque image du glissement serait trop lourd)
const finGlissement = e => { if (e.target === gauche.current && e.propertyName === "max-width") dispatchEvent(new Event("resize")); };
return (
<Grid gutter="lg" className="data-grille" onTransitionEnd={finGlissement}>
<Grid.Col span={{ base: 12, lg: large ? 5 : 8 }} ref={gauche}>
<Stack gap="lg">
<div>
<Title order={2}>Data</Title>
<Text c="dimmed">Les courbes d'une station, un plot ou plusieurs ; sous eux les étiquettes : un clic sur l'une la met en évidence et
l'ouvre.</Text>
</div>
<Selecteur selection={selection} choisir={choisir} />
{charge && <Loader />}
{donnees && <Courbes key={`${station}${du}${au}`} selection={selection} d={donnees} caler={(t, proche) => setInstant({ t, proche })}
source={source} setSource={setSource} familles={familles} cibles={cibles} focus={focus}
analyse={analyse} setAnalyse={setAnalyse} />}
</Stack>
</Grid.Col>
<Grid.Col span={{ base: 12, lg: large ? 7 : 4 }}>
<div className="colle">
<Stack gap="lg">
<ImagesDe selection={selection} compacte large={large} basculer={() => setLarge(!large)} instant={instant} />
{donnees && <Parametres key={`${station}${du}${au}`} d={donnees} familles={familles} setFamilles={setFamilles}
cibles={cibles} setCibles={setCibles} detect={source === "detecteurs"}
focus={focus} setFocus={setFocus} />}
</Stack>
</div>
</Grid.Col>
</Grid>
);
}
// Les familles s'appliquent tout de suite (filtre de la page, Detectors et LLM) ; les cibles, au bouton : chaque jeu de cibles
// relance les détecteurs (les étiquettes LLM ne disent pas leurs capteurs : elles ne les filtrent pas)
function Parametres({ d, familles, setFamilles, cibles, setCibles, detect, focus, setFocus }) {
const capteurs = Object.keys(d.T).filter(k => k && !k.startsWith("system:"));
const refs = new Set(d.plots.flatMap(p => p.traces).filter(t => t.name.endsWith(" (ref.)")).map(t => t.t));
const [coches, setCoches] = useState(cibles ? cibles.split(",") : capteurs);
const voulu = coches.length === capteurs.length ? "" : capteurs.filter(c => coches.includes(c)).join(",");
return (
<Card shadow="sm" withBorder>
<Stack gap="sm">
<Title order={5}>Paramètres du diagnostic</Title>
<Switch label="Focus on event curves" description="Un événement ouvert : les plots ne montrent que ses capteurs"
checked={focus} onChange={e => setFocus(e.currentTarget.checked)} />
<Checkbox.Group label="Familles montrées" value={familles} onChange={setFamilles}>
<SimpleGrid cols={2} spacing={6} verticalSpacing={6} mt={6}>
{DETECTEES.map(f => <Checkbox key={f} size="xs" value={f} label={f} color={FAMILLES[f]} iconColor="#1a1b1e" />)}
</SimpleGrid>
</Checkbox.Group>
<Checkbox.Group label="Cibles considérées (les autres sont écartées)" value={coches} onChange={setCoches}>
<SimpleGrid cols={3} spacing={6} verticalSpacing={6} mt={6}>
{capteurs.map(c => <Checkbox key={c} size="xs" value={c} label={c + (refs.has(c) ? " (ref.)" : "")} />)}
</SimpleGrid>
</Checkbox.Group>
{!detect && <Text size="xs" c="dimmed">Les étiquettes ne disent pas leurs cibles : ce choix ne vaut que pour Detectors.</Text>}
<Group gap="sm">
<Button size="xs" onClick={() => setCibles(voulu)} disabled={!coches.length || voulu === cibles}>Relancer les détecteurs</Button>
<Button size="xs" variant="default" onClick={() => setCoches(coches.length ? [] : capteurs)}>{coches.length ? "Tout décocher" : "Tout cocher"}</Button>
</Group>
</Stack>
</Card>
);
}
// Une ligne de la fiche d'un événement des détecteurs : son nom, puis sa valeur
const Champ = ({ nom, children }) => (
<Group gap="sm" align="flex-start" wrap="nowrap">
<Text size="sm" c="dimmed" w={80} style={{ flexShrink: 0 }}>{nom}</Text>
<Text size="sm" component="div">{children}</Text>
</Group>
);
// Les capteurs d'un événement : ceux des détecteurs, sinon ceux que nomme le texte de l'étiquette (LLM, Analysis)
const nomme = (texte, s) => new RegExp(`(^|[^\\w])${s.replace(/[^\w]/g, "\\$&")}(?![\\w])`).test(texte);
const capteursDe = (l, noms) => l.capteurs ?? noms.filter(s => nomme(l.description, s));
// analyse : le dossier de l'analyse montrée, tenu par App (la barre latérale en ouvre une)
function Courbes({ selection: { station, du, au }, d, caler, source, setSource, familles, cibles, focus, analyse, setAnalyse }) {
const { A, B, T, plots: PLOTS } = d;
const indice = (titre, sinon) => { const i = PLOTS.findIndex(p => p.titre === titre); return i < 0 ? sinon : i; };
const [Plotly, setPlotly] = useState(null), [pret, setPret] = useState(false);
const [vues, setVues] = useState([{ id: 1, m: indice("Relative Corrected Horizontal Shift", 0) }]); // les plots affichés
const [choix, setChoix] = useState(null);
const [indices, setIndices] = useState(""), [rev, setRev] = useState(0);
const [ouverte, setOuverte] = useState(null), [edit, setEdit] = useState(null), [note, setNote] = useState("");
const [toutes, setToutes] = useState([]), [lecture, setLecture] = useState(true), sombre = useComputedColorScheme("light") === "dark";
// toutes : le fichier (ou les détecteurs) ; labels : sur la plage, dans les familles cochées (sans famille ou None : toujours)
const labels = useMemo(() => toutes.filter(x => x.debut < B && x.fin > A
&& (!DETECTEES.includes(x.categorie) || familles.includes(x.categorie))), [toutes, familles]);
const detect = source === "detecteurs", lecteur = source !== "analysis"; // seul Analysis écrit
const dossier = source === "analysis" ? "auto" : source; // le dossier de labeling/ des étiquettes
// figs : id -> div du plot ; dessines : id -> plot qu'il montre ; vue : la plage et la largeur où le texte des étiquettes a été tronqué
const figs = useRef({}), dessines = useRef({}), prochain = useRef(2), barre = useRef(), tries = useRef([]), vue = useRef(""), courant = useRef({});
// le focus : les capteurs de l'événement ouvert (aucun : tous, comme pour No data) ; montres, leur clé
const noms = useMemo(() => Object.keys(T).filter(k => k && !k.startsWith("system:")), [T]);
const gardes = focus && ouverte ? capteursDe(ouverte, noms) : [], montres = gardes.join(",");
courant.current = { vues, labels, choix, ouverte, ouvrir, gardes: new Set(gardes), montres, c: COULEURS[sombre ? "sombre" : "clair"] }; // ce que lisent les événements Plotly
useEffect(() => { import("plotly.js-dist-min").then(m => setPlotly(() => m.default)); }, []);
const liste = () => courant.current.vues.map(v => figs.current[v.id]).filter(g => g?._fullLayout);
// Les zones des étiquettes, la plage choisie, et l'étiquette ouverte : plus marquée, entourée
function zones() {
const { labels, choix, ouverte, c } = courant.current;
const z = (a, b, f, o, ligne = { width: 0 }, couche = "below") => ({ type: "rect", xref: "x", yref: "paper", x0: lisible(a), x1: lisible(b),
y0: 0, y1: 1, fillcolor: f, opacity: o, line: ligne, layer: couche });
return labels.map(l => z(l.debut, l.fin, couleur(l), c.zone)).concat(choix ? [z(choix[0], choix[1], BLEU, 0.25)] : [])
.concat(ouverte ? [z(ouverte.debut, ouverte.fin, couleur(ouverte), 0.3),
z(ouverte.debut, ouverte.fin, "rgba(0,0,0,0)", 1, { color: c.texte, width: 1.5, dash: "dot" }, "above")] : []);
}
// Le contour des barres : épais pour l'étiquette ouverte
const contour = t => {
const { ouverte, c } = courant.current;
return { color: t.map(l => (l === ouverte ? c.texte : c.fond)), width: t.map(l => (l === ouverte ? 3 : 1)) };
};
// Les plots et la barre partagent plage et marges : celui qui change impose les siens aux autres (rien si déjà alignés,
// sinon le relayout appelle aligne en boucle).
function aligne(src) {
const gs = liste(), b = barre.current;
if (!b?._fullLayout || !gs.length) return;
const rg = (src?._fullLayout ? src : gs[0])._fullLayout.xaxis.range.slice();
const l = Math.max(...gs.map(g => g._fullLayout._size.l)), r = Math.max(...gs.map(g => g._fullLayout._size.r));
return Promise.all([...gs, b].map(g => {
const m = g._fullLayout.margin, x = g._fullLayout.xaxis.range;
if (m.l === l && m.r === r && date(x[0]) === date(rg[0]) && date(x[1]) === date(rg[1])) return;
return Plotly.relayout(g, { "xaxis.range": rg, "margin.l": l, "margin.r": r });
})).then(recaleTexte);
}
// Le texte des étiquettes suit le zoom et la largeur de la barre (rien si les deux n'ont pas changé)
function recaleTexte() {
const b = barre.current, L = b?._fullLayout;
if (!L) return;
const v = `${L.xaxis.range}|${L._size.w}`;
if (v !== vue.current) { vue.current = v; return Plotly.restyle(b, { text: [textes(tries.current, L)] }); }
}
// Le texte de chaque étiquette, tronqué à la largeur visible de sa barre (~6 px par caractère en 11 px) ; pour un événement
// des détecteurs, sa famille seulement (ses capteurs dans la bulle, le reste au clic)
function textes(t, L) {
const [r0, r1] = L.xaxis.range.map(date), w = L._size.w;
return t.map(l => {
const x = l.message ? l.categorie : l.description;
const px = (Math.min(date(l.fin), r1) - Math.max(date(l.debut), r0)) / (r1 - r0) * w, n = Math.floor((px - 10) / 6);
return n < 3 ? "" : x.length <= n ? x : x.slice(0, n - 1) + "…";
});
}
// Une trace de capteur sous le focus : visible si c'est l'un des siens, sinon dans la légende seulement ; uirevision de la
// trace : le focus qui change l'emporte sur les clics de légende, qui restent tant qu'il ne change pas
function focalise(t) {
const { gardes, montres } = courant.current;
if (!montres || !t.t || t.t.startsWith("system:")) return { uirevision: montres || 1 };
return { visible: gardes.has(t.t) ? true : "legendonly", uirevision: montres };
}
function dessineFig(g, m) {
const p = PLOTS[m], { c } = courant.current, b = barre.current?._fullLayout;
g.style.height = `${HAUT}px`; // responsive : Plotly reprend la hauteur du div à chaque restyle, il lui en faut une
// uirevision : le zoom et les capteurs cachés restent quand on change de plot ; l'ordonnée, propre à chaque plot, se recale.
// Un nouveau plot prend la plage déjà affichée. t : la place du menu du plot (à gauche) et de la barre d'outils (à droite).
return Plotly.react(g, p.traces.map(t => ({ type: "scatter", mode: t.mode || "lines", marker: { size: 4 }, x: T[t.t], y: t.y, name: t.name,
uid: t.name.replace(/\W/g, "_"), line: t.line, ...focalise(t),
hovertemplate: `${t.name} : %{y}<br>%{x|%Y-%m-%d %H:%M} UTC<extra></extra>` })),
{ ...habillage(c), height: HAUT, hovermode: "closest", margin: { ...marge(), t: 42, b: 36 }, uirevision: 1, shapes: zones(),
legend: { x: 1.01, y: 1, itemwidth: 30, font: { size: 11 } },
xaxis: { type: "date", range: b ? b.xaxis.range.slice() : [lisible(A), lisible(B)], ...axe(c) },
yaxis: { title: { text: p.titre, font: { size: 11, color: c.faible } }, uirevision: p.titre, ...axe(c) } },
OUTILS).then(() => {
if (!g.suivi) {
g.suivi = true;
g.on("plotly_relayout", () => aligne(g));
g.on("plotly_click", ev => caler(String(ev.points[0].x), true)); // un clic sur une courbe : l'image la plus proche
}
return aligne(g);
});
}
// Les plots nouveaux ou changés (tous : au changement de thème)
function dessinePlots(tous) {
return Promise.all(courant.current.vues.filter(v => tous || dessines.current[v.id] !== v.m)
.map(v => { dessines.current[v.id] = v.m; return dessineFig(figs.current[v.id], v.m); }));
}
function dessineBarre() {
const t = [...courant.current.labels].sort((a, b) => (a.debut < b.debut ? -1 : 1));
tries.current = t;
const voies = [], voie = t.map(l => { // la première rangée libre, sinon une nouvelle
const r = voies.findIndex(f => f <= l.debut), i = r < 0 ? voies.length : r;
voies[i] = l.fin;
return i;
});
const n = Math.max(1, voies.length), gs = liste(), f = gs[0]._fullLayout, { c } = courant.current;
vue.current = "";
barre.current.style.height = `${40 + VOIE * n}px`; // comme les plots
return Plotly.react(barre.current, [{ type: "bar", orientation: "h", y: voie, base: t.map(l => lisible(l.debut)),
x: t.map(l => Date.parse(l.fin) - Date.parse(l.debut)), width: 0.8,
marker: { color: t.map(couleur), cornerradius: 4, line: contour(t) },
text: textes(t, barre.current._fullLayout || f), textposition: "inside", insidetextanchor: "start", textangle: 0,
textfont: { family: POLICE, size: 11, color: "#1a1b1e" },
unselected: { marker: { opacity: 1 } }, // sinon une sélection les pâlit
// la bulle : pour un détecteur, ses cibles seulement ; sinon la famille et tout le texte, que la barre tronque
customdata: t.map(l => (l.message ? coupe(l.cibles.length ? l.cibles.join(", ") : l.references.length
? l.references.map(s => s + " (ref.)").join(", ") : "Tous les capteurs")
: (l.categorie ? `<b>${NOM_FAMILLE(l.categorie)}</b><br>` : "") + coupe(l.description))),
hovertemplate: "%{customdata}<extra></extra>" }],
{ ...habillage(c), height: 40 + VOIE * n, dragmode: lecteur ? "zoom" : "select", selectdirection: "h", hovermode: "closest", plot_bgcolor: c.fond, showlegend: false,
margin: { ...marge(), l: Math.max(...gs.map(g => g._fullLayout._size.l)), r: Math.max(...gs.map(g => g._fullLayout._size.r)) },
xaxis: { type: "date", range: f.xaxis.range.slice(), showgrid: false, ticks: "", color: c.texte },
yaxis: { range: [n - 0.5, -0.5], fixedrange: true, showticklabels: false, showgrid: false, zeroline: false },
newselection: { line: { color: BLEU, width: 1 } }, activeselection: { fillcolor: BLEU, opacity: 0.25 } },
{ responsive: true, displayModeBar: false, doubleClick: false });
}
// Le premier dessin, puis les événements de la barre, une fois
useEffect(() => {
if (!Plotly) return;
dessinePlots().then(dessineBarre).then(() => aligne()).then(() => {
barre.current.on("plotly_selected", ev => {
const r = ev?.range?.x;
if (r) setChoix(r.map(v => String(v).slice(0, 16).replace(" ", "T") + "Z"));
});
barre.current.on("plotly_deselect", () => setChoix(null));
barre.current.on("plotly_relayout", () => aligne(barre.current)); // zoomée (Detectors, LLM) ou redimensionnée seule (l'image agrandie)
// Un clic sur une étiquette l'ouvre ; un clic ailleurs sur la barre (pas un glisser) la referme
let surEtiquette = false, x0 = 0;
barre.current.on("plotly_click", ev => { surEtiquette = true; courant.current.ouvrir(tries.current[ev.points[0].pointIndex]); });
barre.current.addEventListener("mousedown", e => { x0 = e.clientX; }, true);
barre.current.addEventListener("click", e => {
if (!surEtiquette && Math.abs(e.clientX - x0) < 4) courant.current.ouvrir(null);
surEtiquette = false;
});
setPret(true);
});
return () => [...Object.values(figs.current), barre.current].forEach(g => g && Plotly.purge(g));
}, [Plotly]);
useEffect(() => { if (pret) dessinePlots().then(() => aligne(barre.current)); }, [vues]);
useEffect(() => { if (pret) dessineBarre(); }, [pret, labels]);
// Glisser sur la barre : sélectionner une plage (Labelling), sinon zoomer dans le temps
useEffect(() => { if (pret) Plotly.relayout(barre.current, { dragmode: lecteur ? "zoom" : "select", selections: [] }); }, [pret, lecteur]);
useEffect(() => { if (pret) dessinePlots(true).then(dessineBarre); }, [sombre]);
useEffect(() => { if (pret) dessinePlots(true); }, [montres]);
useEffect(() => { if (pret) liste().forEach(g => Plotly.relayout(g, { shapes: zones() })); }, [pret, labels, choix, ouverte]);
useEffect(() => {
if (!pret || !barre.current._fullLayout) return;
const k = contour(tries.current);
Plotly.restyle(barre.current, { "marker.line.color": [k.color], "marker.line.width": [k.width] });
}, [ouverte]);
// Lues à chaque chargement et à chaque changement de source : la page montre toujours le fichier ; les détecteurs tournent
// sur la plage la première fois (une minute ou plus), le serveur garde leur résultat
useEffect(() => {
let vivant = true;
setLecture(true);
const url = source === "detecteurs" ? `/api/detecteurs?${new URLSearchParams({ station, du, au, cibles })}`
: `/api/etiquettes?${new URLSearchParams({ station, dossier })}`;
appel(url).then(l => {
if (!vivant) return; // une autre source a été choisie entre-temps
setLecture(false); setToutes(l || []);
});
return () => { vivant = false; };
}, [source, cibles, rev]);
// Un plot de plus : le premier que la page ne montre pas encore, déplacement vertical d'abord
function ajouterPlot() {
const pris = vues.map(v => v.m), id = prochain.current++;
const m = [indice("Relative Corrected Vertical Shift", 0), ...PLOTS.keys()].find(i => !pris.includes(i)) ?? 0;
setVues([...vues, { id, m }]);
}
function enleverPlot(id) {
Plotly.purge(figs.current[id]);
delete figs.current[id]; delete dessines.current[id];
setVues(vues.filter(v => v.id !== id));
}
const modifiee = () => ouverte && edit && (edit.texte.trim() !== ouverte.description || edit.categorie !== (ouverte.categorie || "")
|| edit.debut + "Z" !== ouverte.debut || edit.fin + "Z" !== ouverte.fin);
// l : l'étiquette à afficher, null pour fermer -> false si Marc garde ses changements non enregistrés
function ouvrir(l) {
if (modifiee() && !confirm("Abandonner les changements de cette étiquette ?")) return false;
setOuverte(l); setNote("");
if (l) caler(l.debut); // un nouvel objet à chaque clic : recliquer le même événement y ramène les images
setEdit(l && !lecteur ? { debut: l.debut.slice(0, 16), fin: l.fin.slice(0, 16), categorie: l.categorie || "", texte: l.description } : null);
return true;
}
async function analyser() {
const r = await appel("/api/analyses", "POST", { station, debut: choix[0], fin: choix[1], indices });
if (!r) return; // rien n'est perdu : les indices et la plage restent dans la page
setAnalyse(r.nom); setIndices("");
await Plotly.relayout(barre.current, { selections: [] });
setChoix(null);
}
async function enregistrer() {
const l = await appel("/api/etiquettes", "PUT", { station, dossier, avant: ouverte, debut: edit.debut + "Z", fin: edit.fin + "Z",
categorie: edit.categorie, description: edit.texte.trim() });
if (!l) return; // rien n'est perdu : le texte et les bornes restent dans la fenêtre
setToutes(ls => ls.map(x => (x === ouverte ? l : x)));
setOuverte(l); setNote("Enregistrée");
}
async function supprimer() {
if (!confirm("Supprimer cette étiquette ?")) return;
if (await appel("/api/etiquettes", "DELETE", { station, dossier, avant: ouverte }) === null) return;
setToutes(ls => ls.filter(x => x !== ouverte));
setOuverte(null); setEdit(null);
}
const options = PLOTS.map((p, i) => ({ value: String(i), label: p.titre }));
const peutEnregistrer = modifiee() && edit.texte.trim() && edit.debut && edit.fin && edit.debut < edit.fin;
const bornes = (champ, plus) => lisible(toutes.reduce((m, l) => (plus(l[champ], m) ? l[champ] : m), toutes[0][champ]));
return (
<Card shadow="sm" withBorder>
<Stack gap="sm">
<div>
{vues.map(v => (
<div key={v.id} className="plot">
<div ref={el => { if (el) figs.current[v.id] = el; }} />
<Group gap={4} wrap="nowrap" className="plot-menu">
<NativeSelect size="xs" aria-label="Plot" data={options} value={String(v.m)} w={300}
onChange={e => { const m = +e.currentTarget.value; setVues(vues.map(x => (x.id === v.id ? { ...x, m } : x))); }} />
{vues.length > 1 && (
<Tooltip label="Enlever ce plot">
<ActionIcon variant="subtle" color="gray" aria-label="Enlever ce plot" onClick={() => enleverPlot(v.id)}><IconX size={16} /></ActionIcon>
</Tooltip>
)}
</Group>
</div>
))}
{!pret && <Loader size="sm" />}
</div>
<Group justify="space-between" gap="sm">
<Group gap="sm">
<SegmentedControl size="xs" data={SOURCES} value={source} onChange={v => { if (ouvrir(null)) { setSource(v); setChoix(null); } }} />
{lecture && <Group gap={6}><Loader size="xs" /><Text size="xs" c="dimmed">{detect ? "Les détecteurs tournent sur la plage…" : "Lecture…"}</Text></Group>}
</Group>
<Button size="xs" variant="light" leftSection={<IconPlus size={14} />} onClick={ajouterPlot} disabled={!pret}>Ajouter un plot</Button>
</Group>
<div ref={barre} />
{pret && !lecture && !labels.length && ( // sinon une barre vide ne dit pas pourquoi
<Text size="sm" c="orange">{detect ? `Les détecteurs ne trouvent aucun événement sur cette plage${toutes.length ? " dans les familles cochées" : ""}.`
: toutes.length ? `Aucune étiquette dans les familles cochées sur cette plage : celles de ${station} vont du ${bornes("debut", (a, b) => a < b)} au ${bornes("fin", (a, b) => a > b)} UTC.`
: `${station} n'a aucune étiquette dans labeling/${dossier}/.`}</Text>
)}
<div>
{!ouverte && lecteur && <Text size="sm" c="dimmed">Cliquer sur un événement pour l'ouvrir.</Text>}
{ouverte && lecteur && (
<Card withBorder bg="var(--mantine-color-default-hover)">
<Stack gap={6}>
<Group gap="xs">
<Badge color={couleur(ouverte)} c="#1a1b1e">{ouverte.categorie}</Badge>
<Text size="sm" fw={500}>{ouverte.sorte}</Text>
{ouverte.ignore && <Badge variant="outline" color="gray">grisé au journal</Badge>}
</Group>
<Text size="sm" ff="monospace" fw={600}>{lisible(ouverte.debut)} → {lisible(ouverte.fin)} UTC</Text>
{ouverte.message ? <>
<Champ nom="Capteurs">{ouverte.capteurs.length ? <>
{ouverte.cibles.length > 0 && <div>Cibles ({ouverte.cibles.length}) : {ouverte.cibles.join(", ")}</div>}
{ouverte.references.length > 0 && <div>Références ({ouverte.references.length}) : {ouverte.references.join(", ")}</div>}
</> : "tous les capteurs"}</Champ>
<Champ nom="Message">{ouverte.message}</Champ>
<Champ nom="Action">{ouverte.action}</Champ>
</> : <Champ nom="Description">{ouverte.description}</Champ>}
<Group>
<Button size="xs" variant="default" onClick={() => ouvrir(null)}>Fermer</Button>
{ouverte.analyse && <Button size="xs" variant="light" onClick={() => setAnalyse(ouverte.analyse)}>Voir le rapport</Button>}
</Group>
</Stack>
</Card>
)}
{ouverte && edit && (
<Card withBorder bg="var(--mantine-color-default-hover)">
<Stack gap="xs">
<Group gap="sm" align="flex-end">
<TextInput label="Du (UTC)" type="datetime-local" step={60} value={edit.debut} onChange={e => setEdit({ ...edit, debut: e.currentTarget.value })} />
<TextInput label="Au (UTC)" type="datetime-local" step={60} value={edit.fin} onChange={e => setEdit({ ...edit, fin: e.currentTarget.value })} />
<NativeSelect label="Famille" data={CHOIX_FAMILLE} value={edit.categorie} onChange={e => setEdit({ ...edit, categorie: e.currentTarget.value })} />
</Group>
<Textarea autosize minRows={3} value={edit.texte} onChange={e => setEdit({ ...edit, texte: e.currentTarget.value })} />
<Group gap="sm">
<Button onClick={enregistrer} disabled={!peutEnregistrer}>Enregistrer</Button>
<Button variant="default" onClick={() => ouvrir(null)}>Fermer</Button>
{ouverte.analyse && <Button variant="light" onClick={() => setAnalyse(ouverte.analyse)}>Voir le rapport</Button>}
<Text size="sm" c="teal">{note}</Text>
<Button color="red" variant="light" ml="auto" onClick={supprimer}>Supprimer</Button>
</Group>
</Stack>
</Card>
)}
</div>
{!lecteur && <>
<Text size="sm">{choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : "Glisser sur la barre des étiquettes pour sélectionner la plage à analyser."}</Text>
<Textarea autosize minRows={2} placeholder="Indices pour l'analyste (facultatif) : ce que tu as vu, ce qu'il faut regarder"
value={indices} onChange={e => setIndices(e.currentTarget.value)} />
<Group><Button onClick={analyser} disabled={!(choix && choix[0] < choix[1])}>Analyser la plage</Button></Group>
</>}
{analyse && <Analyse key={analyse} nom={analyse} sombre={sombre} fini={() => setRev(r => r + 1)} fermer={() => setAnalyse(null)} />}
</Stack>
</Card>
);
}
// Le fil d'un agent (analyste, optimisation) : les messages de l'utilisateur (« › ») en gras, le reste en petit, défilé jusqu'en bas
function Fil({ lignes }) {
const fil = useRef();
useEffect(() => { if (fil.current) fil.current.scrollTop = fil.current.scrollHeight; }, [lignes.length]);
if (!lignes.length) return null;
return (
<div ref={fil} style={{ maxHeight: 260, overflowY: "auto" }}>
{lignes.map((l, i) => l.startsWith("› ")
? <Text key={i} size="sm" fw={500} mt={6}>{l}</Text>
: <Text key={i} size="xs" ff="monospace" c="dimmed" style={{ whiteSpace: "pre-wrap" }}>{l}</Text>)}
</div>
);
}
// Un markdown rendu par le serveur (rapport, bilan), à la hauteur de son contenu une fois ses images chargées
function Page({ titre, src }) {
const cadre = useRef();
const ajuste = () => { const b = cadre.current?.contentDocument?.body; if (b) cadre.current.style.height = `${b.scrollHeight + 20}px`; };
return <iframe ref={cadre} title={titre} sandbox="allow-same-origin" onLoad={ajuste} style={{ border: 0, width: "100%", height: 400 }} src={src} />;
}
const COULEUR_ETAT = { "en cours": "blue", fini: "teal", erreur: "red", interrompue: "orange" };
// Une analyse de l'onglet Analysis : son fil (relu toutes les 3 s tant qu'elle travaille), son rapport, et un message à
// l'analyste, qui reprend sa session ; à la fin de chaque tour, les étiquettes se relisent. Une analyse finie s'optimise
// (/detector-learner <analyse>, D-148) : le fil de la séance, puis son bilan sous le rapport
function Analyse({ nom, sombre, fini, fermer }) {
const [a, setA] = useState(null), [tour, setTour] = useState(0), [texte, setTexte] = useState("");
const boite = useRef(), charge = !!a;
useEffect(() => { if (charge) boite.current?.scrollIntoView({ behavior: "smooth", block: "start" }); }, [nom, charge]); // ouverte : on la voit
useEffect(() => {
let vivant = true, minuterie;
const lire = () => appel(`/api/analyses/${nom}`).then(r => {
if (!vivant || !r) return;
setA(r);
if (r.etat === "en cours" || r.optimisation?.etat === "en cours") minuterie = setTimeout(lire, 3000);
else if (r.versees !== null) fini();
});
lire();
return () => { vivant = false; clearTimeout(minuterie); };
}, [nom, tour]);
async function envoyer() {
if (await appel(`/api/analyses/${nom}/message`, "POST", { texte }) == null) return; // le texte reste dans le champ
setTexte(""); setTour(t => t + 1);
}
async function optimiser() {
if (await appel(`/api/analyses/${nom}/optimiser`, "POST") != null) setTour(t => t + 1);
}
if (!a) return <Loader size="sm" />;
const d = a.demande, o = a.optimisation, occupe = a.etat === "en cours", optimise = o?.etat === "en cours";
const au = new Date(Date.parse(d.fin.slice(0, 10)) + 864e5).toISOString().slice(0, 10);
return (
<Card withBorder ref={boite}>
<Stack gap="xs">
<Group justify="space-between">
<Group gap="xs">
<Title order={5}>Analyse {lisible(d.debut)} → {lisible(d.fin)} UTC</Title>
<Badge color={COULEUR_ETAT[a.etat] || "gray"}>{a.etat}</Badge>
{occupe && <Loader size="xs" />}
</Group>
<Group gap="xs">
{a.etat === "fini" && <Tooltip label="Améliorer les détecteurs, puis les outils de lecture, depuis cette analyse (/detector-learner)">
<Button size="xs" variant="light" onClick={optimiser} disabled={optimise}>Optimiser les détecteurs</Button></Tooltip>}
<ActionIcon variant="subtle" color="gray" aria-label="Fermer le rapport" onClick={fermer}><IconX size={16} /></ActionIcon>
</Group>
</Group>
{d.indices && <Text size="sm" c="dimmed">Indices : {d.indices}</Text>}
{a.etat === "interrompue" && <Text size="sm" c="orange">Arrêtée avec le serveur avant la fin.{a.dialogue
? " Sa session est gardée : écrire « continue » ci-dessous pour la reprendre là où elle en était." : ""}</Text>}
{a.versees !== null && a.etat === "fini" && <Text size="sm">{a.versees} étiquette(s) de cette analyse dans labeling/auto/{d.station}.jsonl, à relire.</Text>}
{a.rapport && <Page titre="Rapport" src={`/api/analyses/${nom}/rapport.html?sombre=${sombre}&v=${a.rapport}`} />}
<Fil lignes={a.lignes} />
{a.dialogue && (
<Group align="flex-end" gap="sm" wrap="nowrap">
<Textarea autosize minRows={1} style={{ flex: 1 }} placeholder="Une question, une correction pour l'analyste"
value={texte} onChange={e => setTexte(e.currentTarget.value)} />
<Button onClick={envoyer} disabled={occupe || optimise || !texte.trim()}>Envoyer</Button>
</Group>
)}
{o && (
<Stack gap="xs" mt="sm">
<Group gap="xs">
<Title order={5}>Optimisation</Title>
<Badge color={COULEUR_ETAT[o.etat] || "gray"}>{o.etat}</Badge>
{optimise && <Loader size="xs" />}
</Group>
{o.etat === "interrompue" && <Text size="sm" c="orange">Arrêtée avec le serveur ; la relancer par le bouton.</Text>}
<Fil lignes={o.lignes} />
{o.bilan && <Page titre="Bilan" src={`/api/analyses/${nom}/bilan.html?sombre=${sombre}&v=${o.bilan}`} />}
{o.bilan && <Text size="xs" c="dimmed" ff="monospace">python3 detectors-view/compare.py data/{d.station} --du {d.debut.slice(0, 10)} --au {au}</Text>}
</Stack>
)}
<Text size="xs" c="dimmed">labeling/auto/analyses/{nom}/</Text>
</Stack>
</Card>
);
}
+240
View File
@@ -0,0 +1,240 @@
import { useEffect, useRef, useState } from "react";
import { ActionIcon, Card, Group, Input, Loader, Stack, Text, Tooltip } from "@mantine/core";
import { IconArrowLeft, IconArrowRight, IconChevronLeft, IconChevronRight } from "@tabler/icons-react";
import { appel } from "../commun.jsx";
// Les images de la station et de la plage choisies ; compacte : à la largeur d'une colonne (page Data), au format de l'image ;
// basculer : la flèche qui agrandit l'image vers la gauche (large) ou la ramène ; instant {t} : montrer la première image à t ou après
// ({t, proche} : la plus proche de t, avant ou après)
export function ImagesDe({ selection, compacte, large, basculer, instant }) {
const [donnees, setDonnees] = useState(null), [charge, setCharge] = useState(false);
const { station, du, au } = selection;
useEffect(() => {
setDonnees(null);
if (!station) return;
setCharge(true);
appel(`/api/images?${new URLSearchParams({ station, du, au })}`).then(d => { setDonnees(d); setCharge(false); });
}, [station, du, au]);
if (charge) return <Loader />;
if (donnees && !donnees.images.length) return <Text size="sm" c="dimmed">Aucune image de {station} sur cette plage.</Text>;
return donnees && <Visionneuse key={`${station}${du}${au}`} station={station} d={donnees} compacte={compacte} large={large} basculer={basculer} instant={instant} />;
}
function Visionneuse({ station, d, compacte, large, basculer, instant }) {
const r = { cadre: useRef(), couche: useRef(), img: useRef(), marques: useRef(), vecteurs: useRef(), glis: useRef(),
heure: useRef(), noms: useRef(), barre: useRef(), bande: useRef(), plage: useRef(), echelle: useRef(),
prec: useRef(), suiv: useRef(), montre: useRef() };
const XY = d.positions, refs = new Set(d.references), avecPositions = Object.keys(XY).length > 0;
useEffect(() => installer(r, station, d), [d]);
useEffect(() => { // « AAAA-MM-JJTHH:MMZ » face aux heures des images, « AAAA-MM-JJ HH:MM » (UTC)
if (!instant) return;
const t = instant.t.slice(0, 16).replace("T", " "), i = d.images.findIndex(im => im.t >= t);
const ms = s => Date.parse(s.slice(0, 16).replace(" ", "T") + "Z"), ecart = j => Math.abs(ms(d.images[j].t) - ms(t));
if (instant.proche && i !== 0) r.montre.current(i < 0 || ecart(i - 1) <= ecart(i) ? (i < 0 ? d.images.length : i) - 1 : i);
else r.montre.current(i < 0 ? d.images.length - 1 : i);
}, [instant, d]);
return (
<Card shadow="sm" withBorder padding={0} className="visionneuse">
{basculer && (
<Tooltip label={large ? "Réduire l'image" : "Agrandir l'image"}>
<ActionIcon className="agrandir" variant="filled" color="dark" aria-label={large ? "Réduire l'image" : "Agrandir l'image"} onClick={basculer}>
{large ? <IconArrowRight size={18} /> : <IconArrowLeft size={18} />}
</ActionIcon>
</Tooltip>
)}
<div className={compacte ? "cadre compacte" : "cadre"} ref={r.cadre}>
<div className="couche" ref={r.couche}>
<img ref={r.img} alt="" draggable="false" />
<svg className="marques" ref={r.marques} style={{ display: "none" }}>
{Object.entries(XY).map(([s, [x, y]]) => (
<g key={s} className={refs.has(s) ? "ref" : "cible"}>
<circle cx={x} cy={y} r=".7em" /><text x={x} y={y} dy="-1em">{s}</text>
</g>
))}
</svg>
<svg className="vecteurs" ref={r.vecteurs} style={{ display: "none" }}>
<defs><marker id="pointe" viewBox="0 0 10 14" refX="9" refY="7" markerWidth="5" markerHeight="7" orient="auto">
<path d="M0,0 L10,7 L0,14 z" fill="#2ecc40" /></marker></defs>
</svg>
</div>
</div>
<Stack gap={6} p="md">
<Group gap="sm" wrap="nowrap">
<ActionIcon ref={r.prec} variant="light" aria-label="Image précédente"><IconChevronLeft size={18} /></ActionIcon>
<input ref={r.glis} className="glisseur" type="range" min="0" max={d.images.length - 1} defaultValue="0" />
<ActionIcon ref={r.suiv} variant="light" aria-label="Image suivante"><IconChevronRight size={18} /></ActionIcon>
</Group>
<div className="barre-plages" ref={r.barre}><div className="bande" ref={r.bande} style={{ display: "none" }} /></div>
<Group gap="lg" justify="space-between">
<Text ref={r.heure} ff="monospace" size="sm" />
<Group gap="md">
<label className="case"><input type="checkbox" ref={r.noms} disabled={!avecPositions} /> Noms</label>
{avecPositions
? <span className="legende"><span className="cible">○ Cible</span> <span className="ref">◌ Référence</span></span>
: <Text size="sm" c="dimmed">x, y ne sont pas des positions dans l'image sur cette station</Text>}
</Group>
</Group>
<Group gap="lg" justify="space-between">
<Text ref={r.plage} size="sm" />
<Group gap="xs" wrap="nowrap">
<Text size="sm">Flèches ×</Text>
<Input ref={r.echelle} type="number" min={1} defaultValue={100} w={90} size="xs" />
</Group>
</Group>
<Text size="xs" c="dimmed">← → image · molette : zoom · glisser : se déplacer · double clic : image entière · flèche :
corr_x, corr_y à la fin moins au début (px), dans les axes de l'image</Text>
</Stack>
</Card>
);
}
// Le code de view/view.py (PAGE_JS), sur les éléments de la page -> la fonction qui défait ce qu'il a installé
function installer(r, station, d) {
const IM = d.images.map(i => ({ t: i.t, src: `/api/image/${encodeURIComponent(station)}/${encodeURIComponent(i.nom)}` }));
const C = d.corr, XY = d.positions;
const cadre = r.cadre.current, couche = r.couche.current, img = r.img.current, glis = r.glis.current, heure = r.heure.current;
const marques = r.marques.current, vecteurs = r.vecteurs.current, labels = r.noms.current;
const barre = r.barre.current, bande = r.bande.current, plage = r.plage.current, echelle = r.echelle.current;
let V = 0, Z = { k: 1, x: 0, y: 0 }, P = null;
function zoom() {
Z.x = Math.min(0, Math.max(1 - Z.k, Z.x)); // l'image couvre toujours le cadre : on ne la perd pas en la glissant
Z.y = Math.min(0, Math.max(1 - Z.k, Z.y));
couche.style.transform = `translate(${Z.x * 100}%, ${Z.y * 100}%) scale(${Z.k})`;
// Les noms restent à 12 px à l'écran : les tailles des marques sont en em, et 1 px du svg vaut 1 px de l'image.
const W = img.naturalWidth, H = img.naturalHeight;
if (W) marques.style.fontSize = vecteurs.style.fontSize = `${12 / (Z.k * Math.min(cadre.clientWidth / W, cadre.clientHeight / H))}px`;
cale();
}
const affiche = () => { marques.style.display = labels.checked && img.naturalWidth ? "" : "none"; };
labels.onchange = affiche;
r.montre.current = i => montre(i); // pour la page Data : l'image du début d'un événement
function montre(i) {
V = Math.max(0, Math.min(IM.length - 1, i));
glis.value = V;
img.src = IM[V].src;
for (const n of [V - 1, V + 1]) if (IM[n]) new Image().src = IM[n].src; // les voisines, en cache
}
// L'heure change avec l'image, pas avant : l'image d'avant reste affichée tant que la nouvelle se charge.
img.onload = () => {
heure.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length})`;
marques.setAttribute("viewBox", `0 0 ${img.naturalWidth} ${img.naturalHeight}`); // cadré comme l'image, object-fit: contain
vecteurs.setAttribute("viewBox", marques.getAttribute("viewBox"));
fleches(); zoom(); affiche();
};
img.onerror = () => {
img.removeAttribute("src");
heure.textContent = `${IM[V].t} UTC (${V + 1}/${IM.length}) : image illisible`;
affiche();
};
glis.oninput = () => montre(+glis.value);
r.prec.current.onclick = () => montre(V - 1);
r.suiv.current.onclick = () => montre(V + 1);
const clavier = e => {
if (!glis.offsetParent // la page Data cachée (une autre page affichée) : les flèches ne sont pas pour elle
|| e.target.matches("textarea, select, input:not([type=range])") || !["ArrowLeft", "ArrowRight"].includes(e.key)) return;
e.preventDefault(); // sinon le glisseur, s'il a le focus, avance une seconde fois
montre(V + (e.key === "ArrowLeft" ? -1 : 1));
};
document.addEventListener("keydown", clavier);
const molette = ev => { // zoom autour du pointeur
ev.preventDefault();
const b = cadre.getBoundingClientRect(), u = (ev.clientX - b.left) / b.width, v = (ev.clientY - b.top) / b.height;
const k = Math.min(40, Math.max(1, Z.k * Math.exp(-ev.deltaY / 500)));
Z = { k, x: u - k * (u - Z.x) / Z.k, y: v - k * (v - Z.y) / Z.k };
zoom();
};
cadre.addEventListener("wheel", molette, { passive: false });
cadre.onpointerdown = ev => { // déplacement à la souris
cadre.setPointerCapture(ev.pointerId);
const b = cadre.getBoundingClientRect(), de = { ...Z, cx: ev.clientX, cy: ev.clientY };
cadre.onpointermove = e => { Z.x = de.x + (e.clientX - de.cx) / b.width; Z.y = de.y + (e.clientY - de.cy) / b.height; zoom(); };
cadre.onpointerup = () => { cadre.onpointermove = null; };
};
cadre.ondblclick = () => { Z = { k: 1, x: 0, y: 0 }; zoom(); };
// La plage : glisser sur la barre, alignée sur le glisseur ; les flèches vont de la position du capteur à position + k × déplacement.
function cale() {
const g = glis.getBoundingClientRect(), b = barre.getBoundingClientRect();
barre.style.marginLeft = `${(parseFloat(barre.style.marginLeft) || 0) + g.left - b.left}px`; barre.style.width = `${g.width}px`;
}
const indice = ev => { const b = barre.getBoundingClientRect(); return Math.round(Math.max(0, Math.min(1, (ev.clientX - b.left) / b.width)) * (IM.length - 1)); };
function bandeau() {
const n = Math.max(1, IM.length - 1), [i, j] = P ? [Math.min(...P), Math.max(...P)] : [0, 0];
bande.style.left = `${i / n * 100}%`; bande.style.width = `${(j - i) / n * 100}%`; bande.style.display = P ? "" : "none";
}
function deplacements() {
if (!P || P[0] === P[1]) return {};
const [i, j] = [Math.min(...P), Math.max(...P)], dep = {};
for (const [s, c] of Object.entries(C)) if (c[i] && c[j]) dep[s] = [c[j][0] - c[i][0], c[j][1] - c[i][1]];
return dep;
}
function fleches() {
const dep = deplacements(), W = img.naturalWidth, k = +echelle.value;
vecteurs.style.display = Object.keys(dep).length && W ? "" : "none";
vecteurs.querySelectorAll("line").forEach(l => l.remove());
for (const [s, [dx, dy]] of Object.entries(dep)) {
const [x, y] = XY[s], l = document.createElementNS("http://www.w3.org/2000/svg", "line");
Object.entries({ x1: x, y1: y, x2: x + k * dx, y2: y + k * dy }).forEach(([a, v]) => l.setAttribute(a, v));
const titre = document.createElementNS("http://www.w3.org/2000/svg", "title");
titre.textContent = `${s} : corr_x ${dx.toFixed(3)} px, corr_y ${dy.toFixed(3)} px`;
l.appendChild(titre);
vecteurs.appendChild(l);
}
if (P && P[0] !== P[1]) {
const [i, j] = [Math.min(...P), Math.max(...P)], manque = Object.keys(C).filter(s => !(s in dep));
plage.textContent = `${IM[i].t} → ${IM[j].t} UTC` + (manque.length ? ` · pas de mesure valide à une borne : ${manque.join(", ")}` : "");
} else plage.textContent = Object.keys(C).length ? "Glisser sur la barre pour choisir une plage" : "Pas de flèches : x, y ne sont pas des positions dans l'image";
}
// Ce que saisit le pointeur sur une plage placée : 0 son début, 1 sa fin (à 6 px près), 2 la bande entière, null rien.
function prise(ev) {
if (!P) return null;
const x = ev.clientX - barre.getBoundingClientRect().left, px = i => i / Math.max(1, IM.length - 1) * barre.clientWidth;
return Math.abs(x - px(P[0])) < 6 ? 0 : Math.abs(x - px(P[1])) < 6 ? 1 : x > px(P[0]) && x < px(P[1]) ? 2 : null;
}
barre.onpointermove = e => {
if (!barre.hasPointerCapture(e.pointerId)) barre.style.cursor = ["ew-resize", "ew-resize", "grab"][prise(e)] || "crosshair";
};
barre.onpointerdown = ev => {
barre.setPointerCapture(ev.pointerId);
const g = prise(ev), i0 = indice(ev), de = P && [...P];
if (g === null) P = [i0, i0];
bandeau(); montre(i0);
const survol = barre.onpointermove;
barre.onpointermove = e => {
const i = indice(e);
if (g === 2) { // la bande glisse sans sortir de la barre
const dd = Math.max(-de[0], Math.min(IM.length - 1 - de[1], i - i0));
P = [de[0] + dd, de[1] + dd];
} else P[g === null ? 1 : g] = i;
bandeau(); fleches(); montre(i);
};
barre.onpointerup = () => {
barre.onpointermove = survol;
P = [Math.min(...P), Math.max(...P)];
if (P[0] === P[1]) P = null;
else if (g === null) { // nouvelle plage, facteur proposé : la plus grande flèche fait 8 % de la largeur de l'image
const m = Math.max(...Object.values(deplacements()).map(([a, b]) => Math.hypot(a, b)), 0);
if (m && img.naturalWidth) echelle.value = Math.max(1, Math.round(0.08 * img.naturalWidth / m));
}
bandeau(); fleches();
};
};
echelle.oninput = fleches;
addEventListener("resize", zoom);
const observateur = new ResizeObserver(zoom); // la barre latérale qui se replie change la largeur sans resize
observateur.observe(cadre);
montre(0); cale(); fleches();
return () => {
document.removeEventListener("keydown", clavier);
removeEventListener("resize", zoom);
cadre.removeEventListener("wheel", molette);
observateur.disconnect();
};
}
+39
View File
@@ -0,0 +1,39 @@
/* Le reste du visuel vient de Mantine (thème dans main.jsx) */
.entete { background: #3d4977; color: #fff; border-bottom: 0; }
.message { white-space: pre-wrap; overflow-wrap: anywhere; }
.message.support, .message.relai { background: var(--mantine-color-aimsight-light); }
.message.analyste { background: var(--mantine-color-teal-light); }
.message.marc { background: var(--mantine-color-yellow-light); align-self: flex-end; max-width: 85%; }
.message.relai { border-left: 3px solid var(--mantine-color-aimsight-filled); }
.rapport { width: 100%; height: 78vh; border: 0; display: block; background: #fff; }
/* La page Images (view/view.py) */
.cadre { position: relative; height: calc(100vh - 420px); min-height: 300px; background: #000; overflow: hidden; cursor: grab;
touch-action: none; border-radius: var(--mantine-radius-md) var(--mantine-radius-md) 0 0; }
.cadre:active { cursor: grabbing; }
.cadre.compacte { height: auto; min-height: 0; aspect-ratio: 3 / 2; } /* page Data : la colonne de droite */
.couche { position: absolute; inset: 0; transform-origin: 0 0; }
.couche > * { position: absolute; inset: 0; width: 100%; height: 100%; }
.couche img { object-fit: contain; user-select: none; }
.marques { overflow: visible; pointer-events: none; font-family: sans-serif; }
.marques circle { fill: none; stroke: currentColor; stroke-width: .12em; }
.marques .ref circle { stroke-dasharray: .3em .2em; }
.marques text { fill: currentColor; text-anchor: middle; paint-order: stroke; stroke: rgba(0, 0, 0, .85); stroke-width: .25em; stroke-linejoin: round; }
.cible { color: #ffd400; } .ref { color: #3cc8ff; }
.legende { background: #000; padding: 2px 8px; border-radius: 3px; white-space: nowrap; font-size: var(--mantine-font-size-sm); }
.vecteurs { overflow: visible; pointer-events: none; }
.vecteurs line { stroke: #2ecc40; stroke-width: .18em; marker-end: url(#pointe); }
.glisseur { flex: 1; min-width: 0; accent-color: var(--mantine-primary-color-filled); }
.barre-plages { position: relative; height: 22px; background: var(--mantine-color-default-hover); border: 1px solid var(--mantine-color-default-border);
border-radius: 3px; cursor: crosshair; touch-action: none; }
.bande { position: absolute; top: 0; bottom: 0; background: #e0730080; border-left: 2px solid #e07300; border-right: 2px solid #e07300; }
.case { display: flex; gap: 6px; align-items: center; font-size: var(--mantine-font-size-sm); }
/* page Data : le menu d'un plot dans sa marge du haut ; les images restent en vue quand on fait défiler les plots */
.plot { position: relative; }
.plot-menu { position: absolute; top: 2px; left: 56px; z-index: 2; }
.colle { position: sticky; top: calc(64px + var(--mantine-spacing-lg)); }
/* page Data : la flèche qui agrandit l'image, en haut à gauche de l'image (du côté des plots qu'elle pousse) */
.visionneuse { position: relative; }
.agrandir { position: absolute; top: 8px; left: 8px; z-index: 3; opacity: .75; }
.agrandir:hover { opacity: 1; }
.data-grille .mantine-Grid-col { transition: flex-basis .35s ease, max-width .35s ease; min-width: 0; } /* l'image qui grandit pousse les plots */
+8
View File
@@ -0,0 +1,8 @@
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
// npm run dev : la page sur http://localhost:5173, l'API demandée au serveur Python (port 8770)
export default defineConfig({
plugins: [react()],
server: { proxy: { "/api": "http://127.0.0.1:8770" } },
});