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:
1 parent
8d5dc4a31c
commit
56f0c902d7
112 files changed
+13047
No files matched your search
@@ -0,0 +1,3 @@
|
||||
web/node_modules/
|
||||
web/dist/
|
||||
__pycache__/
|
||||
@@ -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).
|
||||
@@ -0,0 +1,3 @@
|
||||
fastapi
|
||||
uvicorn
|
||||
markdown
|
||||
@@ -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 `` 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)
|
||||
@@ -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__)
|
||||
@@ -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)
|
||||
@@ -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")
|
||||
@@ -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>
|
||||
Generated
+1192
File diff suppressed because it is too large.
Load diff
@@ -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"
|
||||
}
|
||||
}
|
||||
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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>,
|
||||
);
|
||||
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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();
|
||||
};
|
||||
}
|
||||
@@ -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 */
|
||||
@@ -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" } },
|
||||
});
|
||||
Reference in new issue
Block a user