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
@@ -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__)
|
||||
@@ -0,0 +1,211 @@
|
||||
"""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 (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).
|
||||
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
|
||||
import json
|
||||
import os
|
||||
import platform
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import webbrowser
|
||||
from pathlib import Path
|
||||
|
||||
import uvicorn
|
||||
from fastapi import FastAPI, Query, Request
|
||||
from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
|
||||
|
||||
import station
|
||||
from fastapi.staticfiles import StaticFiles
|
||||
|
||||
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 = 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": []}
|
||||
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 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)
|
||||
|
||||
|
||||
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,
|
||||
"station": s.station 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 {}
|
||||
|
||||
|
||||
# --- 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 app/web && npm install && npm run build")
|
||||
|
||||
|
||||
def ouvrir(url: str) -> None:
|
||||
if "microsoft" in platform.uname().release.lower(): # WSL : le navigateur Windows
|
||||
subprocess.Popen(["explorer.exe", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
else:
|
||||
webbrowser.open(url)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
url = f"http://127.0.0.1:{PORT}"
|
||||
print(f"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)
|
||||
@@ -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")
|
||||
Reference in new issue
Block a user