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 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-05 14:25:57 +01:00
1 parent 374d91eb15
commit bd93e708d2
26 files changed
+1263 -206

No files matched your search

-2
View File
@@ -3,5 +3,3 @@
__pycache__/ __pycache__/
tools/typst/documents/ tools/typst/documents/
tools/typst/build/ tools/typst/build/
web/node_modules/
web/dist/
+3 -16
View File
@@ -22,21 +22,9 @@ LANGSMITH_ENDPOINT=https://eu.api.smith.langchain.com
LANGSMITH_PROJECT=Support 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). La page qui pilote ces agents est dans `app/` à la racine du dépôt (D-138) : sa doc, `app/README.md`.
```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/<date>_<STATION>_<sujet>/`. 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é.
## Les dossiers ## 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. - `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). - `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. - `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/` : les deux agents (`agent.py`, la séance `seance.py`), leurs outils, `check.py` (vérifications : `API/.venv/bin/python API/support/check.py`).
- `support/` : le serveur FastAPI, les deux agents, 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. - `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.
-2
View File
@@ -1,5 +1,3 @@
anthropic anthropic
langsmith langsmith
matplotlib matplotlib
fastapi
uvicorn
+1 -57
View File
@@ -262,63 +262,7 @@ def check_stations_dans_la_seance():
assert "stations" in AVEC_SORTIE assert "stations" in AVEC_SORTIE
def check_serveur(): 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,
# 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,
check_chemin, check_station_absente, check_detecteurs, check_plafond, check_image, check_compiler] check_chemin, check_station_absente, check_detecteurs, check_plafond, check_image, check_compiler]
if __name__ == "__main__": if __name__ == "__main__":
-8
View File
@@ -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; }
+2 -1
View File
@@ -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). - **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 <FAMILLE>` (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`. - **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 <FAMILLE>` (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 <mail>` répond à la question d'un client, et à elle seule (premier cas : LENZSPITZE, nuit du 26 au 27.10) ; `/support <STATION>` fait le rapport de situation de la station à partir de ses étiquettes (`labeling/auto/`), appuyé d'images ; `/presentation <STATION>` le met en diapositives PDF à la charte AIMsight, par la fabrique Typst `~/docfactory-presentation` (D-114). Rapports par mois. - **Support** (D-079, D-113) : `/support <mail>` répond à la question d'un client, et à elle seule (premier cas : LENZSPITZE, nuit du 26 au 27.10) ; `/support <STATION>` fait le rapport de situation de la station à partir de ses étiquettes (`labeling/auto/`), appuyé d'images ; `/presentation <STATION>` 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. - **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. - **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** : - **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/<STATION>/ [question]`. - `agent-diagnostic/` : consignes (`instructions.md`, 146 l) et rapports de l'agent de diagnostic (D-082). Appel : `@agent-diagnostic data/<STATION>/ [question]`.
- `support/` : un dossier par demande d'un client (D-079), `<date>_<STATION>_<sujet>/` : `demande.md`, `analyse.md`, `reponse.md` (le mail prêt à envoyer), GIF des images ; ou `<date>_<STATION>_rapport-situation/` : `rapport.md`, ses images, `<station>.typ` (le source) et `<station>.pdf`, nom de la station en minuscules. Contient des mails et images de clients. - `support/` : un dossier par demande d'un client (D-079), `<date>_<STATION>_<sujet>/` : `demande.md`, `analyse.md`, `reponse.md` (le mail prêt à envoyer), GIF des images ; ou `<date>_<STATION>_rapport-situation/` : `rapport.md`, ses images, `<station>.typ` (le source) et `<station>.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/`. - `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`. - `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 ### Code, données, configuration
+3
View File
@@ -0,0 +1,3 @@
web/node_modules/
web/dist/
__pycache__/
+46
View File
@@ -0,0 +1,46 @@
# La web app AIMsight
L'outil 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/<auto|manual>/<STATION>.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`.
@@ -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/<auto|manual>/<STATION>.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/<station>/<fichier>` | une image de `data/<station>/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).
+2
View File
@@ -0,0 +1,2 @@
fastapi
uvicorn
+116
View File
@@ -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__)
@@ -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). 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 asyncio
import base64 import base64
@@ -16,16 +18,19 @@ import webbrowser
from pathlib import Path from pathlib import Path
import uvicorn import uvicorn
from fastapi import FastAPI, Request from fastapi import FastAPI, Query, Request
from fastapi.responses import FileResponse, JSONResponse, StreamingResponse from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
import station
from fastapi.staticfiles import StaticFiles from fastapi.staticfiles import StaticFiles
sys.path.insert(0, str(Path(__file__).resolve().parent)) APP = Path(__file__).resolve().parents[1]
from seance import API, Seance, donnees_par_defaut # noqa: E402 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)) 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 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) CLIENT = None # le client Anthropic des séances ; None : le vrai (check.py y met un faux)
verrou = threading.Lock() verrou = threading.Lock()
etat = {"seance": None, "evenements": []} 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 """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).""" peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
hote = request.headers.get("host", "").rsplit(":", 1)[0] 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")): and not request.headers.get("content-type", "").startswith("application/json")):
return erreur(403, "requête refusée") return erreur(403, "requête refusée")
return await suite(request) return await suite(request)
@@ -68,6 +73,7 @@ def instantane(depuis: int) -> dict:
v = s.derniere_version() if s else None 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, 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, "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")}} "occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}}
@@ -132,12 +138,62 @@ def message(corps: dict):
return {} 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(): if PAGE.is_dir():
app.mount("/", StaticFiles(directory=PAGE, html=True), name="page") app.mount("/", StaticFiles(directory=PAGE, html=True), name="page")
else: else:
@app.get("/") @app.get("/")
def sans_page(): 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: def ouvrir(url: str) -> None:
+257
View File
@@ -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")
File renamed without changes.
+6
View File
@@ -10,6 +10,7 @@
"@mantine/hooks": "^9.7.5", "@mantine/hooks": "^9.7.5",
"@mantine/notifications": "^9.7.5", "@mantine/notifications": "^9.7.5",
"@tabler/icons-react": "^3.50.0", "@tabler/icons-react": "^3.50.0",
"plotly.js-dist-min": "^4.2.0",
"react": "^19.3.1", "react": "^19.3.1",
"react-dom": "^19.3.1" "react-dom": "^19.3.1"
}, },
@@ -814,6 +815,11 @@
"url": "https://github.com/sponsors/jonschlinkert" "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": { "node_modules/postcss": {
"version": "8.5.32", "version": "8.5.32",
"resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.32.tgz", "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.32.tgz",
@@ -11,6 +11,7 @@
"@mantine/hooks": "^9.7.5", "@mantine/hooks": "^9.7.5",
"@mantine/notifications": "^9.7.5", "@mantine/notifications": "^9.7.5",
"@tabler/icons-react": "^3.50.0", "@tabler/icons-react": "^3.50.0",
"plotly.js-dist-min": "^4.2.0",
"react": "^19.3.1", "react": "^19.3.1",
"react-dom": "^19.3.1" "react-dom": "^19.3.1"
}, },
+117
View File
@@ -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 : #/<page>?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 (
<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}>Support</Text>
</Group>
<Group gap="sm" wrap="nowrap">
{dossier && <Text ff="monospace" size="sm" opacity={0.75} visibleFrom="sm">{dossier}</Text>}
<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>
);
}
function Barre({ page, selection, etat, fermer }) {
const c = etat.cout, dollars = v => `${(v ?? 0).toFixed(2)} $`;
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, n === "support" ? {} : selection)} />
))}
{page === "support" && <>
{titre("Séance")}
{AGENTS.map(a => <NavLink key={a} label={NOMS[a]} rightSection={<Etat occupe={etat.occupe[a]} />} />)}
{titre("Coût")}
{AGENTS.map(a => <NavLink key={a} label={NOMS[a]} rightSection={<Text size="sm">{dollars(c?.[a])}</Text>} />)}
<NavLink label={<b>Total</b>} rightSection={<Text size="sm" fw={700}>{dollars(c?.total)}</Text>} />
</>}
</ScrollArea>
</AppShell.Navbar>
);
}
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 (
<AppShell header={{ height: 64 }} padding="lg"
navbar={{ width: 260, breakpoint: "sm", collapsed: { mobile: !mobile, desktop: !bureau } }}>
<Entete dossier={etat.dossier} mobile={mobile} bureau={bureau} basculer={{ mobile: basculerMobile, bureau: basculerBureau }} />
<Barre page={page} selection={page === "support" ? derniere : selection} etat={etat} fermer={fermerMobile} />
<AppShell.Main bg="var(--mantine-color-default-hover)">
{page === "support" && <Support etat={etat} evenements={evenements} />}
{page === "images" && <Images selection={selection} choisir={choisir} />}
{page === "etiquetage" && (
<Suspense fallback={<Loader m="xl" />}><Etiquetage selection={selection} choisir={choisir} /></Suspense>
)}
</AppShell.Main>
</AppShell>
);
}
+52
View File
@@ -0,0 +1,52 @@
import { useEffect, useState } from "react";
import { Button, Card, Group, Select, Text, TextInput } from "@mantine/core";
import { notifications } from "@mantine/notifications";
// Une requête à l'API ; un refus du serveur s'affiche en notification -> le JSON rendu, ou null
export async function appel(chemin, methode = "GET", corps) {
try {
const r = await fetch(chemin, corps === undefined ? { method: methode }
: { method: methode, headers: { "Content-Type": "application/json" }, body: JSON.stringify(corps) });
const json = await r.json().catch(() => ({ erreur: r.statusText }));
if (r.ok) return json;
notifications.show({ color: "red", title: "Refusé", message: json.erreur || r.statusText });
} catch (e) {
notifications.show({ color: "red", title: "Serveur injoignable", message: e.message });
}
return null;
}
export const poster = async (chemin, corps) => (await appel(chemin, "POST", corps)) !== null;
export function Carte({ surtitre, titre, action, children, ...reste }) {
return (
<Card shadow="sm" padding={0} withBorder {...reste}>
<Group px="lg" py="md" justify="space-between" wrap="nowrap" style={{ borderBottom: "1px solid var(--mantine-color-default-border)" }}>
<div>
<Text size="xs" fw={700} tt="uppercase" c="dimmed">{surtitre}</Text>
<Text fw={500}>{titre}</Text>
</div>
{action}
</Group>
{children}
</Card>
);
}
// La station et la plage (UTC, Au exclue ; vides : toute la période), partagées par 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 (
<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>
);
}
File renamed without changes.
+212
View File
@@ -0,0 +1,212 @@
import { useEffect, useRef, useState } from "react";
import { Button, Card, Group, Loader, NativeSelect, Stack, Text, Textarea, TextInput, Title } from "@mantine/core";
import { appel, Selecteur } from "../commun.jsx";
// L'étiquetage (labeling/labeling.py) : deux plots alignés, la barre des étiquettes ; y glisser sélectionne une plage,
// un clic ouvre une étiquette. Les étiquettes sont dans labeling/<auto|manual>/<STATION>.jsonl, relues à chaque chargement.
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) }))];
const GRIS = "#6b6b66", BLEU = "#2a78d6", VOIE = 22; // VOIE : px par rangée d'étiquettes
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 });
export default function Etiquetage({ selection, choisir }) {
const [donnees, setDonnees] = useState(null), [charge, setCharge] = useState(false);
const { station, du, au } = selection;
useEffect(() => {
setDonnees(null);
if (!station) return;
setCharge(true);
appel(`/api/courbes?${new URLSearchParams({ station, du, au })}`).then(d => { setDonnees(d); setCharge(false); });
}, [station, du, au]);
return (
<Stack gap="lg">
<div>
<Title order={2}>Étiquetage</Title>
<Text c="dimmed">Glisser sur la barre des étiquettes sélectionne une plage ; un clic sur une étiquette l'ouvre.</Text>
</div>
<Selecteur selection={selection} choisir={choisir} />
{charge && <Loader />}
{donnees && <Etiqueteur key={`${station}${du}${au}`} station={station} d={donnees} />}
</Stack>
);
}
function Etiqueteur({ station, d }) {
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 [source, setSource] = useState("auto"), [labels, setLabels] = useState([]), [choix, setChoix] = useState(null);
const [m1, setM1] = useState(indice("Relative Corrected Horizontal Shift", 0));
const [m2, setM2] = useState(indice("Relative Corrected Vertical Shift", PLOTS.length > 1 ? 1 : 0));
const [ajout, setAjout] = useState({ categorie: "", texte: "" });
const [ouverte, setOuverte] = useState(null), [edit, setEdit] = useState(null), [note, setNote] = useState("");
const fig = useRef(), fig2 = useRef(), barre = useRef(), tries = useRef([]), courant = useRef({});
courant.current = { labels, choix, ouvrir }; // ce que lisent les événements Plotly, installés une fois
useEffect(() => { import("plotly.js-dist-min").then(m => setPlotly(() => m.default)); }, []);
function zones() {
const { labels, choix } = courant.current;
const z = (a, b, c, o) => ({ type: "rect", xref: "x", yref: "paper", x0: lisible(a), x1: lisible(b), y0: 0, y1: 1,
fillcolor: c, opacity: o, line: { width: 0 }, layer: "below" });
return labels.map(l => z(l.debut, l.fin, couleur(l), 0.12)).concat(choix ? [z(choix[0], choix[1], BLEU, 0.25)] : []);
}
// Les deux plots et la barre partagent plage et marges : celui qui change impose les siens aux deux autres (rien si déjà
// alignés, sinon le relayout appelle aligne en boucle).
function aligne(src = fig.current) {
const g1 = fig.current, g2 = fig2.current, b = barre.current;
if (!b?._fullLayout || !g2?._fullLayout || !g1?._fullLayout) return;
const rg = src._fullLayout.xaxis.range.slice();
const l = Math.max(g1._fullLayout._size.l, g2._fullLayout._size.l), r = Math.max(g1._fullLayout._size.r, g2._fullLayout._size.r);
return Promise.all([g1, g2, b].map(g => {
const m = g._fullLayout.margin, x = g._fullLayout.xaxis.range;
if (m.l === l && m.r === r && Date.parse(x[0]) === Date.parse(rg[0]) && Date.parse(x[1]) === Date.parse(rg[1])) return;
return Plotly.relayout(g, { "xaxis.range": rg, "margin.l": l, "margin.r": r });
}));
}
function dessineFig(g, m) {
const p = PLOTS[m];
// uirevision : le zoom et les capteurs cachés restent d'un plot à l'autre ; l'ordonnée, propre à chaque plot, se recale
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,
hovertemplate: `${t.name} : %{y}<br>%{x|%Y-%m-%d %H:%M} UTC<extra></extra>` })),
{ height: 420, hovermode: "closest", plot_bgcolor: "white", margin: marge(), legend: { x: 1.01, y: 1 }, uirevision: 1, shapes: zones(),
xaxis: { type: "date", range: [lisible(A), lisible(B)], gridcolor: "#e6e6e2" },
yaxis: { title: { text: p.titre }, uirevision: p.titre, gridcolor: "#eeeeea", zeroline: false } },
{ responsive: true, doubleClick: "reset" }).then(() => aligne(g));
}
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), f = fig.current._fullLayout, g = fig2.current._fullLayout;
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.85, marker: { color: t.map(couleur), line: { color: "white", width: 2 } },
text: t.map(l => (l.categorie ? `[${NOM_FAMILLE(l.categorie)}] ` : "") + l.description),
textposition: "inside", insidetextanchor: "start", textangle: 0, unselected: { marker: { opacity: 1 } }, // sinon une sélection les pâlit
hoverinfo: "none" }], // pas de bulle (le clic lit l'étiquette) ; 'none' garde les événements
{ height: 40 + VOIE * n, dragmode: "select", selectdirection: "h", hovermode: "closest", plot_bgcolor: "#f2f2ef", showlegend: false,
margin: { ...marge(), l: Math.max(f._size.l, g._size.l), r: Math.max(f._size.r, g._size.r) }, uniformtext: { minsize: 9, mode: "hide" },
xaxis: { type: "date", range: f.xaxis.range.slice(), showgrid: false },
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, une fois
useEffect(() => {
if (!Plotly) return;
Promise.all([dessineFig(fig.current, m1), dessineFig(fig2.current, m2)]).then(dessineBarre).then(() => aligne()).then(() => {
fig.current.on("plotly_relayout", () => aligne(fig.current));
fig2.current.on("plotly_relayout", () => aligne(fig2.current));
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_click", ev => courant.current.ouvrir(tries.current[ev.points[0].pointIndex]));
setPret(true);
});
return () => [fig, fig2, barre].forEach(g => g.current && Plotly.purge(g.current));
}, [Plotly]);
useEffect(() => { if (pret) dessineFig(fig.current, m1); }, [m1]);
useEffect(() => { if (pret) dessineFig(fig2.current, m2); }, [m2]);
useEffect(() => { if (pret) dessineBarre(); }, [pret, labels]);
useEffect(() => { if (pret) [fig, fig2].forEach(g => Plotly.relayout(g.current, { shapes: zones() })); }, [pret, labels, choix]);
// Lues à chaque chargement et à chaque changement de dossier : la page montre toujours le fichier
useEffect(() => {
appel(`/api/etiquettes?${new URLSearchParams({ station, dossier: source })}`)
.then(l => setLabels(l ? l.filter(x => x.debut < B && x.fin > A) : []));
}, [source]);
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("");
setEdit(l && { debut: l.debut.slice(0, 16), fin: l.fin.slice(0, 16), categorie: l.categorie || "", texte: l.description });
return true;
}
async function ajouter() {
const l = await appel("/api/etiquettes", "POST", { station, dossier: source, debut: choix[0], fin: choix[1],
categorie: ajout.categorie, description: ajout.texte.trim() });
if (!l) return; // rien n'est perdu : le texte et la plage restent dans la page
setLabels(ls => [...ls, l]);
setAjout({ categorie: "", texte: "" });
await Plotly.relayout(barre.current, { selections: [] });
setChoix(null);
}
async function enregistrer() {
const l = await appel("/api/etiquettes", "PUT", { station, dossier: source, 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
setLabels(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: source, avant: ouverte }) === null) return;
setLabels(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;
return (
<Card shadow="sm" withBorder>
<Stack gap="sm">
<Group gap="md" align="flex-end">
<NativeSelect label="Étiquettes" data={[{ value: "auto", label: "auto (l'étiqueteur)" }, { value: "manual", label: "manual (les tiennes)" }]}
value={source} onChange={e => { const v = e.currentTarget.value; if (ouvrir(null)) setSource(v); }} />
{!pret && <Loader size="sm" />}
</Group>
<NativeSelect label="Plot" data={options} value={String(m1)} onChange={e => setM1(+e.currentTarget.value)} maw={420} />
<div ref={fig} />
<NativeSelect label="Plot" data={options} value={String(m2)} onChange={e => setM2(+e.currentTarget.value)} maw={420} />
<div ref={fig2} />
<div ref={barre} />
{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>
<Text size="sm" c="teal">{note}</Text>
<Button color="red" variant="light" ml="auto" onClick={supprimer}>Supprimer</Button>
</Group>
</Stack>
</Card>
)}
<Text size="sm">{choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : "Glisser sur la barre ci-dessus pour sélectionner une plage."}</Text>
<NativeSelect label="Famille" data={CHOIX_FAMILLE} value={ajout.categorie} onChange={e => setAjout({ ...ajout, categorie: e.currentTarget.value })} maw={300} />
<Textarea autosize minRows={3} placeholder="Que voit-on sur cette plage ?" value={ajout.texte}
onChange={e => setAjout({ ...ajout, texte: e.currentTarget.value })} />
<Group><Button onClick={ajouter} disabled={!(choix && choix[0] < choix[1] && ajout.texte.trim())}>Ajouter</Button></Group>
</Stack>
</Card>
);
}
+231
View File
@@ -0,0 +1,231 @@
import { useEffect, useRef, useState } from "react";
import { ActionIcon, Card, Group, Input, Loader, Stack, Text, Title } from "@mantine/core";
import { IconChevronLeft, IconChevronRight } from "@tabler/icons-react";
import { appel, Selecteur } from "../commun.jsx";
// Les images de la caméra (view/view.py) : glisseur, ◀ ▶, flèches du clavier ; molette pour zoomer autour du pointeur,
// glisser pour se déplacer, double clic pour l'image entière ; une plage sur la barre : la flèche de déplacement de chaque capteur.
export default function Images({ selection, choisir }) {
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]);
return (
<Stack gap="lg">
<div>
<Title order={2}>Images</Title>
<Text c="dimmed">Les images de la caméra ; une plage sur la barre montre le déplacement de chaque capteur.</Text>
</div>
<Selecteur selection={selection} choisir={choisir} />
{charge && <Loader />}
{donnees && <Visionneuse key={`${station}${du}${au}`} station={station} d={donnees} />}
</Stack>
);
}
function Visionneuse({ station, d }) {
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() };
const XY = d.positions, refs = new Set(d.references), avecPositions = Object.keys(XY).length > 0;
useEffect(() => installer(r, station, d), [d]);
return (
<Card shadow="sm" withBorder padding={0}>
<div className="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;
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 (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();
};
}
@@ -1,20 +1,11 @@
import { useEffect, useRef, useState } from "react"; import { useEffect, useRef, useState } from "react";
import { import { ActionIcon, Badge, Button, Grid, Group, Image, Paper, ScrollArea, SimpleGrid, Stack, Text, Textarea, Title, Tooltip } from "@mantine/core";
ActionIcon, AppShell, Badge, Burger, Button, Card, Grid, Group, Image, NavLink, Paper, ScrollArea, SimpleGrid,
Stack, Text, Textarea, Title, Tooltip, useComputedColorScheme, useMantineColorScheme,
} from "@mantine/core";
import { useDisclosure } from "@mantine/hooks";
import { notifications } from "@mantine/notifications"; import { notifications } from "@mantine/notifications";
import { IconDownload, IconFilePlus, IconMoon, IconSend, IconSun } from "@tabler/icons-react"; import { IconChartLine, IconDownload, IconPhoto, IconSend } from "@tabler/icons-react";
import { Carte, poster } from "../commun.jsx";
const AGENTS = ["support", "analyste"]; export const AGENTS = ["support", "analyste"];
const NOMS = { support: "Support", analyste: "Analyste" }; export const NOMS = { support: "Support", analyste: "Analyste" };
async function poster(chemin, corps) {
const r = await fetch(chemin, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(corps) });
if (!r.ok) notifications.show({ color: "red", title: "Refusé", message: (await r.json()).erreur });
return r.ok;
}
// Un événement d'un agent → ce que montre son fil // Un événement d'un agent → ce que montre son fil
function message(e) { function message(e) {
@@ -27,66 +18,10 @@ function message(e) {
return { genre: e.agent, qui: NOMS[e.agent], texte: e.texte }; return { genre: e.agent, qui: NOMS[e.agent], texte: e.texte };
} }
function Etat({ occupe }) { export function Etat({ occupe }) {
return <Badge variant="light" color={occupe ? "orange" : "teal"}>{occupe ? "occupé…" : "prêt"}</Badge>; return <Badge variant="light" color={occupe ? "orange" : "teal"}>{occupe ? "occupé…" : "prêt"}</Badge>;
} }
function Entete({ dossier, 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}>Support</Text>
</Group>
<Group gap="sm" wrap="nowrap">
{dossier && <Text ff="monospace" size="sm" opacity={0.75} visibleFrom="sm">{dossier}</Text>}
<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>
);
}
function Barre({ etat }) {
const c = etat.cout, dollars = v => `${(v ?? 0).toFixed(2)} $`;
return (
<AppShell.Navbar p="xs">
<ScrollArea type="scroll">
<Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="sm" pb="xs">Séance</Text>
<NavLink active label="Nouvelle séance" leftSection={<IconFilePlus size={18} />} />
{AGENTS.map(a => <NavLink key={a} label={NOMS[a]} rightSection={<Etat occupe={etat.occupe[a]} />} />)}
<Text size="xs" fw={700} tt="uppercase" c="dimmed" px="sm" pt="lg" pb="xs">Coût</Text>
{AGENTS.map(a => <NavLink key={a} label={NOMS[a]} rightSection={<Text size="sm">{dollars(c?.[a])}</Text>} />)}
<NavLink label={<b>Total</b>} rightSection={<Text size="sm" fw={700}>{dollars(c?.total)}</Text>} />
</ScrollArea>
</AppShell.Navbar>
);
}
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>
);
}
function Saisie({ occupe }) { function Saisie({ occupe }) {
const [mail, setMail] = useState(""), [contexte, setContexte] = useState(""), [images, setImages] = useState([]); const [mail, setMail] = useState(""), [contexte, setContexte] = useState(""), [images, setImages] = useState([]);
@@ -174,42 +109,33 @@ function Rapport({ version, dossier }) {
); );
} }
export default function App() { // Les 7 derniers jours, sur la station de la séance : la plage du client se règle ensuite dans la page
const [etat, setEtat] = useState({ occupe: { support: false, analyste: false } }); function lien(page, station) {
const [evenements, setEvenements] = useState([]); const du = new Date(Date.now() - 7 * 864e5).toISOString().slice(0, 10);
const [mobile, { toggle: basculerMobile }] = useDisclosure(false); return `#/${page}?station=${encodeURIComponent(station)}&du=${du}`;
const [bureau, { toggle: basculerBureau }] = useDisclosure(true); }
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();
}, []);
export default function Support({ etat, evenements }) {
return ( return (
<AppShell header={{ height: 64 }} padding="lg" <Stack gap="lg">
navbar={{ width: 260, breakpoint: "sm", collapsed: { mobile: !mobile, desktop: !bureau } }}> <Group justify="space-between" align="flex-end">
<Entete dossier={etat.dossier} mobile={mobile} bureau={bureau} basculer={{ mobile: basculerMobile, bureau: basculerBureau }} /> <div>
<Barre etat={etat} /> <Title order={2}>Support</Title>
<AppShell.Main bg="var(--mantine-color-default-hover)"> <Text c="dimmed">Colle le mail du client et ton contexte, puis Analyser ; parle au support ou à l'analyste dans leur fil.</Text>
<Stack gap="lg"> </div>
<div> {etat.station && (
<Title order={2}>Support</Title> <Group gap="xs">
<Text c="dimmed">Colle le mail du client et ton contexte, puis Analyser ; parle au support ou à l'analyste dans leur fil.</Text> <Button component="a" href={lien("images", etat.station)} variant="light" leftSection={<IconPhoto size={16} />}>Images de {etat.station}</Button>
</div> <Button component="a" href={lien("etiquetage", etat.station)} variant="light" leftSection={<IconChartLine size={16} />}>Étiquetage</Button>
<Saisie occupe={etat.occupe.support || etat.occupe.analyste} /> </Group>
<SimpleGrid cols={{ base: 1, md: 2 }} spacing="lg"> )}
{AGENTS.map(a => <Fil key={a} agent={a} occupe={etat.occupe[a]} seance={etat.dossier} </Group>
evenements={evenements.filter(e => e.agent === a)} />)} <Saisie occupe={etat.occupe.support || etat.occupe.analyste} />
</SimpleGrid> <SimpleGrid cols={{ base: 1, md: 2 }} spacing="lg">
<Rapport version={etat.version} dossier={etat.dossier} /> {AGENTS.map(a => <Fil key={a} agent={a} occupe={etat.occupe[a]} seance={etat.dossier}
</Stack> evenements={evenements.filter(e => e.agent === a)} />)}
</AppShell.Main> </SimpleGrid>
</AppShell> <Rapport version={etat.version} dossier={etat.dossier} />
</Stack>
); );
} }
+29
View File
@@ -0,0 +1,29 @@
/* 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; }
.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); }
File renamed without changes.
+8 -1
View File
@@ -1267,7 +1267,14 @@ Règles du journal :
## D-137 — 2026-11-05 — La page support de l'API devient une web app : React et Python (FastAPI) ## D-137 — 2026-11-05 — La page support de l'API devient une web app : React et Python (FastAPI)
- **Statut** : active. Complète D-133. - **Statut** : active. Complète D-133.
- **Décision** : la page support de `API/` est refaite en web app, aux mêmes fonctions : un front React (Vite, JavaScript) dans `API/web/`, ses composants pris à la bibliothèque open source Mantine (MIT), un serveur FastAPI (`API/support/serveur.py`) qui sert la page construite (`API/web/dist`) et l'API sous `/api` ; les événements des agents sont poussés à la page (`/api/flux`, server-sent events) au lieu d'être interrogés chaque seconde. Les agents, leurs outils, les prompts et le savoir restent tels quels. Outil interne, local d'abord ; le dossier des données, celui des séances et le port se règlent par variables (`AIMSIGHT_DATA`, `AIMSIGHT_CASES`, `AIMSIGHT_PORT`) pour un déploiement futur. Pas de PostgreSQL, d'historique des séances, d'authentification ni de plafond de coût pour l'instant ; le pompage des données reste tel quel. - **Décision** : la page support de `API/` est refaite en web app, aux mêmes fonctions : un front React (Vite, JavaScript) dans `API/web/` (`app/web/` depuis D-138), ses composants pris à la bibliothèque open source Mantine (MIT), un serveur FastAPI (`API/support/serveur.py`, `app/serveur/` depuis D-138) qui sert la page construite (`API/web/dist`) et l'API sous `/api` ; les événements des agents sont poussés à la page (`/api/flux`, server-sent events) au lieu d'être interrogés chaque seconde. Les agents, leurs outils, les prompts et le savoir restent tels quels. Outil interne, local d'abord ; le dossier des données, celui des séances et le port se règlent par variables (`AIMSIGHT_DATA`, `AIMSIGHT_CASES`, `AIMSIGHT_PORT`) pour un déploiement futur. Pas de PostgreSQL, d'historique des séances, d'authentification ni de plafond de coût pour l'instant ; le pompage des données reste tel quel.
- **Pourquoi** : la page doit pouvoir grandir (historique, boîte mail, voix) et passer un jour sur un serveur (l'utilisateur, 2026-11-05). - **Pourquoi** : la page doit pouvoir grandir (historique, boîte mail, voix) et passer un jour sur un serveur (l'utilisateur, 2026-11-05).
- **Options écartées** : Spring Boot (les agents et tous leurs outils sont en Python, comme l'application de référence d'AIMsight, Flask ; il aurait fallu réécrire la boucle des agents en Java et appeler chaque outil en Python de l'extérieur) ; PostgreSQL dès maintenant (il viendra avec l'historique des séances, « faisons au plus simple », l'utilisateur) ; reprendre un template d'administration (Carolina, UiFort : React 16 et Material-UI 4, trop vieux pour React 19, « on ne veut pas reprendre ses éléments », l'utilisateur) ; recoder les composants à la main (Mantine donne d'office la barre repliable, le tiroir mobile, les transitions et le mode sombre). - **Options écartées** : Spring Boot (les agents et tous leurs outils sont en Python, comme l'application de référence d'AIMsight, Flask ; il aurait fallu réécrire la boucle des agents en Java et appeler chaque outil en Python de l'extérieur) ; PostgreSQL dès maintenant (il viendra avec l'historique des séances, « faisons au plus simple », l'utilisateur) ; reprendre un template d'administration (Carolina, UiFort : React 16 et Material-UI 4, trop vieux pour React 19, « on ne veut pas reprendre ses éléments », l'utilisateur) ; recoder les composants à la main (Mantine donne d'office la barre repliable, le tiroir mobile, les transitions et le mode sombre).
- **Conséquence** : `npm run build` dans `API/web/` avant de lancer le serveur ; `npm run dev` pour travailler sur la page (port 5173, l'API demandée au serveur Python). - **Conséquence** : `npm run build` dans `API/web/` avant de lancer le serveur ; `npm run dev` pour travailler sur la page (port 5173, l'API demandée au serveur Python).
## D-138 — 2026-11-05 — La web app dans son dossier `app/`, avec les pages Images et Étiquetage
- **Statut** : active. Complète D-133 et D-137.
- **Décision** : la web app quitte `API/` pour son propre dossier `app/` à la racine : `app/serveur/` (FastAPI) et `app/web/` (React, Mantine). `API/` redevient les agents seuls (agent, séance, outils, prompts, savoir, séances) ; la page Support les pilote. L'app gagne deux pages, refaites en React à l'identique des outils de Marc : **Images** (`view/view.py` : glisseur, zoom, noms des capteurs, flèches de déplacement sur une plage) et **Étiquetage** (`labeling/labeling.py` : deux plots alignés, barre des étiquettes, ajouter, modifier, supprimer) ; un sélecteur de station et de dates partagé, dans l'adresse (`#/images?station=…&du=…&au=…`) ; depuis une séance, deux boutons ouvrent ces pages sur la station du cas. Les étiquettes restent dans `labeling/{auto,manual}/` du dépôt, où l'app écrit (`AIMSIGHT_LABELS`) : une seule vérité pour les détecteurs et les agents. Conception : `app/docs/2026-11-05-pages-images-etiquetage-design.md`.
- **Pourquoi** : « que tout soit centralisé dans l'app », le diagnostic manuel compris ; et l'app, devenue plus que le support par l'API, a son propre dossier (l'utilisateur, 2026-11-05).
- **Options écartées** : intégrer `view.py` et `labeling.py` tels quels dans un cadre (deux serveurs de plus, un autre visuel, du code hors de l'app au déploiement) ; copier les étiquettes dans l'app (deux vérités).
- **Conséquence** : `API/` ne lit toujours que `data/` ; l'app lit `data/` et écrit dans `labeling/auto/` et `labeling/manual/`. Les anciens outils restent (le projet Claude Code s'en sert). Le calcul copié (positions, références, id des étiquettes) est dans `app/serveur/station.py`, sa provenance dans `app/README.md`.
+4 -4
View File
@@ -183,12 +183,12 @@ bash .claude/skills/presentation/compiler.sh support/<dossier>
Faire ou refaire la présentation avec l'agent : `/presentation <STATION>` (`.claude/skills/presentation/SKILL.md`, D-114). Faire ou refaire la présentation avec l'agent : `/presentation <STATION>` (`.claude/skills/presentation/SKILL.md`, D-114).
## La page support par l'API Claude (D-133) ## La web app : support, images, étiquetage (D-133, D-138)
Sous-projet `API/` (sa doc : `API/README.md`). Une fois : `python3 -m venv API/.venv && API/.venv/bin/pip install -r API/requirements.txt`, et les clés dans `API/.env` (`ANTHROPIC_API_KEY`, `LANGSMITH_API_KEY`, `LANGSMITH_TRACING=true`, `LANGSMITH_PROJECT=Support`), et la page React construite : `cd API/web && npm install && npm run build` (à refaire quand la page change, D-137). Puis : Sous-projet `API/` (sa doc : `API/README.md`). Une fois : `python3 -m venv API/.venv && API/.venv/bin/pip install -r API/requirements.txt`, et les clés dans `API/.env` (`ANTHROPIC_API_KEY`, `LANGSMITH_API_KEY`, `LANGSMITH_TRACING=true`, `LANGSMITH_PROJECT=Support`), `API/.venv/bin/pip install -r app/requirements.txt`, et la web app construite : `cd app/web && npm install && npm run build` (à refaire quand la page change ; doc : `app/README.md`, D-137, D-138). Puis :
```bash ```bash
API/.venv/bin/python API/support/serveur.py API/.venv/bin/python app/serveur/serveur.py
``` ```
Coller le mail du client (les captures se collent dans la même zone), ajouter son contexte, Analyser ; répondre au support ou à l'analyste dans leur fil ; le PDF s'affiche en dessous, par version. La séance est gardée dans `API/cases/`. Page Support : coller le mail du client (les captures se collent dans la même zone), ajouter son contexte, Analyser ; répondre au support ou à l'analyste dans leur fil ; le PDF s'affiche en dessous, par version. La séance est gardée dans `API/cases/`. Pages Images et Étiquetage : celles de `view.py` et `labeling.py`, sur une station et une plage ; les étiquettes s'écrivent dans `labeling/`.