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:
1 parent
374d91eb15
commit
bd93e708d2
26 files changed
+1263
-206
No files matched your search
@@ -3,5 +3,3 @@
|
||||
__pycache__/
|
||||
tools/typst/documents/
|
||||
tools/typst/build/
|
||||
web/node_modules/
|
||||
web/dist/
|
||||
+3
-16
@@ -22,21 +22,9 @@ LANGSMITH_ENDPOINT=https://eu.api.smith.langchain.com
|
||||
LANGSMITH_PROJECT=Support
|
||||
```
|
||||
|
||||
## Lancer la web app (D-137)
|
||||
## La web app
|
||||
|
||||
Une fois, et après chaque changement de la page : construire le front React (Node 22).
|
||||
|
||||
```bash
|
||||
cd API/web && npm install && npm run build
|
||||
```
|
||||
|
||||
Puis le serveur, qui sert la page et l'API :
|
||||
|
||||
```bash
|
||||
API/.venv/bin/python API/support/serveur.py
|
||||
```
|
||||
|
||||
La page s'ouvre sur `http://127.0.0.1:8770`. Une séance à la fois ; elle est gardée dans `cases/<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é.
|
||||
La page qui pilote ces agents est dans `app/` à la racine du dépôt (D-138) : sa doc, `app/README.md`.
|
||||
|
||||
## Les dossiers
|
||||
|
||||
@@ -44,6 +32,5 @@ La page s'ouvre sur `http://127.0.0.1:8770`. Une séance à la fois ; elle est g
|
||||
- `prompts/` : les prompts système du support et de l'analyste (en balises) ; le savoir de `knowledge/` y est ajouté au chargement.
|
||||
- `knowledge/` : ce que lisent les agents, copié du projet (pour l'analyste, les cartes dans le prompt, le reste à la demande par `lire_document`, D-136) : `analyste/` (familles, carte des étiquettes, connaissances, outils de lecture, règles de preuve), `support/` (présentation, modèle Typst, rédaction).
|
||||
- `tools/` : copies des outils de lecture (`agent-tools/`), des détecteurs (`detectors/`), des figures (`figures/`), de la fabrique Typst (`typst/brand/`) ; `journal.py`, les événements des détecteurs avec leurs capteurs ; `stabilite.py`, la médiane de corr_y jour par jour et son étendue, par cible.
|
||||
- `web/` : la page React, ses composants de Mantine (MIT : en-tête, barre latérale repliable, tiroir sur téléphone, cartes, notifications, mode sombre) ; `src/App.jsx` : la saisie, les deux fils, le rapport ; `src/main.jsx` : le thème (bleu #5383ff, Roboto) ; `dist/` et `node_modules/` hors de git.
|
||||
- `support/` : le serveur FastAPI, les deux agents, leurs outils, `check.py` (vérifications : `API/.venv/bin/python API/support/check.py`).
|
||||
- `support/` : les deux agents (`agent.py`, la séance `seance.py`), leurs outils, `check.py` (vérifications : `API/.venv/bin/python API/support/check.py`).
|
||||
- `cases/` : une séance par dossier : le mail, le contexte, les deux historiques, les figures, le source Typst, les PDF par version. Contient des mails et des images de clients.
|
||||
@@ -1,5 +1,3 @@
|
||||
anthropic
|
||||
langsmith
|
||||
matplotlib
|
||||
fastapi
|
||||
uvicorn
|
||||
+1
-57
@@ -262,63 +262,7 @@ def check_stations_dans_la_seance():
|
||||
assert "stations" in AVEC_SORTIE
|
||||
|
||||
|
||||
def check_serveur():
|
||||
# le vrai serveur sur un port libre, une séance au faux client : la garde, l'analyse, le flux, le PDF absent
|
||||
import json
|
||||
import shutil
|
||||
import socket
|
||||
import threading
|
||||
import time
|
||||
import urllib.request
|
||||
from urllib.error import HTTPError
|
||||
import uvicorn
|
||||
import seance
|
||||
import serveur
|
||||
with socket.socket() as so:
|
||||
so.bind(("127.0.0.1", 0))
|
||||
port = so.getsockname()[1]
|
||||
cases = seance.CASES
|
||||
seance.CASES, serveur.CLIENT = seance_temporaire(), FauxClient(reponse([Bloc(type="text", text="Bonjour Marc")], "end_turn"))
|
||||
srv = uvicorn.Server(uvicorn.Config(serveur.app, host="127.0.0.1", port=port, log_level="error"))
|
||||
threading.Thread(target=srv.run, daemon=True).start()
|
||||
while not srv.started:
|
||||
time.sleep(0.05)
|
||||
base = f"http://127.0.0.1:{port}"
|
||||
|
||||
def appel(chemin, corps=None, entetes=None):
|
||||
r = urllib.request.Request(base + chemin, json.dumps(corps).encode() if corps is not None else None,
|
||||
{"Content-Type": "application/json", **(entetes or {})})
|
||||
try:
|
||||
with urllib.request.urlopen(r) as rep:
|
||||
return rep.status
|
||||
except HTTPError as e:
|
||||
return e.code
|
||||
try:
|
||||
assert appel("/api/pdf", entetes={"Host": "evil.example:80"}) == 403
|
||||
assert appel("/api/analyser", {"mail": "x"}, {"Content-Type": "text/plain"}) == 403
|
||||
assert appel("/api/analyser", {"mail": " "}) == 400
|
||||
assert appel("/api/analyser", {"mail": "Bonjour", "contexte": "", "images": []}) == 200
|
||||
with urllib.request.urlopen(base + "/api/flux", timeout=10) as f:
|
||||
premier, textes = None, []
|
||||
for ligne in f:
|
||||
if ligne.startswith(b"data: "):
|
||||
m = json.loads(ligne[6:])
|
||||
premier = premier or m
|
||||
textes += [e["texte"] for e in m["evenements"]]
|
||||
if "Bonjour Marc" in textes and not m["occupe"]["support"]:
|
||||
break
|
||||
assert premier["depuis"] == 0 and premier["id"], premier
|
||||
assert appel("/api/pdf") == 404
|
||||
(serveur.etat["seance"].dossier / "v1.pdf").write_bytes(b"%PDF-1.4")
|
||||
with urllib.request.urlopen(base + "/api/pdf") as rep:
|
||||
assert rep.read() == b"%PDF-1.4" and rep.headers["Content-Disposition"].startswith("inline"), rep.headers
|
||||
finally:
|
||||
srv.should_exit = True
|
||||
shutil.rmtree(seance.CASES)
|
||||
seance.CASES = cases
|
||||
|
||||
|
||||
CHECKS = [check_serveur, check_lire_document, check_cartes, check_stabilite, check_image_proche, check_max_tokens, check_sans_repli, check_capture_reduite, check_stations_dans_la_seance, check_boucle, check_erreur, check_cout, check_source, check_outil_qui_leve, check_lecture_refusee,
|
||||
CHECKS = [check_lire_document, check_cartes, check_stabilite, check_image_proche, check_max_tokens, check_sans_repli, check_capture_reduite, check_stations_dans_la_seance, check_boucle, check_erreur, check_cout, check_source, check_outil_qui_leve, check_lecture_refusee,
|
||||
check_chemin, check_station_absente, check_detecteurs, check_plafond, check_image, check_compiler]
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -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; }
|
||||
@@ -14,7 +14,7 @@ Cadrage du product owner : sous-projet G, santé des sites et notifications au c
|
||||
- **Maquettes du site** (D-022, D-039) : client « System Summary », une page par station, un bloc par domaine ; support « Home », une notification par station et par domaine Orange ou Red, liée à la vue client (D-025).
|
||||
- **Déplacements, le cap actuel : le journal du matin** (D-056). Une anomalie de déplacement est ce qui rend les courbes non plates : presque toujours un moment où il ne faut pas se fier aux données (pluie, buée, train, toile d'araignée, turbulence…), parfois un vrai mouvement (E-004, incident de Barcelone). Détecteurs élémentaires classés par catégorie (D-074), onglet `Journal` de la maquette Explore, amélioration par `/events-learner` (D-057), base d'events `events/` revue par `/review-event` (D-075). Les détecteurs s'alignent sur toutes les étiquettes de `labeling/auto/`, sans events (D-118) : l'`etiqueteur` étiquette en amont, puis `/detector-learner <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 par l'API Claude** (D-133), le passage à l'opérationnel : sous-projet autonome `API/`, séparé de `.claude/` ; une web app `support` (React et FastAPI, D-137), deux clients API (support, analyste), un PDF qui répond au mail du client ; workflow validé par l'utilisateur le 2026-11-05 sur un premier cas réel (Crissier, LENZSPITZE, `API/cases/`) ; la copie des détecteurs à rafraîchir après leur optimisation. Préalable : les détecteurs lisent la caméra et les métriques (point 78 du plan vivant).
|
||||
- **Support par l'API Claude** (D-133), le passage à l'opérationnel : sous-projet autonome `API/`, séparé de `.claude/`, deux clients API (support, analyste), un PDF qui répond au mail du client ; workflow validé par l'utilisateur le 2026-11-05 sur un premier cas réel (Crissier, LENZSPITZE, `API/cases/`) ; la copie des détecteurs à rafraîchir après leur optimisation. La web app `app/` (React, Mantine, FastAPI, D-137, D-138) les pilote, et centralise le diagnostic manuel : pages Support, Images et Étiquetage. Préalable : les détecteurs lisent la caméra et les métriques (point 78 du plan vivant).
|
||||
- **Agent de diagnostic** (D-046, D-058, D-082) : gardé dans le doute, pour un cas que les détecteurs n'expliquent pas.
|
||||
- **En attente** : agents LLM côté serveur (D-027) et enquête par API (D-042), documents seulement ; communication avec la caméra (dev container, D-038), en attente de la doc de l'API REST ; détection des sauts et tendances (D-055, onglet `Displacements`), très expérimentale.
|
||||
- **Prochaine étape** :
|
||||
@@ -116,6 +116,7 @@ python3 -m venv .venv && .venv/bin/pip install plotly matplotlib # recréer .
|
||||
- `agent-diagnostic/` : consignes (`instructions.md`, 146 l) et rapports de l'agent de diagnostic (D-082). Appel : `@agent-diagnostic data/<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.
|
||||
- `API/` : le support par l'API Claude (D-133), un sous-projet autonome : sa doc dans `API/README.md`, ses copies dans `API/PROVENANCE.md` ; les agents Claude Code n'y lisent rien, et lui ne lit rien du reste du dépôt hors de `data/`.
|
||||
- `app/` : la web app (D-137, D-138), sa doc dans `app/README.md` : `serveur/` (FastAPI), `web/` (React, Mantine) ; pages Support (pilote les agents de `API/`), Images et Étiquetage (comme `view.py` et `labeling.py`, elle écrit dans `labeling/`).
|
||||
- `extraction/` : pompage `pomper.py` des données de la plateforme (D-056), en lecture seule, lancé par l'utilisateur dans le dev container de l'application de référence `~/monitoring-dashboard` ; sans argument, il met à jour jusqu'à maintenant les stations de `stations.txt` (D-096) ; mode d'emploi `extraction/README.md`.
|
||||
|
||||
### Code, données, configuration
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
web/node_modules/
|
||||
web/dist/
|
||||
__pycache__/
|
||||
@@ -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).
|
||||
@@ -0,0 +1,2 @@
|
||||
fastapi
|
||||
uvicorn
|
||||
@@ -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).
|
||||
Réglages : AIMSIGHT_DATA (données), AIMSIGHT_CASES (séances), AIMSIGHT_PORT (port, 8770).
|
||||
Les pages Images et Étiquetage lisent data/ et les étiquettes de labeling/ (station.py).
|
||||
Réglages : AIMSIGHT_DATA (données), AIMSIGHT_LABELS (étiquettes), AIMSIGHT_CASES (séances), AIMSIGHT_PORT (port, 8770).
|
||||
"""
|
||||
import asyncio
|
||||
import base64
|
||||
@@ -16,16 +18,19 @@ import webbrowser
|
||||
from pathlib import Path
|
||||
|
||||
import uvicorn
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi import FastAPI, Query, Request
|
||||
from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
|
||||
|
||||
import station
|
||||
from fastapi.staticfiles import StaticFiles
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||
from seance import API, Seance, donnees_par_defaut # noqa: E402
|
||||
APP = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(APP.parent / "API" / "support")) # les agents du support
|
||||
from seance import Seance, donnees_par_defaut # noqa: E402
|
||||
|
||||
PORT = int(os.environ.get("AIMSIGHT_PORT", 8770))
|
||||
HOTES = {"127.0.0.1", "localhost"} # contre le DNS rebinding : un autre site ne lit ni mails ni PDF
|
||||
PAGE = API / "web" / "dist"
|
||||
PAGE = APP / "web" / "dist"
|
||||
CLIENT = None # le client Anthropic des séances ; None : le vrai (check.py y met un faux)
|
||||
verrou = threading.Lock()
|
||||
etat = {"seance": None, "evenements": []}
|
||||
@@ -55,7 +60,7 @@ async def garde(request: Request, suite):
|
||||
"""Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne
|
||||
peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
|
||||
hote = request.headers.get("host", "").rsplit(":", 1)[0]
|
||||
if hote not in HOTES or (request.method == "POST"
|
||||
if hote not in HOTES or (request.method in ("POST", "PUT", "DELETE")
|
||||
and not request.headers.get("content-type", "").startswith("application/json")):
|
||||
return erreur(403, "requête refusée")
|
||||
return await suite(request)
|
||||
@@ -68,6 +73,7 @@ def instantane(depuis: int) -> dict:
|
||||
v = s.derniere_version() if s else None
|
||||
return {"evenements": evs, "n": n, "cout": s.cout() if s else None, "version": v.name if v else None,
|
||||
"dossier": s.dossier.name if s else None, "id": s.id if s else None,
|
||||
"station": s.station if s else None,
|
||||
"occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}}
|
||||
|
||||
|
||||
@@ -132,12 +138,62 @@ def message(corps: dict):
|
||||
return {}
|
||||
|
||||
|
||||
# --- les pages Images et Étiquetage (station.py)
|
||||
|
||||
@app.exception_handler(station.Refus)
|
||||
def refus(_, e):
|
||||
return erreur(400, str(e))
|
||||
|
||||
|
||||
@app.get("/api/stations")
|
||||
def stations():
|
||||
return station.stations()
|
||||
|
||||
|
||||
@app.get("/api/images")
|
||||
def images(station_: str = Query(alias="station"), du: str = "", au: str = ""):
|
||||
return station.images(station_, du, au)
|
||||
|
||||
|
||||
@app.get("/api/image/{station_}/{nom}")
|
||||
def image(station_: str, nom: str):
|
||||
return FileResponse(station.image(station_, nom), headers={"Cache-Control": "max-age=86400"})
|
||||
|
||||
|
||||
@app.get("/api/courbes")
|
||||
def courbes(station_: str = Query(alias="station"), du: str = "", au: str = ""):
|
||||
return station.courbes(station_, du, au)
|
||||
|
||||
|
||||
@app.get("/api/etiquettes")
|
||||
def etiquettes(station_: str = Query(alias="station"), dossier: str = "manual"):
|
||||
try:
|
||||
return station.lire(station_, dossier)
|
||||
except json.JSONDecodeError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier
|
||||
return erreur(500, f"labeling/{dossier}/{station_}.jsonl illisible : {e}")
|
||||
|
||||
|
||||
@app.post("/api/etiquettes")
|
||||
def ajouter(corps: dict):
|
||||
return station.ajouter(corps)
|
||||
|
||||
|
||||
@app.put("/api/etiquettes")
|
||||
def modifier(corps: dict):
|
||||
return station.modifier(corps)
|
||||
|
||||
|
||||
@app.delete("/api/etiquettes")
|
||||
def supprimer(corps: dict):
|
||||
return station.supprimer(corps)
|
||||
|
||||
|
||||
if PAGE.is_dir():
|
||||
app.mount("/", StaticFiles(directory=PAGE, html=True), name="page")
|
||||
else:
|
||||
@app.get("/")
|
||||
def sans_page():
|
||||
return erreur(503, "la page n'est pas construite : cd API/web && npm install && npm run build")
|
||||
return erreur(503, "la page n'est pas construite : cd app/web && npm install && npm run build")
|
||||
|
||||
|
||||
def ouvrir(url: str) -> None:
|
||||
@@ -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.
@@ -10,6 +10,7 @@
|
||||
"@mantine/hooks": "^9.7.5",
|
||||
"@mantine/notifications": "^9.7.5",
|
||||
"@tabler/icons-react": "^3.50.0",
|
||||
"plotly.js-dist-min": "^4.2.0",
|
||||
"react": "^19.3.1",
|
||||
"react-dom": "^19.3.1"
|
||||
},
|
||||
@@ -814,6 +815,11 @@
|
||||
"url": "https://github.com/sponsors/jonschlinkert"
|
||||
}
|
||||
},
|
||||
"node_modules/plotly.js-dist-min": {
|
||||
"version": "4.2.0",
|
||||
"resolved": "https://registry.npmjs.org/plotly.js-dist-min/-/plotly.js-dist-min-4.2.0.tgz",
|
||||
"integrity": "sha512-nxwhTxrRtQAWcZLBplb7xi73o0P2z/zjNuh1RKO4ssmPK7Kh30bQcObnAJhekBogI2rqUMbM0JJZC0TrG5Tq5Q=="
|
||||
},
|
||||
"node_modules/postcss": {
|
||||
"version": "8.5.32",
|
||||
"resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.32.tgz",
|
||||
@@ -11,6 +11,7 @@
|
||||
"@mantine/hooks": "^9.7.5",
|
||||
"@mantine/notifications": "^9.7.5",
|
||||
"@tabler/icons-react": "^3.50.0",
|
||||
"plotly.js-dist-min": "^4.2.0",
|
||||
"react": "^19.3.1",
|
||||
"react-dom": "^19.3.1"
|
||||
},
|
||||
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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.
@@ -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>
|
||||
);
|
||||
}
|
||||
@@ -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 {
|
||||
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 { ActionIcon, Badge, Button, Grid, Group, Image, Paper, ScrollArea, SimpleGrid, Stack, Text, Textarea, Title, Tooltip } from "@mantine/core";
|
||||
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"];
|
||||
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;
|
||||
}
|
||||
export const AGENTS = ["support", "analyste"];
|
||||
export const NOMS = { support: "Support", analyste: "Analyste" };
|
||||
|
||||
// Un événement d'un agent → ce que montre son fil
|
||||
function message(e) {
|
||||
@@ -27,66 +18,10 @@ function message(e) {
|
||||
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>;
|
||||
}
|
||||
|
||||
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 }) {
|
||||
const [mail, setMail] = useState(""), [contexte, setContexte] = useState(""), [images, setImages] = useState([]);
|
||||
|
||||
@@ -174,42 +109,33 @@ function Rapport({ version, dossier }) {
|
||||
);
|
||||
}
|
||||
|
||||
export default function App() {
|
||||
const [etat, setEtat] = useState({ occupe: { support: false, analyste: false } });
|
||||
const [evenements, setEvenements] = useState([]);
|
||||
const [mobile, { toggle: basculerMobile }] = useDisclosure(false);
|
||||
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();
|
||||
}, []);
|
||||
// Les 7 derniers jours, sur la station de la séance : la plage du client se règle ensuite dans la page
|
||||
function lien(page, station) {
|
||||
const du = new Date(Date.now() - 7 * 864e5).toISOString().slice(0, 10);
|
||||
return `#/${page}?station=${encodeURIComponent(station)}&du=${du}`;
|
||||
}
|
||||
|
||||
export default function Support({ etat, evenements }) {
|
||||
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 etat={etat} />
|
||||
<AppShell.Main bg="var(--mantine-color-default-hover)">
|
||||
<Stack gap="lg">
|
||||
<div>
|
||||
<Title order={2}>Support</Title>
|
||||
<Text c="dimmed">Colle le mail du client et ton contexte, puis Analyser ; parle au support ou à l'analyste dans leur fil.</Text>
|
||||
</div>
|
||||
<Saisie occupe={etat.occupe.support || etat.occupe.analyste} />
|
||||
<SimpleGrid cols={{ base: 1, md: 2 }} spacing="lg">
|
||||
{AGENTS.map(a => <Fil key={a} agent={a} occupe={etat.occupe[a]} seance={etat.dossier}
|
||||
evenements={evenements.filter(e => e.agent === a)} />)}
|
||||
</SimpleGrid>
|
||||
<Rapport version={etat.version} dossier={etat.dossier} />
|
||||
</Stack>
|
||||
</AppShell.Main>
|
||||
</AppShell>
|
||||
<Stack gap="lg">
|
||||
<Group justify="space-between" align="flex-end">
|
||||
<div>
|
||||
<Title order={2}>Support</Title>
|
||||
<Text c="dimmed">Colle le mail du client et ton contexte, puis Analyser ; parle au support ou à l'analyste dans leur fil.</Text>
|
||||
</div>
|
||||
{etat.station && (
|
||||
<Group gap="xs">
|
||||
<Button component="a" href={lien("images", etat.station)} variant="light" leftSection={<IconPhoto size={16} />}>Images de {etat.station}</Button>
|
||||
<Button component="a" href={lien("etiquetage", etat.station)} variant="light" leftSection={<IconChartLine size={16} />}>Étiquetage</Button>
|
||||
</Group>
|
||||
)}
|
||||
</Group>
|
||||
<Saisie occupe={etat.occupe.support || etat.occupe.analyste} />
|
||||
<SimpleGrid cols={{ base: 1, md: 2 }} spacing="lg">
|
||||
{AGENTS.map(a => <Fil key={a} agent={a} occupe={etat.occupe[a]} seance={etat.dossier}
|
||||
evenements={evenements.filter(e => e.agent === a)} />)}
|
||||
</SimpleGrid>
|
||||
<Rapport version={etat.version} dossier={etat.dossier} />
|
||||
</Stack>
|
||||
);
|
||||
}
|
||||
@@ -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
@@ -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)
|
||||
- **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).
|
||||
- **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).
|
||||
|
||||
## 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`.
|
||||
@@ -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).
|
||||
|
||||
## 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
|
||||
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/`.
|
||||
Reference in new issue
Block a user