app/: the web app in its own folder, with the Images and Labeling pages (D-138)

- app/serveur/ (FastAPI) and app/web/ (React, Mantine) moved out of API/, which keeps
  only the agents; the Support page drives them
- Images page: view.py in React (slider, zoom, sensor names, displacement arrows on a range)
- Labeling page: labeling.py in React (two aligned plots, label bar, add, edit, delete);
  labels are written to labeling/{auto,manual}/ of the repo (AIMSIGHT_LABELS)
- shared station and date selector kept in the address; buttons from a support session
- app/serveur/station.py: the data of both pages, copied computations listed in app/README.md
- app/serveur/check.py: server and station checks (labels in a temporary folder)

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

No files matched your search

+1 -57
View File
@@ -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__":
-155
View File
@@ -1,155 +0,0 @@
"""La web app support : API/.venv/bin/python API/support/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.
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).
"""
import asyncio
import base64
import json
import os
import platform
import subprocess
import sys
import threading
import webbrowser
from pathlib import Path
import uvicorn
from fastapi import FastAPI, Request
from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
from fastapi.staticfiles import StaticFiles
sys.path.insert(0, str(Path(__file__).resolve().parent))
from seance import API, 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"
CLIENT = None # le client Anthropic des séances ; None : le vrai (check.py y met un faux)
verrou = threading.Lock()
etat = {"seance": None, "evenements": []}
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
def journal(e: dict) -> None:
with verrou:
etat["evenements"].append(e)
def en_fond(f, *args):
def lancer():
try:
f(*args)
except Exception as e: # noqa: BLE001 — une erreur de la séance s'affiche dans la page, le serveur continue
journal({"agent": "support", "type": "erreur", "texte": f"{type(e).__name__}: {e}"})
threading.Thread(target=lancer, daemon=True).start()
def erreur(code: int, texte: str) -> JSONResponse:
return JSONResponse({"erreur": texte}, code)
@app.middleware("http")
async def garde(request: Request, suite):
"""Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne
peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas)."""
hote = request.headers.get("host", "").rsplit(":", 1)[0]
if hote not in HOTES or (request.method == "POST"
and not request.headers.get("content-type", "").startswith("application/json")):
return erreur(403, "requête refusée")
return await suite(request)
def instantane(depuis: int) -> dict:
s = etat["seance"]
with verrou:
evs, n = etat["evenements"][depuis:], len(etat["evenements"])
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,
"occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}}
@app.get("/api/flux")
async def flux(request: Request):
"""Un message à chaque changement : les nouveaux événements et l'état de la séance. Une nouvelle séance repart de
zéro (son id change) : la page vide alors ses fils."""
async def messages():
n, id_vu, dernier, calme = 0, None, None, 0
while not await request.is_disconnected():
s = etat["seance"]
if s and s.id != id_vu:
n, id_vu = 0, s.id
m = instantane(n)
reste = {k: v for k, v in m.items() if k != "evenements"}
if m["evenements"] or reste != dernier or dernier is None:
m["depuis"] = n # 0 : tout l'historique de la séance, la page remplace ses fils au lieu d'ajouter
n, dernier, calme = m["n"], reste, 0
yield f"data: {json.dumps(m, ensure_ascii=False)}\n\n"
elif (calme := calme + 1) >= 60: # ~15 s sans rien : un commentaire garde la connexion ouverte
calme = 0
yield ": calme\n\n"
await asyncio.sleep(0.25)
return StreamingResponse(messages(), media_type="text/event-stream", headers={"Cache-Control": "no-cache"})
@app.get("/api/pdf")
def pdf():
s = etat["seance"]
v = s.derniere_version() if s else None
if not v:
return erreur(404, "pas encore de PDF")
return FileResponse(v, media_type="application/pdf", filename=f"{s.dossier.name}_{v.name}",
content_disposition_type="inline")
@app.post("/api/analyser")
def analyser(corps: dict):
s = etat["seance"]
if s and (s.occupe("support") or s.occupe("analyste")):
return erreur(409, "une séance travaille encore")
if not corps.get("mail", "").strip():
return erreur(400, "le mail est vide")
images = [(i["type"], base64.b64decode(i["base64"])) for i in corps.get("images", [])]
s = Seance(corps["mail"], images, corps.get("contexte", ""), donnees_par_defaut(), journal, client=CLIENT)
with verrou:
etat["seance"], etat["evenements"] = s, []
en_fond(s.demarrer)
return {"dossier": s.dossier.name}
@app.post("/api/message")
def message(corps: dict):
s, agent, texte = etat["seance"], corps.get("agent"), corps.get("texte", "").strip()
if not s:
return erreur(400, "pas de séance : coller un mail et Analyser")
if agent not in ("support", "analyste") or not texte:
return erreur(400, "agent ou texte manquant")
if s.occupe(agent):
return erreur(409, f"{agent} occupé")
en_fond(s.parler, agent, texte)
return {}
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")
def ouvrir(url: str) -> None:
if "microsoft" in platform.uname().release.lower(): # WSL : le navigateur Windows
subprocess.Popen(["explorer.exe", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
else:
webbrowser.open(url)
if __name__ == "__main__":
url = f"http://127.0.0.1:{PORT}"
print(f"Support AIMsight : {url}")
if "--sans-navigateur" not in sys.argv:
threading.Timer(1, ouvrir, [url]).start()
uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)