"""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, avec au besoin sa famille (labeling/familles.md, D-109) ; les données se consultent sur le monitoring. En haut, le data loader de la page 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 labeling/manual/.jsonl (D-102), ou dans labeling/auto/.jsonl, celles de l'étiqueteur (D-105, D-106), au choix du menu Labels : {"debut": "2026-10-08T01:00Z", "fin": "2026-10-08T02:45Z", "categorie": "obstruction", "description": "…"}, en UTC, les noms 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 enregistre son nouveau texte, sa catégorie et ses bornes (deux champs de date, en UTC), Delete la retire. Au survol d'une courbe : le capteur, sa valeur et l'heure (UTC). Son serveur 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 le data loader) et /labels (lire, ajouter, modifier, retirer) ; un changement de son code demande de l'arrêter (run.md). Usage : python3 labeling/labeling.py [ [--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___.html, ouverte) """ import argparse import glob import html import http.server import json import os import re 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) from common.stations import load_csv, parse_name # noqa: E402 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) DOSSIERS = ("auto", "manual") # celles de l'étiqueteur (D-105, D-106), affichées par défaut, et celles de l'expert (D-102) # 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" # 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(_|$)") FORMAT = "%Y-%m-%dT%H:%MZ" # Les familles des étiquettes (labeling/familles.md, D-109 à D-111), plus « aucune » pour l'expert : ce qui ne touche pas les courbes CATEGORIES_LABELS = {"visibilite": "Visibility", "obstruction": "Obstruction", "deplacement_thermique": "Thermal displacement", "deplacement": "Displacement", "cible_degradee": "Faulty target", "trou": "No data", "aucune": "None (curves untouched)"} # 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 = """ // une couleur par famille, assez claire pour le texte de la barre ; GRIS : sans famille const COULEURS = {visibilite: '#8ec5e8', obstruction: '#f0b072', deplacement_thermique: '#f08a7e', deplacement: '#b39ddb', cible_degradee: '#e6d46a', trou: '#c4c4be', aucune: '#a8d5a2'}; const GRIS = '#6b6b66', couleur = l => COULEURS[l.categorie] || GRIS, BLEU = '#2a78d6', VOIE = 22; // VOIE : px par rangée d'étiquettes const fig = document.getElementById('fig'), barre = document.getElementById('barre'), menu = document.getElementById('plot'), fig2 = document.getElementById('fig2'), menu2 = document.getElementById('plot2'); const source = document.getElementById('source'); const texte = document.getElementById('texte'), add = document.getElementById('add'), plage = document.getElementById('plage'); const edition = document.getElementById('edition'), editTexte = document.getElementById('edit-texte'); const editDebut = document.getElementById('edit-debut'), editFin = document.getElementById('edit-fin'); // en UTC, sans le Z const save = document.getElementById('save'), note = document.getElementById('edit-note'); const categorie = document.getElementById('categorie'), editCategorie = document.getElementById('edit-categorie'); // '' : sans const AIDE = plage.textContent; // 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; const lisible = s => s.slice(0, 16).replace('T', ' '); const cat = l => l.categorie ? `[${CATS[l.categorie] || l.categorie}] ` : ''; 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, couleur(l), 0.3)).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) { if (!barre._fullLayout || !fig2._fullLayout) return; // au chargement, les plots se dessinent avant la barre const rg = src._fullLayout.xaxis.range.slice(); const l = Math.max(fig._fullLayout._size.l, fig2._fullLayout._size.l), r = Math.max(fig._fullLayout._size.r, fig2._fullLayout._size.r); return Promise.all([fig, fig2, barre].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.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 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}
%{x|%Y-%m-%d %H:%M} UTC`})), {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(g)); } function dessineBarre() { 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 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, g = fig2._fullLayout; return Plotly.react(barre, [{type: 'bar', orientation: 'h', y: voie, base: tries.map(l => lisible(l.debut)), x: tries.map(l => Date.parse(l.fin) - Date.parse(l.debut)), width: 0.85, marker: {color: tries.map(couleur), line: {color: 'white', width: 2}}, // le liseré sépare deux étiquettes bout à bout text: tries.map(l => cat(l) + l.description), textposition: 'inside', insidetextanchor: 'start', textangle: 0, unselected: {marker: {opacity: 1}}, // sinon une sélection les pâlit hoverinfo: 'text', hovertext: tries.map(l => `${lisible(l.debut)} → ${lisible(l.fin)} UTC
${cat(l)}${l.description.replace(/\\n/g, '
')}
click: read, edit`)}], {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}); } 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 Promise.all([fig, fig2].map(g => Plotly.relayout(g, {shapes: zones()}))); } const modifiee = () => ouverte && (editTexte.value.trim() !== ouverte.description || editCategorie.value !== (ouverte.categorie || '') || editDebut.value + 'Z' !== ouverte.debut || editFin.value + 'Z' !== ouverte.fin); function majEdition(message = '') { save.disabled = !modifiee() || !editTexte.value.trim() || !(editDebut.value && editFin.value && editDebut.value < editFin.value); 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; editDebut.value = l.debut.slice(0, 16); editFin.value = l.fin.slice(0, 16); editTexte.value = l.description; editCategorie.value = l.categorie || ''; majEdition(); edition.scrollIntoView({block: 'nearest'}); } editTexte.oninput = editDebut.oninput = editFin.oninput = editCategorie.onchange = () => majEdition(); document.getElementById('fermer').onclick = () => ouvre(null); document.getElementById('supprimer').onclick = async () => { if (!confirm('Delete this label?')) return; const r = await fetch('/labels', {method: 'DELETE', body: JSON.stringify({station: STATION, dossier: source.value, 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 choisit(choix); }; save.onclick = async () => { save.disabled = true; const corps = {station: STATION, dossier: source.value, avant: ouverte, debut: editDebut.value + 'Z', fin: editFin.value + 'Z', categorie: editCategorie.value, 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 et les bornes restent dans la fenêtre majEdition(); return alert('Not saved: ' + (r.statusText || r.message)); } const nouvelle = await r.json(); // remplace l'ancienne : un Save retire aussi son champ revue labels[labels.indexOf(ouverte)] = ouverte = nouvelle; await dessineBarre(); await choisit(choix); majEdition('Saved'); }; menu.onchange = () => dessineFig(fig, menu); menu2.onchange = () => dessineFig(fig2, menu2); source.onchange = () => { ouvre(null); if (ouverte) return source.value = DOSSIERS.find(d => d !== source.value); // changements gardés : on reste charge(); }; texte.oninput = maj; add.onclick = async () => { add.disabled = true; const corps = {station: STATION, dossier: source.value, debut: choix[0], fin: choix[1], categorie: categorie.value, 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 = categorie.value = ''; await dessineBarre(); await Plotly.relayout(barre, {selections: []}); await choisit(null); }; // corr_x et corr_y à l'ouverture, ce que l'étiquetage regarde d'abord ; sinon le premier et le suivant du menu const indice = (titre, sinon) => { const i = PLOTS.findIndex(p => p.titre === titre); return i < 0 ? sinon : i; }; menu.value = indice('Relative Corrected Horizontal Shift', 0); menu2.value = indice('Relative Corrected Vertical Shift', PLOTS.length > 1 ? 1 : 0); Promise.all([dessineFig(fig, menu), dessineFig(fig2, menu2)]).then(dessineBarre).then(() => aligne()).then(() => { fig.on('plotly_relayout', () => aligne(fig)); fig2.on('plotly_relayout', () => aligne(fig2)); 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)); barre.on('plotly_click', ev => ouvre(tries[ev.points[0].pointIndex])); charge(); }); // Lues à chaque chargement, pas écrites dans la page : recharger montre toujours le fichier. function charge() { return fetch('/labels?station=' + encodeURIComponent(STATION) + '&dossier=' + source.value) .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(() => Promise.all([fig, fig2].map(g => Plotly.relayout(g, {shapes: zones()})))); }) .catch(e => alert('Labels not read: ' + e.message)); } """ 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): """-> (T, [plot]) : T, les heures de chaque série, une fois, elles reviennent dans chaque plot (clé : le capteur, "" pour la 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.""" 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]}) 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 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]) T, liste = plots(mesures, [p for p in donnees.charger_camera(dossier) if a <= p["t"] < b], metriques(dossier, a, b), a, b) 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("{html.escape(p["titre"])}' for i, p in enumerate(liste)) cats = '' + "".join(f'' for k, v in CATEGORIES_LABELS.items()) chemin.write_text(f"""Labeling {html.escape(nom)}

Labeling, {html.escape(station)}

{chargeur.formulaire(station, du or "", au or "")}

Drag on the bar above to select a time range.

""", encoding="utf-8") return chemin def fichier(station, dossier): if dossier not in DOSSIERS: # devient un chemin, comme la station raise ValueError("unknown labels folder") return ICI / dossier / f"{station}.jsonl" def lire(station, dossier): f = fichier(station, dossier) # 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 categorie(corps): """La catégorie d'un Add ou d'un Save : une clé de CATEGORIES_LABELS, ou '' (sans catégorie).""" c = corps.get("categorie", "") if c and c not in CATEGORIES_LABELS: raise ValueError("unknown category") return c def ajouter(corps): """Le corps d'un Add (station, debut, fin, categorie, description) -> l'étiquette écrite ; ValueError s'il n'est pas bon.""" station, debut, fin, description = corps["station"], corps["debut"], corps["fin"], corps["description"].strip() if station not in chargeur.stations(): # le nom devient un chemin : une station de data/, rien d'autre raise ValueError("unknown station") if not description or datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT): raise ValueError("empty text or range") c = categorie(corps) label = {"debut": debut, "fin": fin} | ({"categorie": c} if c else {}) | {"description": description} f = fichier(station, corps.get("dossier", "manual")) # 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 def modifier(corps): """Le corps d'un Save (station, avant : l'étiquette telle que la page l'a lue, description : le nouveau texte, categorie, debut, fin : ses bornes, facultatives) -> l'étiquette écrite ; ValueError s'il n'est pas bon.""" station, avant, description = corps["station"], corps["avant"], corps["description"].strip() debut, fin = corps.get("debut", avant["debut"]), corps.get("fin", avant["fin"]) if station not in chargeur.stations(): raise ValueError("unknown station") if not description or datetime.strptime(debut, FORMAT) >= datetime.strptime(fin, FORMAT): raise ValueError("empty text or range") c = categorie(corps) if "categorie" in corps else avant.get("categorie", "") # debut, fin, categorie en tête, comme à l'Add ; les autres champs à leur place label = dict.fromkeys(("debut", "fin", "categorie")) | avant | {"debut": debut, "fin": fin, "categorie": c, "description": description} if not c: del label["categorie"] label.pop("revue", None) # texte, catégorie ou bornes changés : à revoir par /review-labels (D-103) return remplace(station, corps.get("dossier", "manual"), 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.get("dossier", "manual"), corps["avant"], None) return corps["avant"] def remplace(station, dossier, 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.""" f = fichier(station, dossier) 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") # é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") 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() q = parse_qs(url.query) station, dossier = q.get("station", [""])[0], q.get("dossier", ["manual"])[0] if station not in chargeur.stations() or dossier not in DOSSIERS: return self.send_error(400, "Unknown station or labels folder") try: self.repond(lire(station, dossier)) except ValueError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier self.send_error(500, f"labeling/{dossier}/{station}.jsonl unreadable: {e}") def ecrit(self, action): 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: self.repond(action(json.loads(self.rfile.read(int(self.headers["Content-Length"]))))) except (KeyError, TypeError, AttributeError, ValueError) as e: self.send_error(400, str(e)) def do_POST(self): self.ecrit(ajouter) def do_PUT(self): self.ecrit(modifier) def do_DELETE(self): self.ecrit(supprimer) 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__)