sprint95: B.4 - visualisation DAG d'un pipeline composé (SVG server-side)

Outil d'inspection, pas de construction - le YAML reste source de
vérité. Permet d'auditer rapidement la qualité d'une pipeline d'axe
B avec plusieurs jonctions.

picarones/report/pipeline_dag_render.py :
- build_pipeline_dag_html(nodes, labels, edges=None,
thresholds=(0.05, 0.15), higher_is_better=False) :
graphe orienté gauche → droite en SVG natif (pas de lib, pas de JS).
- Nœuds = rectangles annotés du nom + input/output types.
- Arêtes = flèches colorées vert/orange/rouge selon valeur de la
métrique à la jonction, étiquette type + métrique:valeur formatée.
- Légende intégrée avec seuils.
- Mode higher_is_better=True inverse la sémantique (F1/recall).
- Adaptive : "" si moins d'un nœud.
- Auto-déduction d'arêtes séquentielles si non fournies.
- Anti-injection sur 4 vecteurs (nom nœud, artifact_type,
metric_name, input/output_types).

Pas de drag-and-drop, pas de drill-down - le visuel sert à inspecter
et déboguer. Le drill-down par document reste dans error_absorption
(Sprint 94).

6 clés i18n FR/EN (dag_*). 18 tests dans test_sprint95_pipeline_dag.py
incluant 3 cas de couleur sur seuil, higher_is_better, anti-injection
sur 4 vecteurs, rendu EN, complétude i18n.

Tests : 3055 passed, 2 skipped.

https://claude.ai/code/session_01RusTQYcSfXqTsbFNvwmCV7

CHANGELOG.md

@@ -16,6 +16,51 @@ La numérotation de version suit [Semantic Versioning](https://semver.org/lang/f
 
 ### Ajouté
 
+- **Sprint 95 — B.4 : visualisation DAG d'un pipeline composé
+  (rendu SVG server-side).**  Outil d'**inspection**, pas de
+  construction — le YAML reste source de vérité.  Permet
+  d'auditer rapidement la qualité d'une pipeline d'axe B
+  (Sprint 63+).  Nouveau module
+  `picarones/report/pipeline_dag_render.py` :
+  `build_pipeline_dag_html(nodes, labels, edges=None,
+  thresholds=(0.05, 0.15), higher_is_better=False)` rend un
+  graphe orienté gauche → droite en SVG natif (pas de
+  bibliothèque, pas de JS).  Chaque nœud est un rectangle
+  annoté du nom du module + types d'entrée/sortie.  Chaque
+  arête est une flèche colorée vert/orange/rouge selon la
+  valeur de la métrique calculée à la jonction, avec
+  étiquette ``type d'artefact`` + ``métrique : valeur``
+  (formatée en pourcent ou décimal).  Légende intégrée avec
+  les seuils.  Mode ``higher_is_better=True`` inverse la
+  sémantique pour les métriques type F1/recall.  Adaptive :
+  ``""`` si moins d'un nœud.  Auto-déduction des arêtes
+  séquentielles si non fournies.  Anti-injection systématique
+  via ``html.escape`` sur le nom du nœud, le type d'artefact,
+  le nom de métrique et les listes input/output_types.
+
+  **Pas de drag-and-drop, pas de notebook, pas de drill-down
+  par document** : le visuel sert à inspecter et déboguer,
+  pas à construire.  Une institution sérieuse versionne ses
+  pipelines en YAML dans Git, pas en JSON exporté d'une UI.
+  Le drill-down par document reste sur le tableau de
+  ``error_absorption`` (Sprint 94) qui montre déjà les tokens
+  corrigés / introduits par jonction.
+
+  +6 clés i18n FR/EN (`dag_*`).  +18 tests dans
+  `test_sprint95_pipeline_dag.py` (vide → "", single node sans
+  flèche, 2 nœuds 1 arête avec étiquettes + valeur formatée
+  4.0%, chaîne 3 nœuds 2 flèches, auto-déduction d'arêtes,
+  3 cas de couleur (vert ≤ 0.05, jaune ≤ 0.15, rouge > 0.15),
+  inversion higher_is_better avec F1=0.96 → vert, nœud
+  inconnu dans une arête skipped, valeur de métrique absente
+  affichée comme — ; anti-injection 4 vecteurs : nom de nœud,
+  artifact_type, metric_name, input/output types ; rendu en
+  anglais ; complétude i18n 6 clés).  **Verrou levé** : un
+  benchmark d'axe B avec 3+ étapes (par ex. OCR → LLM →
+  ALTO_mapper) voit immédiatement à quelle jonction la
+  qualité décroche, sans avoir à parcourir un tableau de
+  métriques.
+
 - **Sprint 94 — B.3 : métrique d'absorption d'erreur (couche
   calcul + vue HTML).**  Quand un module post-correction LLM
   aplatit les différences entre OCR amont, ce n'est pas qu'il

CLAUDE.md

@@ -207,6 +207,7 @@ AZURE_DOC_INTEL_KEY=...
 | 33 | **Sprint 2 du plan d'évolution 2026 — Phase 0.2 : interface module générique**. Nouveau module `picarones/core/modules.py` avec l'enum `ArtifactType` (IMAGE, TEXT, ALTO, PAGE, ENTITIES, READING_ORDER) et la classe abstraite `BaseModule` qui déclare `input_types`/`output_types`, `execution_mode` (`"io"`/`"cpu"`), une méthode `process(dict[ArtifactType, Any]) → dict[ArtifactType, Any]`, et des helpers `validate_inputs`/`validate_outputs`. `BaseOCREngine` (`picarones/engines/base.py`) hérite désormais de `BaseModule` avec `input_types=(IMAGE,)` et `output_types=(TEXT,)` ; sa nouvelle méthode `process` wrappe l'API historique `run()`. Aucun adaptateur OCR existant n'est touché — `test_engines.py` passe à 20/20 sans modification. +23 tests dans `test_sprint33_module_interface.py` (contrat, validation, MockModule TEXT→ALTO démonstratif comme demandé par le plan, délégation `BaseOCREngine.process → run`, cohérence ArtifactType/GTLevel). **Verrou levé** : un même runner peut maintenant exécuter un OCR (image→texte), un mappeur VLM→ALTO, un rewriter ALTO→ALTO, un module NER (texte→entités), etc. — fondation directe pour l'axe B du plan. |
 | 34 | **Sprint 3 du plan d'évolution 2026 — Phase 0.3 : registre typé de métriques (clôture Phase 0)**. Nouveaux modules `picarones/core/metric_registry.py` (`MetricSpec`, `@register_metric`, `select_metrics`, `compute_at_junction`) et `picarones/core/builtin_metrics.py` qui enregistre `cer`, `wer`, `mer`, `wil` sur `(TEXT, TEXT)` plus un stub `text_preservation_after_reconstruction` sur `(TEXT, ALTO)` comme preuve de concept de jonction hétérogène. **Approche strictement additive** : ni `metrics.py` ni `compute_metrics` ne sont modifiés, le rapport HTML reste identique octet par octet. La sélection par signature de types est exacte (pas de coercion). +21 tests dans `test_sprint34_metric_registry.py`, dont une parité numérique CER/WER/MER/WIL avec `compute_metrics` legacy à 1e-9 près sur 4 paires de textes. **Verrou levé** : le runner d'une pipeline composée peut maintenant calculer automatiquement la métrique adéquate à chaque jonction de son DAG selon les types d'artefacts produits/attendus — fondation directe pour la métrique d'absorption d'erreur (acte B.3) et toutes les métriques structurelles à venir (Layout F1, reading order F1, NER). |
 | 35 | **Sprint 4 du plan d'évolution 2026 — Étape 2 / axe A : métriques inter-moteurs (couche de calcul)**. Nouveau module `picarones/core/inter_engine.py` qui répond à deux questions distinctes mais liées : *(a) à quel point les moteurs font-ils des erreurs de natures différentes ?* via `kl_divergence`, `jensen_shannon_divergence` (symétrique, bornée `[0, 1]`), et `taxonomy_divergence_matrix` qui construit la matrice triangulaire inter-moteurs ; *(b) quel CER serait atteignable si on combinait les moteurs ?* via `oracle_token_recall` (proxy bag-of-words, borne supérieure du recall atteignable), `complementarity_gap` (oracle vs meilleur moteur seul, gap absolu/relatif), et `pairwise_disagreement_rate`. Fonctions pures, sans I/O ni intégration runner — la couche de calcul est livrée indépendamment, le câblage narratif (`ENSEMBLE_OPPORTUNITY`) et HTML (matrice de divergence, badge oracle) suit au Sprint 36. +27 tests couvrant les invariants mathématiques (KL ≥ 0, KL(p,p) = 0, JS symétrique et bornée, oracle ≥ best_single, multiplicité respectée), les cas concrets (deux moteurs spécialisés sortent comme candidats ensemble, complémentarité parfaite atteint oracle = 1), et les garde-fous (référence vide, hypothèses vides, métrique inconnue). |
+| 95 | **Sprint 64 du plan d'évolution 2026 — B.4 : visualisation DAG d'un pipeline composé (rendu SVG server-side)**. Outil d'**inspection**, pas de construction — le YAML reste source de vérité. Nouveau module `picarones/report/pipeline_dag_render.py` : `build_pipeline_dag_html(nodes, labels, edges=None, thresholds=(0.05, 0.15), higher_is_better=False)` rend un graphe orienté gauche → droite en SVG natif (pas de bibliothèque, pas de JS). Nœuds = rectangles avec nom + input/output types. Arêtes = flèches colorées vert/orange/rouge selon la valeur de métrique à la jonction, avec étiquette `type + métrique : valeur` (formatée %). Légende intégrée. Mode `higher_is_better=True` inverse la sémantique pour F1/recall. Adaptive : `""` si moins d'un nœud. Auto-déduction d'arêtes séquentielles si non fournies. Anti-injection systématique sur 4 vecteurs (nom nœud, artifact_type, metric_name, input/output_types). Pas de drag-and-drop, pas de drill-down par document — le visuel sert à inspecter et déboguer, pas à construire. Le drill-down reste dans `error_absorption` (Sprint 94). +6 clés i18n FR/EN (`dag_*`). +18 tests dans `test_sprint95_pipeline_dag.py` (vide, single node, 2 nœuds 1 arête, chaîne 3 nœuds, auto-edges, 3 couleurs sur seuil, higher_is_better, ghost node skipped, valeur absente, anti-injection 4 vecteurs, rendu EN, complétude i18n 6 clés). **Verrou levé** : un benchmark d'axe B voit immédiatement à quelle jonction la qualité décroche, sans parcourir un tableau de métriques. |
 | 94 | **Sprint 63 du plan d'évolution 2026 — B.3 : métrique d'absorption d'erreur (couche calcul + vue HTML)**. Quand un module post-correction LLM aplatit les différences entre OCR amont, ce n'est pas qu'il « améliore » tous les moteurs — c'est qu'il introduit ses propres biais qui dominent ceux de l'OCR. À chaque jonction, deux flux séparés : taux de correction (parmi les erreurs avant, combien corrigées) et taux d'introduction (parmi les erreurs après, combien nouvelles). Nouveau module `picarones/core/error_absorption.py` : `compute_error_absorption(reference, before, after, case_sensitive=False)` alignement multi-set token-level sur whitespace, retourne `{n_gt_tokens, n_errors_before, n_errors_after, n_corrected, n_introduced, n_kept_wrong, correction_rate (None si 0 err avant), introduction_rate (None si 0 err après), net_improvement, corrected_tokens, introduced_tokens (casse GT)}`. None si GT vide. `aggregate_error_absorption(per_doc, sample_tokens=50)` somme corpus-wide + recalcul micro + cap échantillon. Généralisation du score sur-normalisation (A.I.7) à toute jonction OCR→LLM/OCR→reconstructor/VLM→ALTO_mapper. Pas de classification d'erreur (volume, pas qualité — taxonomy reste dans Sprint 5). Module de rendu `picarones/report/error_absorption_render.py` : tableau résumé jonctions × {erreurs avant, après, corrigées coloré vert, introduites coloré rouge, % corrigées (rouge → vert), % introduites (vert → rouge), amélioration nette colorée selon signe + magnitude, échantillon tokens introduits cap}. Adaptive masking. Module pur — l'utilisateur compose les `junctions` depuis `PipelineBenchmarkResult` (Sprint 64). Visualisation Sankey reportée. +11 clés i18n FR/EN (`absorption_*`). +20 tests dans `test_sprint94_error_absorption.py` (identité, perfect correction, pure introduction, **cas réaliste mix maistre Pierre du Bois → maître Pierre du Bois** corrige+introduit en parallèle, GT vide → None, case-insensitive + opt-in, multiplicité, agrégation micro-rate + skip None + cap, vue HTML 4 cas dont anti-injection junction_name + échantillon introduits + FR + EN, complétude i18n 11 clés). **Verrou levé** : un bench de pipeline composée distingue désormais un module qui *corrige* d'un module qui *absorbe* — *« le LLM corrige 65 % des erreurs OCR mais introduit 12 % de nouvelles erreurs (modernisations maistre/nostre) »*. Sans cette métrique, on confondait correction et écrasement. |
 | 93 | **Sprint 62 du plan d'évolution 2026 — A.II.7 : métriques d'image prédictives (couche calcul + vue HTML)**. `image_quality.py` (Sprint 5) mesurait des features indépendamment ; ce module les combine en deux indicateurs corpus-level. Nouveau module `picarones/core/image_predictive.py` : `compute_paleographic_complexity(quality, weights)` retourne score ∈ [0,1] + components + weights_used (combinaison pondérée éditoriale 0.30 noise / 0.30 blur / 0.20 low_contrast / 0.20 rotation, bornes forcées) ; `compute_corpus_homogeneity(image_qualities)` retourne score ∈ [0,1] (moyenne des écart-types normalisés sur 4 features) + n_docs + per_feature, 0 = uniforme (moyenne globale fiable), 1 = très hétérogène ; `aggregate_corpus_predictive` synthétise complexité (mean/median/min/max/stdev) + homogeneity. Pas de prédiction CER absolue (philosophie banc d'essai exclut un modèle entraîné par moteur). Module de rendu `picarones/report/image_predictive_render.py` : 2 blocs — tableau résumé complexité (mean coloré gradient vert → rouge, médiane, min, max, stdev, docs) + tableau homogénéité (score coloré + détail par feature mean/stdev/contribution normalisée). Adaptive masking. Module pur — l'utilisateur compose. +20 clés i18n FR/EN (`imgpred_*`). +21 tests dans `test_sprint93_image_predictive.py` (cas trivial → ≈0, cas extrême → ≈1, bornes [0,1], poids custom, défauts somment à 1, garde-fous None ; corpus uniforme → 0, hétérogène > 0.5, lt 2 → None ; cas réaliste BnF mix trivial/difficile ; vue HTML 4 cas dont anti-injection FR + EN ; complétude i18n 19 clés). **Verrou levé** : un benchmark BnF voit désormais *« corpus-wide complexity 0,42 (modérée), homogeneity 0,18 (uniforme — moyenne fiable) »* dans la vue Analyses — explique une partie du CER observé sans prédiction prescriptive. |
 | 92 | **Sprint 61 du plan d'évolution 2026 — A.II.9 : métriques longitudinales (régression linéaire + change-point + détecteur narratif + vue HTML)**. L'historique SQLite (Sprint 8) collectait sans qu'aucune métrique n'en sorte. Complémentaire à A.I.3 qui dit *« écart anormal sur ce corpus »* sans caractériser la dynamique. Nouveau module `picarones/core/longitudinal.py` : `compute_linear_trend` régression OLS pure Python sans scipy retourne `LinearTrend(slope, intercept, r_squared, n_runs)` ; `detect_change_point(series, min_segment_size=3)` balayage exhaustif (Pettitt simplifié) retourne `ChangePointResult(index, timestamp, mean_before, mean_after, delta, n_before, n_after)` ; `compute_engine_longitudinal` combine les deux avec garde-fou `min_runs_for_trend=3` et seuil `change_point_threshold=0.01` (1 pt CER) ; `compute_corpus_longitudinal` agrège tous les moteurs. Nouveau `FactType.REGRESSION_IN_HISTORY` (priority 170, MEDIUM par défaut, HIGH si `|absolute_delta| ≥ 0.05`) + détecteur lit `benchmark_data["longitudinal_trends"]`, déclenche si pente > +1 pt CER/an **ou** change-point delta > 1 pt CER, payload trace `pattern in {"trend", "change_point", "trend_and_change_point"}`. Templates FR/EN sans chiffres en dur. Ajout aux paires complémentaires : `(GLOBAL_LEADER_CER, REGRESSION_IN_HISTORY)` et `(ENGINE_OFF_BASELINE, REGRESSION_IN_HISTORY)`. Module de rendu `picarones/report/longitudinal_render.py` : tableau moteur × {n_runs, premier CER, dernier CER, Δ cumulé coloré (vert→orange→rouge sur ±5 pts ; bleu si amélioration), pente annualisée, R², point de rupture avec timestamp + delta}. Tri par Δ décroissant. Adaptive masking. +10 clés i18n FR/EN (`longitudinal_*`). +28 tests (régression OLS, change-point, intégration entries + filtre corpus + min_runs + threshold, multi-moteurs, détecteur 6 cas, **traçabilité anti-hallucination FR + EN** sur sentences de `build_synthesis`, vue HTML 4 cas dont anti-injection, complétude i18n 10 clés). **Verrou levé** : un benchmark voit désormais *« sur les 8 runs historiques pour tess, le CER moyen est passé de 4 % à 7 % (variation cumulée 3 points) »* — permet de relier une régression à un changement de pipeline. |
@@ -312,7 +313,7 @@ au template `_narrative_summary.html` (placé entre `_header.html` et `_critical
 ## Contexte développement
 
 - **Environnement** : GitHub Codespaces (`/workspaces/Picarones`), Python 3.12
-- **Tests** : 3037 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprints 45+46 = stratification A.III livrée bout-en-bout ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livrées ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; Sprints 71-72 = A.I.1 livré bout-en-bout ; Sprints 73-74 = A.I.3 livré bout-en-bout ; Sprints 75-77 = A.I.4 livré bout-en-bout ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; Sprint 81 = A.I.8 couche calcul ; Sprint 82 = A.I.9 — « Leviers d'amélioration » bout-en-bout ; Sprint 83 = A.II.4 — métriques de fiabilité (IAA Cohen κ + Krippendorff α + stabilité multi-runs, couche calcul) ; Sprint 84 = A.II.5a — recherchabilité fuzzy ; Sprint 85 = A.II.5b — précision séquences numériques ; Sprint 86 = A.II.5 bout-en-bout (câblage runner + vues HTML) ; Sprint 87 = A.II.2 (delta Flesch) câblé bout-en-bout ; Sprint 88 = A.I.8 — vue HTML « Déficit projeté de robustesse » bout-en-bout ; Sprint 89 = A.II.8b — score de spécialisation inter-moteurs (couche calcul + vue HTML « Top paires spécialisées ») ; Sprint 90 = A.II.4 finition — détecteur narratif `engine_unstable` + vue HTML stabilité multi-runs ; Sprint 91 = A.II.6 — métriques économiques (throughput effectif + coût marginal par erreur évitée, couche calcul + vue HTML throughput) ; Sprint 92 = A.II.9 — métriques longitudinales (régression linéaire + change-point + détecteur narratif + vue HTML) ; Sprint 93 = A.II.7 — métriques d'image prédictives (complexité paléographique + homogénéité corpus, couche calcul + vue HTML) ; **Sprint 94 = B.3 — métrique d'absorption d'erreur (corrections vs introductions par jonction de pipeline, couche calcul + vue HTML)**)
+- **Tests** : 3055 passed, 2 skipped (Sprints 32-34 = Phase 0 close ; Sprints 35-37 = inter-moteurs livrés bout-en-bout ; Sprints 38+40+41 = NER livré bout-en-bout ; Sprints 39+42+43 = calibration livrée bout-en-bout côté rapport ; Sprint 44 = médiane par défaut ; Sprints 45+46 = stratification A.III livrée bout-en-bout ; Sprints 47-51 = les 5 adapters OCR exposent leurs confidences natives ; **Étape 2 close** ; Sprints 52-54 = axe A.II.2 (métriques structurelles) couches de calcul intégralement livrées ; Sprints 55-62 = extension philologique livrée bout-en-bout sur trois périodes + numéraux romains transversaux + câblage runner adaptive + vue HTML « Profil philologique » ; Sprints 63-70 = axe B livré bout-en-bout ; Sprints 71-72 = A.I.1 livré bout-en-bout ; Sprints 73-74 = A.I.3 livré bout-en-bout ; Sprints 75-77 = A.I.4 livré bout-en-bout ; Sprint 78 = A.I.5 couche calcul ; Sprint 79 = A.I.6 couche calcul ; Sprint 80 = A.I.7 ; Sprint 81 = A.I.8 couche calcul ; Sprint 82 = A.I.9 — « Leviers d'amélioration » bout-en-bout ; Sprint 83 = A.II.4 — métriques de fiabilité (IAA Cohen κ + Krippendorff α + stabilité multi-runs, couche calcul) ; Sprint 84 = A.II.5a — recherchabilité fuzzy ; Sprint 85 = A.II.5b — précision séquences numériques ; Sprint 86 = A.II.5 bout-en-bout (câblage runner + vues HTML) ; Sprint 87 = A.II.2 (delta Flesch) câblé bout-en-bout ; Sprint 88 = A.I.8 — vue HTML « Déficit projeté de robustesse » bout-en-bout ; Sprint 89 = A.II.8b — score de spécialisation inter-moteurs (couche calcul + vue HTML « Top paires spécialisées ») ; Sprint 90 = A.II.4 finition — détecteur narratif `engine_unstable` + vue HTML stabilité multi-runs ; Sprint 91 = A.II.6 — métriques économiques (throughput effectif + coût marginal par erreur évitée, couche calcul + vue HTML throughput) ; Sprint 92 = A.II.9 — métriques longitudinales (régression linéaire + change-point + détecteur narratif + vue HTML) ; Sprint 93 = A.II.7 — métriques d'image prédictives (complexité paléographique + homogénéité corpus, couche calcul + vue HTML) ; Sprint 94 = B.3 — métrique d'absorption d'erreur (corrections vs introductions par jonction de pipeline, couche calcul + vue HTML) ; **Sprint 95 = B.4 — visualisation DAG d'un pipeline composé (rendu SVG server-side, outil d'inspection)**)
 - **Plan d'évolution actif** : [`docs/roadmap/evolution-2026.md`](docs/roadmap/evolution-2026.md)
 - **Branche active** : `claude/analyze-project-evolution-KOA56`
 - **Transcript de la conversation de développement** :

picarones/report/i18n/en.json

@@ -381,5 +381,11 @@
   "absorption_corr_rate": "% corrected",
   "absorption_intro_rate": "% introduced",
   "absorption_net": "Net improvement",
-  "absorption_sample": "Sample (intro)"
+  "absorption_sample": "Sample (intro)",
+  "dag_title": "Pipeline DAG",
+  "dag_note": "Directed graph of the composed pipeline. Each edge shows the artifact type transmitted and the metric computed at the junction. Green/orange/red colour code by threshold. Inspection tool — YAML remains the source of truth.",
+  "dag_legend": "Reading",
+  "dag_legend_green": "high quality",
+  "dag_legend_yellow": "moderate quality",
+  "dag_legend_red": "low quality"
 }

picarones/report/i18n/fr.json

@@ -381,5 +381,11 @@
   "absorption_corr_rate": "% corrigées",
   "absorption_intro_rate": "% introduites",
   "absorption_net": "Amélioration nette",
-  "absorption_sample": "Échantillon (intro)"
+  "absorption_sample": "Échantillon (intro)",
+  "dag_title": "Pipeline DAG",
+  "dag_note": "Graphe orienté du pipeline composé. Chaque arête porte le type d'artefact transmis et la métrique calculée à la jonction. Code couleur vert/orange/rouge selon le seuil. Outil d'inspection — le YAML reste source de vérité.",
+  "dag_legend": "Lecture",
+  "dag_legend_green": "qualité élevée",
+  "dag_legend_yellow": "qualité moyenne",
+  "dag_legend_red": "qualité faible"
 }

picarones/report/pipeline_dag_render.py

@@ -0,0 +1,307 @@
+"""Visualisation DAG d'un pipeline composé — Sprint 95 (B.4).
+
+Sprint 95 — B.4 du plan d'évolution 2026.
+
+Outil d'inspection, pas de construction
+---------------------------------------
+Le YAML reste source de vérité.  Cette vue **affiche** le
+graphe orienté de la pipeline pour permettre l'inspection et
+le debug d'un benchmark d'axe B (Sprint 63+) — elle ne
+construit rien, ne supporte pas le drag-and-drop, n'exporte
+aucun JSON modifiable.
+
+Pattern identique aux autres rendus : SVG **server-side**,
+pas de JS, anti-injection systématique.
+
+Vue
+---
+Layout horizontal de gauche à droite :
+
+- Chaque **nœud** est un rectangle annoté du nom du module et
+  de ses types d'entrée/sortie.
+- Chaque **arête** porte une étiquette : type d'artefact +
+  métrique principale + valeur, avec un code couleur
+  vert/jaune/rouge selon le seuil sur la valeur.
+
+Adaptive : ``""`` si moins d'un nœud.
+
+Note d'intégration
+------------------
+Module pur — l'utilisateur compose les structures simples
+``nodes`` et ``edges`` depuis sa ``PipelineSpec`` (Sprint 63)
+et son ``PipelineBenchmarkResult`` (Sprint 64) :
+
+.. code-block:: python
+
+    from picarones.report.pipeline_dag_render import build_pipeline_dag_html
+
+    nodes = [
+        {"name": s.name, "input_types": [t.value for t in s.module.input_types],
+         "output_types": [t.value for t in s.module.output_types]}
+        for s in spec.steps
+    ]
+    edges = []
+    for prev, curr in zip(spec.steps, spec.steps[1:]):
+        agg = bench.aggregate_for_step(curr.name)
+        for art_type, metrics in (agg.junction_metrics or {}).items():
+            for metric_name, value in metrics.items():
+                edges.append({
+                    "from": prev.name, "to": curr.name,
+                    "artifact_type": art_type, "metric_name": metric_name,
+                    "metric_value": value.get("mean"),
+                })
+    html = build_pipeline_dag_html(nodes, edges, labels)
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+
+# Seuils par défaut sur les métriques d'erreur (CER-like, lower is better).
+_DEFAULT_THRESHOLDS = (0.05, 0.15)  # vert ≤ 0.05, jaune ≤ 0.15, rouge > 0.15
+
+
+def _classify_metric(
+    value: Optional[float],
+    thresholds: tuple[float, float],
+    higher_is_better: bool,
+) -> str:
+    """Retourne ``"green"``, ``"yellow"``, ``"red"`` ou ``"none"``."""
+    if value is None:
+        return "none"
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        return "none"
+    low, high = thresholds
+    if higher_is_better:
+        # Inversion : haut = bon
+        if v >= 1.0 - low:
+            return "green"
+        if v >= 1.0 - high:
+            return "yellow"
+        return "red"
+    if v <= low:
+        return "green"
+    if v <= high:
+        return "yellow"
+    return "red"
+
+
+_QUALITY_COLORS = {
+    "green":  "#16a34a",
+    "yellow": "#d97706",
+    "red":    "#dc2626",
+    "none":   "#6b7280",
+}
+
+
+def _format_value(value: Optional[float]) -> str:
+    if value is None:
+        return "—"
+    try:
+        v = float(value)
+    except (TypeError, ValueError):
+        return "—"
+    if abs(v) < 1.0:
+        return f"{v * 100:.1f}%"
+    return f"{v:.2f}"
+
+
+def build_pipeline_dag_html(
+    nodes: Optional[list[dict]],
+    labels: Optional[dict[str, str]] = None,
+    edges: Optional[list[dict]] = None,
+    *,
+    thresholds: tuple[float, float] = _DEFAULT_THRESHOLDS,
+    higher_is_better: bool = False,
+) -> str:
+    """Construit la vue HTML « Pipeline DAG ».
+
+    Parameters
+    ----------
+    nodes:
+        Liste de dicts ``{"name", "input_types"?, "output_types"?}``
+        dans l'ordre topologique.  Si vide ou ``None``, retourne
+        ``""``.
+    labels:
+        Dict i18n.  Clés sous le préfixe ``dag_*``.
+    edges:
+        Liste de dicts ``{"from", "to", "artifact_type"?,
+        "metric_name"?, "metric_value"?}``.  Optionnel —
+        auto-déduit séquentiel sinon.
+    thresholds:
+        ``(seuil_vert, seuil_jaune)`` sur la valeur de métrique.
+        Défaut ``(0.05, 0.15)`` — convention CER.
+    higher_is_better:
+        Si ``True``, la sémantique est inversée (1 = meilleur).
+    """
+    nodes = list(nodes or [])
+    if not nodes:
+        return ""
+    edges = list(edges or [])
+    labels = labels or {}
+    title = labels.get("dag_title", "Pipeline DAG")
+    note = labels.get(
+        "dag_note",
+        "Graphe orienté du pipeline composé. Chaque arête porte "
+        "le type d'artefact transmis et la métrique calculée à "
+        "la jonction. Code couleur vert/orange/rouge selon le "
+        "seuil. Outil d'inspection — le YAML reste source de "
+        "vérité.",
+    )
+    # Layout horizontal régulier
+    n = len(nodes)
+    box_width = 160
+    box_height = 70
+    h_gap = 110          # espace horizontal entre nœuds
+    margin = 30
+    svg_width = margin * 2 + n * box_width + (n - 1) * h_gap
+    svg_height = box_height + margin * 2 + 60  # +60 pour étiquettes arêtes
+    centre_y = margin + box_height / 2 + 30  # offset pour étiquette de tête
+
+    # Index des nœuds par name pour récupérer la position
+    node_x: dict[str, float] = {}
+    parts: list[str] = [
+        '<section class="dag-section" style="margin:1rem 0">',
+        f'<h3 style="margin:0 0 .3rem 0">{_e(title)}</h3>',
+        f'<div style="font-size:.85rem;opacity:.75;margin-bottom:.5rem">'
+        f'{_e(note)}</div>',
+        f'<svg viewBox="0 0 {svg_width} {svg_height}" '
+        f'role="img" aria-label="{_e(title)}" '
+        'xmlns="http://www.w3.org/2000/svg" '
+        'style="max-width:100%;height:auto;'
+        'font-family:system-ui,sans-serif;font-size:12px">',
+        # Définition d'une flèche
+        '<defs>'
+        '<marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" '
+        'markerWidth="6" markerHeight="6" orient="auto-start-reverse">'
+        '<path d="M0,0 L10,5 L0,10 z" fill="#374151"/>'
+        '</marker>'
+        '</defs>',
+    ]
+
+    # Étape 1 : nœuds
+    for i, node in enumerate(nodes):
+        name = str(node.get("name") or f"step_{i}")
+        x = margin + i * (box_width + h_gap)
+        y = margin + 30
+        node_x[name] = x + box_width
+        in_types = ", ".join(node.get("input_types") or [])
+        out_types = ", ".join(node.get("output_types") or [])
+        parts.append(
+            f'<rect x="{x}" y="{y}" width="{box_width}" '
+            f'height="{box_height}" rx="6" fill="#f3f4f6" '
+            f'stroke="#374151" stroke-width="1.5"/>'
+        )
+        parts.append(
+            f'<text x="{x + box_width / 2}" y="{y + 22}" '
+            f'text-anchor="middle" font-weight="600" '
+            f'fill="#111827">{_e(name)}</text>'
+        )
+        if in_types:
+            parts.append(
+                f'<text x="{x + box_width / 2}" y="{y + 40}" '
+                f'text-anchor="middle" fill="#4b5563" '
+                f'font-size="10">in: {_e(in_types)}</text>'
+            )
+        if out_types:
+            parts.append(
+                f'<text x="{x + box_width / 2}" y="{y + 56}" '
+                f'text-anchor="middle" fill="#4b5563" '
+                f'font-size="10">out: {_e(out_types)}</text>'
+            )
+
+    # Étape 2 : arêtes (mappées sur paires séquentielles si pas de
+    # "from"/"to" explicites — voir nodes par défaut)
+    auto_edges: list[dict] = []
+    if not edges:
+        for prev, curr in zip(nodes, nodes[1:]):
+            auto_edges.append({
+                "from": prev.get("name"),
+                "to": curr.get("name"),
+            })
+    else:
+        auto_edges = edges
+
+    for edge in auto_edges:
+        src = str(edge.get("from") or "")
+        dst = str(edge.get("to") or "")
+        if not src or not dst:
+            continue
+        # Position : du bord droit du src au bord gauche du dst
+        # Heuristique : on prend la position du nœud src dans la
+        # liste pour calculer x1, et celle de dst pour x2.
+        try:
+            i_src = next(
+                i for i, n_ in enumerate(nodes)
+                if n_.get("name") == src
+            )
+            i_dst = next(
+                i for i, n_ in enumerate(nodes)
+                if n_.get("name") == dst
+            )
+        except StopIteration:
+            continue
+        x1 = margin + i_src * (box_width + h_gap) + box_width
+        x2 = margin + i_dst * (box_width + h_gap)
+        y = centre_y
+        # Classe la métrique pour le code couleur
+        value = edge.get("metric_value")
+        try:
+            value_f = float(value) if value is not None else None
+        except (TypeError, ValueError):
+            value_f = None
+        cls = _classify_metric(value_f, thresholds, higher_is_better)
+        color = _QUALITY_COLORS[cls]
+        # Trace la flèche
+        parts.append(
+            f'<line x1="{x1}" y1="{y}" x2="{x2}" y2="{y}" '
+            f'stroke="{color}" stroke-width="2" '
+            f'marker-end="url(#arrow)"/>'
+        )
+        # Étiquette : type + métrique : valeur
+        artifact_type = edge.get("artifact_type") or ""
+        metric_name = edge.get("metric_name") or ""
+        value_str = _format_value(value_f)
+        label_lines: list[str] = []
+        if artifact_type:
+            label_lines.append(str(artifact_type))
+        if metric_name:
+            label_lines.append(f"{metric_name}: {value_str}")
+        if label_lines:
+            label_x = (x1 + x2) / 2
+            for k, line in enumerate(label_lines):
+                parts.append(
+                    f'<text x="{label_x}" y="{y - 8 - k * 12}" '
+                    f'text-anchor="middle" fill="{color}" '
+                    f'font-size="10" font-weight="600">'
+                    f'{_e(line)}</text>'
+                )
+    parts.append("</svg>")
+
+    # Légende
+    h_legend = labels.get("dag_legend", "Lecture")
+    legend_green = labels.get("dag_legend_green", "qualité élevée")
+    legend_yellow = labels.get("dag_legend_yellow", "qualité moyenne")
+    legend_red = labels.get("dag_legend_red", "qualité faible")
+    parts.append(
+        '<div style="font-size:.8rem;opacity:.75;margin-top:.4rem">'
+        f'<strong>{_e(h_legend)} :</strong> '
+        f'<span style="color:{_QUALITY_COLORS["green"]};'
+        f'font-weight:600">●</span> {_e(legend_green)} '
+        f'(≤ {thresholds[0] * 100:.0f}%) '
+        f'<span style="color:{_QUALITY_COLORS["yellow"]};'
+        f'font-weight:600">●</span> {_e(legend_yellow)} '
+        f'(≤ {thresholds[1] * 100:.0f}%) '
+        f'<span style="color:{_QUALITY_COLORS["red"]};'
+        f'font-weight:600">●</span> {_e(legend_red)}'
+        '</div>'
+    )
+    parts.append("</section>")
+    return "".join(parts)
+
+
+__all__ = ["build_pipeline_dag_html"]

tests/test_sprint95_pipeline_dag.py

@@ -0,0 +1,208 @@
+"""Tests Sprint 95 — B.4 : visualisation DAG d'un pipeline composé.
+
+Couvre :
+
+1. ``build_pipeline_dag_html`` :
+   - vide / None → ``""``
+   - 1 nœud → SVG sans arête
+   - 2 nœuds + 1 arête
+   - 3 nœuds chaînés
+   - arêtes auto-déduites si non fournies
+   - couleur selon seuil de la métrique
+   - mode higher_is_better
+2. Anti-injection sur nom de nœud, type d'artefact, nom de
+   métrique.
+3. Affichage de la valeur de métrique formatée.
+4. Complétude i18n FR/EN.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from picarones.report.pipeline_dag_render import build_pipeline_dag_html
+
+
+def _load_labels(lang: str) -> dict:
+    p = (
+        Path(__file__).parent.parent
+        / "picarones" / "report" / "i18n" / f"{lang}.json"
+    )
+    return json.loads(p.read_text(encoding="utf-8"))
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 1. build_pipeline_dag_html
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestRender:
+    def test_empty_returns_empty(self) -> None:
+        assert build_pipeline_dag_html(None) == ""
+        assert build_pipeline_dag_html([]) == ""
+
+    def test_single_node_renders_svg_no_edge(self) -> None:
+        nodes = [{"name": "tess", "output_types": ["TEXT"]}]
+        html = build_pipeline_dag_html(nodes, _load_labels("fr"))
+        assert "<svg" in html
+        assert "tess" in html
+        # Pas de flèche tracée (pas d'arête)
+        assert "marker-end" not in html
+
+    def test_two_nodes_one_edge(self) -> None:
+        nodes = [
+            {"name": "ocr", "output_types": ["TEXT"]},
+            {"name": "llm", "input_types": ["TEXT"]},
+        ]
+        edges = [{"from": "ocr", "to": "llm",
+                  "artifact_type": "TEXT",
+                  "metric_name": "cer",
+                  "metric_value": 0.04}]
+        html = build_pipeline_dag_html(
+            nodes, _load_labels("fr"), edges=edges,
+        )
+        # Nœuds présents
+        assert "ocr" in html
+        assert "llm" in html
+        # Étiquettes d'arête
+        assert "TEXT" in html
+        assert "cer" in html
+        assert "4.0%" in html
+        # Flèche présente
+        assert "marker-end" in html
+
+    def test_three_nodes_chain(self) -> None:
+        nodes = [
+            {"name": "a"}, {"name": "b"}, {"name": "c"},
+        ]
+        edges = [
+            {"from": "a", "to": "b", "metric_value": 0.05},
+            {"from": "b", "to": "c", "metric_value": 0.10},
+        ]
+        html = build_pipeline_dag_html(nodes, edges=edges)
+        # Deux flèches
+        assert html.count("marker-end") == 2
+
+    def test_auto_edges_when_missing(self) -> None:
+        # Pas d'arêtes fournies → auto-déduit séquentielles
+        nodes = [{"name": "a"}, {"name": "b"}, {"name": "c"}]
+        html = build_pipeline_dag_html(nodes)
+        assert html.count("marker-end") == 2
+
+    def test_colour_green_for_low_cer(self) -> None:
+        nodes = [{"name": "a"}, {"name": "b"}]
+        edges = [{"from": "a", "to": "b",
+                  "metric_value": 0.02}]  # ≤ 0.05 → vert
+        html = build_pipeline_dag_html(nodes, edges=edges)
+        assert "#16a34a" in html  # green
+
+    def test_colour_yellow(self) -> None:
+        nodes = [{"name": "a"}, {"name": "b"}]
+        edges = [{"from": "a", "to": "b", "metric_value": 0.10}]
+        html = build_pipeline_dag_html(nodes, edges=edges)
+        assert "#d97706" in html  # yellow
+
+    def test_colour_red_for_high_cer(self) -> None:
+        nodes = [{"name": "a"}, {"name": "b"}]
+        edges = [{"from": "a", "to": "b", "metric_value": 0.30}]
+        html = build_pipeline_dag_html(nodes, edges=edges)
+        assert "#dc2626" in html  # red
+
+    def test_higher_is_better_inverts(self) -> None:
+        # F1 = 0.95 = bonne qualité (haut)
+        nodes = [{"name": "a"}, {"name": "b"}]
+        edges = [{"from": "a", "to": "b", "metric_value": 0.96}]
+        html = build_pipeline_dag_html(
+            nodes, edges=edges, higher_is_better=True,
+        )
+        assert "#16a34a" in html
+
+    def test_unknown_node_in_edge_skipped(self) -> None:
+        nodes = [{"name": "a"}, {"name": "b"}]
+        edges = [
+            {"from": "a", "to": "b", "metric_value": 0.05},
+            {"from": "ghost", "to": "b", "metric_value": 0.01},
+        ]
+        html = build_pipeline_dag_html(nodes, edges=edges)
+        # Une seule flèche valide
+        assert html.count("marker-end") == 1
+
+    def test_handles_missing_metric_value(self) -> None:
+        nodes = [{"name": "a"}, {"name": "b"}]
+        edges = [{"from": "a", "to": "b",
+                  "artifact_type": "TEXT",
+                  "metric_name": "cer"}]  # pas de valeur
+        html = build_pipeline_dag_html(nodes, edges=edges)
+        assert "—" in html or "cer" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 2. Anti-injection
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestAntiInjection:
+    def test_node_name(self) -> None:
+        nodes = [{"name": "<script>alert(1)</script>"}]
+        html = build_pipeline_dag_html(nodes, _load_labels("fr"))
+        assert "<script>alert" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_artifact_type(self) -> None:
+        nodes = [{"name": "a"}, {"name": "b"}]
+        edges = [{"from": "a", "to": "b",
+                  "artifact_type": "<img/>",
+                  "metric_value": 0.05}]
+        html = build_pipeline_dag_html(nodes, edges=edges)
+        assert "<img/>" not in html
+        assert "&lt;img" in html
+
+    def test_metric_name(self) -> None:
+        nodes = [{"name": "a"}, {"name": "b"}]
+        edges = [{"from": "a", "to": "b",
+                  "metric_name": "<script>x",
+                  "metric_value": 0.05}]
+        html = build_pipeline_dag_html(nodes, edges=edges)
+        assert "<script>x" not in html
+        assert "&lt;script&gt;" in html
+
+    def test_input_output_types(self) -> None:
+        nodes = [{"name": "a", "input_types": ["<svg/>"],
+                  "output_types": ["<x>"]}]
+        html = build_pipeline_dag_html(nodes, _load_labels("fr"))
+        assert "<svg/>" not in html
+        assert "&lt;svg" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 3. Rendu en anglais
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class TestI18nRendering:
+    def test_english(self) -> None:
+        nodes = [{"name": "a"}]
+        html = build_pipeline_dag_html(nodes, _load_labels("en"))
+        assert "Inspection tool" in html or "source of truth" in html
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 4. Complétude i18n
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_KEYS = {
+    "dag_title", "dag_note", "dag_legend",
+    "dag_legend_green", "dag_legend_yellow", "dag_legend_red",
+}
+
+
+class TestI18nCompleteness:
+    def test_fr(self) -> None:
+        d = _load_labels("fr")
+        assert not _KEYS - d.keys()
+
+    def test_en(self) -> None:
+        d = _load_labels("en")
+        assert not _KEYS - d.keys()