2026-10-30 08:59:38 +01:00
"""L'outil d'étiquetage de l'expert (D-098, point 68 du plan du journal du matin) : se repérer dans le temps et écrire ce qu'on
voit, en langage naturel, sans catégorie ; les données se consultent sur le monitoring. En haut, le data loader de la page
2026-10-30 11:23:31 +01:00
Status ; un menu déroulant, un plot à la fois, comme le menu Advanced d'Explore, plus les métriques système numériques de
metrics/ (« System: … », sans les identifiants) ; dessous, une barre de temps aux mêmes abscisses, qui suit le zoom : y glisser sélectionne une plage, puis du texte et Add. Add écrit aussitôt une ligne dans
2026-10-30 08:59:38 +01:00
labeling/<STATION>.jsonl : {"debut": "2026-10-08T01:00Z", "fin": "2026-10-08T02:45Z", "description": "…"}, en UTC, les noms
2026-11-02 08:56:16 +01:00
de champs de l'analyste (etiquettes.json). Les zones étiquetées sont grisées sur tous les plots ; sur la barre, une barre
chacune, son texte au survol, celles qui se chevauchent l'une sous l'autre. Un clic sur l'une l'affiche dessous, et Save y
2026-11-02 09:56:04 +01:00
enregistre son nouveau texte, Delete la retire ; ses bornes se corrigent dans ce fichier, puis recharger la page. Au survol
d'une courbe : le capteur, sa valeur et l'heure (UTC). Son serveur
2026-11-02 08:56:16 +01:00
local (http://127.0.0.1:8767, lancé en tâche de fond) sert out/ et data/, plus /analyse (ce script lancé à chaque fois, comme
2026-11-02 09:56:04 +01:00
le data loader) et /labels (lire, ajouter, modifier, retirer) ; un changement de son code demande de l'arrêter (run.md).
2026-10-30 08:59:38 +01:00
Usage : python3 labeling/labeling.py [<dossier de station> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ]]
(sans dossier : le data loader seul ; --au exclu ; sans dates, toute la période du dossier ; page :
out/labeling_<STATION>_<du>_<au>.html, ouverte)
"""
import argparse
2026-10-30 11:23:31 +01:00
import glob
2026-10-30 08:59:38 +01:00
import html
import http.server
import json
import os
2026-10-30 11:23:31 +01:00
import re
2026-10-30 08:59:38 +01:00
import sys
from datetime import datetime
from pathlib import Path
from urllib.parse import parse_qs , urlsplit
ICI = Path ( __file__ ) . resolve () . parent
sys . path [: 0 ] = [ str ( ICI . parent / "detectors-view" ), str ( ICI . parent / "detectors-view" / "data-loader" )]
import chargeur # noqa: E402 (son formulaire, son serveur ; bascule seule sur .venv si plotly manque)
import detecteurs # noqa: E402 (les couleurs et les références de la page Status)
2026-10-30 11:23:31 +01:00
from common.stations import load_csv , parse_name # noqa: E402
2026-10-30 08:59:38 +01:00
from detecteurs import ROOT , donnees # noqa: E402
from plotly.offline import get_plotlyjs_version # noqa: E402
PORT = 8767 # ni celui de common.page (8765), ni celui du data loader (8766)
# Le menu Advanced d'Explore (select_graph, Dashboard/layouts/ExploreLayout.py de l'application de référence), dans son ordre
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)" ))
CAMERA = "Camera movement"
2026-10-30 11:23:31 +01:00
# Pas de copie des identifiants (CLAUDE.md, « data/ ») : ces fichiers ne sont pas lus ; SIM_CCID a souvent l'air d'un nombre.
IDENTIFIANT = re . compile ( r "SIM_CCID$|ip(_|$)" )
2026-10-30 08:59:38 +01:00
FORMAT = "%Y-%m- %d T%H:%MZ"
# Une figure Plotly n'a qu'un mode de glissement : le plot zoome, la barre, figure à part, sélectionne. Elle reprend à chaque
# changement du plot sa plage et ses marges, la légende pouvant les élargir : c'est ce qui garde les abscisses alignées.
PAGE_JS = """
const GRIS = '#6b6b66', BLEU = '#2a78d6', VOIE = 22; // VOIE : px par rangée d'étiquettes
const fig = document.getElementById('fig'), barre = document.getElementById('barre'), menu = document.getElementById('plot');
const texte = document.getElementById('texte'), add = document.getElementById('add'), plage = document.getElementById('plage');
2026-11-02 08:56:16 +01:00
const edition = document.getElementById('edition'), editPlage = document.getElementById('edit-plage'), editTexte = document.getElementById('edit-texte');
const save = document.getElementById('save'), note = document.getElementById('edit-note');
2026-10-30 08:59:38 +01:00
const AIDE = plage.textContent;
2026-11-02 08:56:16 +01:00
// choix : la plage sélectionnée, [debut, fin] au format des étiquettes ; tries : les étiquettes dans l'ordre de la barre ;
// ouverte : celle affichée sous la barre
let labels = [], choix = null, tries = [], ouverte = null;
2026-10-30 08:59:38 +01:00
const lisible = s => s.slice(0, 16).replace('T', ' ');
const marge = () => ({l: 60, r: 20, t: 10, b: 30});
function zones() {
const z = (a, b, couleur, o) => ({type: 'rect', xref: 'x', yref: 'paper', x0: lisible(a), x1: lisible(b), y0: 0, y1: 1,
fillcolor: couleur, opacity: o, line: {width: 0} , layer: 'below'});
return labels.map(l => z(l.debut, l.fin, GRIS, 0.2)).concat(choix ? [z(choix[0], choix[1], BLEU, 0.25)] : []);
}
function aligne() {
const f = fig._fullLayout;
if (!barre._fullLayout) return; // au chargement, la barre se dessine juste après le plot
return Plotly.relayout(barre, {'xaxis.range': f.xaxis.range.slice(), 'margin.l': f._size.l, 'margin.r': f._size.r});
}
function dessineFig() {
const p = PLOTS[menu.value];
// uirevision : le zoom et les capteurs cachés restent d'un plot à l'autre ; l'ordonnée, propre à chaque plot, se recale
// uid sans espace ni parenthèse : Plotly s'en sert comme d'un sélecteur CSS
2026-10-30 11:23:31 +01:00
return Plotly.react(fig, 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, '_'),
2026-11-02 09:56:04 +01:00
line: t.line, hovertemplate: `$ {t.name} : % {y} <br>%{x|%Y-%m- %d %H:%M} UTC<extra></extra>`})),
2026-10-30 08:59:38 +01:00
{height: 460, 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);
}
function dessineBarre() {
2026-11-02 08:56:16 +01:00
tries = [...labels].sort((a, b) => a.debut < b.debut ? -1 : 1);
const voies = [], voie = tries.map(l => { // la première rangée libre, sinon une nouvelle, comme les status
2026-10-30 08:59:38 +01:00
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._fullLayout;
return Plotly.react(barre, [{type: 'bar', orientation: 'h', y: voie, base: tries.map(l => lisible(l.debut)),
2026-11-02 10:01:46 +01:00
x: tries.map(l => Date.parse(l.fin) - Date.parse(l.debut)), width: 0.85, marker: {color: GRIS, line: {color: 'white', width: 2}}, // le liseré sépare deux étiquettes bout à bout
text: tries.map(l => l.description),
2026-10-30 08:59:38 +01:00
textposition: 'inside', insidetextanchor: 'start', textangle: 0, unselected: {marker: {opacity: 1} }, // sinon une sélection les pâlit
2026-11-02 08:56:16 +01:00
hoverinfo: 'text', hovertext: tries.map(l => `${lisible(l.debut)} → ${lisible(l.fin)} UTC<br>${l.description.replace(/ \\ n/g, '<br>')}<br><i>click: read, edit</i>`)}],
2026-10-30 08:59:38 +01:00
{height: 40 + VOIE * n, dragmode: 'select', selectdirection: 'h', hovermode: 'closest', plot_bgcolor: '#f2f2ef', showlegend: false,
margin: {...marge(), l: f._size.l, r: f._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});
}
function maj() {
plage.textContent = choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : AIDE;
add.disabled = !(choix && choix[0] < choix[1] && texte.value.trim());
}
function choisit(c) {
choix = c;
maj();
return Plotly.relayout(fig, {shapes: zones()});
}
2026-11-02 08:56:16 +01:00
const modifiee = () => ouverte && editTexte.value.trim() !== ouverte.description;
function majEdition(message = '') {
save.disabled = !modifiee() || !editTexte.value.trim();
note.textContent = message;
}
function ouvre(l) { // l : l'étiquette à afficher, null pour fermer ; un texte modifié, non enregistré, ne se perd pas sans le dire
if (modifiee() && !confirm('Discard your changes to this label?')) return;
ouverte = l;
edition.hidden = !l;
if (!l) return;
editPlage.textContent = `${lisible(l.debut)} → ${lisible(l.fin)} UTC`;
editTexte.value = l.description;
majEdition();
edition.scrollIntoView({block: 'nearest'});
}
editTexte.oninput = () => majEdition();
document.getElementById('fermer').onclick = () => ouvre(null);
2026-11-02 09:56:04 +01:00
document.getElementById('supprimer').onclick = async () => {
if (!confirm('Delete this label?')) return;
const r = await fetch('/labels', {method: 'DELETE', body: JSON.stringify({station: STATION, avant: ouverte})}).catch(e => e);
if (!r.ok) return alert('Not deleted: ' + (r.statusText || r.message));
labels = labels.filter(l => l !== ouverte);
ouverte = null;
edition.hidden = true;
await dessineBarre();
await Plotly.relayout(fig, {shapes: zones()});
};
2026-11-02 08:56:16 +01:00
save.onclick = async () => {
save.disabled = true;
const corps = {station: STATION, avant: ouverte, description: editTexte.value.trim()};
const r = await fetch('/labels', {method: 'PUT', body: JSON.stringify(corps)}).catch(e => e);
if (!r.ok) { // rien n'est perdu : le texte reste dans la fenêtre
majEdition();
return alert('Not saved: ' + (r.statusText || r.message));
}
ouverte.description = (await r.json()).description;
editTexte.value = ouverte.description;
await dessineBarre();
majEdition('Saved');
};
2026-10-30 08:59:38 +01:00
menu.onchange = dessineFig;
texte.oninput = maj;
add.onclick = async () => {
add.disabled = true;
const corps = {station: STATION, debut: choix[0], fin: choix[1], description: texte.value.trim()};
const r = await fetch('/labels', {method: 'POST', body: JSON.stringify(corps)}).catch(e => e);
if (!r.ok) { // rien n'est perdu : le texte et la plage restent dans la page
maj();
return alert('Not saved: ' + (r.statusText || r.message));
}
labels.push(await r.json());
texte.value = '';
await dessineBarre();
await Plotly.relayout(barre, {selections: []});
await choisit(null);
};
dessineFig().then(dessineBarre).then(() => {
fig.on('plotly_relayout', aligne);
barre.on('plotly_selected', ev => {
const r = ev && ev.range && ev.range.x;
if (r) choisit(r.map(v => String(v).slice(0, 16).replace(' ', 'T') + 'Z'));
});
barre.on('plotly_deselect', () => choisit(null));
2026-11-02 08:56:16 +01:00
barre.on('plotly_click', ev => ouvre(tries[ev.points[0].pointIndex]));
2026-10-30 08:59:38 +01:00
// Lues à chaque chargement, pas écrites dans la page : recharger montre toujours le fichier.
fetch('/labels?station=' + encodeURIComponent(STATION))
.then(r => r.ok ? r.json() : Promise.reject(new Error(r.statusText)))
.then(l => {
labels = l.filter(x => x.debut < B && x.fin > A);
return dessineBarre().then(() => Plotly.relayout(fig, {shapes: zones()}));
})
.catch(e => alert('Labels not read: ' + e.message));
});
"""
2026-10-30 11:23:31 +01:00
def metriques ( dossier , a , b ):
"""Les métriques système numériques de metrics/ sur [a, b) -> {nom: {t: valeur ou None}}, sans celles qui n'ont aucune valeur."""
series = {}
for p in sorted ( glob . glob ( os . path . join ( dossier , "metrics" , "*.csv" ))):
n = parse_name ( p )
if n and not IDENTIFIANT . match ( n [ 1 ]):
try :
series . setdefault ( n [ 1 ], {}) . update ( load_csv ( p )) # à heure égale, le dernier fichier, comme load_stations
except ValueError : # une métrique texte (link, mode…) : pas de courbe
pass
dans = { m : { t : v if isinstance ( v , float ) else None for t , v in sorted ( s . items ()) if a <= t < b } for m , s in series . items ()}
return { m : s for m , s in dans . items () if any ( v is not None for v in s . values ())}
def plots ( mesures , poses , systeme , a , b ):
2026-10-30 08:59:38 +01:00
"""-> (T, [plot]) : T, les heures de chaque série, une fois, elles reviennent dans chaque plot (clé : le capteur, "" pour la
2026-10-30 11:23:31 +01:00
caméra, « system: » et son nom pour une métrique) ; plot : titre et traces (name, t : sa clé dans T, y, line ; mode pour
les métriques, horaires : une valeur seule entre deux trous ne se verrait pas sans marqueur), sans les plots ni les capteurs vides."""
2026-10-30 08:59:38 +01:00
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 = detecteurs . references ( mesures , a , b )
out = []
for col , titre in PLOTS :
series = { s : valeurs ( ms , col ) for s , ms in dans . items ()}
traces = [{ "name" : s + " (ref.)" * ( s in refs ), "t" : s , "y" : y ,
"line" : { "width" : 1.2 , "color" : detecteurs . COULEURS [ i % len ( detecteurs . COULEURS )], "dash" : "dot" if s in refs else "solid" }}
for i , ( s , y ) in enumerate ( series . items ()) if any ( v is not None for v in y )]
if traces :
out . append ({ "titre" : titre , "traces" : traces })
if poses :
out . append ({ "titre" : CAMERA + " (deg)" , "traces" : [{ "name" : c , "t" : "" , "y" : valeurs ( poses , c ), "line" : { "width" : 1.2 , "color" : couleur }}
for c , couleur in detecteurs . POSE ]})
2026-10-30 11:23:31 +01:00
T = { "" : [ heure ( p [ "t" ]) for p in poses ], ** { s : [ heure ( m [ "t" ]) for m in ms ] for s , ms in dans . items ()}}
for nom in sorted ( systeme , key = str . lower ):
s = systeme [ nom ]
T [ "system:" + nom ] = [ heure ( t ) for t in s ]
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 s . values ()],
"line" : { "width" : 1.2 , "color" : detecteurs . COULEURS [ 0 ]}}]})
return T , out
2026-10-30 08:59:38 +01:00
def page ( dossier , du = None , au = None ):
mesures = donnees . charger ( dossier )
if not mesures :
raise SystemExit ( f "Aucun export « advanced » dans { dossier } ." )
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 ])
2026-10-30 11:23:31 +01:00
T , liste = plots ( mesures , [ p for p in donnees . charger_camera ( dossier ) if a <= p [ "t" ] < b ], metriques ( dossier , a , b ), a , b )
2026-10-30 08:59:38 +01:00
if not liste :
raise SystemExit ( f "Aucune mesure dans { dossier } du { du } au { au } ." )
station = os . path . basename ( os . path . normpath ( dossier ))
nom = f " { station } _ { donnees . iso ( a )[: 10 ] } _ { donnees . iso ( b )[: 10 ] } "
chemin = ROOT / "out" / f "labeling_ { nom } .html"
chemin . parent . mkdir ( exist_ok = True )
js = lambda v : json . dumps ( v , separators = ( "," , ":" )) . replace ( "</" , "< \\ /" ) # noqa: E731
options = "" . join ( f '<option value=" { i } "> { html . escape ( p [ "titre" ]) } </option>' for i , p in enumerate ( liste ))
chemin . write_text ( f """<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Labeling { html . escape ( nom ) } </title>
<script src="https://cdn.plot.ly/plotly- { get_plotlyjs_version () } .min.js"></script>
<style>body {{ font-family:system-ui,sans-serif;margin:16px;background:#fff;color:#1a1a19 }}
2026-11-02 08:56:16 +01:00
textarea {{ width:100%;box-sizing:border-box;font:inherit;padding:6px }} select,button {{ font:inherit }} #plage {{ margin:8px 0 }}
2026-11-02 09:56:04 +01:00
#edition {{ border:1px solid #d5d5d0;border-radius:6px;padding:8px 12px;margin:8px 0;background:#f7f7f4 }} #edition textarea {{ margin-top:6px }} #edition p {{ margin:6px 0 0;display:flex;gap:6px;align-items:center }}
#supprimer {{ margin-left:auto;color:#fff;background:#c0392b;border:1px solid #a93226;border-radius:4px;padding:1px 10px }} </style></head><body>
2026-10-30 08:59:38 +01:00
<h2>Labeling, { html . escape ( station ) } </h2>
{ chargeur . formulaire ( station , du or "" , au or "" ) }
<label>Plot <select id="plot"> { options } </select></label>
<div id="fig"></div>
<div id="barre"></div>
2026-11-02 08:56:16 +01:00
<section id="edition" hidden><b id="edit-plage"></b>
2026-11-02 09:57:09 +01:00
<textarea id="edit-texte" rows="5"></textarea>
2026-11-02 09:56:04 +01:00
<p><button id="save" disabled>Save</button> <button id="fermer">Close</button> <span id="edit-note"></span><button id="supprimer">Delete</button></p></section>
2026-10-30 08:59:38 +01:00
<p id="plage">Drag on the bar above to select a time range.</p>
2026-11-02 09:57:09 +01:00
<textarea id="texte" rows="5" placeholder="What do we see in this range?"></textarea>
2026-10-30 08:59:38 +01:00
<p><button id="add" disabled>Add</button></p>
<script>const T = { js ( T ) } , PLOTS = { js ( liste ) } , STATION = { js ( station ) } , A = { js ( donnees . iso ( a )) } , B = { js ( donnees . iso ( b )) } ;
{ PAGE_JS } </script>
</body></html>""" , encoding = "utf-8" )
return chemin
def fichier ( station ):
return ICI / f " { station } .jsonl"
def lire ( station ):
f = fichier ( station )
# 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 ajouter ( corps ):
"""Le corps d'un Add (station, debut, fin, description) -> l'étiquette écrite ; ValueError s'il n'est pas bon."""
station , debut , fin , description = corps [ "station" ], corps [ "debut" ], corps [ "fin" ], corps [ "description" ] . strip ()
2026-11-02 09:42:08 +01:00
if station not in chargeur . stations (): # le nom devient un chemin : une station de data/, rien d'autre
2026-10-30 08:59:38 +01:00
raise ValueError ( "unknown station" )
if not description or datetime . strptime ( debut , FORMAT ) >= datetime . strptime ( fin , FORMAT ):
raise ValueError ( "empty text or range" )
label = { "debut" : debut , "fin" : fin , "description" : description }
f = fichier ( station )
# Une ligne retirée à la main peut laisser le fichier sans fin de ligne : la suivante se collerait à elle.
avant = f . read_bytes () if f . exists () else b ""
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
2026-11-02 08:56:16 +01:00
def modifier ( corps ):
"""Le corps d'un Save (station, avant : l'étiquette telle que la page l'a lue, description : le nouveau texte) -> l'étiquette
2026-11-02 09:56:04 +01:00
écrite ; ValueError s'il n'est pas bon."""
2026-11-02 08:56:16 +01:00
station , avant , description = corps [ "station" ], corps [ "avant" ], corps [ "description" ] . strip ()
2026-11-02 09:42:08 +01:00
if station not in chargeur . stations ():
2026-11-02 08:56:16 +01:00
raise ValueError ( "unknown station" )
if not description :
raise ValueError ( "empty text" )
2026-11-02 09:56:04 +01:00
label = { ** avant , "description" : description }
label . pop ( "revue" , None ) # texte changé : à revoir par le label-reviewer (D-101)
return remplace ( station , avant , label )
def supprimer ( corps ):
"""Le corps d'un Delete (station, avant : l'étiquette telle que la page l'a lue) -> l'étiquette retirée."""
if corps [ "station" ] not in chargeur . stations ():
raise ValueError ( "unknown station" )
remplace ( corps [ "station" ], corps [ "avant" ], None )
return corps [ "avant" ]
def remplace ( station , avant , label ):
"""Remplace l'étiquette avant par label (None : la retire) -> label. Retrouvée par son contenu, pas par son rang : le
fichier a pu changer à la main depuis le chargement de la page. Les autres lignes restent telles quelles."""
2026-11-02 08:56:16 +01:00
f = fichier ( station )
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 :
2026-11-02 09:56:04 +01:00
lignes [ i : i + 1 ] = [] if label is None else [ json . dumps ( label , ensure_ascii = False )]
2026-11-02 08:56:16 +01:00
provisoire = f . with_name ( f . name + ".tmp" ) # écrit à côté puis remplacé : une coupure ne peut pas abîmer le fichier
provisoire . write_text ( " \n " . join ( lignes ), encoding = "utf-8" )
os . replace ( provisoire , f )
return label
raise ValueError ( "this label is no longer in the file, reload the page" )
2026-10-30 08:59:38 +01:00
class Serveur ( chargeur . Chargeur ):
SCRIPT = __file__
def repond ( self , valeur ):
corps = json . dumps ( valeur , ensure_ascii = False ) . encode ()
self . send_response ( 200 )
self . send_header ( "Content-Type" , "application/json; charset=utf-8" )
self . send_header ( "Content-Length" , str ( len ( corps )))
self . end_headers ()
self . wfile . write ( corps )
def do_GET ( self ):
url = urlsplit ( self . path )
if url . path != "/labels" :
return super () . do_GET ()
station = parse_qs ( url . query ) . get ( "station" , [ "" ])[ 0 ]
2026-11-02 09:42:08 +01:00
if station not in chargeur . stations ():
2026-10-30 08:59:38 +01:00
return self . send_error ( 400 , "Unknown station" )
try :
self . repond ( lire ( station ))
except ValueError as e : # une ligne abîmée à la main : le dire, sans toucher au fichier
self . send_error ( 500 , f "labeling/ { station } .jsonl unreadable: { e } " )
2026-11-02 08:56:16 +01:00
def ecrit ( self , action ):
2026-10-30 08:59:38 +01:00
if self . path != "/labels" :
return self . send_error ( 404 )
# Ce fichier sera lu par l'analyste : une autre page du navigateur ne doit pas pouvoir y écrire.
if self . headers . get ( "Origin" ) not in ( None , f "http://127.0.0.1: { PORT } " ):
return self . send_error ( 403 )
try :
2026-11-02 08:56:16 +01:00
self . repond ( action ( json . loads ( self . rfile . read ( int ( self . headers [ "Content-Length" ])))))
2026-10-30 08:59:38 +01:00
except ( KeyError , TypeError , AttributeError , ValueError ) as e :
2026-11-02 08:56:16 +01:00
self . send_error ( 400 , str ( e ))
def do_POST ( self ):
self . ecrit ( ajouter )
def do_PUT ( self ):
self . ecrit ( modifier )
2026-10-30 08:59:38 +01:00
2026-11-02 09:56:04 +01:00
def do_DELETE ( self ):
self . ecrit ( supprimer )
2026-10-30 08:59:38 +01:00
if __name__ == "__main__" :
if sys . argv [ 1 :] == [ "serve" ]:
http . server . ThreadingHTTPServer (( "127.0.0.1" , PORT ), Serveur ) . serve_forever ()
p = argparse . ArgumentParser ( description = __doc__ , formatter_class = argparse . RawDescriptionHelpFormatter )
p . add_argument ( "dossier" , nargs = "?" , help = "sans dossier : le data loader seul" )
p . add_argument ( "--du" )
p . add_argument ( "--au" )
p . add_argument ( "--sans-ouvrir" , action = "store_true" , help = "écrit la page sans l'ouvrir" )
o = p . parse_args ()
chemin = page ( o . dossier , o . du , o . au ) if o . dossier else chargeur . accueil ( "Labeling" , "labeling-loader" )
print ( chemin )
if not o . sans_ouvrir :
chargeur . open_served ( chemin , PORT , __file__ )