From bd93e708d20dae6b448b96f926d210e0428bc26d Mon Sep 17 00:00:00 2001 From: maxime Date: Thu, 5 Nov 2026 14:25:57 +0100 Subject: [PATCH] app/: the web app in its own folder, with the Images and Labeling pages (D-138) - app/serveur/ (FastAPI) and app/web/ (React, Mantine) moved out of API/, which keeps only the agents; the Support page drives them - Images page: view.py in React (slider, zoom, sensor names, displacement arrows on a range) - Labeling page: labeling.py in React (two aligned plots, label bar, add, edit, delete); labels are written to labeling/{auto,manual}/ of the repo (AIMSIGHT_LABELS) - shared station and date selector kept in the address; buttons from a support session - app/serveur/station.py: the data of both pages, copied computations listed in app/README.md - app/serveur/check.py: server and station checks (labels in a temporary folder) Co-Authored-By: Claude Opus 5.5 --- API/.gitignore | 2 - API/README.md | 19 +- API/requirements.txt | 2 - API/support/check.py | 58 +--- API/web/src/style.css | 8 - CLAUDE.md | 3 +- app/.gitignore | 3 + app/README.md | 46 ++++ ...26-11-05-pages-images-etiquetage-design.md | 76 ++++++ app/requirements.txt | 2 + app/serveur/check.py | 116 ++++++++ {API/support => app/serveur}/serveur.py | 74 ++++- app/serveur/station.py | 257 ++++++++++++++++++ {API => app}/web/index.html | 0 {API => app}/web/package-lock.json | 6 + {API => app}/web/package.json | 1 + app/web/src/App.jsx | 117 ++++++++ app/web/src/commun.jsx | 52 ++++ {API => app}/web/src/main.jsx | 0 app/web/src/pages/Etiquetage.jsx | 212 +++++++++++++++ app/web/src/pages/Images.jsx | 231 ++++++++++++++++ .../App.jsx => app/web/src/pages/Support.jsx | 138 +++------- app/web/src/style.css | 29 ++ {API => app}/web/vite.config.js | 0 docs/decisions.md | 9 +- run.md | 8 +- 26 files changed, 1263 insertions(+), 206 deletions(-) delete mode 100644 API/web/src/style.css create mode 100644 app/.gitignore create mode 100644 app/README.md create mode 100644 app/docs/2026-11-05-pages-images-etiquetage-design.md create mode 100644 app/requirements.txt create mode 100644 app/serveur/check.py rename {API/support => app/serveur}/serveur.py (70%) create mode 100644 app/serveur/station.py rename {API => app}/web/index.html (100%) rename {API => app}/web/package-lock.json (99%) rename {API => app}/web/package.json (92%) create mode 100644 app/web/src/App.jsx create mode 100644 app/web/src/commun.jsx rename {API => app}/web/src/main.jsx (100%) create mode 100644 app/web/src/pages/Etiquetage.jsx create mode 100644 app/web/src/pages/Images.jsx rename API/web/src/App.jsx => app/web/src/pages/Support.jsx (50%) create mode 100644 app/web/src/style.css rename {API => app}/web/vite.config.js (100%) diff --git a/API/.gitignore b/API/.gitignore index 0a4a079..219ff4e 100644 --- a/API/.gitignore +++ b/API/.gitignore @@ -3,5 +3,3 @@ __pycache__/ tools/typst/documents/ tools/typst/build/ -web/node_modules/ -web/dist/ diff --git a/API/README.md b/API/README.md index c85bf95..44ab808 100644 --- a/API/README.md +++ b/API/README.md @@ -22,21 +22,9 @@ LANGSMITH_ENDPOINT=https://eu.api.smith.langchain.com LANGSMITH_PROJECT=Support ``` -## Lancer la web app (D-137) +## La web app -Une fois, et après chaque changement de la page : construire le front React (Node 22). - -```bash -cd API/web && npm install && npm run build -``` - -Puis le serveur, qui sert la page et l'API : - -```bash -API/.venv/bin/python API/support/serveur.py -``` - -La page s'ouvre sur `http://127.0.0.1:8770`. Une séance à la fois ; elle est gardée dans `cases/__/`. Réglages par variables : `AIMSIGHT_DATA` (données, défaut `data/` du dépôt), `AIMSIGHT_CASES` (séances, défaut `API/cases/`), `AIMSIGHT_PORT` (8770). Pour travailler sur la page : `npm run dev` dans `API/web/` (http://localhost:5173, rechargée à chaque enregistrement), le serveur Python lancé à côté. +La page qui pilote ces agents est dans `app/` à la racine du dépôt (D-138) : sa doc, `app/README.md`. ## Les dossiers @@ -44,6 +32,5 @@ La page s'ouvre sur `http://127.0.0.1:8770`. Une séance à la fois ; elle est g - `prompts/` : les prompts système du support et de l'analyste (en balises) ; le savoir de `knowledge/` y est ajouté au chargement. - `knowledge/` : ce que lisent les agents, copié du projet (pour l'analyste, les cartes dans le prompt, le reste à la demande par `lire_document`, D-136) : `analyste/` (familles, carte des étiquettes, connaissances, outils de lecture, règles de preuve), `support/` (présentation, modèle Typst, rédaction). - `tools/` : copies des outils de lecture (`agent-tools/`), des détecteurs (`detectors/`), des figures (`figures/`), de la fabrique Typst (`typst/brand/`) ; `journal.py`, les événements des détecteurs avec leurs capteurs ; `stabilite.py`, la médiane de corr_y jour par jour et son étendue, par cible. -- `web/` : la page React, ses composants de Mantine (MIT : en-tête, barre latérale repliable, tiroir sur téléphone, cartes, notifications, mode sombre) ; `src/App.jsx` : la saisie, les deux fils, le rapport ; `src/main.jsx` : le thème (bleu #5383ff, Roboto) ; `dist/` et `node_modules/` hors de git. -- `support/` : le serveur FastAPI, les deux agents, leurs outils, `check.py` (vérifications : `API/.venv/bin/python API/support/check.py`). +- `support/` : les deux agents (`agent.py`, la séance `seance.py`), leurs outils, `check.py` (vérifications : `API/.venv/bin/python API/support/check.py`). - `cases/` : une séance par dossier : le mail, le contexte, les deux historiques, les figures, le source Typst, les PDF par version. Contient des mails et des images de clients. diff --git a/API/requirements.txt b/API/requirements.txt index 73d2112..95b2c24 100644 --- a/API/requirements.txt +++ b/API/requirements.txt @@ -1,5 +1,3 @@ anthropic langsmith matplotlib -fastapi -uvicorn diff --git a/API/support/check.py b/API/support/check.py index dd766fa..4d59023 100644 --- a/API/support/check.py +++ b/API/support/check.py @@ -262,63 +262,7 @@ def check_stations_dans_la_seance(): assert "stations" in AVEC_SORTIE -def check_serveur(): - # le vrai serveur sur un port libre, une séance au faux client : la garde, l'analyse, le flux, le PDF absent - import json - import shutil - import socket - import threading - import time - import urllib.request - from urllib.error import HTTPError - import uvicorn - import seance - import serveur - with socket.socket() as so: - so.bind(("127.0.0.1", 0)) - port = so.getsockname()[1] - cases = seance.CASES - seance.CASES, serveur.CLIENT = seance_temporaire(), FauxClient(reponse([Bloc(type="text", text="Bonjour Marc")], "end_turn")) - 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): - r = urllib.request.Request(base + chemin, json.dumps(corps).encode() if corps is not None else None, - {"Content-Type": "application/json", **(entetes or {})}) - try: - with urllib.request.urlopen(r) as rep: - return rep.status - except HTTPError as e: - return e.code - try: - assert appel("/api/pdf", entetes={"Host": "evil.example:80"}) == 403 - assert appel("/api/analyser", {"mail": "x"}, {"Content-Type": "text/plain"}) == 403 - assert appel("/api/analyser", {"mail": " "}) == 400 - assert appel("/api/analyser", {"mail": "Bonjour", "contexte": "", "images": []}) == 200 - with urllib.request.urlopen(base + "/api/flux", timeout=10) as f: - premier, textes = None, [] - for ligne in f: - if ligne.startswith(b"data: "): - m = json.loads(ligne[6:]) - premier = premier or m - textes += [e["texte"] for e in m["evenements"]] - if "Bonjour Marc" in textes and not m["occupe"]["support"]: - break - assert premier["depuis"] == 0 and premier["id"], premier - assert appel("/api/pdf") == 404 - (serveur.etat["seance"].dossier / "v1.pdf").write_bytes(b"%PDF-1.4") - with urllib.request.urlopen(base + "/api/pdf") as rep: - assert rep.read() == b"%PDF-1.4" and rep.headers["Content-Disposition"].startswith("inline"), rep.headers - finally: - srv.should_exit = True - shutil.rmtree(seance.CASES) - seance.CASES = cases - - -CHECKS = [check_serveur, check_lire_document, check_cartes, check_stabilite, check_image_proche, check_max_tokens, check_sans_repli, check_capture_reduite, check_stations_dans_la_seance, check_boucle, check_erreur, check_cout, check_source, check_outil_qui_leve, check_lecture_refusee, +CHECKS = [check_lire_document, check_cartes, check_stabilite, check_image_proche, check_max_tokens, check_sans_repli, check_capture_reduite, check_stations_dans_la_seance, check_boucle, check_erreur, check_cout, check_source, check_outil_qui_leve, check_lecture_refusee, check_chemin, check_station_absente, check_detecteurs, check_plafond, check_image, check_compiler] if __name__ == "__main__": diff --git a/API/web/src/style.css b/API/web/src/style.css deleted file mode 100644 index 980d3b2..0000000 --- a/API/web/src/style.css +++ /dev/null @@ -1,8 +0,0 @@ -/* 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; } diff --git a/CLAUDE.md b/CLAUDE.md index 8f91b1c..d97c5e0 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -14,7 +14,7 @@ Cadrage du product owner : sous-projet G, santé des sites et notifications au c - **Maquettes du site** (D-022, D-039) : client « System Summary », une page par station, un bloc par domaine ; support « Home », une notification par station et par domaine Orange ou Red, liée à la vue client (D-025). - **Déplacements, le cap actuel : le journal du matin** (D-056). Une anomalie de déplacement est ce qui rend les courbes non plates : presque toujours un moment où il ne faut pas se fier aux données (pluie, buée, train, toile d'araignée, turbulence…), parfois un vrai mouvement (E-004, incident de Barcelone). Détecteurs élémentaires classés par catégorie (D-074), onglet `Journal` de la maquette Explore, amélioration par `/events-learner` (D-057), base d'events `events/` revue par `/review-event` (D-075). Les détecteurs s'alignent sur toutes les étiquettes de `labeling/auto/`, sans events (D-118) : l'`etiqueteur` étiquette en amont, puis `/detector-learner ` (D-116, D-132) : une famille sur toutes les stations, le `detectors-critic` juge les détecteurs face aux étiquettes, le `detectors-upgrader` les adapte, le `detectors-control` garde toutes les stations et familles ; l'analyste, le `tool-builder` et l'`event-builder` (D-088 à D-092, D-097) sont hors de la séance ; la carte des événements apprend de chaque event validé (D-087). Tout le suivi est dans le plan vivant `docs/superpowers/plans/2026-10-23-journal-du-matin.md`. - **Support** (D-079, D-113) : `/support ` répond à la question d'un client, et à elle seule (premier cas : LENZSPITZE, nuit du 26 au 27.10) ; `/support ` fait le rapport de situation de la station à partir de ses étiquettes (`labeling/auto/`), appuyé d'images ; `/presentation ` le met en diapositives PDF à la charte AIMsight, par la fabrique Typst `~/docfactory-presentation` (D-114). Rapports par mois. -- **Support par l'API Claude** (D-133), le passage à l'opérationnel : sous-projet autonome `API/`, séparé de `.claude/` ; une web app `support` (React et FastAPI, D-137), deux clients API (support, analyste), un PDF qui répond au mail du client ; workflow validé par l'utilisateur le 2026-11-05 sur un premier cas réel (Crissier, LENZSPITZE, `API/cases/`) ; la copie des détecteurs à rafraîchir après leur optimisation. Préalable : les détecteurs lisent la caméra et les métriques (point 78 du plan vivant). +- **Support par l'API Claude** (D-133), le passage à l'opérationnel : sous-projet autonome `API/`, séparé de `.claude/`, deux clients API (support, analyste), un PDF qui répond au mail du client ; workflow validé par l'utilisateur le 2026-11-05 sur un premier cas réel (Crissier, LENZSPITZE, `API/cases/`) ; la copie des détecteurs à rafraîchir après leur optimisation. La web app `app/` (React, Mantine, FastAPI, D-137, D-138) les pilote, et centralise le diagnostic manuel : pages Support, Images et Étiquetage. Préalable : les détecteurs lisent la caméra et les métriques (point 78 du plan vivant). - **Agent de diagnostic** (D-046, D-058, D-082) : gardé dans le doute, pour un cas que les détecteurs n'expliquent pas. - **En attente** : agents LLM côté serveur (D-027) et enquête par API (D-042), documents seulement ; communication avec la caméra (dev container, D-038), en attente de la doc de l'API REST ; détection des sauts et tendances (D-055, onglet `Displacements`), très expérimentale. - **Prochaine étape** : @@ -116,6 +116,7 @@ python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer . - `agent-diagnostic/` : consignes (`instructions.md`, 146 l) et rapports de l'agent de diagnostic (D-082). Appel : `@agent-diagnostic data// [question]`. - `support/` : un dossier par demande d'un client (D-079), `__/` : `demande.md`, `analyse.md`, `reponse.md` (le mail prêt à envoyer), GIF des images ; ou `__rapport-situation/` : `rapport.md`, ses images, `.typ` (le source) et `.pdf`, nom de la station en minuscules. Contient des mails et images de clients. - `API/` : le support par l'API Claude (D-133), un sous-projet autonome : sa doc dans `API/README.md`, ses copies dans `API/PROVENANCE.md` ; les agents Claude Code n'y lisent rien, et lui ne lit rien du reste du dépôt hors de `data/`. +- `app/` : la web app (D-137, D-138), sa doc dans `app/README.md` : `serveur/` (FastAPI), `web/` (React, Mantine) ; pages Support (pilote les agents de `API/`), Images et Étiquetage (comme `view.py` et `labeling.py`, elle écrit dans `labeling/`). - `extraction/` : pompage `pomper.py` des données de la plateforme (D-056), en lecture seule, lancé par l'utilisateur dans le dev container de l'application de référence `~/monitoring-dashboard` ; sans argument, il met à jour jusqu'à maintenant les stations de `stations.txt` (D-096) ; mode d'emploi `extraction/README.md`. ### Code, données, configuration diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 0000000..03a6d62 --- /dev/null +++ b/app/.gitignore @@ -0,0 +1,3 @@ +web/node_modules/ +web/dist/ +__pycache__/ diff --git a/app/README.md b/app/README.md new file mode 100644 index 0000000..5688b53 --- /dev/null +++ b/app/README.md @@ -0,0 +1,46 @@ +# La web app AIMsight + +L'outil interne du support et du diagnostic manuel (D-137, D-138) : trois pages dans la barre latérale. + +- **Support** : coller le mail du client et son contexte, Analyser ; les fils du support et de l'analyste (les agents de `API/`, `API/README.md`), le PDF par version. Dès que la séance a sa station, deux boutons ouvrent Images et Étiquetage sur elle. +- **Images** : 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 (cibles en jaune, références en bleu) ; une plage sur la barre sous le glisseur dessine la flèche de déplacement de chaque capteur (corr_x, corr_y, facteur modifiable). +- **Étiquetage** : comme `labeling/labeling.py` : deux plots alignés (déplacements, caméra, qualité, métriques système), la barre des étiquettes (`auto` ou `manual`) ; y glisser sélectionne une plage, puis famille, texte, Ajouter ; un clic ouvre une étiquette : bornes, famille, texte, Enregistrer, Supprimer. Écrit dans `labeling//.jsonl`. + +Images et Étiquetage partagent la station et la plage (UTC, Au exclue), dans l'adresse : `#/images?station=NIEDERHORN&du=2026-09-25&au=2026-10-08`. + +## Lancer + +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 des agents (`API/.venv`, plus `app/requirements.txt`) : + +```bash +API/.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_CASES` (séances, défaut `API/cases/`), `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` (séance, flux des agents, PDF, stations, images, courbes, étiquettes) ; ne répond qu'aux pages du poste (Host local, JSON déclaré). +- `serveur/station.py` : les données des pages Images et Étiquetage ; lecture seule sur `data/`, écrit seulement dans `labeling/{auto,manual}/`. +- `serveur/check.py` : vérifications, sans appel à l'API : `API/.venv/bin/python app/serveur/check.py`. +- `web/` : React (Vite) et Mantine ; `src/App.jsx` (en-tête, barre latérale, pages, adresse), `src/pages/` (une page par fichier), `src/commun.jsx` (requêtes, cartes, sélecteur), `src/main.jsx` (thème). Plotly ne se charge qu'avec Étiquetage. `dist/` et `node_modules/` hors de git. +- `docs/` : la conception des pages Images et Étiquetage. + +## Copies + +Le calcul des pages Images et Étiquetage reprend les outils du projet ; 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 : `API/tools/agent-tools/donnees.py`. diff --git a/app/docs/2026-11-05-pages-images-etiquetage-design.md b/app/docs/2026-11-05-pages-images-etiquetage-design.md new file mode 100644 index 0000000..5b7a105 --- /dev/null +++ b/app/docs/2026-11-05-pages-images-etiquetage-design.md @@ -0,0 +1,76 @@ +# Les pages Images et Étiquetage dans la web app support + +Conception validée par Marc le 2026-11-05 ; l'app a ensuite quitté `API/` pour `app/` (D-138). Complète D-133 et D-137. + +## L'intention + +Marc fait son diagnostic à la main avec deux outils du projet : `view/view.py` (les images de la caméra) et `labeling/labeling.py` (les courbes et les étiquettes). Il veut que **tout soit centralisé dans l'app** : la page Support, plus ces deux pages, refaites en React dans la même app (Mantine, FastAPI), avec les mêmes gestes. Pas de nouvelle fonction : les deux outils, à l'identique, dans l'app. + +## Les buts et les limites + +- **Buts** : trois pages dans la barre latérale (Support, Images, Étiquetage) ; un seul sélecteur de station et de dates pour Images et Étiquetage ; depuis une séance de support, un accès direct à Images et à Étiquetage sur la station du cas. +- **Hors du périmètre** : rien de neuf dans les deux pages (pas de nouveau plot, pas de nouvelle fonction d'image) ; pas de PostgreSQL ni d'authentification ; les anciens outils restent dans le dépôt (le projet Claude Code s'en sert : `run.sh`, `/review-labels`), Marc cesse simplement de les utiliser. +- **À éviter** : deux vérités pour les étiquettes. Les étiquettes restent dans `labeling/` du dépôt, là où les détecteurs et les agents les lisent ; l'app y écrit, rien n'est copié. + +## Ce que Marc a décidé + +- Les deux pages refaites en React dans l'app, pas intégrées telles quelles (2026-11-05). +- L'app écrit les étiquettes dans `labeling/` du projet (proposé, accepté avec React). + +## La navigation + +- **Barre latérale** : trois liens, Support, Images, Étiquetage, avec une icône chacun. La section « Séance » (état des agents, coût) ne s'affiche que sur la page Support. +- **L'adresse suit la page** : `#/support`, `#/images?station=LENZSPITZE&du=2026-10-26&au=2026-10-28`, `#/etiquetage?…`. Recharger garde la page, la station et les dates ; le bouton Retour du navigateur marche. Pas de bibliothèque de routage : un `hashchange` suffit pour trois pages. +- **Le sélecteur** (Images, Étiquetage) : en haut de la page, une ligne : Station (menu des dossiers de `data/`), Du, Au (dates UTC, Au exclue, vides : toute la période), Charger. Il est partagé : passer d'Images à Étiquetage garde la station et les dates, et recharge la page sur elles. +- **Depuis le support** : dès que la séance a sa station (`poser_station`), deux boutons en tête des fils, « Images » et « Étiquetage », ouvrent la page sur cette station et les 7 derniers jours de ses données (la séance ne garde pas la plage du client ; Marc la règle ensuite). + +## La page Images (comme `view.py`) + +- L'image dans un cadre noir : molette pour zoomer autour du pointeur (×1 à ×40), glisser pour se déplacer, double clic pour l'image entière ; le zoom reste d'une image à l'autre. +- Glisseur, ◀ ▶ et les flèches du clavier ; l'heure UTC et le rang (« 12/288 ») ; les deux images voisines préchargées ; l'heure change quand la nouvelle image est chargée ; une image illisible le dit. +- Case **Noms** : chaque capteur à sa position médiane sur la plage, cible en jaune, référence en bleu et cercle pointillé (référence : `reproj_err` rempli) ; les noms restent à 12 px à l'écran quel que soit le zoom ; case grisée, avec la phrase « x, y ne sont pas des positions dans l'image », sur les stations où x, y ne sont pas des pixels (NADELHORN par endroits). +- **La barre des plages** sous le glisseur : y glisser choisit une plage d'images ; une plage placée se modifie par ses bords ou se déplace en entier ; un clic hors d'elle l'efface. Chaque capteur porte alors sa flèche verte : corr_x, corr_y à la fin moins au début (mesure valide la plus proche de l'heure de l'image, à 30 min près), amplifiée par un facteur modifiable, proposé pour que la plus grande flèche fasse 8 % de la largeur de l'image ; au survol d'une flèche, ses valeurs ; la plage en texte, et les capteurs sans mesure valide à une borne. + +## La page Étiquetage (comme `labeling.py`) + +- **Étiquettes** : un menu, `auto` (celles de l'étiqueteur, par défaut) ou `manual` (celles de Marc). +- **Deux plots** l'un sous l'autre, chacun avec son menu, dans l'ordre de `labeling.py` : error_value, x, y, relative_x, relative_y, corr_x, corr_y, reproj_err, mouvement de la caméra, métriques de qualité, puis les métriques système numériques (sans les identifiants). À l'ouverture : corr_x en haut, corr_y en bas. Le zoom de l'un s'applique à l'autre et à la barre (mêmes abscisses, mêmes marges) ; les capteurs cachés et le zoom restent d'un plot à l'autre ; au survol : capteur, valeur, heure UTC. Les zones étiquetées grisées sur les deux plots, la sélection en bleu. +- **La barre des étiquettes** sous les plots : une barre par étiquette, couleur de sa famille, son texte dedans, celles qui se chevauchent sur des rangées différentes ; y glisser sélectionne une plage ; un clic sur une étiquette l'ouvre. +- **Ajouter** : la plage sélectionnée (en texte), la famille (menu, facultative : les six familles et « None »), le texte ; Ajouter écrit aussitôt une ligne dans `labeling//.jsonl`. Dans `auto`, l'étiquette reçoit son id stable (D-131). +- **Modifier** : l'étiquette ouverte montre ses bornes (UTC), sa famille, son texte ; Enregistrer (actif seulement si quelque chose a changé ; retire le champ `revue`, D-103), Fermer (demande confirmation si un changement n'est pas enregistré), Supprimer (avec confirmation). L'étiquette est retrouvée dans le fichier par son contenu, pas par son rang ; si le fichier a changé entre-temps, l'app le dit et ne touche à rien. Écriture par fichier temporaire puis remplacement. +- Les étiquettes sont relues à chaque chargement : la page montre toujours le fichier. + +## Le serveur + +Nouvelles routes de `app/serveur/serveur.py` (le calcul dans `app/serveur/station.py`), toutes en lecture seule sur `data/` : + +| Route | Rend | +|---|---| +| `GET /api/stations` | les dossiers de `data/` | +| `GET /api/images?station&du&au` | les images de la plage (heure, adresse), les positions médianes, les références, corr_x/corr_y de chaque capteur à l'heure de chaque image | +| `GET /api/image//` | une image de `data//images/` | +| `GET /api/courbes?station&du&au` | les plots de la page Étiquetage (heures une fois par série, valeurs, titres, couleurs) et les bornes de la plage | +| `GET /api/etiquettes?station&dossier` | les étiquettes du fichier | +| `POST`, `PUT`, `DELETE /api/etiquettes` | ajouter, modifier, retirer | + +- Station : seulement un dossier de `data/` ; `dossier` : `auto` ou `manual` ; image : seulement un fichier de `images/` (chemins contenus). +- La garde actuelle (Host local, JSON déclaré) s'étend à PUT et DELETE. +- Les calculs viennent des outils existants, **copiés** dans `app/serveur/station.py`, leur provenance dans `app/README.md` : `positions`, `references`, les couleurs des capteurs et de la pose (`detectors-view/detecteurs.py`), `attribuer` (`labeling/ids.py`) ; la lecture des données par `API/tools/agent-tools/donnees.py` (déjà copié : `charger`, `charger_camera`, `charger_metriques`, `heure_image`). +- Réglage : `AIMSIGHT_LABELS` (défaut : `labeling/` du dépôt), comme `AIMSIGHT_DATA`. `API/` ne lit toujours que `data/` ; c'est l'app qui lit `data/` et écrit dans `labeling/{auto,manual}/` (D-138). + +## Le front + +- Une page par fichier dans `app/web/src/pages/` (`Support.jsx`, `Images.jsx`, `Etiquetage.jsx`), le reste dans `App.jsx`. +- Les courbes : Plotly (`plotly.js-dist-min`, la bibliothèque des outils actuels), chargé seulement à l'ouverture d'Étiquetage, pour que Support reste léger. +- Textes de l'interface en français (outil interne). +- Les heures partout en UTC. + +## Vérifier + +- `check.py` : les routes `stations`, `images`, `courbes` sur une station de `data/` ; ajouter, modifier, retirer une étiquette dans un dossier `labeling/` temporaire (avec l'id en `auto`) ; une station ou un chemin hors de `data/` refusés. +- Par captures (Chrome headless) : Images et Étiquetage sur NIEDERHORN du 2026-09-25 au 2026-10-08 (le jeu de test des détecteurs) et sur LENZSPITZE et NADELHORN, sur ordinateur et téléphone. +- Marc compare avec ses outils actuels sur une plage qu'il connaît. + +## Laissé au constructeur + +La forme exacte des réponses JSON, le découpage en composants, la façon d'aligner les plots (celle de `labeling.py` marche : relayout des trois figures sur la plage et les marges de celle qui change). diff --git a/app/requirements.txt b/app/requirements.txt new file mode 100644 index 0000000..97dc7cd --- /dev/null +++ b/app/requirements.txt @@ -0,0 +1,2 @@ +fastapi +uvicorn diff --git a/app/serveur/check.py b/app/serveur/check.py new file mode 100644 index 0000000..1db900c --- /dev/null +++ b/app/serveur/check.py @@ -0,0 +1,116 @@ +"""Vérifications de la web app, sans appel à l'API (faux client) : API/.venv/bin/python app/serveur/check.py [nom]""" +import json +import shutil +import socket +import sys +import threading +import time +import urllib.request +from pathlib import Path +from urllib.error import HTTPError + +ICI = Path(__file__).resolve().parent +sys.path[:0] = [str(ICI), str(ICI.parents[1] / "API" / "support")] +import uvicorn # noqa: E402 +import seance # noqa: E402 +import serveur # noqa: E402 +import station # noqa: E402 +from check import Bloc, FauxClient, reponse, seance_temporaire # noqa: E402 (les faux de API/support/check.py) + + +def check_serveur(): + # le vrai serveur sur un port libre, une séance au faux client : la garde, l'analyse, le flux, le PDF absent + with socket.socket() as so: + so.bind(("127.0.0.1", 0)) + port = so.getsockname()[1] + cases = seance.CASES + seance.CASES, serveur.CLIENT = seance_temporaire(), FauxClient(reponse([Bloc(type="text", text="Bonjour Marc")], "end_turn")) + 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): + r = urllib.request.Request(base + chemin, json.dumps(corps).encode() if corps is not None else None, + {"Content-Type": "application/json", **(entetes or {})}) + try: + with urllib.request.urlopen(r) as rep: + return rep.status + except HTTPError as e: + return e.code + try: + assert appel("/api/pdf", entetes={"Host": "evil.example:80"}) == 403 + assert appel("/api/analyser", {"mail": "x"}, {"Content-Type": "text/plain"}) == 403 + assert appel("/api/analyser", {"mail": " "}) == 400 + assert appel("/api/analyser", {"mail": "Bonjour", "contexte": "", "images": []}) == 200 + with urllib.request.urlopen(base + "/api/flux", timeout=10) as f: + premier, textes = None, [] + for ligne in f: + if ligne.startswith(b"data: "): + m = json.loads(ligne[6:]) + premier = premier or m + textes += [e["texte"] for e in m["evenements"]] + if "Bonjour Marc" in textes and not m["occupe"]["support"]: + break + assert premier["depuis"] == 0 and premier["id"], premier + assert appel("/api/pdf") == 404 + (serveur.etat["seance"].dossier / "v1.pdf").write_bytes(b"%PDF-1.4") + with urllib.request.urlopen(base + "/api/pdf") as rep: + assert rep.read() == b"%PDF-1.4" and rep.headers["Content-Disposition"].startswith("inline"), rep.headers + finally: + srv.should_exit = True + shutil.rmtree(seance.CASES) + seance.CASES = cases + + +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 des pages Images et Étiquetage, 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 + 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 + + +CHECKS = [check_serveur, check_station] + +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__) diff --git a/API/support/serveur.py b/app/serveur/serveur.py similarity index 70% rename from API/support/serveur.py rename to app/serveur/serveur.py index 5b4480f..36f9e85 100644 --- a/API/support/serveur.py +++ b/app/serveur/serveur.py @@ -1,8 +1,10 @@ -"""La web app support : API/.venv/bin/python API/support/serveur.py → http://127.0.0.1:8770 +"""La web app : API/.venv/bin/python app/serveur/serveur.py → http://127.0.0.1:8770 -Le serveur FastAPI sert la page React construite (API/web/dist, `npm run build` dans API/web) et l'API sous /api. +Le serveur FastAPI sert la page React construite (app/web/dist, `npm run build` dans app/web) et l'API sous /api. +La page Support pilote les agents de API/ (API/support/seance.py). Une séance à la fois, en mémoire ; /api/flux pousse à la page les événements des agents (server-sent events). -Réglages : AIMSIGHT_DATA (données), AIMSIGHT_CASES (séances), AIMSIGHT_PORT (port, 8770). +Les pages Images et Étiquetage lisent data/ et les étiquettes de labeling/ (station.py). +Réglages : AIMSIGHT_DATA (données), AIMSIGHT_LABELS (étiquettes), AIMSIGHT_CASES (séances), AIMSIGHT_PORT (port, 8770). """ import asyncio import base64 @@ -16,16 +18,19 @@ import webbrowser from pathlib import Path import uvicorn -from fastapi import FastAPI, Request +from fastapi import FastAPI, Query, Request from fastapi.responses import FileResponse, JSONResponse, StreamingResponse + +import station from fastapi.staticfiles import StaticFiles -sys.path.insert(0, str(Path(__file__).resolve().parent)) -from seance import API, Seance, donnees_par_defaut # noqa: E402 +APP = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(APP.parent / "API" / "support")) # les agents du support +from seance import Seance, donnees_par_defaut # noqa: E402 PORT = int(os.environ.get("AIMSIGHT_PORT", 8770)) HOTES = {"127.0.0.1", "localhost"} # contre le DNS rebinding : un autre site ne lit ni mails ni PDF -PAGE = API / "web" / "dist" +PAGE = APP / "web" / "dist" CLIENT = None # le client Anthropic des séances ; None : le vrai (check.py y met un faux) verrou = threading.Lock() etat = {"seance": None, "evenements": []} @@ -55,7 +60,7 @@ 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 == "POST" + 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) @@ -68,6 +73,7 @@ def instantane(depuis: int) -> dict: v = s.derniere_version() if s else None return {"evenements": evs, "n": n, "cout": s.cout() if s else None, "version": v.name if v else None, "dossier": s.dossier.name if s else None, "id": s.id if s else None, + "station": s.station if s else None, "occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}} @@ -132,12 +138,62 @@ def message(corps: dict): return {} +# --- les pages Images et Étiquetage (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/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) + + 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 API/web && npm install && npm run build") + return erreur(503, "la page n'est pas construite : cd app/web && npm install && npm run build") def ouvrir(url: str) -> None: diff --git a/app/serveur/station.py b/app/serveur/station.py new file mode 100644 index 0000000..289791b --- /dev/null +++ b/app/serveur/station.py @@ -0,0 +1,257 @@ +"""Les données des pages Images et Étiquetage : 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, API/tools/agent-tools/donnees.py. Lecture seule sur data/ ; écrit seulement dans labeling/{auto,manual}/. +""" +import bisect +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.insert(0, str(RACINE / "API" / "tools" / "agent-tools")) +import donnees # 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)} + + +# --- la page Images (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 Étiquetage (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 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}") + 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)) + 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} + + +# --- 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") diff --git a/API/web/index.html b/app/web/index.html similarity index 100% rename from API/web/index.html rename to app/web/index.html diff --git a/API/web/package-lock.json b/app/web/package-lock.json similarity index 99% rename from API/web/package-lock.json rename to app/web/package-lock.json index 26e0c56..cec4734 100644 --- a/API/web/package-lock.json +++ b/app/web/package-lock.json @@ -10,6 +10,7 @@ "@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" }, @@ -814,6 +815,11 @@ "url": "https://github.com/sponsors/jonschlinkert" } }, + "node_modules/plotly.js-dist-min": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/plotly.js-dist-min/-/plotly.js-dist-min-4.2.0.tgz", + "integrity": "sha512-nxwhTxrRtQAWcZLBplb7xi73o0P2z/zjNuh1RKO4ssmPK7Kh30bQcObnAJhekBogI2rqUMbM0JJZC0TrG5Tq5Q==" + }, "node_modules/postcss": { "version": "8.5.32", "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.32.tgz", diff --git a/API/web/package.json b/app/web/package.json similarity index 92% rename from API/web/package.json rename to app/web/package.json index 1bbf71d..943d0e6 100644 --- a/API/web/package.json +++ b/app/web/package.json @@ -11,6 +11,7 @@ "@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" }, diff --git a/app/web/src/App.jsx b/app/web/src/App.jsx new file mode 100644 index 0000000..6811724 --- /dev/null +++ b/app/web/src/App.jsx @@ -0,0 +1,117 @@ +import { lazy, Suspense, useEffect, useState } from "react"; +import { + ActionIcon, AppShell, Burger, Group, Loader, NavLink, ScrollArea, Text, Tooltip, useComputedColorScheme, useMantineColorScheme, +} from "@mantine/core"; +import { useDisclosure } from "@mantine/hooks"; +import { IconChartLine, IconMessages, IconMoon, IconPhoto, IconSun } from "@tabler/icons-react"; +import Support, { AGENTS, Etat, NOMS } from "./pages/Support.jsx"; +import Images from "./pages/Images.jsx"; + +const Etiquetage = lazy(() => import("./pages/Etiquetage.jsx")); // Plotly, chargé seulement ici +const PAGES = [["support", "Support", IconMessages], ["images", "Images", IconPhoto], ["etiquetage", "Étiquetage", IconChartLine]]; + +// L'adresse : #/?station=…&du=…&au=… ; recharger garde la page et la sélection, Retour marche +function lireAdresse() { + const [page, q = ""] = location.hash.replace(/^#\/?/, "").split("?"); + const p = new URLSearchParams(q); + return { page: PAGES.some(([n]) => n === page) ? page : "support", + selection: { station: p.get("station") || "", du: p.get("du") || "", au: p.get("au") || "" } }; +} + +function adresse(page, s) { + const q = new URLSearchParams(Object.entries(s).filter(([, v]) => v)).toString(); + return `#/${page}${q ? "?" + q : ""}`; +} + +function Entete({ dossier, mobile, bureau, basculer }) { + const { setColorScheme } = useMantineColorScheme(), schema = useComputedColorScheme("light"); + return ( + + + + + + AIMsight + Support + + + {dossier && {dossier}} + + setColorScheme(schema === "dark" ? "light" : "dark")}> + {schema === "dark" ? : } + + + + + + ); +} + +function Barre({ page, selection, etat, fermer }) { + const c = etat.cout, dollars = v => `${(v ?? 0).toFixed(2)} $`; + const titre = t => {t}; + return ( + + + {titre("Pages")} + {PAGES.map(([n, nom, Icone]) => ( + } active={page === n} onClick={fermer} + href={adresse(n, n === "support" ? {} : selection)} /> + ))} + {page === "support" && <> + {titre("Séance")} + {AGENTS.map(a => } />)} + {titre("Coût")} + {AGENTS.map(a => {dollars(c?.[a])}} />)} + Total} rightSection={{dollars(c?.total)}} /> + } + + + ); +} + +export default function App() { + const [{ page, selection }, setLieu] = useState(lireAdresse); + const [etat, setEtat] = useState({ occupe: { support: false, analyste: false } }); + const [evenements, setEvenements] = useState([]); + const [mobile, { toggle: basculerMobile, close: fermerMobile }] = useDisclosure(false); + const [bureau, { toggle: basculerBureau }] = useDisclosure(true); + // La dernière station et plage vues, pour revenir à Images ou Étiquetage depuis Support + const [derniere, setDerniere] = useState(selection); + + useEffect(() => { + const suivre = () => setLieu(lireAdresse()); + addEventListener("hashchange", suivre); + return () => removeEventListener("hashchange", suivre); + }, []); + useEffect(() => { if (page !== "support") setDerniere(selection); }, [page, selection.station, selection.du, selection.au]); + + // La séance tourne même quand on regarde une autre page : le flux reste ouvert + useEffect(() => { + const flux = new EventSource("/api/flux"); + flux.onmessage = ev => { + const r = JSON.parse(ev.data), nouveaux = r.evenements.filter(e => e.type !== "cout"); + // depuis = 0 : tout l'historique de la séance (nouvelle séance, ou reconnexion) ; sinon la suite + setEvenements(evs => (r.depuis === 0 ? nouveaux : [...evs, ...nouveaux])); + setEtat(r); + }; + return () => flux.close(); + }, []); + + const choisir = s => { location.hash = adresse(page, s); }; + return ( + + + + + {page === "support" && } + {page === "images" && } + {page === "etiquetage" && ( + }> + )} + + + ); +} diff --git a/app/web/src/commun.jsx b/app/web/src/commun.jsx new file mode 100644 index 0000000..ded7cf7 --- /dev/null +++ b/app/web/src/commun.jsx @@ -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 ( + + +
+ {surtitre} + {titre} +
+ {action} +
+ {children} +
+ ); +} + +// La station et la plage (UTC, Au exclue ; vides : toute la période), partagées par Images et Étiquetage 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 ( + + +