Files
aimsight-app/app/web/src/pages/Data.jsx
T
maximeandClaude Opus 5.5 8c82368dec Aligné sur le dépôt detectors finalisé (3886196) : scripts/, events, /detectors:wf-improve avec sa requête complète
La page Data lit detectors/scripts/categories.py (events) ; « Optimiser » envoie à /detectors:wf-improve la plage
de l'analyse, ses étiquettes, la vérité de référence, les familles, rapport.md et le dossier de sortie
<analyse>/detectors/<heure>/, dont le summary.md est le bilan affiché. Run app ne monte detectors qu'une fois,
sur main, pour ne pas masquer les commits d'une optimisation. Docs et commandes (--from/--to) à jour.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 13:10:33 +01:00

563 lines
36 KiB
React
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { useEffect, useMemo, useRef, useState } from "react";
import {
ActionIcon, Badge, Button, Card, Checkbox, Grid, Group, Loader, NativeSelect, SegmentedControl, SimpleGrid, Stack, Switch, Text, Textarea, TextInput, Title, Tooltip,
useComputedColorScheme,
} from "@mantine/core";
import { IconPlus, IconX } from "@tabler/icons-react";
import { appel, Selecteur } from "../commun.jsx";
import { ImagesDe } from "./Images.jsx";
// Data, le visualiseur de courbes (et l'étiquetage de labeling/labeling.py) : un plot au départ, d'autres à ajouter ou enlever,
// tous alignés sur le temps ; sous eux les étiquettes : Detectors (les événements du journal), LLM (labeling/auto/, en lecture)
// ou Analysis (les mêmes, à modifier, supprimer ; glisser sur la barre sélectionne une plage, que l'analyste diagnostique et
// étiquette ; ailleurs, glisser zoome) ; un clic ouvre une
// étiquette et la met en évidence. À droite, les images de la station, et sous elles les paramètres du diagnostic.
const FAMILLES = { "Visibility": "#8ec5e8", "Obstruction": "#f0b072", "Thermal displacement": "#f08a7e", "Displacement": "#b39ddb",
"Target issue": "#e6d46a", "No data": "#c4c4be", "None": "#a8d5a2" };
const NOM_FAMILLE = f => (f === "None" ? "None (courbes intactes)" : f);
const CHOIX_FAMILLE = [{ value: "", label: "(sans famille)" }, ...Object.keys(FAMILLES).map(f => ({ value: f, label: NOM_FAMILLE(f) }))];
// LLM et Analysis : les mêmes étiquettes, labeling/auto/ ; LLM les lit, Analysis les modifie, supprime, et en fait faire par
// l'analyste sur une plage (app/serveur/analyse.py)
const SOURCES = [{ value: "detecteurs", label: "Detectors" }, { value: "auto", label: "LLM" }, { value: "analysis", label: "Analysis" }];
const GRIS = "#b0b0aa", BLEU = "#2a78d6", VOIE = 26, HAUT = 330; // VOIE : px par rangée d'étiquettes ; HAUT : d'un plot
const couleur = l => FAMILLES[l.categorie] || GRIS;
const lisible = s => s.slice(0, 16).replace("T", " ");
const marge = () => ({ l: 60, r: 20, t: 10, b: 30 });
// L'habillage, aux couleurs de Mantine (dark.0 à dark.7 en sombre, gray en clair)
const COULEURS = { clair: { texte: "#495057", faible: "#868e96", grille: "#eef0f2", axe: "#dee2e6", fond: "#f1f3f5", bulle: "#ffffff", zone: 0.05 },
sombre: { texte: "#c9c9c9", faible: "#828282", grille: "#2e2e2e", axe: "#424242", fond: "#3b3b3b", bulle: "#242424", zone: 0.07 } };
const POLICE = "Roboto, sans-serif";
const habillage = c => ({ paper_bgcolor: "rgba(0,0,0,0)", plot_bgcolor: "rgba(0,0,0,0)", font: { family: POLICE, size: 11, color: c.texte },
hoverlabel: { bgcolor: c.bulle, bordercolor: c.axe, align: "left", font: { family: POLICE, size: 12, color: c.texte } },
modebar: { bgcolor: "rgba(0,0,0,0)", color: c.faible, activecolor: "#5383ff" } });
const axe = c => ({ gridcolor: c.grille, linecolor: c.axe, showline: true, zeroline: false, ticks: "" });
const OUTILS = { responsive: true, doubleClick: "reset", displaylogo: false, showTips: false,
modeBarButtonsToRemove: ["lasso2d", "select2d", "autoScale2d", "zoomIn2d", "zoomOut2d", "hoverClosestCartesian", "hoverCompareCartesian", "toggleSpikelines"] };
const date = v => Date.parse(String(v).replace(" ", "T").replace(/Z?$/, "Z")); // une date Plotly ou d'étiquette -> ms UTC
const coupe = s => s.replace(/(.{1,80})(\s|$)/g, "$1<br>"); // la bulle : des lignes de 80 caractères au plus
const DETECTEES = Object.keys(FAMILLES).filter(f => f !== "None"); // les familles des détecteurs (categories.py)
export default function Data({ selection, choisir, analyse, setAnalyse }) {
const [donnees, setDonnees] = useState(null), [charge, setCharge] = useState(false), [large, setLarge] = useState(false);
const gauche = useRef(), [instant, setInstant] = useState(null); // instant : où caler les images (le début de l'événement cliqué)
// Les paramètres du diagnostic, sous l'image (Detectors et LLM) : familles montrées (filtre de la page) ; cibles gardées ("" :
// toutes ; sinon les détecteurs retournent sans les autres)
const [source, setSource] = useState("detecteurs"), [familles, setFamilles] = useState(DETECTEES), [cibles, setCibles] = useState("");
const [focus, setFocus] = useState(false); // un événement ouvert : les plots ne montrent que ses capteurs
const { station, du, au } = selection;
useEffect(() => {
setDonnees(null); setCibles("");
if (!station) return;
setCharge(true);
appel(`/api/courbes?${new URLSearchParams({ station, du, au })}`).then(d => { setDonnees(d); setCharge(false); });
}, [station, du, au]);
// Les colonnes glissent (style.css) ; Plotly ne suit que la fenêtre : à la fin du glissement, les plots se recalent sur leur
// nouvelle largeur (les redessiner à chaque image du glissement serait trop lourd)
const finGlissement = e => { if (e.target === gauche.current && e.propertyName === "max-width") dispatchEvent(new Event("resize")); };
return (
<Grid gutter="lg" className="data-grille" onTransitionEnd={finGlissement}>
<Grid.Col span={{ base: 12, lg: large ? 5 : 8 }} ref={gauche}>
<Stack gap="lg">
<div>
<Title order={2}>Data</Title>
<Text c="dimmed">Les courbes d'une station, un plot ou plusieurs ; sous eux les étiquettes : un clic sur l'une la met en évidence et
l'ouvre.</Text>
</div>
<Selecteur selection={selection} choisir={choisir} />
{charge && <Loader />}
{donnees && <Courbes key={`${station}${du}${au}`} selection={selection} d={donnees} caler={(t, proche) => setInstant({ t, proche })}
source={source} setSource={setSource} familles={familles} cibles={cibles} focus={focus}
analyse={analyse} setAnalyse={setAnalyse} />}
</Stack>
</Grid.Col>
<Grid.Col span={{ base: 12, lg: large ? 7 : 4 }}>
<div className="colle">
<Stack gap="lg">
<ImagesDe selection={selection} compacte large={large} basculer={() => setLarge(!large)} instant={instant} />
{donnees && <Parametres key={`${station}${du}${au}`} d={donnees} familles={familles} setFamilles={setFamilles}
cibles={cibles} setCibles={setCibles} detect={source === "detecteurs"}
focus={focus} setFocus={setFocus} />}
</Stack>
</div>
</Grid.Col>
</Grid>
);
}
// Les familles s'appliquent tout de suite (filtre de la page, Detectors et LLM) ; les cibles, au bouton : chaque jeu de cibles
// relance les détecteurs (les étiquettes LLM ne disent pas leurs capteurs : elles ne les filtrent pas)
function Parametres({ d, familles, setFamilles, cibles, setCibles, detect, focus, setFocus }) {
const capteurs = Object.keys(d.T).filter(k => k && !k.startsWith("system:"));
const refs = new Set(d.plots.flatMap(p => p.traces).filter(t => t.name.endsWith(" (ref.)")).map(t => t.t));
const [coches, setCoches] = useState(cibles ? cibles.split(",") : capteurs);
const voulu = coches.length === capteurs.length ? "" : capteurs.filter(c => coches.includes(c)).join(",");
return (
<Card shadow="sm" withBorder>
<Stack gap="sm">
<Title order={5}>Paramètres du diagnostic</Title>
<Switch label="Focus on event curves" description="Un événement ouvert : les plots ne montrent que ses capteurs"
checked={focus} onChange={e => setFocus(e.currentTarget.checked)} />
<Checkbox.Group label="Familles montrées" value={familles} onChange={setFamilles}>
<SimpleGrid cols={2} spacing={6} verticalSpacing={6} mt={6}>
{DETECTEES.map(f => <Checkbox key={f} size="xs" value={f} label={f} color={FAMILLES[f]} iconColor="#1a1b1e" />)}
</SimpleGrid>
</Checkbox.Group>
<Checkbox.Group label="Cibles considérées (les autres sont écartées)" value={coches} onChange={setCoches}>
<SimpleGrid cols={3} spacing={6} verticalSpacing={6} mt={6}>
{capteurs.map(c => <Checkbox key={c} size="xs" value={c} label={c + (refs.has(c) ? " (ref.)" : "")} />)}
</SimpleGrid>
</Checkbox.Group>
{!detect && <Text size="xs" c="dimmed">Les étiquettes ne disent pas leurs cibles : ce choix ne vaut que pour Detectors.</Text>}
<Group gap="sm">
<Button size="xs" onClick={() => setCibles(voulu)} disabled={!coches.length || voulu === cibles}>Relancer les détecteurs</Button>
<Button size="xs" variant="default" onClick={() => setCoches(coches.length ? [] : capteurs)}>{coches.length ? "Tout décocher" : "Tout cocher"}</Button>
</Group>
</Stack>
</Card>
);
}
// Une ligne de la fiche d'un événement des détecteurs : son nom, puis sa valeur
const Champ = ({ nom, children }) => (
<Group gap="sm" align="flex-start" wrap="nowrap">
<Text size="sm" c="dimmed" w={80} style={{ flexShrink: 0 }}>{nom}</Text>
<Text size="sm" component="div">{children}</Text>
</Group>
);
// Les capteurs d'un événement : ceux des détecteurs, sinon ceux que nomme le texte de l'étiquette (LLM, Analysis)
const nomme = (texte, s) => new RegExp(`(^|[^\\w])${s.replace(/[^\w]/g, "\\$&")}(?![\\w])`).test(texte);
const capteursDe = (l, noms) => l.capteurs ?? noms.filter(s => nomme(l.description, s));
// analyse : le dossier de l'analyse montrée, tenu par App (la barre latérale en ouvre une)
function Courbes({ selection: { station, du, au }, d, caler, source, setSource, familles, cibles, focus, analyse, setAnalyse }) {
const { A, B, T, plots: PLOTS } = d;
const indice = (titre, sinon) => { const i = PLOTS.findIndex(p => p.titre === titre); return i < 0 ? sinon : i; };
const [Plotly, setPlotly] = useState(null), [pret, setPret] = useState(false);
const [vues, setVues] = useState([{ id: 1, m: indice("Relative Corrected Horizontal Shift", 0) }]); // les plots affichés
const [choix, setChoix] = useState(null);
const [indices, setIndices] = useState(""), [rev, setRev] = useState(0);
const [ouverte, setOuverte] = useState(null), [edit, setEdit] = useState(null), [note, setNote] = useState("");
const [toutes, setToutes] = useState([]), [lecture, setLecture] = useState(true), sombre = useComputedColorScheme("light") === "dark";
// toutes : le fichier (ou les détecteurs) ; labels : sur la plage, dans les familles cochées (sans famille ou None : toujours)
const labels = useMemo(() => toutes.filter(x => x.debut < B && x.fin > A
&& (!DETECTEES.includes(x.categorie) || familles.includes(x.categorie))), [toutes, familles]);
const detect = source === "detecteurs", lecteur = source !== "analysis"; // seul Analysis écrit
const dossier = source === "analysis" ? "auto" : source; // le dossier de labeling/ des étiquettes
// figs : id -> div du plot ; dessines : id -> plot qu'il montre ; vue : la plage et la largeur où le texte des étiquettes a été tronqué
const figs = useRef({}), dessines = useRef({}), prochain = useRef(2), barre = useRef(), tries = useRef([]), vue = useRef(""), courant = useRef({});
// le focus : les capteurs de l'événement ouvert (aucun : tous, comme pour No data) ; montres, leur clé
const noms = useMemo(() => Object.keys(T).filter(k => k && !k.startsWith("system:")), [T]);
const gardes = focus && ouverte ? capteursDe(ouverte, noms) : [], montres = gardes.join(",");
courant.current = { vues, labels, choix, ouverte, ouvrir, gardes: new Set(gardes), montres, c: COULEURS[sombre ? "sombre" : "clair"] }; // ce que lisent les événements Plotly
useEffect(() => { import("plotly.js-dist-min").then(m => setPlotly(() => m.default)); }, []);
const liste = () => courant.current.vues.map(v => figs.current[v.id]).filter(g => g?._fullLayout);
// Les zones des étiquettes, la plage choisie, et l'étiquette ouverte : plus marquée, entourée
function zones() {
const { labels, choix, ouverte, c } = courant.current;
const z = (a, b, f, o, ligne = { width: 0 }, couche = "below") => ({ type: "rect", xref: "x", yref: "paper", x0: lisible(a), x1: lisible(b),
y0: 0, y1: 1, fillcolor: f, opacity: o, line: ligne, layer: couche });
return labels.map(l => z(l.debut, l.fin, couleur(l), c.zone)).concat(choix ? [z(choix[0], choix[1], BLEU, 0.25)] : [])
.concat(ouverte ? [z(ouverte.debut, ouverte.fin, couleur(ouverte), 0.3),
z(ouverte.debut, ouverte.fin, "rgba(0,0,0,0)", 1, { color: c.texte, width: 1.5, dash: "dot" }, "above")] : []);
}
// Le contour des barres : épais pour l'étiquette ouverte
const contour = t => {
const { ouverte, c } = courant.current;
return { color: t.map(l => (l === ouverte ? c.texte : c.fond)), width: t.map(l => (l === ouverte ? 3 : 1)) };
};
// Les plots et la barre partagent plage et marges : celui qui change impose les siens aux autres (rien si déjà alignés,
// sinon le relayout appelle aligne en boucle).
function aligne(src) {
const gs = liste(), b = barre.current;
if (!b?._fullLayout || !gs.length) return;
const rg = (src?._fullLayout ? src : gs[0])._fullLayout.xaxis.range.slice();
const l = Math.max(...gs.map(g => g._fullLayout._size.l)), r = Math.max(...gs.map(g => g._fullLayout._size.r));
return Promise.all([...gs, b].map(g => {
const m = g._fullLayout.margin, x = g._fullLayout.xaxis.range;
if (m.l === l && m.r === r && date(x[0]) === date(rg[0]) && date(x[1]) === date(rg[1])) return;
return Plotly.relayout(g, { "xaxis.range": rg, "margin.l": l, "margin.r": r });
})).then(recaleTexte);
}
// Le texte des étiquettes suit le zoom et la largeur de la barre (rien si les deux n'ont pas changé)
function recaleTexte() {
const b = barre.current, L = b?._fullLayout;
if (!L) return;
const v = `${L.xaxis.range}|${L._size.w}`;
if (v !== vue.current) { vue.current = v; return Plotly.restyle(b, { text: [textes(tries.current, L)] }); }
}
// Le texte de chaque étiquette, tronqué à la largeur visible de sa barre (~6 px par caractère en 11 px) ; pour un événement
// des détecteurs, sa famille seulement (ses capteurs dans la bulle, le reste au clic)
function textes(t, L) {
const [r0, r1] = L.xaxis.range.map(date), w = L._size.w;
return t.map(l => {
const x = l.message ? l.categorie : l.description;
const px = (Math.min(date(l.fin), r1) - Math.max(date(l.debut), r0)) / (r1 - r0) * w, n = Math.floor((px - 10) / 6);
return n < 3 ? "" : x.length <= n ? x : x.slice(0, n - 1) + "…";
});
}
// Une trace de capteur sous le focus : visible si c'est l'un des siens, sinon dans la légende seulement ; uirevision de la
// trace : le focus qui change l'emporte sur les clics de légende, qui restent tant qu'il ne change pas
function focalise(t) {
const { gardes, montres } = courant.current;
if (!montres || !t.t || t.t.startsWith("system:")) return { uirevision: montres || 1 };
return { visible: gardes.has(t.t) ? true : "legendonly", uirevision: montres };
}
function dessineFig(g, m) {
const p = PLOTS[m], { c } = courant.current, b = barre.current?._fullLayout;
g.style.height = `${HAUT}px`; // responsive : Plotly reprend la hauteur du div à chaque restyle, il lui en faut une
// uirevision : le zoom et les capteurs cachés restent quand on change de plot ; l'ordonnée, propre à chaque plot, se recale.
// Un nouveau plot prend la plage déjà affichée. t : la place du menu du plot (à gauche) et de la barre d'outils (à droite).
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, ...focalise(t),
hovertemplate: `${t.name} : %{y}<br>%{x|%Y-%m-%d %H:%M} UTC<extra></extra>` })),
{ ...habillage(c), height: HAUT, hovermode: "closest", margin: { ...marge(), t: 42, b: 36 }, uirevision: 1, shapes: zones(),
legend: { x: 1.01, y: 1, itemwidth: 30, font: { size: 11 } },
xaxis: { type: "date", range: b ? b.xaxis.range.slice() : [lisible(A), lisible(B)], ...axe(c) },
yaxis: { title: { text: p.titre, font: { size: 11, color: c.faible } }, uirevision: p.titre, ...axe(c) } },
OUTILS).then(() => {
if (!g.suivi) {
g.suivi = true;
g.on("plotly_relayout", () => aligne(g));
g.on("plotly_click", ev => caler(String(ev.points[0].x), true)); // un clic sur une courbe : l'image la plus proche
}
return aligne(g);
});
}
// Les plots nouveaux ou changés (tous : au changement de thème)
function dessinePlots(tous) {
return Promise.all(courant.current.vues.filter(v => tous || dessines.current[v.id] !== v.m)
.map(v => { dessines.current[v.id] = v.m; return dessineFig(figs.current[v.id], v.m); }));
}
function dessineBarre() {
const t = [...courant.current.labels].sort((a, b) => (a.debut < b.debut ? -1 : 1));
tries.current = t;
const voies = [], voie = t.map(l => { // la première rangée libre, sinon une nouvelle
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), gs = liste(), f = gs[0]._fullLayout, { c } = courant.current;
vue.current = "";
barre.current.style.height = `${40 + VOIE * n}px`; // comme les plots
return Plotly.react(barre.current, [{ type: "bar", orientation: "h", y: voie, base: t.map(l => lisible(l.debut)),
x: t.map(l => Date.parse(l.fin) - Date.parse(l.debut)), width: 0.8,
marker: { color: t.map(couleur), cornerradius: 4, line: contour(t) },
text: textes(t, barre.current._fullLayout || f), textposition: "inside", insidetextanchor: "start", textangle: 0,
textfont: { family: POLICE, size: 11, color: "#1a1b1e" },
unselected: { marker: { opacity: 1 } }, // sinon une sélection les pâlit
// la bulle : pour un détecteur, ses cibles seulement ; sinon la famille et tout le texte, que la barre tronque
customdata: t.map(l => (l.message ? coupe(l.cibles.length ? l.cibles.join(", ") : l.references.length
? l.references.map(s => s + " (ref.)").join(", ") : "Tous les capteurs")
: (l.categorie ? `<b>${NOM_FAMILLE(l.categorie)}</b><br>` : "") + coupe(l.description))),
hovertemplate: "%{customdata}<extra></extra>" }],
{ ...habillage(c), height: 40 + VOIE * n, dragmode: lecteur ? "zoom" : "select", selectdirection: "h", hovermode: "closest", plot_bgcolor: c.fond, showlegend: false,
margin: { ...marge(), l: Math.max(...gs.map(g => g._fullLayout._size.l)), r: Math.max(...gs.map(g => g._fullLayout._size.r)) },
xaxis: { type: "date", range: f.xaxis.range.slice(), showgrid: false, ticks: "", color: c.texte },
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 });
}
// Le premier dessin, puis les événements de la barre, une fois
useEffect(() => {
if (!Plotly) return;
dessinePlots().then(dessineBarre).then(() => aligne()).then(() => {
barre.current.on("plotly_selected", ev => {
const r = ev?.range?.x;
if (r) setChoix(r.map(v => String(v).slice(0, 16).replace(" ", "T") + "Z"));
});
barre.current.on("plotly_deselect", () => setChoix(null));
barre.current.on("plotly_relayout", () => aligne(barre.current)); // zoomée (Detectors, LLM) ou redimensionnée seule (l'image agrandie)
// Un clic sur une étiquette l'ouvre ; un clic ailleurs sur la barre (pas un glisser) la referme
let surEtiquette = false, x0 = 0;
barre.current.on("plotly_click", ev => { surEtiquette = true; courant.current.ouvrir(tries.current[ev.points[0].pointIndex]); });
barre.current.addEventListener("mousedown", e => { x0 = e.clientX; }, true);
barre.current.addEventListener("click", e => {
if (!surEtiquette && Math.abs(e.clientX - x0) < 4) courant.current.ouvrir(null);
surEtiquette = false;
});
setPret(true);
});
return () => [...Object.values(figs.current), barre.current].forEach(g => g && Plotly.purge(g));
}, [Plotly]);
useEffect(() => { if (pret) dessinePlots().then(() => aligne(barre.current)); }, [vues]);
useEffect(() => { if (pret) dessineBarre(); }, [pret, labels]);
// Glisser sur la barre : sélectionner une plage (Labelling), sinon zoomer dans le temps
useEffect(() => { if (pret) Plotly.relayout(barre.current, { dragmode: lecteur ? "zoom" : "select", selections: [] }); }, [pret, lecteur]);
useEffect(() => { if (pret) dessinePlots(true).then(dessineBarre); }, [sombre]);
useEffect(() => { if (pret) dessinePlots(true); }, [montres]);
useEffect(() => { if (pret) liste().forEach(g => Plotly.relayout(g, { shapes: zones() })); }, [pret, labels, choix, ouverte]);
useEffect(() => {
if (!pret || !barre.current._fullLayout) return;
const k = contour(tries.current);
Plotly.restyle(barre.current, { "marker.line.color": [k.color], "marker.line.width": [k.width] });
}, [ouverte]);
// Lues à chaque chargement et à chaque changement de source : la page montre toujours le fichier ; les détecteurs tournent
// sur la plage la première fois (une minute ou plus), le serveur garde leur résultat
useEffect(() => {
let vivant = true;
setLecture(true);
const url = source === "detecteurs" ? `/api/detecteurs?${new URLSearchParams({ station, du, au, cibles })}`
: `/api/etiquettes?${new URLSearchParams({ station, dossier })}`;
appel(url).then(l => {
if (!vivant) return; // une autre source a été choisie entre-temps
setLecture(false); setToutes(l || []);
});
return () => { vivant = false; };
}, [source, cibles, rev]);
// Un plot de plus : le premier que la page ne montre pas encore, déplacement vertical d'abord
function ajouterPlot() {
const pris = vues.map(v => v.m), id = prochain.current++;
const m = [indice("Relative Corrected Vertical Shift", 0), ...PLOTS.keys()].find(i => !pris.includes(i)) ?? 0;
setVues([...vues, { id, m }]);
}
function enleverPlot(id) {
Plotly.purge(figs.current[id]);
delete figs.current[id]; delete dessines.current[id];
setVues(vues.filter(v => v.id !== id));
}
const modifiee = () => ouverte && edit && (edit.texte.trim() !== ouverte.description || edit.categorie !== (ouverte.categorie || "")
|| edit.debut + "Z" !== ouverte.debut || edit.fin + "Z" !== ouverte.fin);
// l : l'étiquette à afficher, null pour fermer -> false si Marc garde ses changements non enregistrés
function ouvrir(l) {
if (modifiee() && !confirm("Abandonner les changements de cette étiquette ?")) return false;
setOuverte(l); setNote("");
if (l) caler(l.debut); // un nouvel objet à chaque clic : recliquer le même événement y ramène les images
setEdit(l && !lecteur ? { debut: l.debut.slice(0, 16), fin: l.fin.slice(0, 16), categorie: l.categorie || "", texte: l.description } : null);
return true;
}
async function analyser() {
const r = await appel("/api/analyses", "POST", { station, debut: choix[0], fin: choix[1], indices });
if (!r) return; // rien n'est perdu : les indices et la plage restent dans la page
setAnalyse(r.nom); setIndices("");
await Plotly.relayout(barre.current, { selections: [] });
setChoix(null);
}
async function enregistrer() {
const l = await appel("/api/etiquettes", "PUT", { station, dossier, avant: ouverte, debut: edit.debut + "Z", fin: edit.fin + "Z",
categorie: edit.categorie, description: edit.texte.trim() });
if (!l) return; // rien n'est perdu : le texte et les bornes restent dans la fenêtre
setToutes(ls => ls.map(x => (x === ouverte ? l : x)));
setOuverte(l); setNote("Enregistrée");
}
async function supprimer() {
if (!confirm("Supprimer cette étiquette ?")) return;
if (await appel("/api/etiquettes", "DELETE", { station, dossier, avant: ouverte }) === null) return;
setToutes(ls => ls.filter(x => x !== ouverte));
setOuverte(null); setEdit(null);
}
const options = PLOTS.map((p, i) => ({ value: String(i), label: p.titre }));
const peutEnregistrer = modifiee() && edit.texte.trim() && edit.debut && edit.fin && edit.debut < edit.fin;
const bornes = (champ, plus) => lisible(toutes.reduce((m, l) => (plus(l[champ], m) ? l[champ] : m), toutes[0][champ]));
return (
<Card shadow="sm" withBorder>
<Stack gap="sm">
<div>
{vues.map(v => (
<div key={v.id} className="plot">
<div ref={el => { if (el) figs.current[v.id] = el; }} />
<Group gap={4} wrap="nowrap" className="plot-menu">
<NativeSelect size="xs" aria-label="Plot" data={options} value={String(v.m)} w={300}
onChange={e => { const m = +e.currentTarget.value; setVues(vues.map(x => (x.id === v.id ? { ...x, m } : x))); }} />
{vues.length > 1 && (
<Tooltip label="Enlever ce plot">
<ActionIcon variant="subtle" color="gray" aria-label="Enlever ce plot" onClick={() => enleverPlot(v.id)}><IconX size={16} /></ActionIcon>
</Tooltip>
)}
</Group>
</div>
))}
{!pret && <Loader size="sm" />}
</div>
<Group justify="space-between" gap="sm">
<Group gap="sm">
<SegmentedControl size="xs" data={SOURCES} value={source} onChange={v => { if (ouvrir(null)) { setSource(v); setChoix(null); } }} />
{lecture && <Group gap={6}><Loader size="xs" /><Text size="xs" c="dimmed">{detect ? "Les détecteurs tournent sur la plage…" : "Lecture…"}</Text></Group>}
</Group>
<Button size="xs" variant="light" leftSection={<IconPlus size={14} />} onClick={ajouterPlot} disabled={!pret}>Ajouter un plot</Button>
</Group>
<div ref={barre} />
{pret && !lecture && !labels.length && ( // sinon une barre vide ne dit pas pourquoi
<Text size="sm" c="orange">{detect ? `Les détecteurs ne trouvent aucun événement sur cette plage${toutes.length ? " dans les familles cochées" : ""}.`
: toutes.length ? `Aucune étiquette dans les familles cochées sur cette plage : celles de ${station} vont du ${bornes("debut", (a, b) => a < b)} au ${bornes("fin", (a, b) => a > b)} UTC.`
: `${station} n'a aucune étiquette dans labeling/${dossier}/.`}</Text>
)}
<div>
{!ouverte && lecteur && <Text size="sm" c="dimmed">Cliquer sur un événement pour l'ouvrir.</Text>}
{ouverte && lecteur && (
<Card withBorder bg="var(--mantine-color-default-hover)">
<Stack gap={6}>
<Group gap="xs">
<Badge color={couleur(ouverte)} c="#1a1b1e">{ouverte.categorie}</Badge>
<Text size="sm" fw={500}>{ouverte.sorte}</Text>
{ouverte.ignore && <Badge variant="outline" color="gray">grisé au journal</Badge>}
</Group>
<Text size="sm" ff="monospace" fw={600}>{lisible(ouverte.debut)} → {lisible(ouverte.fin)} UTC</Text>
{ouverte.message ? <>
<Champ nom="Capteurs">{ouverte.capteurs.length ? <>
{ouverte.cibles.length > 0 && <div>Cibles ({ouverte.cibles.length}) : {ouverte.cibles.join(", ")}</div>}
{ouverte.references.length > 0 && <div>Références ({ouverte.references.length}) : {ouverte.references.join(", ")}</div>}
</> : "tous les capteurs"}</Champ>
<Champ nom="Message">{ouverte.message}</Champ>
<Champ nom="Action">{ouverte.action}</Champ>
</> : <Champ nom="Description">{ouverte.description}</Champ>}
<Group>
<Button size="xs" variant="default" onClick={() => ouvrir(null)}>Fermer</Button>
{ouverte.analyse && <Button size="xs" variant="light" onClick={() => setAnalyse(ouverte.analyse)}>Voir le rapport</Button>}
</Group>
</Stack>
</Card>
)}
{ouverte && edit && (
<Card withBorder bg="var(--mantine-color-default-hover)">
<Stack gap="xs">
<Group gap="sm" align="flex-end">
<TextInput label="Du (UTC)" type="datetime-local" step={60} value={edit.debut} onChange={e => setEdit({ ...edit, debut: e.currentTarget.value })} />
<TextInput label="Au (UTC)" type="datetime-local" step={60} value={edit.fin} onChange={e => setEdit({ ...edit, fin: e.currentTarget.value })} />
<NativeSelect label="Famille" data={CHOIX_FAMILLE} value={edit.categorie} onChange={e => setEdit({ ...edit, categorie: e.currentTarget.value })} />
</Group>
<Textarea autosize minRows={3} value={edit.texte} onChange={e => setEdit({ ...edit, texte: e.currentTarget.value })} />
<Group gap="sm">
<Button onClick={enregistrer} disabled={!peutEnregistrer}>Enregistrer</Button>
<Button variant="default" onClick={() => ouvrir(null)}>Fermer</Button>
{ouverte.analyse && <Button variant="light" onClick={() => setAnalyse(ouverte.analyse)}>Voir le rapport</Button>}
<Text size="sm" c="teal">{note}</Text>
<Button color="red" variant="light" ml="auto" onClick={supprimer}>Supprimer</Button>
</Group>
</Stack>
</Card>
)}
</div>
{!lecteur && <>
<Text size="sm">{choix ? `${lisible(choix[0])} → ${lisible(choix[1])} UTC` : "Glisser sur la barre des étiquettes pour sélectionner la plage à analyser."}</Text>
<Textarea autosize minRows={2} placeholder="Indices pour l'analyste (facultatif) : ce que tu as vu, ce qu'il faut regarder"
value={indices} onChange={e => setIndices(e.currentTarget.value)} />
<Group><Button onClick={analyser} disabled={!(choix && choix[0] < choix[1])}>Analyser la plage</Button></Group>
</>}
{analyse && <Analyse key={analyse} nom={analyse} sombre={sombre} fini={() => setRev(r => r + 1)} fermer={() => setAnalyse(null)} />}
</Stack>
</Card>
);
}
// Le fil d'un agent (analyste, optimisation) : les messages de l'utilisateur (« › ») en gras, le reste en petit, défilé jusqu'en bas
function Fil({ lignes }) {
const fil = useRef();
useEffect(() => { if (fil.current) fil.current.scrollTop = fil.current.scrollHeight; }, [lignes.length]);
if (!lignes.length) return null;
return (
<div ref={fil} style={{ maxHeight: 260, overflowY: "auto" }}>
{lignes.map((l, i) => l.startsWith("› ")
? <Text key={i} size="sm" fw={500} mt={6}>{l}</Text>
: <Text key={i} size="xs" ff="monospace" c="dimmed" style={{ whiteSpace: "pre-wrap" }}>{l}</Text>)}
</div>
);
}
// Un markdown rendu par le serveur (rapport, bilan), à la hauteur de son contenu une fois ses images chargées
function Page({ titre, src }) {
const cadre = useRef();
const ajuste = () => { const b = cadre.current?.contentDocument?.body; if (b) cadre.current.style.height = `${b.scrollHeight + 20}px`; };
return <iframe ref={cadre} title={titre} sandbox="allow-same-origin" onLoad={ajuste} style={{ border: 0, width: "100%", height: 400 }} src={src} />;
}
const COULEUR_ETAT = { "en cours": "blue", fini: "teal", erreur: "red", interrompue: "orange" };
// Une analyse de l'onglet Analysis : son fil (relu toutes les 3 s tant qu'elle travaille), son rapport, et un message à
// l'analyste, qui reprend sa session ; à la fin de chaque tour, les étiquettes se relisent. Une analyse finie s'optimise
// (/detectors:wf-improve sur la plage de l'analyse, puis le tool-builder) : le fil de la séance, puis ses bilans sous le rapport
function Analyse({ nom, sombre, fini, fermer }) {
const [a, setA] = useState(null), [tour, setTour] = useState(0), [texte, setTexte] = useState("");
const boite = useRef(), charge = !!a;
useEffect(() => { if (charge) boite.current?.scrollIntoView({ behavior: "smooth", block: "start" }); }, [nom, charge]); // ouverte : on la voit
useEffect(() => {
let vivant = true, minuterie;
const lire = () => appel(`/api/analyses/${nom}`).then(r => {
if (!vivant || !r) return;
setA(r);
if (r.etat === "en cours" || r.optimisation?.etat === "en cours") minuterie = setTimeout(lire, 3000);
else if (r.versees !== null) fini();
});
lire();
return () => { vivant = false; clearTimeout(minuterie); };
}, [nom, tour]);
async function envoyer() {
if (await appel(`/api/analyses/${nom}/message`, "POST", { texte }) == null) return; // le texte reste dans le champ
setTexte(""); setTour(t => t + 1);
}
async function optimiser() {
if (await appel(`/api/analyses/${nom}/optimiser`, "POST") != null) setTour(t => t + 1);
}
if (!a) return <Loader size="sm" />;
const d = a.demande, o = a.optimisation, occupe = a.etat === "en cours", optimise = o?.etat === "en cours";
const au = new Date(Date.parse(d.fin.slice(0, 10)) + 864e5).toISOString().slice(0, 10);
return (
<Card withBorder ref={boite}>
<Stack gap="xs">
<Group justify="space-between">
<Group gap="xs">
<Title order={5}>Analyse {lisible(d.debut)} → {lisible(d.fin)} UTC</Title>
<Badge color={COULEUR_ETAT[a.etat] || "gray"}>{a.etat}</Badge>
{occupe && <Loader size="xs" />}
</Group>
<Group gap="xs">
{a.etat === "fini" && <Tooltip label="Améliorer les détecteurs, puis les outils de lecture, depuis cette analyse (/detectors:wf-improve)">
<Button size="xs" variant="light" onClick={optimiser} disabled={optimise}>Optimiser les détecteurs</Button></Tooltip>}
<ActionIcon variant="subtle" color="gray" aria-label="Fermer le rapport" onClick={fermer}><IconX size={16} /></ActionIcon>
</Group>
</Group>
{d.indices && <Text size="sm" c="dimmed">Indices : {d.indices}</Text>}
{a.etat === "interrompue" && <Text size="sm" c="orange">Arrêtée avec le serveur avant la fin.{a.dialogue
? " Sa session est gardée : écrire « continue » ci-dessous pour la reprendre là où elle en était." : ""}</Text>}
{a.versees !== null && a.etat === "fini" && <Text size="sm">{a.versees} étiquette(s) de cette analyse dans labeling/auto/{d.station}.jsonl, à relire.</Text>}
{a.rapport && <Page titre="Rapport" src={`/api/analyses/${nom}/rapport.html?sombre=${sombre}&v=${a.rapport}`} />}
<Fil lignes={a.lignes} />
{a.dialogue && (
<Group align="flex-end" gap="sm" wrap="nowrap">
<Textarea autosize minRows={1} style={{ flex: 1 }} placeholder="Une question, une correction pour l'analyste"
value={texte} onChange={e => setTexte(e.currentTarget.value)} />
<Button onClick={envoyer} disabled={occupe || optimise || !texte.trim()}>Envoyer</Button>
</Group>
)}
{o && (
<Stack gap="xs" mt="sm">
<Group gap="xs">
<Title order={5}>Optimisation</Title>
<Badge color={COULEUR_ETAT[o.etat] || "gray"}>{o.etat}</Badge>
{optimise && <Loader size="xs" />}
</Group>
{o.etat === "interrompue" && <Text size="sm" c="orange">Arrêtée avec le serveur ; la relancer par le bouton.</Text>}
<Fil lignes={o.lignes} />
{o.bilan && <Page titre="Bilan" src={`/api/analyses/${nom}/bilan.html?sombre=${sombre}&v=${o.bilan}`} />}
{o.bilan && <Text size="xs" c="dimmed" ff="monospace">python3 detectors/skills/wf-improve/scripts/score.py data/{d.station} --labels labeling/auto/{d.station}.jsonl --from {d.debut.slice(0, 10)} --to {au}</Text>}
</Stack>
)}
<Text size="xs" c="dimmed">labeling/auto/analyses/{nom}/</Text>
</Stack>
</Card>
);
}