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

+116
View File
@@ -0,0 +1,116 @@
"""Vérifications de la web app, sans appel à l'API (faux client) : API/.venv/bin/python app/serveur/check.py [nom]"""
import json
import shutil
import socket
import sys
import threading
import time
import urllib.request
from pathlib import Path
from urllib.error import HTTPError
ICI = Path(__file__).resolve().parent
sys.path[:0] = [str(ICI), str(ICI.parents[1] / "API" / "support")]
import uvicorn # noqa: E402
import seance # noqa: E402
import serveur # noqa: E402
import station # noqa: E402
from check import Bloc, FauxClient, reponse, seance_temporaire # noqa: E402 (les faux de API/support/check.py)
def check_serveur():
# le vrai serveur sur un port libre, une séance au faux client : la garde, l'analyse, le flux, le PDF absent
with socket.socket() as so:
so.bind(("127.0.0.1", 0))
port = so.getsockname()[1]
cases = seance.CASES
seance.CASES, serveur.CLIENT = seance_temporaire(), FauxClient(reponse([Bloc(type="text", text="Bonjour Marc")], "end_turn"))
srv = uvicorn.Server(uvicorn.Config(serveur.app, host="127.0.0.1", port=port, log_level="error"))
threading.Thread(target=srv.run, daemon=True).start()
while not srv.started:
time.sleep(0.05)
base = f"http://127.0.0.1:{port}"
def appel(chemin, corps=None, entetes=None):
r = urllib.request.Request(base + chemin, json.dumps(corps).encode() if corps is not None else None,
{"Content-Type": "application/json", **(entetes or {})})
try:
with urllib.request.urlopen(r) as rep:
return rep.status
except HTTPError as e:
return e.code
try:
assert appel("/api/pdf", entetes={"Host": "evil.example:80"}) == 403
assert appel("/api/analyser", {"mail": "x"}, {"Content-Type": "text/plain"}) == 403
assert appel("/api/analyser", {"mail": " "}) == 400
assert appel("/api/analyser", {"mail": "Bonjour", "contexte": "", "images": []}) == 200
with urllib.request.urlopen(base + "/api/flux", timeout=10) as f:
premier, textes = None, []
for ligne in f:
if ligne.startswith(b"data: "):
m = json.loads(ligne[6:])
premier = premier or m
textes += [e["texte"] for e in m["evenements"]]
if "Bonjour Marc" in textes and not m["occupe"]["support"]:
break
assert premier["depuis"] == 0 and premier["id"], premier
assert appel("/api/pdf") == 404
(serveur.etat["seance"].dossier / "v1.pdf").write_bytes(b"%PDF-1.4")
with urllib.request.urlopen(base + "/api/pdf") as rep:
assert rep.read() == b"%PDF-1.4" and rep.headers["Content-Disposition"].startswith("inline"), rep.headers
finally:
srv.should_exit = True
shutil.rmtree(seance.CASES)
seance.CASES = cases
def leve(f, *a):
try:
f(*a)
except station.Refus as e:
return str(e)
raise AssertionError(f"{f.__name__}{a} n'a pas refusé")
def check_station():
# les données des pages Images et Étiquetage, sur les vraies données ; les étiquettes dans un dossier temporaire
assert "NIEDERHORN" in station.stations()
im = station.images("NIEDERHORN", "2026-09-25", "2026-09-26")
assert im["images"] and im["positions"] and set(im["corr"]) == set(im["positions"]), list(im)
assert all(len(c) == len(im["images"]) for c in im["corr"].values())
assert station.image("NIEDERHORN", im["images"][0]["nom"]).is_file()
leve(station.image, "NIEDERHORN", "../../../.env")
leve(station.images, "../API", "", "")
assert station.images("LENZSPITZE", "2026-10-26", "2026-10-27")["images"]
c = station.courbes("LENZSPITZE", "2026-10-26", "2026-10-27")
titres = [p["titre"] for p in c["plots"]]
assert "Relative Corrected Vertical Shift" in titres and any(t.startswith("System: ") for t in titres), titres
assert not any("SIM_CCID" in t or t.startswith("System: ip") for t in titres)
assert all(len(c["T"][tr["t"]]) == len(tr["y"]) for p in c["plots"] for tr in p["traces"])
avant, station.ETIQUETTES = station.ETIQUETTES, seance_temporaire()
try:
e = station.ajouter({"station": "NIEDERHORN", "dossier": "auto", "debut": "2026-09-25T01:00Z",
"fin": "2026-09-25T02:00Z", "categorie": "Visibility", "description": "brouillard"})
assert e["id"] == "NIEDERHORN-1" and next(iter(e)) == "id", e
e2 = station.modifier({"station": "NIEDERHORN", "dossier": "auto", "avant": e,
"debut": e["debut"], "fin": e["fin"], "categorie": "", "description": "pluie"})
assert e2 == {"id": "NIEDERHORN-1", "debut": e["debut"], "fin": e["fin"], "description": "pluie"}, e2
assert station.lire("NIEDERHORN", "auto") == [e2]
assert "plus dans le fichier" in leve(station.supprimer, {"station": "NIEDERHORN", "dossier": "auto", "avant": e})
station.supprimer({"station": "NIEDERHORN", "dossier": "auto", "avant": e2})
assert station.lire("NIEDERHORN", "auto") == []
leve(station.ajouter, {"station": "NIEDERHORN", "dossier": "../x", "debut": "a", "fin": "b", "description": "x"})
leve(station.ajouter, {"station": "NIEDERHORN", "debut": "2026-09-25T02:00Z", "fin": "2026-09-25T01:00Z", "description": "x"})
finally:
shutil.rmtree(station.ETIQUETTES)
station.ETIQUETTES = avant
CHECKS = [check_serveur, check_station]
if __name__ == "__main__":
nom = sys.argv[1] if len(sys.argv) > 1 else None
for f in CHECKS:
if nom in (None, f.__name__):
f()
print("ok", f.__name__)
+211
View File
@@ -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)
+257
View File
@@ -0,0 +1,257 @@
"""Les données des pages Images et Étiquetage : les images d'une station, ses courbes, ses étiquettes.
Repris de view/view.py et labeling/labeling.py (le calcul, pas les pages) ; positions, references, COULEURS, POSE et
attribuer sont copiés de detectors-view/detecteurs.py et labeling/ids.py (app/README.md, « Copies »). La lecture des données est
celle des agents, API/tools/agent-tools/donnees.py. Lecture seule sur data/ ; écrit seulement dans labeling/{auto,manual}/.
"""
import bisect
import csv
import glob
import json
import os
import re
import statistics
import sys
from datetime import datetime, timedelta
from pathlib import Path
RACINE = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(RACINE / "API" / "tools" / "agent-tools"))
import donnees # noqa: E402
DONNEES = Path(os.environ.get("AIMSIGHT_DATA", RACINE / "data")).resolve()
ETIQUETTES = Path(os.environ.get("AIMSIGHT_LABELS", RACINE / "labeling")).resolve()
DOSSIERS = ("auto", "manual") # celles de l'étiqueteur (D-105), celles de Marc (D-102)
FAMILLES = ("Visibility", "Obstruction", "Thermal displacement", "Displacement", "Target issue", "No data", "None") # D-109
FORMAT = "%Y-%m-%dT%H:%MZ"
MARGE_PX = 150 # detecteurs.MARGE_PX : x, y ne sont des positions dans l'image que loin du coin
COULEURS = ["#2a78d6", "#eb6834", "#1baf7a", "#8a5cd6", "#d6a12a", "#d63b8a", "#3bb3d6", "#6b6b66"] # un capteur chacun
POSE = (("pan", "#1a1a19"), ("tilt", "#8a8a85"), ("rotation", "#b5651d"))
# Le menu Advanced d'Explore, dans son ordre (labeling.PLOTS, QUALITE)
PLOTS = (("error_value", "Error value"), ("x", "X [px]"), ("y", "Y [px]"),
("relative_x", "Relative Horizontal Shift"), ("relative_y", "Relative Vertical Shift"),
("corr_x", "Relative Corrected Horizontal Shift"), ("corr_y", "Relative Corrected Vertical Shift"),
("reproj_err", "References (reproj. error)"))
QUALITE = (("peak", "Quality: Peak"), ("flux", "Quality: Flux"), ("sharpness", "Quality: Sharpness"),
("fwhm", "Quality: FWHM [px]"), ("dominance", "Quality: Dominance"), ("snr", "Quality: SNR"))
IDENTIFIANT = re.compile(r"(SIM_CCID|ip(_.*)?)$") # jamais lus (CLAUDE.md, « data/ »)
METRIQUE = re.compile(r"^(.+?)_\d{4}_\d{2}_\d{2}_")
class Refus(ValueError):
"""Une demande à refuser (400), avec sa raison."""
def stations():
return sorted(d.name for d in DONNEES.iterdir() if d.is_dir())
def dossier(station):
if station not in stations(): # le nom devient un chemin : un dossier de data/, rien d'autre
raise Refus(f"station inconnue : {station}")
return DONNEES / station
def bornes(du, au):
return donnees.instant(du or "0001-01-01"), donnees.instant(au or "9999-01-01")
# --- detectors-view/detecteurs.py
def positions(mesures, a, b):
"""La position médiane de chaque capteur dans l'image sur [a, b) ({} si x, y n'y sont pas des positions)."""
maisons = {s: (statistics.median(xs), statistics.median(ys)) for s, ms in mesures.items()
if (xs := [m["x"] for m in ms if a <= m["t"] < b and m["x"] is not None])
and (ys := [m["y"] for m in ms if a <= m["t"] < b and m["y"] is not None])}
return maisons if any(abs(x) > MARGE_PX or abs(y) > MARGE_PX for x, y in maisons.values()) else {}
def references(mesures, a, b):
"""Capteurs de la compensation sur la plage : ceux qui ont un reproj_err (références seulement)."""
return {s for s, ms in mesures.items() if any(m["reproj_err"] is not None for m in ms if a <= m["t"] < b)}
# --- la page Images (view/view.py)
def images(station, du, au):
"""Les images de [du, au), les positions médianes des capteurs, les références, et par capteur entouré son corr_x,
corr_y à l'heure de chaque image : la mesure valide la plus proche, à 30 min près, sinon 0."""
d, (a, b) = dossier(station), bornes(du, au)
vues = [(t, im) for im in sorted(glob.glob(str(d / "images" / "*"))) if (t := donnees.heure_image(im)) and a <= t < b]
if not vues:
raise Refus(f"aucune image de {station} sur cette plage")
mesures = donnees.charger(d)
maisons, refs = positions(mesures, a, b), references(mesures, a, b)
# ponytail: une seule mesure à chaque borne, bruitée ; une médiane sur une fenêtre si les flèches tremblent trop
marge, corr = timedelta(minutes=30), {}
for s in maisons:
serie = [(m["t"], m["corr_x"], m["corr_y"]) for m in mesures[s] if m["corr_x"] is not None and m["corr_y"] is not None]
temps, corr[s] = [m[0] for m in serie], []
for t, _ in vues:
k = bisect.bisect_left(temps, t)
k = min((n for n in (k - 1, k) if 0 <= n < len(serie)), key=lambda n: abs(temps[n] - t), default=None)
corr[s].append([round(serie[k][1], 4), round(serie[k][2], 4)] if k is not None and abs(temps[k] - t) <= marge else 0)
return {"images": [{"t": donnees.iso(t).replace("T", " ").rstrip("Z"), "nom": os.path.basename(im)} for t, im in vues],
"positions": {s: [round(x, 1), round(y, 1)] for s, (x, y) in sorted(maisons.items())},
"references": sorted(refs), "corr": corr}
def image(station, nom):
f = (dossier(station) / "images" / nom).resolve()
if f.parent != (DONNEES / station / "images").resolve() or not f.is_file():
raise Refus("image inconnue")
return f
# --- la page Étiquetage (labeling/labeling.py)
def metriques(d, a, b):
"""Les métriques système numériques de metrics/ sur [a, b) -> {nom: {t: valeur ou None}} (une valeur vide : None, le
trou se voit), sans les métriques texte, les identifiants, ni celles qui n'ont aucune valeur."""
station, series, texte = d.name + "_", {}, set()
for p in sorted(glob.glob(str(d / "metrics" / "*.csv"))):
if not (m := METRIQUE.match(os.path.basename(p))) or IDENTIFIANT.match(nom := m.group(1).removeprefix(station)):
continue
with open(p, newline="") as f:
for r in csv.DictReader(f):
t, v = donnees.instant(r["time_utc"]), (r.get("metric") or "").strip("[]'\" ")
if not a <= t < b:
continue
try:
series.setdefault(nom, {})[t] = float(v) if v else None
except ValueError:
texte.add(nom) # link, mode… : pas de courbe
return {n: dict(sorted(s.items())) for n, s in series.items()
if n not in texte and any(v is not None for v in s.values())}
def courbes(station, du, au):
"""-> {A, B, T, plots} : T, les heures de chaque série, une fois (clé : le capteur, "" pour la caméra, « system: »
et son nom pour une métrique) ; plot : titre et traces (name, t, y, line, mode), sans plots ni capteurs vides."""
d = dossier(station)
mesures = donnees.charger(d)
if not mesures:
raise Refus(f"aucun export « advanced » pour {station}")
tous = sorted({m["t"] for ms in mesures.values() for m in ms})
a = donnees.instant(du) if du else tous[0]
b = donnees.instant(au) if au else tous[-1] + (tous[-1] - tous[-2] if len(tous) > 1 else timedelta(hours=1))
poses = [p for p in donnees.charger_camera(d) if a <= p["t"] < b]
heure = lambda t: t.strftime("%Y-%m-%d %H:%M") # noqa: E731 (UTC, sans fuseau : comme l'affiche Plotly)
valeurs = lambda s, c: [None if m[c] is None else round(m[c], 5) for m in s] # noqa: E731
dans = {s: [m for m in mesures[s] if a <= m["t"] < b] for s in sorted(mesures)}
refs, out = references(mesures, a, b), []
def par_capteur(colonnes):
for col, titre in colonnes:
traces = [{"name": s + " (ref.)" * (s in refs), "t": s, "y": y,
"line": {"width": 1.2, "color": COULEURS[i % len(COULEURS)], "dash": "dot" if s in refs else "solid"}}
for i, (s, y) in enumerate((s, valeurs(ms, col)) for s, ms in dans.items()) if any(v is not None for v in y)]
if traces:
out.append({"titre": titre, "traces": traces})
par_capteur(PLOTS)
if poses:
out.append({"titre": "Camera movement (deg)", "traces": [{"name": c, "t": "", "y": valeurs(poses, c),
"line": {"width": 1.2, "color": col}} for c, col in POSE]})
par_capteur(QUALITE)
T = {"": [heure(p["t"]) for p in poses], **{s: [heure(m["t"]) for m in ms] for s, ms in dans.items()}}
systeme = metriques(d, a, b)
for nom in sorted(systeme, key=str.lower):
T["system:" + nom] = [heure(t) for t in systeme[nom]]
out.append({"titre": "System: " + nom, "traces": [{"name": nom, "t": "system:" + nom, "mode": "lines+markers",
"y": [None if v is None else round(v, 5) for v in systeme[nom].values()],
"line": {"width": 1.2, "color": COULEURS[0]}}]})
if not out:
raise Refus(f"aucune mesure de {station} sur cette plage")
return {"A": donnees.iso(a), "B": donnees.iso(b), "T": T, "plots": out}
# --- les étiquettes (labeling/labeling.py, labeling/ids.py)
def fichier(station, source):
if source not in DOSSIERS:
raise Refus("dossier d'étiquettes inconnu")
dossier(station)
return ETIQUETTES / source / f"{station}.jsonl"
def lire(station, source):
f = fichier(station, source)
# split et non splitlines : celui-ci couperait aussi sur les séparateurs Unicode que le texte peut contenir
return [json.loads(l) for l in f.read_text(encoding="utf-8").split("\n") if l.strip()] if f.exists() else []
def attribuer(station, etiquettes):
"""labeling/ids.attribuer (D-131) : un id aux étiquettes qui n'en ont pas, le suivant de la station, en premier champ."""
n = max((int(e["id"].rsplit("-", 1)[1]) for e in etiquettes if "id" in e), default=0)
for e in etiquettes:
if "id" not in e:
n += 1
e["id"] = f"{station}-{n}"
if next(iter(e)) != "id":
reste = {k: v for k, v in e.items() if k != "id"}
ident = e["id"]
e.clear()
e.update({"id": ident}, **reste)
def _valide(corps, debut, fin):
description = (corps.get("description") or "").strip()
try:
vide = datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT)
except (TypeError, ValueError):
raise Refus("bornes illisibles (AAAA-MM-JJTHH:MMZ)") from None
if not description or vide:
raise Refus("texte vide ou plage vide")
c = corps.get("categorie") or ""
if c and c not in FAMILLES:
raise Refus("famille inconnue")
return description, c
def ajouter(corps):
station, source = corps.get("station"), corps.get("dossier", "manual")
f = fichier(station, source)
description, c = _valide(corps, corps.get("debut"), corps.get("fin"))
label = {"debut": corps["debut"], "fin": corps["fin"]} | ({"categorie": c} if c else {}) | {"description": description}
if source == "auto": # une étiquette automatique porte un id stable, le suivant de sa station (D-131)
attribuer(station, lire(station, "auto") + [label])
f.parent.mkdir(parents=True, exist_ok=True)
avant = f.read_bytes() if f.exists() else b"" # une ligne retirée à la main peut laisser le fichier sans fin de ligne
with open(f, "ab") as sortie:
sortie.write(b"\n" * bool(avant and not avant.endswith(b"\n")) + json.dumps(label, ensure_ascii=False).encode() + b"\n")
return label
def modifier(corps):
avant = corps.get("avant") or {}
debut, fin = corps.get("debut", avant.get("debut")), corps.get("fin", avant.get("fin"))
description, c = _valide(corps, debut, fin)
label = dict.fromkeys(("id", "debut", "fin", "categorie")) | avant | {"debut": debut, "fin": fin, "categorie": c,
"description": description}
if label["id"] is None:
del label["id"]
if not c:
del label["categorie"]
label.pop("revue", None) # changée : à revoir par /review-labels (D-103)
return remplace(corps.get("station"), corps.get("dossier", "manual"), avant, label)
def supprimer(corps):
remplace(corps.get("station"), corps.get("dossier", "manual"), corps.get("avant"), None)
return corps.get("avant")
def remplace(station, source, avant, label):
"""Remplace l'étiquette avant par label (None : la retire), retrouvée par son contenu, pas par son rang : le fichier
a pu changer depuis le chargement de la page. Écrit à côté puis remplace : une coupure n'abîme pas le fichier."""
f = fichier(station, source)
lignes = f.read_text(encoding="utf-8").split("\n") if f.exists() else []
for i, ligne in enumerate(lignes):
if ligne.strip() and json.loads(ligne) == avant:
lignes[i:i + 1] = [] if label is None else [json.dumps(label, ensure_ascii=False)]
provisoire = f.with_name(f.name + ".tmp")
provisoire.write_text("\n".join(lignes), encoding="utf-8")
os.replace(provisoire, f)
return label
raise Refus("cette étiquette n'est plus dans le fichier : recharger la page")