feat(migration): Phase 5.C batch 7 — pré-requis + 2 derniers renderers

Septième et dernière vague de Phase 5.C. Migre d'abord les
modules de mesure dont dépendent les renderers
``numerical_sequences`` et ``pipeline``, puis migre ces 2 derniers
renderers vers ``reports_v2/html/renderers/``.

Pré-requis migrés (modules de mesure)
-------------------------------------
| Source legacy | Destination canonique |
|------------------------------------------------|------------------------------------------------|
| ``measurements/roman_numerals.py`` (478) | ``evaluation/metrics/roman_numerals.py`` |
| ``measurements/numerical_sequences.py`` (422) | ``evaluation/metrics/numerical_sequences.py`` |
| ``measurements/pipeline_benchmark.py`` (367) | ``evaluation/pipeline_benchmark.py`` |
| ``measurements/pipeline_comparison.py`` (301) | ``evaluation/pipeline_comparison.py`` |
| ``core/pipeline.py`` (607) | ``evaluation/pipeline.py`` |

Puis les 2 derniers renderers
-----------------------------
| Source legacy | Destination canonique |
|------------------------------------------------|------------------------------------------------------|
| ``report/numerical_sequences_render.py`` (149) | ``reports_v2/html/renderers/numerical_sequences.py`` |
| ``report/pipeline_render.py`` (707) | ``reports_v2/html/renderers/pipeline.py`` |

Total : ~3031 lignes relocalisées. 7 nouveaux shims minimaux.

État final de ``picarones/core/``
---------------------------------
Le répertoire ``picarones/core/`` est désormais **entièrement
constitué de shims** (10 fichiers, tous < 30 lignes). Aucun
module Cercle 1 réel ne subsiste — les abstractions vivent dans
``domain/`` (Pydantic immutable) et ``evaluation/`` (riche en
behavior). ``EXPECTED_CERCLE1`` du test
``test_public_api.py::TestCercle1IsLean`` est désormais un set
vide, documentant explicitement que la Phase 1 du retrait du
legacy est complète au niveau ``core/``.

Adaptations transverses
-----------------------
- Imports internes mis à jour entre modules canoniques.
- ``test_module_coverage.py::TEST_ONLY_BASELINE`` étendu à 4
modules supplémentaires.
- ``test_file_budgets.py`` : 4 entrées legacy retirées,
remplacées par les chemins canoniques.
- ``docs/tutorials/writing-a-pipeline-module.md`` : tous les
imports mis à jour.

Cumul Phase 5.C
---------------
**29 / 29 renderers migrés** (~8263 lignes au total) à travers
les 7 batches. Phase 5.C est terminée.

Acceptance
----------
5019 tests passent, lint vert, architecture vérifiée.

Restantes pour Phase 5
----------------------
- Phase 5.D : 5 vues (``views/*.py``).
- Phase 5.E : ``generator.py``, ``comparison.py``,
``snapshot.py``, ``report_data/``, templates Jinja2.

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

docs/migration/legacy-retirement-plan.md

@@ -696,12 +696,11 @@ architecture vérifiée.
 - Batch 4 ✅ (cf. ci-dessous) — 5 renderers (188-321 LOC).
 - Batch 5 ✅ (cf. ci-dessous) — 5 renderers (148-314 LOC).
 - Batch 6 ✅ (cf. ci-dessous) — 2 renderers (``levers``, ``philological``).
-- Batch 7 (final) : ``pipeline_render`` (707 l) +
-  ``numerical_sequences_render`` (149 l).
-  Pré-requis : migration de ``measurements/pipeline_benchmark``,
-  ``measurements/pipeline_comparison``,
-  ``measurements/numerical_sequences``,
-  ``measurements/roman_numerals`` vers ``evaluation/metrics/``.
+- Batch 7 ✅ (cf. ci-dessous) — pré-requis migrés
+  (``roman_numerals``, ``numerical_sequences``,
+  ``pipeline_benchmark``, ``pipeline_comparison``,
+  ``core/pipeline``) puis 2 renderers
+  (``numerical_sequences``, ``pipeline``).
 - Phase 5.D : 5 vues (``views/*.py``).
 - Phase 5.E : ``generator.py``, ``comparison.py``,
   ``snapshot.py``, ``report_data/``, templates Jinja2.
@@ -886,6 +885,73 @@ Total : ~776 lignes relocalisées.
 **Acceptance batch 6** : 5019 tests passent, lint vert,
 architecture vérifiée.
 
+#### Phase 5.C.batch7 — Lot 7 : pré-requis + 2 derniers renderers (2026-05)
+
+Le batch 7 finalise Phase 5.C en migrant **d'abord** les
+modules de mesure dont dépendent les renderers
+``numerical_sequences`` et ``pipeline`` :
+
+| Source legacy                                  | Destination canonique                          |
+|------------------------------------------------|------------------------------------------------|
+| ``measurements/roman_numerals.py`` (478)       | ``evaluation/metrics/roman_numerals.py``       |
+| ``measurements/numerical_sequences.py`` (422)  | ``evaluation/metrics/numerical_sequences.py``  |
+| ``measurements/pipeline_benchmark.py`` (367)   | ``evaluation/pipeline_benchmark.py``           |
+| ``measurements/pipeline_comparison.py`` (301)  | ``evaluation/pipeline_comparison.py``          |
+| ``core/pipeline.py`` (607)                     | ``evaluation/pipeline.py``                     |
+
+Puis les 2 derniers renderers :
+
+| Source legacy                                  | Destination canonique                                |
+|------------------------------------------------|------------------------------------------------------|
+| ``report/numerical_sequences_render.py`` (149) | ``reports_v2/html/renderers/numerical_sequences.py`` |
+| ``report/pipeline_render.py`` (707)            | ``reports_v2/html/renderers/pipeline.py``            |
+
+Total : ~3031 lignes relocalisées dans ce batch.  7 nouveaux
+shims minimaux (< 25 lignes) avec ``DeprecationWarning``.
+
+État final de ``picarones/core/``
+---------------------------------
+
+Le répertoire ``picarones/core/`` est désormais **entièrement
+constitué de shims** (10 fichiers, tous < 30 lignes).  Aucun
+module Cercle 1 réel ne subsiste — les abstractions vivent dans
+``domain/`` (Pydantic immutable) et ``evaluation/`` (riche en
+behavior).  ``EXPECTED_CERCLE1`` du test
+``test_public_api.py::TestCercle1IsLean`` est désormais un set
+vide, documentant explicitement que la Phase 1 du retrait du
+legacy est complète au niveau ``core/``.
+
+Adaptations transverses
+-----------------------
+
+- Imports internes mis à jour entre modules canoniques
+  (``evaluation/metrics/numerical_sequences.py`` → canonique
+  ``roman_numerals``, ``evaluation/pipeline_comparison.py`` →
+  canonique ``pipeline_benchmark``, etc.).
+- ``test_module_coverage.py::TEST_ONLY_BASELINE`` étendu à
+  ``"numerical_sequences"``, ``"numerical_sequences_hooks"``,
+  ``"pipeline_benchmark"``, ``"pipeline_comparison"``.
+- ``test_file_budgets.py`` : 4 entrées legacy retirées,
+  remplacées par les chemins canoniques.
+- ``test_public_api.py::EXPECTED_CERCLE1`` : ``pipeline.py``
+  retiré (set désormais vide).
+- ``docs/tutorials/writing-a-pipeline-module.md`` : tous les
+  imports mis à jour vers les chemins canoniques.
+
+**Cumul Phase 5.C** (batches 1-7) : **29 / 29 renderers migrés**
+(~8263 lignes au total).  Phase 5.C est terminée.
+
+**Acceptance batch 7** : 5019 tests passent, lint vert,
+architecture vérifiée (anti-cycles, file budgets,
+EXPECTED_CERCLE1 vide).
+
+Restantes pour Phase 5
+----------------------
+
+- Phase 5.D : 5 vues (``views/*.py``).
+- Phase 5.E : ``generator.py``, ``comparison.py``,
+  ``snapshot.py``, ``report_data/``, templates Jinja2.
+
 ### Phase 6 — Pipelines OCR+LLM (`pipelines/`)
 
 **Modules** : `pipelines/base.OCRLLMPipeline` (3 modes), `pipelines/

docs/tutorials/writing-a-pipeline-module.md

@@ -18,7 +18,7 @@
 
 ```python
 from picarones.core.modules import BaseModule, ArtifactType
-from picarones.core.pipeline import (
+from picarones.evaluation.pipeline import (
     PipelineRunner, PipelineSpec, PipelineStep,
 )
 
@@ -150,7 +150,7 @@ class NERExtractor(BaseModule):
 ### 3.a Mono-document (Sprint 63)
 
 ```python
-from picarones.core.pipeline import (
+from picarones.evaluation.pipeline import (
     PipelineRunner, PipelineSpec, PipelineStep,
 )
 
@@ -178,7 +178,7 @@ que `Document.ground_truths` porte une `TextGT` (ou `AltoGT`,
 ### 3.b Corpus complet (Sprint 64)
 
 ```python
-from picarones.measurements.pipeline_benchmark import run_pipeline_benchmark
+from picarones.evaluation.pipeline_benchmark import run_pipeline_benchmark
 
 bench = run_pipeline_benchmark(spec, my_corpus)
 print(bench.n_pipelines_succeeded, "/", bench.n_docs)
@@ -203,7 +203,7 @@ bench = run_pipeline_benchmark(spec, corpus, initial_inputs_factory=my_factory)
 ### 3.c Comparer N pipelines (Sprint 65)
 
 ```python
-from picarones.measurements.pipeline_comparison import compare_pipelines
+from picarones.evaluation.pipeline_comparison import compare_pipelines
 
 comparison = compare_pipelines(
     [spec_baseline, spec_with_correcteur_a, spec_with_correcteur_b],
@@ -259,7 +259,7 @@ Sans `inputs_from`, `correct_b` aurait reçu la sortie de
 
 ```python
 from pathlib import Path
-from picarones.report.pipeline_render import build_pipeline_report_html
+from picarones.reports_v2.html.renderers.pipeline import build_pipeline_report_html
 
 bench = run_pipeline_benchmark(spec, corpus)
 Path("rapport_pipeline.html").write_text(
@@ -271,7 +271,7 @@ Path("rapport_pipeline.html").write_text(
 
 ```python
 from picarones.core.modules import ArtifactType
-from picarones.report.pipeline_render import (
+from picarones.reports_v2.html.renderers.pipeline import (
     RankingSpec, build_pipeline_comparison_report_html,
 )
 

picarones/__init__.py

@@ -69,7 +69,7 @@ from picarones.domain.facts import (
     FactImportance,
     FactType,
 )
-from picarones.core.pipeline import (
+from picarones.evaluation.pipeline import (
     PipelineResult,
     PipelineRunner,
     PipelineSpec,

picarones/cli/_pipeline.py

@@ -66,7 +66,7 @@ def pipeline_run_cmd(
     import json as _json
 
     from picarones.evaluation.corpus import load_corpus_from_directory
-    from picarones.measurements.pipeline_benchmark import run_pipeline_benchmark
+    from picarones.evaluation.pipeline_benchmark import run_pipeline_benchmark
     from picarones.measurements.pipeline_spec_loader import load_pipeline_spec_from_yaml
 
     spec = load_pipeline_spec_from_yaml(spec_path)
@@ -114,7 +114,7 @@ def pipeline_run_cmd(
         )
         click.echo(f"JSON exporté : {output_json}")
     if output_html is not None:
-        from picarones.report.pipeline_render import build_pipeline_report_html
+        from picarones.reports_v2.html.renderers.pipeline import build_pipeline_report_html
         Path(output_html).write_text(
             build_pipeline_report_html(bench, lang=lang),
             encoding="utf-8",
@@ -163,7 +163,7 @@ def pipeline_compare_cmd(
     """Compare N pipelines décrites dans SPECS_PATH sur le même corpus."""
     from picarones.evaluation.corpus import load_corpus_from_directory
     from picarones.domain.artifacts import ArtifactType
-    from picarones.measurements.pipeline_comparison import compare_pipelines
+    from picarones.evaluation.pipeline_comparison import compare_pipelines
     from picarones.measurements.pipeline_spec_loader import (
         load_comparison_specs_from_yaml,
     )
@@ -187,7 +187,7 @@ def pipeline_compare_cmd(
             shown = f"{value:.4f}" if value is not None else "N/A"
             click.echo(f"  {i}. {name}: {shown}")
     if output_html is not None:
-        from picarones.report.pipeline_render import (
+        from picarones.reports_v2.html.renderers.pipeline import (
             RankingSpec,
             build_pipeline_comparison_report_html,
         )

picarones/core/pipeline.py

@@ -1,607 +1,18 @@
-"""Banc d'essai de pipelines composées — Sprint 63 (axe B).
+"""``picarones.core.pipeline`` — shim re-export (déprécié, suppression 2.0).
 
-Sprint 63 — Étape 4 / axe B du plan d'évolution 2026 : démarrage du
-banc d'essai de pipelines.
-
-Philosophie
------------
-Picarones est un **banc d'essai**, pas un atelier de production.
-Cette infrastructure permet d'**évaluer des pipelines composées de
-modules tiers** que l'utilisateur amène — par exemple :
-
-- ``[OCR(image→texte)] → [reconstructeur ALTO tiers(texte→ALTO)]``
-- ``[VLM(image→ALTO)] → [post-processing tiers(ALTO→ALTO)]``
-- ``[OCR(image→texte)] → [LLM correcteur(texte→texte)]``
-
-Picarones **ne fournit aucun module métier** (pas de
-reconstructeur ALTO, pas de correcteur, pas de re-segmenteur).
-L'utilisateur branche ses propres ``BaseModule`` (Sprint 33), le
-runner orchestre l'exécution séquentielle, valide les types aux
-jonctions et **évalue automatiquement** chaque artefact produit
-contre la GT du même niveau (Sprint 32) en sélectionnant les
-métriques pertinentes du registre typé (Sprint 34).
-
-Périmètre Sprint 63
--------------------
-Inclus :
-
-- Spécification déclarative d'une pipeline séquentielle.
-- Exécution sur un seul document avec passage typé d'artefacts.
-- Validation des types aux jonctions inter-modules.
-- Évaluation automatique aux jonctions GT-vs-sortie pour chaque
-  niveau de GT disponible sur le document.
-- Mesure du temps par étape.
-- Capture gracieuse des erreurs (un module qui lève n'arrête pas
-  les étapes suivantes — leur entrée manquante est rapportée
-  comme erreur explicite).
-
-Reporté à des sprints dédiés :
-
-- DAG branchant non séquentiel (1 → {2, 3} → 4) — Sprint 64+.
-- Orchestration corpus-wide + agrégation par pipeline — Sprint 65+.
-- Vue HTML dédiée aux pipelines composées — Sprint 66+.
-- Cache d'artefacts intermédiaires — non prévu.
-- Parallélisation inter-étapes — non prévue (les modules
-  ``execution_mode`` sont déjà respectés par le runner historique
-  pour le bench OCR mono-étage).
+Canonique : :mod:`picarones.evaluation.pipeline`.  Phase 5.C.batch7
+du retrait du legacy.
 """
 
 from __future__ import annotations
 
-import logging
-import time
-from dataclasses import dataclass, field
-from typing import Any, Optional
-
-from picarones.evaluation.corpus import Document, GTLevel
-from picarones.evaluation.metric_registry import compute_at_junction
-from picarones.domain.artifacts import ArtifactType
-from picarones.domain.module_protocol import BaseModule
-
-# Sprint A3 (renforce la règle Cercle 1 → Cercle 1 uniquement) — la
-# cérémonie d'eager-load des métriques typées (Sprint 34) qui vivait
-# ici a été déplacée dans ``picarones/measurements/__init__.py``. Tout
-# consommateur de ``compute_at_junction`` (typiquement la classe
-# ``PipelineRunner`` ci-dessous) doit avoir importé
-# ``picarones.measurements`` au moins une fois — c'est le cas dans
-# l'API publique via ``picarones.__init__`` qui déclenche le trigger.
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Conversion ArtifactType <-> GTLevel
-# ──────────────────────────────────────────────────────────────────────────
-
-
-#: Map ``ArtifactType`` canonique → ``GTLevel`` legacy.  Phase 4-bis :
-#: ``ArtifactType`` a été migré vers ``domain/artifacts.py`` qui
-#: distingue ``RAW_TEXT``/``CORRECTED_TEXT`` (vs ``TEXT`` legacy) et
-#: ``ALTO_XML``/``PAGE_XML`` (vs ``ALTO``/``PAGE`` legacy).  Les
-#: valeurs canoniques ne matchent donc plus celles de ``GTLevel``.
-#: Ce mapping explicite fait le pont — sera retiré en 2.0 quand
-#: ``GTLevel`` aura aussi été retiré au profit de la projection
-#: ``ArtifactType → niveau d'évaluation`` du rewrite.
-_ARTIFACT_TO_GT_LEVEL: dict[ArtifactType, GTLevel] = {
-    ArtifactType.RAW_TEXT: GTLevel.TEXT,
-    ArtifactType.CORRECTED_TEXT: GTLevel.TEXT,
-    ArtifactType.ALTO_XML: GTLevel.ALTO,
-    ArtifactType.PAGE_XML: GTLevel.PAGE,
-    ArtifactType.ENTITIES: GTLevel.ENTITIES,
-    ArtifactType.READING_ORDER: GTLevel.READING_ORDER,
-}
-
-
-def _artifact_type_to_gt_level(at: ArtifactType) -> Optional[GTLevel]:
-    """Retourne le ``GTLevel`` correspondant à un ``ArtifactType``.
-
-    ``IMAGE`` n'a pas de correspondance GT (on n'évalue pas une
-    image en sortie d'un module — c'est typiquement une entrée).
-    Les types ``CONFIDENCES``, ``ALIGNMENT``, ``CANONICAL_DOCUMENT``
-    n'ont pas non plus de niveau de GT direct dans le legacy.
-    """
-    return _ARTIFACT_TO_GT_LEVEL.get(at)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# PipelineStep + PipelineSpec
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@dataclass
-class PipelineStep:
-    """Une étape dans une pipeline composée.
-
-    L'étape porte un nom lisible (utile pour le rapport et le
-    diagnostic) et une instance de ``BaseModule`` fournie par
-    l'utilisateur.  Les types d'entrée et de sortie ne sont pas
-    redéclarés ici : ils sont lus depuis le module lui-même
-    (``module.input_types`` / ``module.output_types``).
-
-    Sprint 66 — DAG branchant
-    -------------------------
-    ``inputs_from`` permet de désigner explicitement, pour chaque
-    type d'entrée, l'étape source dont on veut consommer l'artefact.
-    Utile quand plusieurs étapes antérieures produisent le même
-    type et qu'on veut éviter l'écrasement implicite (par exemple
-    deux correcteurs LLM en parallèle qui partent du même OCR).
-
-    - ``inputs_from = {}`` (défaut) : pour chaque type d'entrée,
-      le runner prend la version **la plus récente** disponible
-      dans le bag (comportement Sprint 63, rétrocompat stricte).
-    - ``inputs_from = {ArtifactType.TEXT: "ocr"}`` : exige la
-      version du ``TEXT`` produite par l'étape nommée ``"ocr"``.
-      Si cette étape n'existe pas ou n'a pas produit ce type,
-      ``PipelineSpec.validate`` remonte un problème explicite et
-      le runner remonte une erreur d'entrée manquante.
-
-    La chaîne spéciale ``"__initial__"`` désigne les artefacts
-    fournis dans ``initial_inputs`` (par exemple ``IMAGE``).
-    """
-
-    name: str
-    module: BaseModule
-    inputs_from: dict[ArtifactType, str] = field(default_factory=dict)
-
-    @property
-    def input_types(self) -> tuple[ArtifactType, ...]:
-        return tuple(self.module.input_types)
-
-    @property
-    def output_types(self) -> tuple[ArtifactType, ...]:
-        return tuple(self.module.output_types)
-
-    def __repr__(self) -> str:
-        ins = ",".join(t.value for t in self.input_types) or "·"
-        outs = ",".join(t.value for t in self.output_types) or "·"
-        if self.inputs_from:
-            refs = ",".join(
-                f"{t.value}@{src}" for t, src in self.inputs_from.items()
-            )
-            return f"PipelineStep({self.name}: [{refs}] → {outs})"
-        return f"PipelineStep({self.name}: {ins} → {outs})"
-
-
-@dataclass
-class PipelineSpec:
-    """DAG séquentiel de ``PipelineStep``.
-
-    Sprint 63 — séquentiel uniquement : l'étape ``i+1`` consomme
-    les artefacts produits par l'étape ``i`` (et tous les artefacts
-    initiaux fournis au runner, par exemple l'image source).
-
-    Le DAG branchant arrive dans un sprint dédié.
-    """
-
-    name: str
-    steps: list[PipelineStep] = field(default_factory=list)
-
-    def validate(self, initial_inputs: tuple[ArtifactType, ...]) -> list[str]:
-        """Vérifie que les types s'enchaînent et retourne la liste
-        des problèmes détectés (vide si la pipeline est valide).
-
-        Une pipeline est valide si, pour chaque étape, tous les
-        ``input_types`` sont disponibles : soit dans les
-        ``initial_inputs`` (typiquement ``IMAGE``), soit produits
-        par une étape antérieure.
-
-        Sprint 66 — validation des références ``inputs_from`` :
-        si une étape déclare ``inputs_from[type] = "foo"``,
-        l'étape ``foo`` doit exister parmi les étapes antérieures
-        et avoir ce type dans ses ``output_types``.  La chaîne
-        spéciale ``"__initial__"`` désigne les entrées initiales.
-        """
-        problems: list[str] = []
-        if not self.steps:
-            problems.append("pipeline vide : au moins une étape est requise")
-            return problems
-        # Map type → set des steps qui ont produit ce type
-        # ("__initial__" pour les entrées initiales) — utilisé pour
-        # valider les références ``inputs_from``.
-        producers: dict[ArtifactType, set[str]] = {
-            t: {"__initial__"} for t in initial_inputs
-        }
-        # Map step_name → set des types produits, pour la validation
-        # des références.
-        step_outputs: dict[str, set[ArtifactType]] = {
-            "__initial__": set(initial_inputs),
-        }
-        # Set des types disponibles à un instant t (latest seulement).
-        available: set[ArtifactType] = set(initial_inputs)
-
-        for i, step in enumerate(self.steps):
-            # 1. Toutes les entrées doivent être disponibles
-            missing = [t for t in step.input_types if t not in available]
-            if missing:
-                miss_str = ",".join(t.value for t in missing)
-                problems.append(
-                    f"étape {i} ({step.name}) demande {miss_str} "
-                    f"qui n'est ni dans les entrées initiales "
-                    f"ni produit par une étape antérieure"
-                )
-            # 2. Vérification des références ``inputs_from``
-            for ref_type, ref_step in step.inputs_from.items():
-                if ref_type not in step.input_types:
-                    problems.append(
-                        f"étape {i} ({step.name}) déclare "
-                        f"inputs_from[{ref_type.value}]={ref_step!r} "
-                        f"mais le module ne consomme pas ce type"
-                    )
-                    continue
-                if ref_step not in step_outputs:
-                    problems.append(
-                        f"étape {i} ({step.name}) référence "
-                        f"inputs_from[{ref_type.value}]={ref_step!r} "
-                        f"qui n'est pas une étape antérieure connue"
-                    )
-                    continue
-                if ref_type not in step_outputs[ref_step]:
-                    problems.append(
-                        f"étape {i} ({step.name}) référence "
-                        f"inputs_from[{ref_type.value}]={ref_step!r} "
-                        f"mais cette étape ne produit pas ce type"
-                    )
-            # 3. Mise à jour pour les étapes suivantes
-            available.update(step.output_types)
-            step_outputs[step.name] = set(step.output_types)
-            for out_type in step.output_types:
-                producers.setdefault(out_type, set()).add(step.name)
-        return problems
-
-    def is_valid(self, initial_inputs: tuple[ArtifactType, ...]) -> bool:
-        return not self.validate(initial_inputs)
-
-    def __repr__(self) -> str:
-        chain = " → ".join(str(s) for s in self.steps)
-        return f"PipelineSpec({self.name}: {chain})"
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# StepResult + PipelineResult
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@dataclass
-class StepResult:
-    """Résultat de l'exécution d'une étape sur un document.
-
-    Champs
-    ------
-    step_name:
-        Nom de l'étape (cf. ``PipelineStep.name``).
-    duration_seconds:
-        Temps d'exécution de ``module.process`` mesuré en wall-clock.
-    output_types:
-        Types effectivement présents dans la sortie (peut être un
-        sous-ensemble de ``module.output_types`` si le module a
-        omis un type — cas reporté ici comme info pour diagnostic).
-    junction_metrics:
-        Pour chaque type produit qui correspond à un ``GTLevel``
-        dont le document porte une GT : dictionnaire ``{type: dict
-        métriques}`` retourné par ``compute_at_junction``.
-    error:
-        ``None`` si l'étape s'est bien déroulée ; sinon message
-        d'erreur (le module a levé, l'entrée est manquante, ou la
-        validation des types a échoué).
-    """
-
-    step_name: str
-    duration_seconds: float
-    output_types: tuple[ArtifactType, ...]
-    junction_metrics: dict[str, dict[str, Any]] = field(default_factory=dict)
-    """Map ``{artifact_type_value: {metric_name: value}}``.
-
-    La clé est la valeur string du ``ArtifactType`` (ex. ``"text"``,
-    ``"alto"``) et non l'enum lui-même, pour faciliter la
-    sérialisation JSON.
-    """
-    error: Optional[str] = None
-
-
-@dataclass
-class PipelineResult:
-    """Résultat complet d'une exécution de pipeline sur un document.
-
-    On capture la durée totale, la durée par étape et les
-    métriques aux jonctions pour chaque artefact produit qui a une
-    GT correspondante.
-    """
-
-    pipeline_name: str
-    doc_id: str
-    steps: list[StepResult] = field(default_factory=list)
-    total_duration_seconds: float = 0.0
-    error: Optional[str] = None
-    """Erreur fatale au niveau pipeline (ex. validation des types
-    en amont avant la première étape).  ``None`` n'implique pas
-    qu'aucune étape n'a échoué — voir ``StepResult.error`` pour le
-    détail par étape."""
-
-    @property
-    def succeeded(self) -> bool:
-        """Vrai si la pipeline s'est exécutée jusqu'au bout sans
-        qu'aucune étape ne lève d'erreur."""
-        if self.error is not None:
-            return False
-        return all(s.error is None for s in self.steps)
-
-    @property
-    def failing_steps(self) -> list[str]:
-        """Noms des étapes ayant levé une erreur."""
-        return [s.step_name for s in self.steps if s.error is not None]
-
-    def junction_metrics_for(
-        self, artifact_type: ArtifactType,
-    ) -> Optional[dict[str, Any]]:
-        """Retourne les métriques de la **dernière** étape qui a
-        produit ``artifact_type``, ou ``None`` si aucune étape ne
-        l'a produit avec succès.
-
-        Utile pour comparer plusieurs pipelines qui produisent in
-        fine le même type (ex. deux DAG aboutissant à du texte
-        corrigé).
-        """
-        from picarones.domain.artifacts import LEGACY_VALUE_ALIASES
-        legacy_alias = LEGACY_VALUE_ALIASES.get(artifact_type.value)
-        for step in reversed(self.steps):
-            if step.error is not None:
-                continue
-            metrics = step.junction_metrics.get(artifact_type.value)
-            if metrics is None and legacy_alias is not None:
-                # Phase 4-bis : un caller legacy peut avoir construit
-                # le dict avec la clé pré-rewrite ("text" au lieu de
-                # "raw_text").  expand_legacy_keys synchronise les deux
-                # côtés sur les sites d'écriture du runner, mais des
-                # StepResult construits à la main par les tests ou par
-                # un caller externe peuvent encore avoir une seule
-                # clé — on tolère.
-                metrics = step.junction_metrics.get(legacy_alias)
-            if metrics is not None:
-                return metrics
-        return None
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Exécuteur
-# ──────────────────────────────────────────────────────────────────────────
-
-
-class PipelineRunner:
-    """Exécute une ``PipelineSpec`` sur un document.
-
-    Sprint 63 — un seul document à la fois.  L'orchestration
-    corpus-wide et l'agrégation par pipeline sont reportées à un
-    sprint dédié.
-
-    Usage typique
-    -------------
-
-    >>> spec = PipelineSpec(
-    ...     name="ocr_then_rewrite",
-    ...     steps=[
-    ...         PipelineStep("ocr", my_ocr_module),
-    ...         PipelineStep("rewrite", my_llm_rewriter),
-    ...     ],
-    ... )
-    >>> runner = PipelineRunner()
-    >>> result = runner.run(spec, document, {ArtifactType.IMAGE: "/path/img.png"})
-    >>> result.succeeded
-    True
-    >>> result.junction_metrics_for(ArtifactType.TEXT)
-    {'cer': 0.05, 'wer': 0.12, ...}
-    """
-
-    @staticmethod
-    def run(
-        spec: PipelineSpec,
-        document: Document,
-        initial_inputs: dict[ArtifactType, Any],
-    ) -> PipelineResult:
-        """Exécute ``spec`` sur ``document`` à partir de
-        ``initial_inputs``.
-
-        Parameters
-        ----------
-        spec:
-            Spécification de la pipeline.
-        document:
-            Document du corpus, porteur de zéro ou plusieurs niveaux
-            de GT (Sprint 32).
-        initial_inputs:
-            Artefacts initiaux par type — typiquement
-            ``{ArtifactType.IMAGE: "/path/img.png"}`` pour une
-            pipeline qui démarre par un OCR.
-
-        Returns
-        -------
-        PipelineResult
-            Résultat complet : durée totale, résultat par étape,
-            métriques aux jonctions évaluées contre la GT.
-        """
-        result = PipelineResult(
-            pipeline_name=spec.name, doc_id=document.doc_id,
-        )
-
-        # Validation amont : si la pipeline est statiquement
-        # invalide, on n'exécute aucune étape.
-        problems = spec.validate(tuple(initial_inputs.keys()))
-        if problems:
-            result.error = " ; ".join(problems)
-            return result
-
-        # Sprint 66 — bag versionné : ``versioned[(type, src_step)]``
-        # contient l'artefact produit par ``src_step`` pour ``type``.
-        # ``src_step`` vaut ``"__initial__"`` pour les entrées
-        # initiales fournies par l'utilisateur.  ``latest[type]``
-        # désigne le nom de l'étape qui a produit la version la plus
-        # récente du type — utilisé en l'absence d'``inputs_from``
-        # explicite (rétrocompat Sprint 63).
-        versioned: dict[tuple[ArtifactType, str], Any] = {
-            (t, "__initial__"): v for t, v in initial_inputs.items()
-        }
-        latest: dict[ArtifactType, str] = {
-            t: "__initial__" for t in initial_inputs
-        }
-
-        pipeline_t0 = time.monotonic()
-        for step in spec.steps:
-            step_result = PipelineRunner._run_step(
-                step, versioned, latest, document,
-            )
-            result.steps.append(step_result)
-        result.total_duration_seconds = time.monotonic() - pipeline_t0
-        return result
-
-    @staticmethod
-    def _run_step(
-        step: PipelineStep,
-        versioned: dict[tuple[ArtifactType, str], Any],
-        latest: dict[ArtifactType, str],
-        document: Document,
-    ) -> StepResult:
-        # Sprint 66 — résolution des entrées : pour chaque type
-        # demandé, on consulte ``inputs_from`` ; sinon on prend la
-        # dernière version disponible (rétrocompat Sprint 63).
-        resolved: dict[ArtifactType, Any] = {}
-        missing: list[str] = []
-        for t in step.input_types:
-            src = step.inputs_from.get(t, latest.get(t))
-            if src is None:
-                missing.append(t.value)
-                continue
-            key = (t, src)
-            if key not in versioned:
-                # Référence explicite vers une étape qui n'a pas
-                # produit cet artefact (ex. l'étape source a échoué).
-                missing.append(f"{t.value}@{src}")
-                continue
-            resolved[t] = versioned[key]
-        if missing:
-            miss_str = ",".join(missing)
-            return StepResult(
-                step_name=step.name,
-                duration_seconds=0.0,
-                output_types=(),
-                error=f"entrée manquante : {miss_str}",
-            )
-        inputs_for_module = resolved
-        # Exécution chronométrée
-        t0 = time.monotonic()
-        try:
-            outputs = step.module.process(inputs_for_module)
-        except Exception as exc:  # noqa: BLE001
-            duration = time.monotonic() - t0
-            logger.warning(
-                "[pipeline_runner] étape '%s' a levé : %s",
-                step.name, exc,
-            )
-            return StepResult(
-                step_name=step.name,
-                duration_seconds=duration,
-                output_types=(),
-                error=f"{type(exc).__name__}: {exc}",
-            )
-        duration = time.monotonic() - t0
-
-        # Validation des sorties : le module est censé déclarer ses
-        # output_types, on vérifie qu'il les a tous produits.  Si
-        # ce n'est pas le cas, on remonte une erreur explicite mais
-        # on conserve les sorties effectivement présentes (utile
-        # pour le diagnostic).
-        if not isinstance(outputs, dict):
-            return StepResult(
-                step_name=step.name,
-                duration_seconds=duration,
-                output_types=(),
-                error=(
-                    f"le module a retourné {type(outputs).__name__}, "
-                    f"un dict[ArtifactType, Any] est attendu"
-                ),
-            )
-        produced = tuple(t for t in step.output_types if t in outputs)
-        missing_outputs = [t for t in step.output_types if t not in outputs]
-        error: Optional[str] = None
-        if missing_outputs:
-            miss_str = ",".join(t.value for t in missing_outputs)
-            error = f"sortie manquante : {miss_str}"
-
-        # Mise à jour du bag versionné : on stocke la sortie sous
-        # une clé (type, step.name) ET on met à jour ``latest`` pour
-        # que les étapes suivantes la récupèrent par défaut.
-        for t in produced:
-            versioned[(t, step.name)] = outputs[t]
-            latest[t] = step.name
-
-        # Évaluation aux jonctions : pour chaque type produit, si
-        # la GT du même niveau existe, on calcule les métriques.
-        junction_metrics: dict[str, dict[str, Any]] = {}
-        for at in produced:
-            gt_level = _artifact_type_to_gt_level(at)
-            if gt_level is None:
-                continue
-            gt_payload = document.get_gt(gt_level)
-            if gt_payload is None:
-                continue
-            try:
-                metrics = compute_at_junction(
-                    _gt_payload_to_value(gt_payload),
-                    outputs[at],
-                    (at, at),
-                )
-            except Exception as exc:  # noqa: BLE001
-                logger.warning(
-                    "[pipeline_runner] évaluation à la jonction %s "
-                    "a levé : %s",
-                    at.value, exc,
-                )
-                continue
-            if metrics:
-                junction_metrics[at.value] = metrics
-
-        # Phase 4-bis : double-clé pour rétrocompat.  Les tests
-        # legacy cherchent junction_metrics["text"] mais le runner
-        # peut produire junction_metrics["raw_text"] si l'enum est
-        # migré (ArtifactType.TEXT alias de RAW_TEXT, valeur
-        # "raw_text").  expand_legacy_keys ajoute la clé legacy
-        # ("text") à côté de la canonique ("raw_text") sans écraser.
-        from picarones.domain.artifacts import expand_legacy_keys
-        expand_legacy_keys(junction_metrics)
-
-        return StepResult(
-            step_name=step.name,
-            duration_seconds=duration,
-            output_types=produced,
-            junction_metrics=junction_metrics,
-            error=error,
-        )
-
-
-def _gt_payload_to_value(payload: Any) -> Any:
-    """Extrait la valeur exploitable d'un ``GTPayload`` typé.
-
-    Pour ``TextGT`` on veut juste la chaîne ; pour les autres
-    payloads on retourne le payload entier (la métrique sait quoi
-    en faire selon sa signature de types).
-    """
-    # Import paresseux pour éviter une dépendance cyclique
-    from picarones.evaluation.corpus import (
-        AltoGT, EntitiesGT, PageGT, ReadingOrderGT, TextGT,
-    )
-    if isinstance(payload, TextGT):
-        return payload.text
-    if isinstance(payload, EntitiesGT):
-        return payload.entities
-    if isinstance(payload, ReadingOrderGT):
-        return payload.region_order
-    if isinstance(payload, (AltoGT, PageGT)):
-        return payload
-    return payload
+import warnings
 
+from picarones.evaluation.pipeline import *  # noqa: F401, F403
 
-__all__ = [
-    "PipelineRunner",
-    "PipelineResult",
-    "PipelineSpec",
-    "PipelineStep",
-    "StepResult",
-]
+warnings.warn(
+    "picarones.core.pipeline is deprecated and will be removed in 2.0.  "
+    "Import from picarones.evaluation.pipeline instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/evaluation/metrics/numerical_sequences.py

@@ -0,0 +1,428 @@
+"""Précision sur séquences numériques — Sprint 85 (A.II.5b).
+
+Phase 5.C.batch7 — module relocalisé depuis
+``picarones.measurements.numerical_sequences`` vers
+``picarones.evaluation.metrics.numerical_sequences``.  Le chemin
+legacy reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Sprint 85 — A.II.5b du plan d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Pour un économiste-historien, un éditeur de chartes ou un
+archiviste, la **fidélité aux séquences numériques** est un
+proxy direct de la qualité éditoriale.  Un OCR qui rate
+*« 1789 »* dans une charte révolutionnaire ou *« f. 12v »*
+dans une cote d'archives produit un corpus inutilisable pour la
+recherche fine, même si le CER global est respectable.
+
+Catégories couvertes
+--------------------
+1. **Dates arabes** : ``1789``, ``1450``, ``1ᵉʳ janvier 1789``
+   (le module détecte les **années** sur 4 chiffres dans la
+   plage [1000-2099]).
+2. **Numéraux romains** : ``MDCLXVIII``, ``XIV``, ``Tome IV``.
+   Réutilise ``picarones.measurements.roman_numerals`` (Sprint 60).
+3. **Foliotation** : ``f. 12``, ``f. 12r``, ``fol. 24v``,
+   ``p. 5``, ``pp. 12-15``, ``n° 42``.
+4. **Montants** : ``12 livres``, ``5 sols``, ``8 deniers``,
+   ``100 £``, ``50 ₣``, ``20 €``, formes Ancien Régime
+   (``l.``, ``s.``, ``d.``).
+5. **Années régnales** : ``an III``, ``l'an V``, ``an de
+   grâce 1450``, ``an de la République``.
+
+Méthode
+-------
+Pour chaque catégorie, on extrait les occurrences (regex
+spécialisée) en GT et en hypothèse.  On classe ensuite chaque
+GT en **3 statuts** :
+
+- ``strict_preserved`` : forme exacte présente dans
+  l'hypothèse (sensible à la casse seulement pour la
+  foliotation, sinon la convention est documentée par
+  catégorie) ;
+- ``value_preserved`` : la **valeur** apparaît même si la
+  forme diffère (ex. ``XIV`` GT et ``14`` hypothèse —
+  considéré comme valeur préservée mais forme non) ;
+- ``lost`` : aucune trace exploitable.
+
+Sortie
+------
+``compute_numerical_sequence_metrics(reference, hypothesis)``
+retourne :
+
+```
+{
+    "global_strict_score": float,        # ∈ [0, 1]
+    "global_value_score": float,         # ∈ [0, 1]
+    "n_total": int,
+    "per_category": {
+        "year": {"n_total": int, "strict": int, "value": int,
+                 "strict_score": float, "value_score": float,
+                 "lost_items": list[str]},
+        "roman": {...},
+        "foliation": {...},
+        "currency": {...},
+        "regnal": {...},
+    },
+}
+```
+
+Limites
+-------
+- Les regex sont **conservatrices** : on rate quelques
+  formes rares plutôt que de produire des faux positifs (par
+  exemple, ``mil cinq cens`` en français médiéval n'est pas
+  détecté comme année — la couche calcul s'en tient aux
+  formes les plus reconnaissables).  Pour un corpus
+  spécifique, l'utilisateur peut composer ses propres
+  détecteurs et les passer via ``custom_detectors``.
+- ``value_preserved`` exige une équivalence de **valeur
+  numérique** : ``XIV`` ↔ ``14`` est OK pour les romains ;
+  ``f. 12v`` ↔ ``f. 12r`` n'est **pas** OK pour la
+  foliotation (recto/verso est une information distincte).
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Optional
+
+from picarones.evaluation.metric_registry import register_metric
+from picarones.domain.artifacts import ArtifactType
+from picarones.evaluation.metrics.roman_numerals import (
+    detect_roman_numerals,
+    roman_to_int,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Constantes / catégories
+# ──────────────────────────────────────────────────────────────────────────
+
+
+CATEGORIES = ("year", "roman", "foliation", "currency", "regnal")
+
+
+# Dates arabes — 4 chiffres dans la plage [1000-2099].
+# On exige une frontière de mot pour ne pas attraper
+# « 12345 » (volume) ou « 0001 » (numéro de page).
+_RE_YEAR = re.compile(r"\b(1[0-9]{3}|20[0-9]{2})\b")
+
+
+# Foliotation : f. 12, f. 12r, fol. 24v, p. 5, pp. 12-15, n° 42
+# La capture conserve la forme intégrale (avec ponctuation et
+# r/v) parce que recto/verso est une information distincte.
+_RE_FOLIATION = re.compile(
+    r"\b(?:fol\.?|f\.|pp\.|p\.|n\.°|n°)\s*"  # préfixe : fol., f., pp., p., n°
+    r"(\d+(?:\s*-\s*\d+)?)"                  # nombre ou plage (12 / 12-15)
+    r"\s*([rvRV])?",                         # suffixe optionnel r/v
+    re.UNICODE,
+)
+
+
+# Montants : nombre suivi d'une unité monétaire.
+# On accepte espaces multiples mais pas de saut de ligne.
+_RE_CURRENCY = re.compile(
+    r"\b(\d+(?:[.,]\d+)?)\s*"                # montant (entier ou décimal)
+    r"(livres?|sols?|deniers?|écus?|florins?|francs?|"
+    r"l\.|s\.|d\.|£|€|₣)"                    # unité
+    r"(?=\b|[\s,;.!?:]|$)",                  # frontière souple post-symbole
+    re.UNICODE | re.IGNORECASE,
+)
+
+
+# Années régnales : « an III », « an de grâce 1450 »,
+# « l'an V de la République ».
+# Capture le numéral (romain ou arabe).
+_RE_REGNAL = re.compile(
+    r"\b(?:l['’]\s*)?an\s+(?:de\s+(?:grâce|la\s+R[eé]publique)\s+)?"
+    r"([IVXLCDMivxlcdm]+|\d{1,4})\b",
+    re.UNICODE,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Détection par catégorie
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _detect_years(text: str) -> list[tuple[str, int]]:
+    """Retourne [(forme, valeur)] pour chaque année 4 chiffres."""
+    if not text:
+        return []
+    return [(m.group(0), int(m.group(0))) for m in _RE_YEAR.finditer(text)]
+
+
+def _detect_romans_with_values(text: str) -> list[tuple[str, int]]:
+    """Numéraux romains accompagnés de leur valeur entière.
+    Délègue à ``roman_numerals.detect_roman_numerals`` (Sprint 60),
+    qui retourne ``(start, form, value)``.
+    """
+    if not text:
+        return []
+    out: list[tuple[str, int]] = []
+    for _start, form, value in detect_roman_numerals(text, min_length=2):
+        if value is not None:
+            out.append((form, value))
+    return out
+
+
+def _detect_foliations(text: str) -> list[tuple[str, str]]:
+    """Foliotation. Retourne [(forme_complète, clé_normalisée)] où la
+    clé inclut le suffixe r/v normalisé (recto/verso).
+    """
+    if not text:
+        return []
+    out: list[tuple[str, str]] = []
+    for m in _RE_FOLIATION.finditer(text):
+        full = m.group(0).strip()
+        nums = re.sub(r"\s+", "", m.group(1))  # ex : "12-15"
+        suffix = (m.group(2) or "").lower()
+        key = f"{nums}{suffix}"
+        out.append((full, key))
+    return out
+
+
+def _detect_currencies(text: str) -> list[tuple[str, tuple[str, str]]]:
+    """Montants. Clé = (montant_normalisé, unité_canonique).
+
+    L'unité canonique compresse les variantes (« livres » et
+    « livre » → « livre » ; « £ » reste « £ »).
+    """
+    if not text:
+        return []
+    canon = {
+        "livre": "livre", "livres": "livre", "l.": "livre",
+        "sol": "sol", "sols": "sol", "s.": "sol",
+        "denier": "denier", "deniers": "denier", "d.": "denier",
+        "écu": "écu", "écus": "écu",
+        "florin": "florin", "florins": "florin",
+        "franc": "franc", "francs": "franc",
+        "£": "£", "€": "€", "₣": "₣",
+    }
+    out: list[tuple[str, tuple[str, str]]] = []
+    for m in _RE_CURRENCY.finditer(text):
+        amount = m.group(1).replace(",", ".")
+        unit_raw = m.group(2).lower()
+        unit = canon.get(unit_raw, unit_raw)
+        out.append((m.group(0), (amount, unit)))
+    return out
+
+
+def _detect_regnal(text: str) -> list[tuple[str, int]]:
+    """Années régnales. Retourne [(forme, valeur_int)] avec la
+    valeur extraite (romain → int ou arabe → int).
+    """
+    if not text:
+        return []
+    out: list[tuple[str, int]] = []
+    for m in _RE_REGNAL.finditer(text):
+        numeral = m.group(1)
+        value: Optional[int]
+        if numeral.isdigit():
+            value = int(numeral)
+        else:
+            value = roman_to_int(numeral)
+        if value is not None:
+            out.append((m.group(0), value))
+    return out
+
+
+_DETECTORS = {
+    "year": _detect_years,
+    "roman": _detect_romans_with_values,
+    "foliation": _detect_foliations,
+    "currency": _detect_currencies,
+    "regnal": _detect_regnal,
+}
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul principal
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _classify_per_category(
+    gt_items: list,
+    hyp_items: list,
+    *,
+    form_extractor,
+    value_extractor,
+) -> dict:
+    """Pour chaque item GT, le classe en strict_preserved /
+    value_preserved / lost.
+
+    Multiplicité respectée : un item hypothèse ne peut servir
+    qu'à un seul match (forme prioritaire sur valeur).
+    """
+    hyp_used = [False] * len(hyp_items)
+    n_strict = 0
+    n_value = 0
+    lost: list[str] = []
+    # Première passe : matchs stricts (forme exacte)
+    matched: list[bool] = [False] * len(gt_items)
+    for gi, gt_item in enumerate(gt_items):
+        gt_form = form_extractor(gt_item)
+        for hi, hyp_item in enumerate(hyp_items):
+            if hyp_used[hi]:
+                continue
+            if form_extractor(hyp_item) == gt_form:
+                hyp_used[hi] = True
+                matched[gi] = True
+                n_strict += 1
+                break
+    # Deuxième passe : matchs sur valeur (forme différente)
+    for gi, gt_item in enumerate(gt_items):
+        if matched[gi]:
+            n_value += 1  # strict implique value
+            continue
+        gt_val = value_extractor(gt_item)
+        for hi, hyp_item in enumerate(hyp_items):
+            if hyp_used[hi]:
+                continue
+            if value_extractor(hyp_item) == gt_val:
+                hyp_used[hi] = True
+                matched[gi] = True
+                n_value += 1
+                break
+        if not matched[gi]:
+            lost.append(form_extractor(gt_item))
+    n_total = len(gt_items)
+    return {
+        "n_total": n_total,
+        "strict": n_strict,
+        "value": n_value,
+        "strict_score": n_strict / n_total if n_total else 0.0,
+        "value_score": n_value / n_total if n_total else 0.0,
+        "lost_items": lost,
+    }
+
+
+def compute_numerical_sequence_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+) -> dict:
+    """Calcule la précision sur séquences numériques.
+
+    Returns
+    -------
+    dict
+        Voir docstring du module.  Si ``reference`` est vide
+        ou ne contient aucune séquence détectée, retourne
+        ``{n_total: 0, ...}`` avec scores à 0 (pas None).
+    """
+    ref = reference or ""
+    hyp = hypothesis or ""
+
+    # Spécifications par catégorie : (gt_items, hyp_items,
+    # extractor de forme, extractor de valeur).
+    specs: dict[str, dict] = {}
+    # year : (form="1789", value=1789)
+    specs["year"] = {
+        "gt": _detect_years(ref),
+        "hyp": _detect_years(hyp),
+        "form": lambda it: it[0],
+        "value": lambda it: it[1],
+    }
+    # roman : (form="MDCLXVIII", value=1668)
+    specs["roman"] = {
+        "gt": _detect_romans_with_values(ref),
+        "hyp": _detect_romans_with_values(hyp),
+        "form": lambda it: it[0],
+        "value": lambda it: it[1],
+    }
+    # foliation : (form="f. 12r", value="12r")
+    specs["foliation"] = {
+        "gt": _detect_foliations(ref),
+        "hyp": _detect_foliations(hyp),
+        "form": lambda it: it[0],
+        "value": lambda it: it[1],
+    }
+    # currency : (form="12 livres", value=("12", "livre"))
+    specs["currency"] = {
+        "gt": _detect_currencies(ref),
+        "hyp": _detect_currencies(hyp),
+        "form": lambda it: it[0],
+        "value": lambda it: it[1],
+    }
+    # regnal : (form="an III", value=3)
+    specs["regnal"] = {
+        "gt": _detect_regnal(ref),
+        "hyp": _detect_regnal(hyp),
+        "form": lambda it: it[0],
+        "value": lambda it: it[1],
+    }
+
+    per_category: dict[str, dict] = {}
+    total = 0
+    total_strict = 0
+    total_value = 0
+    for cat, spec in specs.items():
+        breakdown = _classify_per_category(
+            spec["gt"], spec["hyp"],
+            form_extractor=spec["form"],
+            value_extractor=spec["value"],
+        )
+        per_category[cat] = breakdown
+        total += breakdown["n_total"]
+        total_strict += breakdown["strict"]
+        total_value += breakdown["value"]
+
+    return {
+        "n_total": total,
+        "global_strict_score": (
+            total_strict / total if total else 0.0
+        ),
+        "global_value_score": (
+            total_value / total if total else 0.0
+        ),
+        "per_category": per_category,
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement registre typé
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="numerical_sequence_strict_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Précision sur séquences numériques en mode strict (forme "
+        "préservée). Couvre années arabes, numéraux romains, "
+        "foliotation, montants Ancien Régime, années régnales."
+    ),
+)
+def numerical_sequence_strict_score(reference: str, hypothesis: str) -> float:
+    return compute_numerical_sequence_metrics(
+        reference, hypothesis,
+    )["global_strict_score"]
+
+
+@register_metric(
+    name="numerical_sequence_value_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Précision sur séquences numériques en mode valeur "
+        "(la valeur est préservée même si la forme diffère, "
+        "ex. XIV → 14)."
+    ),
+)
+def numerical_sequence_value_score(reference: str, hypothesis: str) -> float:
+    return compute_numerical_sequence_metrics(
+        reference, hypothesis,
+    )["global_value_score"]
+
+
+__all__ = [
+    "CATEGORIES",
+    "compute_numerical_sequence_metrics",
+    "numerical_sequence_strict_score",
+    "numerical_sequence_value_score",
+]

picarones/evaluation/metrics/roman_numerals.py

@@ -0,0 +1,484 @@
+"""Numéraux romains — Sprint 60.
+
+Phase 5.C.batch7 — module relocalisé depuis
+``picarones.measurements.roman_numerals`` vers
+``picarones.evaluation.metrics.roman_numerals``.  Le chemin legacy
+reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Sprint 60 — Étape 3 / extension philologique transversale du plan
+d'évolution 2026.
+
+Pourquoi ce module
+------------------
+Les numéraux romains traversent **toutes les périodes patrimoniales**
+servies par Picarones :
+
+- **Médiéval** : minuscules avec ``j`` final pour le dernier ``i``
+  (``ij`` = 2, ``iij`` = 3, ``viij`` = 8, ``mcclxxxij`` = 1282).
+  Convention scribale standard dans les chartes et registres.
+- **Imprimé ancien** : majuscules (``Tome IV``, ``Chap. VII``).
+- **Moderne** : majuscules pour les souverains (``Louis XIV``) et
+  les siècles (``XIXᵉ siècle`` — la partie exposant ᵉ est gérée
+  par le Sprint 59 ``ordinals``, ce module ne traite que la partie
+  numérale ``XIX``).
+
+Quatre traitements possibles d'un numéral par l'OCR
+----------------------------------------------------
+Pour chaque numéral romain présent dans la GT, l'OCR peut :
+
+1. **Préserver strictement** : forme exacte gardée
+   (``mcclxxxij`` → ``mcclxxxij``).  Édition diplomatique idéale.
+2. **Préserver en changeant la casse** : la valeur est intacte mais
+   la convention typographique est modifiée
+   (``xiv`` → ``XIV``).  Modernisation typographique courante.
+3. **Préserver en supprimant le ``j`` final** :
+   (``mcclxxxij`` → ``mcclxxxii``).  Modernisation orthographique
+   médiévale → standard académique moderne.
+4. **Convertir en chiffres arabes** : la valeur est préservée mais
+   le système de numération est modernisé
+   (``XIV`` → ``14``).  Modernisation profonde, perte de
+   l'information typographique.
+5. **Perdre** : aucune trace de la valeur dans l'hypothèse.
+
+Ce module retourne un breakdown par statut pour que le chercheur
+juge lui-même la convention adoptée par chaque moteur, **sans
+classification automatique imposée**.
+
+Stratégie de découpage
+----------------------
+Cohérente avec NER (38), Flesch (52), Reading order F1 (53),
+Layout F1 (54), Bloc Unicode (55), Abréviations (56), MUFI (57),
+Imprimé ancien (58), Archives modernes (59) : couche de calcul
+pure d'abord ; câblage runner et HTML dans des sprints dédiés.
+
+Limites documentées
+-------------------
+- Détection greedy par regex ``\\b[IVXLCDMivxlcdmj]+\\b`` puis
+  validation par parsing.  Les faux positifs restent possibles sur
+  des mots courts (``I`` pronom anglais, ``MM`` initiales, ``LL``).
+  Le paramètre ``min_length`` permet de filtrer les single-letter.
+- Pas de gestion des notations rares avec barre suscript pour
+  multiplier par 1000 (V̄ = 5000, X̄ = 10000) — usage très rare en
+  corpus patrimonial européen courant.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Optional
+
+from picarones.evaluation.metric_registry import register_metric
+from picarones.domain.artifacts import ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Table de conversion + parsing
+# ──────────────────────────────────────────────────────────────────────────
+
+ROMAN_VALUES: dict[str, int] = {
+    "I": 1,    "V": 5,    "X": 10,
+    "L": 50,   "C": 100,  "D": 500,  "M": 1000,
+}
+
+# Caractères acceptés en entrée (incluant minuscules + j médiéval).
+_ROMAN_CHARS = "IVXLCDMivxlcdmj"
+_ROMAN_RE = re.compile(rf"\b[{_ROMAN_CHARS}]+\b")
+
+
+def _normalize_roman(s: str) -> str:
+    """Normalise un numéral romain : majuscule + ``j`` final → ``i``.
+
+    Les manuscrits médiévaux notent traditionnellement le dernier
+    ``i`` d'une suite par ``j`` (« ij », « iij », « viij »…).  On
+    convertit pour pouvoir parser comme un numéral standard.
+    """
+    if not s:
+        return ""
+    upper = s.upper()
+    if upper.endswith("J"):
+        upper = upper[:-1] + "I"
+    return upper
+
+
+def _parse_normalized_roman(s: str) -> Optional[int]:
+    """Parse un numéral romain **après normalisation** (majuscule,
+    sans ``j`` médiéval).  Retourne ``None`` si la chaîne n'est pas
+    un numéral romain valide.
+
+    Validation : on parse en additionnant/soustrayant selon la règle
+    classique, puis on **regénère la forme standard** et on compare
+    pour rejeter les formes non canoniques (« IIII » au lieu de
+    « IV », « VV » au lieu de « X »).  Cette stricte validation
+    garantit qu'on ne compte pas des séquences absurdes comme
+    « XXXX » comme un numéral.
+
+    Note : les manuscrits médiévaux utilisent fr��quemment « IIII »
+    pour 4 (notation soustractive plus tardive).  On accepte donc
+    aussi cette forme via une règle relâchée : tant que les valeurs
+    sont décroissantes ou suivent la règle soustractive standard,
+    on accepte.
+    """
+    if not s or not all(c in "IVXLCDM" for c in s):
+        return None
+    # Calcul par soustraction.
+    total = 0
+    prev_value = 0
+    for ch in reversed(s):
+        v = ROMAN_VALUES[ch]
+        if v < prev_value:
+            total -= v
+        else:
+            total += v
+        prev_value = v
+    if total <= 0:
+        return None
+    # Validation relâchée : on accepte les formes médiévales (IIII,
+    # VIIII) mais on rejette les vraiment absurdes (IIIII, VVVV).
+    if not _is_plausible_roman(s):
+        return None
+    return total
+
+
+def _is_plausible_roman(s: str) -> bool:
+    """Validation relâchée d'un numéral romain (majuscule).
+
+    On rejette :
+
+    - 5 caractères identiques d'affilée ou plus (« IIIII », « XXXXX »).
+    - Les répétitions de V, L, D (jamais répétés en notation
+      classique : « VV », « LL », « DD »).
+    - Les paires soustractives non standard.  En romain canonique,
+      seules sont valides : IV, IX, XL, XC, CD, CM.  Toute autre
+      combinaison « petit avant grand » est rejetée.  Cela élimine
+      les faux positifs sur des mots français comme « ici » (qui
+      formerait sinon « I + C » = 99) ou « IL » qui formerait 49.
+    """
+    if not s:
+        return False
+    # Pas de répétitions invalides
+    for forbidden in ("VV", "LL", "DD", "IIIII", "XXXXX", "CCCCC", "MMMMMM"):
+        if forbidden in s:
+            return False
+    # Paires soustractives autorisées (toutes les autres sont rejetées)
+    legal_subtractive = {"IV", "IX", "XL", "XC", "CD", "CM"}
+    for i in range(len(s) - 1):
+        a, b = s[i], s[i + 1]
+        if ROMAN_VALUES[a] < ROMAN_VALUES[b]:
+            if (a + b) not in legal_subtractive:
+                return False
+    return True
+
+
+def roman_to_int(s: Optional[str]) -> Optional[int]:
+    """Convertit une chaîne en numéral romain entier.  Tolère casse
+    et ``j`` médiéval final.  Retourne ``None`` si invalide.
+    """
+    if not s:
+        return None
+    return _parse_normalized_roman(_normalize_roman(s))
+
+
+def int_to_roman(n: int) -> str:
+    """Convertit un entier en numéral romain majuscule standard.
+
+    Utilise la notation classique (IV, IX, XL, XC, CD, CM) — pas la
+    forme médiévale relâchée.
+    """
+    if n <= 0:
+        raise ValueError("n must be positive")
+    pairs = [
+        (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
+        (100, "C"),  (90, "XC"),  (50, "L"),  (40, "XL"),
+        (10, "X"),   (9, "IX"),   (5, "V"),   (4, "IV"),
+        (1, "I"),
+    ]
+    out: list[str] = []
+    for value, symbol in pairs:
+        while n >= value:
+            out.append(symbol)
+            n -= value
+    return "".join(out)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Détection dans le texte
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def detect_roman_numerals(
+    text: Optional[str],
+    *,
+    min_length: int = 1,
+) -> list[tuple[int, str, int]]:
+    """Retourne les numéraux romains valides dans ``text``.
+
+    Forme : ``[(start_index, numeral_string, integer_value), ...]``
+    triée par index croissant.
+
+    Parameters
+    ----------
+    text:
+        Texte à analyser.
+    min_length:
+        Longueur minimale d'un numéral retenu.  Par défaut ``1``.
+        Mettre à ``2`` pour filtrer les single-letter ambigus (``I``
+        pronom, ``M`` initiale).
+
+    Faux positifs connus
+    --------------------
+    - ``I`` (pronom anglais), ``M`` ou ``D`` en initiale d'une
+      personne ne peuvent pas être distingués sans NER.  Le chercheur
+      qui s'inquiète de ces faux positifs peut passer
+      ``min_length=2``.
+    """
+    if not text:
+        return []
+    found: list[tuple[int, str, int]] = []
+    for match in _ROMAN_RE.finditer(text):
+        s = match.group(0)
+        if len(s) < min_length:
+            continue
+        value = roman_to_int(s)
+        if value is None:
+            continue
+        found.append((match.start(), s, value))
+    return found
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Classification de la restitution dans l'hypothèse
+# ──────────────────────────────────────────��───────────────────────────────
+
+# Statuts possibles, dans l'ordre de priorité (un numéral est
+# classé selon le premier statut qui s'applique).
+
+STATUS_STRICT_PRESERVED   = "strict_preserved"
+STATUS_CASE_CHANGED       = "case_changed"
+STATUS_J_DROPPED          = "j_dropped"
+STATUS_CONVERTED_TO_ARABIC = "converted_to_arabic"
+STATUS_LOST               = "lost"
+
+ALL_STATUSES = (
+    STATUS_STRICT_PRESERVED,
+    STATUS_CASE_CHANGED,
+    STATUS_J_DROPPED,
+    STATUS_CONVERTED_TO_ARABIC,
+    STATUS_LOST,
+)
+
+# Statuts qui indiquent une préservation de la valeur (par opposition
+# à la perte).
+VALUE_PRESERVING_STATUSES = frozenset({
+    STATUS_STRICT_PRESERVED,
+    STATUS_CASE_CHANGED,
+    STATUS_J_DROPPED,
+    STATUS_CONVERTED_TO_ARABIC,
+})
+
+
+def _classify_restitution(numeral: str, value: int, hyp: str) -> str:
+    """Classifie comment ``numeral`` (de valeur ``value``) est
+    restitué dans ``hyp`` selon les 5 statuts définis."""
+    # 1. Forme stricte présente
+    if re.search(r"(?<![A-Za-z])" + re.escape(numeral) + r"(?![A-Za-z])", hyp):
+        return STATUS_STRICT_PRESERVED
+    # 2. Variante de casse seule
+    swapped = numeral.swapcase()
+    if swapped != numeral and re.search(
+        r"(?<![A-Za-z])" + re.escape(swapped) + r"(?![A-Za-z])", hyp,
+    ):
+        return STATUS_CASE_CHANGED
+    # 3. ``j`` final remplacé par ``i`` (ou inverse)
+    if numeral.lower().endswith("j"):
+        no_j = numeral[:-1] + ("I" if numeral[-1] == "J" else "i")
+    elif numeral.lower().endswith("i"):
+        no_j = numeral[:-1] + ("J" if numeral[-1] == "I" else "j")
+    else:
+        no_j = numeral
+    if no_j != numeral and re.search(
+        r"(?<![A-Za-z])" + re.escape(no_j) + r"(?![A-Za-z])", hyp,
+    ):
+        return STATUS_J_DROPPED
+    # Variante de casse + j-flip combinés
+    no_j_swapped = no_j.swapcase()
+    if no_j_swapped != numeral and re.search(
+        r"(?<![A-Za-z])" + re.escape(no_j_swapped) + r"(?![A-Za-z])", hyp,
+    ):
+        return STATUS_J_DROPPED
+    # 4. Conversion en chiffres arabes
+    if re.search(r"(?<!\d)" + str(value) + r"(?!\d)", hyp):
+        return STATUS_CONVERTED_TO_ARABIC
+    # 5. Perdu
+    return STATUS_LOST
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Calcul de la métrique
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compute_roman_numeral_metrics(
+    reference: Optional[str],
+    hypothesis: Optional[str],
+    *,
+    min_length: int = 1,
+) -> dict:
+    """Calcule la préservation des numéraux romains.
+
+    Pour chaque numéral romain dans la GT, on classifie sa
+    restitution dans l'hypothèse selon l'un des 5 statuts (forme
+    stricte / casse modifiée / j supprimé / conversion arabe / perdu).
+
+    Returns
+    -------
+    dict
+        ``{
+            "n_numerals_reference": int,
+            "n_strict_preserved": int,
+            "n_value_preserved": int,    # tous statuts sauf LOST
+            "global_strict_score": float,
+            "global_value_score": float,
+            "per_status": {status: count for status in ALL_STATUSES},
+            "per_numeral": [
+                {"index", "numeral", "value", "status"}
+            ],
+            "lost_numerals": [
+                {"index", "numeral", "value"}
+            ],
+        }``
+
+    Cas dégénérés
+    -------------
+    - GT vide ou sans numéral → tous compteurs à 0, scores à 0.0,
+      ``per_status`` initialisé à 0 sur tous les statuts.
+    - GT avec numéraux + hyp vide → tous classés ``lost``,
+      strict_score = value_score = 0.0.
+    """
+    ref = reference or ""
+    hyp = hypothesis or ""
+
+    detected = detect_roman_numerals(ref, min_length=min_length)
+    n_total = len(detected)
+    per_status_init = {status: 0 for status in ALL_STATUSES}
+
+    if n_total == 0:
+        return {
+            "n_numerals_reference": 0,
+            "n_strict_preserved": 0,
+            "n_value_preserved": 0,
+            "global_strict_score": 0.0,
+            "global_value_score": 0.0,
+            "per_status": per_status_init,
+            "per_numeral": [],
+            "lost_numerals": [],
+        }
+
+    per_status: dict[str, int] = dict(per_status_init)
+    per_numeral: list[dict] = []
+    lost: list[dict] = []
+    for index, numeral, value in detected:
+        status = _classify_restitution(numeral, value, hyp)
+        per_status[status] = per_status.get(status, 0) + 1
+        per_numeral.append({
+            "index": index,
+            "numeral": numeral,
+            "value": value,
+            "status": status,
+        })
+        if status == STATUS_LOST:
+            lost.append({"index": index, "numeral": numeral, "value": value})
+
+    n_strict = per_status[STATUS_STRICT_PRESERVED]
+    n_value = sum(per_status[s] for s in VALUE_PRESERVING_STATUSES)
+
+    return {
+        "n_numerals_reference": n_total,
+        "n_strict_preserved": n_strict,
+        "n_value_preserved": n_value,
+        "global_strict_score": n_strict / n_total,
+        "global_value_score": n_value / n_total,
+        "per_status": per_status,
+        "per_numeral": per_numeral,
+        "lost_numerals": lost,
+    }
+
+
+def roman_numeral_strict_score(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : taux global de préservation **stricte** des
+    numéraux romains ∈ [0, 1]."""
+    return compute_roman_numeral_metrics(
+        reference, hypothesis,
+    )["global_strict_score"]
+
+
+def roman_numeral_value_score(
+    reference: Optional[str], hypothesis: Optional[str],
+) -> float:
+    """Raccourci : taux global de préservation de la **valeur** des
+    numéraux romains (toute forme confondue : strict, case_changed,
+    j_dropped, arabe) ∈ [0, 1]."""
+    return compute_roman_numeral_metrics(
+        reference, hypothesis,
+    )["global_value_score"]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Enregistrement dans le registre typé (Sprint 34)
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@register_metric(
+    name="roman_numeral_strict_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux de préservation stricte des numéraux romains "
+        "(forme exacte gardée : casse, j médiéval final). "
+        "Métrique transversale aux périodes médiévale, imprimé "
+        "ancien et moderne."
+    ),
+    higher_is_better=True,
+    tags={"text", "roman_numerals", "philology"},
+)
+def _registered_strict(reference: str, hypothesis: str) -> float:
+    return roman_numeral_strict_score(reference, hypothesis)
+
+
+@register_metric(
+    name="roman_numeral_value_score",
+    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
+    description=(
+        "Taux de préservation de la valeur numérique des numéraux "
+        "romains, indépendamment de la forme (strict, casse "
+        "changée, j supprimé, conversion en chiffres arabes). "
+        "Le breakdown per_status permet au chercheur de juger la "
+        "convention adoptée."
+    ),
+    higher_is_better=True,
+    tags={"text", "roman_numerals", "philology"},
+)
+def _registered_value(reference: str, hypothesis: str) -> float:
+    return roman_numeral_value_score(reference, hypothesis)
+
+
+__all__ = [
+    "ROMAN_VALUES",
+    "ALL_STATUSES",
+    "STATUS_STRICT_PRESERVED",
+    "STATUS_CASE_CHANGED",
+    "STATUS_J_DROPPED",
+    "STATUS_CONVERTED_TO_ARABIC",
+    "STATUS_LOST",
+    "VALUE_PRESERVING_STATUSES",
+    "compute_roman_numeral_metrics",
+    "detect_roman_numerals",
+    "int_to_roman",
+    "roman_numeral_strict_score",
+    "roman_numeral_value_score",
+    "roman_to_int",
+]

picarones/evaluation/pipeline.py

@@ -0,0 +1,622 @@
+"""Banc d'essai de pipelines composées — Sprint 63 (axe B).
+
+Phase 5.C.batch7 — module relocalisé depuis
+``picarones.core.pipeline`` vers ``picarones.evaluation.pipeline``.
+Le chemin legacy reste disponible via un shim avec
+``DeprecationWarning`` ; suppression prévue en 2.0.
+
+Coexistence avec ``picarones.pipeline.executor``
+------------------------------------------------
+Le présent module porte le ``PipelineRunner`` historique
+(Sprint 63), riche en behavior, qui orchestre l'exécution
+mono-document.  Le module canonique
+``picarones.pipeline.executor`` (Sprint S6) propose un design
+différent (instance-based, immutable specs).  Les deux
+cohabitent volontairement ; un convertisseur explicite viendra
+quand un caller institutionnel l'exigera.
+
+Sprint 63 — Étape 4 / axe B du plan d'évolution 2026 : démarrage du
+banc d'essai de pipelines.
+
+Philosophie
+-----------
+Picarones est un **banc d'essai**, pas un atelier de production.
+Cette infrastructure permet d'**évaluer des pipelines composées de
+modules tiers** que l'utilisateur amène — par exemple :
+
+- ``[OCR(image→texte)] → [reconstructeur ALTO tiers(texte→ALTO)]``
+- ``[VLM(image→ALTO)] → [post-processing tiers(ALTO→ALTO)]``
+- ``[OCR(image→texte)] → [LLM correcteur(texte→texte)]``
+
+Picarones **ne fournit aucun module métier** (pas de
+reconstructeur ALTO, pas de correcteur, pas de re-segmenteur).
+L'utilisateur branche ses propres ``BaseModule`` (Sprint 33), le
+runner orchestre l'exécution séquentielle, valide les types aux
+jonctions et **évalue automatiquement** chaque artefact produit
+contre la GT du même niveau (Sprint 32) en sélectionnant les
+métriques pertinentes du registre typé (Sprint 34).
+
+Périmètre Sprint 63
+-------------------
+Inclus :
+
+- Spécification déclarative d'une pipeline séquentielle.
+- Exécution sur un seul document avec passage typé d'artefacts.
+- Validation des types aux jonctions inter-modules.
+- Évaluation automatique aux jonctions GT-vs-sortie pour chaque
+  niveau de GT disponible sur le document.
+- Mesure du temps par étape.
+- Capture gracieuse des erreurs (un module qui lève n'arrête pas
+  les étapes suivantes — leur entrée manquante est rapportée
+  comme erreur explicite).
+
+Reporté à des sprints dédiés :
+
+- DAG branchant non séquentiel (1 → {2, 3} → 4) — Sprint 64+.
+- Orchestration corpus-wide + agrégation par pipeline — Sprint 65+.
+- Vue HTML dédiée aux pipelines composées — Sprint 66+.
+- Cache d'artefacts intermédiaires — non prévu.
+- Parallélisation inter-étapes — non prévue (les modules
+  ``execution_mode`` sont déjà respectés par le runner historique
+  pour le bench OCR mono-étage).
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from picarones.evaluation.corpus import Document, GTLevel
+from picarones.evaluation.metric_registry import compute_at_junction
+from picarones.domain.artifacts import ArtifactType
+from picarones.domain.module_protocol import BaseModule
+
+# Sprint A3 (renforce la règle Cercle 1 → Cercle 1 uniquement) — la
+# cérémonie d'eager-load des métriques typées (Sprint 34) qui vivait
+# ici a été déplacée dans ``picarones/measurements/__init__.py``. Tout
+# consommateur de ``compute_at_junction`` (typiquement la classe
+# ``PipelineRunner`` ci-dessous) doit avoir importé
+# ``picarones.measurements`` au moins une fois — c'est le cas dans
+# l'API publique via ``picarones.__init__`` qui déclenche le trigger.
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Conversion ArtifactType <-> GTLevel
+# ──────────────────────────────────────────────────────────────────────────
+
+
+#: Map ``ArtifactType`` canonique → ``GTLevel`` legacy.  Phase 4-bis :
+#: ``ArtifactType`` a été migré vers ``domain/artifacts.py`` qui
+#: distingue ``RAW_TEXT``/``CORRECTED_TEXT`` (vs ``TEXT`` legacy) et
+#: ``ALTO_XML``/``PAGE_XML`` (vs ``ALTO``/``PAGE`` legacy).  Les
+#: valeurs canoniques ne matchent donc plus celles de ``GTLevel``.
+#: Ce mapping explicite fait le pont — sera retiré en 2.0 quand
+#: ``GTLevel`` aura aussi été retiré au profit de la projection
+#: ``ArtifactType → niveau d'évaluation`` du rewrite.
+_ARTIFACT_TO_GT_LEVEL: dict[ArtifactType, GTLevel] = {
+    ArtifactType.RAW_TEXT: GTLevel.TEXT,
+    ArtifactType.CORRECTED_TEXT: GTLevel.TEXT,
+    ArtifactType.ALTO_XML: GTLevel.ALTO,
+    ArtifactType.PAGE_XML: GTLevel.PAGE,
+    ArtifactType.ENTITIES: GTLevel.ENTITIES,
+    ArtifactType.READING_ORDER: GTLevel.READING_ORDER,
+}
+
+
+def _artifact_type_to_gt_level(at: ArtifactType) -> Optional[GTLevel]:
+    """Retourne le ``GTLevel`` correspondant à un ``ArtifactType``.
+
+    ``IMAGE`` n'a pas de correspondance GT (on n'évalue pas une
+    image en sortie d'un module — c'est typiquement une entrée).
+    Les types ``CONFIDENCES``, ``ALIGNMENT``, ``CANONICAL_DOCUMENT``
+    n'ont pas non plus de niveau de GT direct dans le legacy.
+    """
+    return _ARTIFACT_TO_GT_LEVEL.get(at)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# PipelineStep + PipelineSpec
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class PipelineStep:
+    """Une étape dans une pipeline composée.
+
+    L'étape porte un nom lisible (utile pour le rapport et le
+    diagnostic) et une instance de ``BaseModule`` fournie par
+    l'utilisateur.  Les types d'entrée et de sortie ne sont pas
+    redéclarés ici : ils sont lus depuis le module lui-même
+    (``module.input_types`` / ``module.output_types``).
+
+    Sprint 66 — DAG branchant
+    -------------------------
+    ``inputs_from`` permet de désigner explicitement, pour chaque
+    type d'entrée, l'étape source dont on veut consommer l'artefact.
+    Utile quand plusieurs étapes antérieures produisent le même
+    type et qu'on veut éviter l'écrasement implicite (par exemple
+    deux correcteurs LLM en parallèle qui partent du même OCR).
+
+    - ``inputs_from = {}`` (défaut) : pour chaque type d'entrée,
+      le runner prend la version **la plus récente** disponible
+      dans le bag (comportement Sprint 63, rétrocompat stricte).
+    - ``inputs_from = {ArtifactType.TEXT: "ocr"}`` : exige la
+      version du ``TEXT`` produite par l'étape nommée ``"ocr"``.
+      Si cette étape n'existe pas ou n'a pas produit ce type,
+      ``PipelineSpec.validate`` remonte un problème explicite et
+      le runner remonte une erreur d'entrée manquante.
+
+    La chaîne spéciale ``"__initial__"`` désigne les artefacts
+    fournis dans ``initial_inputs`` (par exemple ``IMAGE``).
+    """
+
+    name: str
+    module: BaseModule
+    inputs_from: dict[ArtifactType, str] = field(default_factory=dict)
+
+    @property
+    def input_types(self) -> tuple[ArtifactType, ...]:
+        return tuple(self.module.input_types)
+
+    @property
+    def output_types(self) -> tuple[ArtifactType, ...]:
+        return tuple(self.module.output_types)
+
+    def __repr__(self) -> str:
+        ins = ",".join(t.value for t in self.input_types) or "·"
+        outs = ",".join(t.value for t in self.output_types) or "·"
+        if self.inputs_from:
+            refs = ",".join(
+                f"{t.value}@{src}" for t, src in self.inputs_from.items()
+            )
+            return f"PipelineStep({self.name}: [{refs}] → {outs})"
+        return f"PipelineStep({self.name}: {ins} → {outs})"
+
+
+@dataclass
+class PipelineSpec:
+    """DAG séquentiel de ``PipelineStep``.
+
+    Sprint 63 — séquentiel uniquement : l'étape ``i+1`` consomme
+    les artefacts produits par l'étape ``i`` (et tous les artefacts
+    initiaux fournis au runner, par exemple l'image source).
+
+    Le DAG branchant arrive dans un sprint dédié.
+    """
+
+    name: str
+    steps: list[PipelineStep] = field(default_factory=list)
+
+    def validate(self, initial_inputs: tuple[ArtifactType, ...]) -> list[str]:
+        """Vérifie que les types s'enchaînent et retourne la liste
+        des problèmes détectés (vide si la pipeline est valide).
+
+        Une pipeline est valide si, pour chaque étape, tous les
+        ``input_types`` sont disponibles : soit dans les
+        ``initial_inputs`` (typiquement ``IMAGE``), soit produits
+        par une étape antérieure.
+
+        Sprint 66 — validation des références ``inputs_from`` :
+        si une étape déclare ``inputs_from[type] = "foo"``,
+        l'étape ``foo`` doit exister parmi les étapes antérieures
+        et avoir ce type dans ses ``output_types``.  La chaîne
+        spéciale ``"__initial__"`` désigne les entrées initiales.
+        """
+        problems: list[str] = []
+        if not self.steps:
+            problems.append("pipeline vide : au moins une étape est requise")
+            return problems
+        # Map type → set des steps qui ont produit ce type
+        # ("__initial__" pour les entrées initiales) — utilisé pour
+        # valider les références ``inputs_from``.
+        producers: dict[ArtifactType, set[str]] = {
+            t: {"__initial__"} for t in initial_inputs
+        }
+        # Map step_name → set des types produits, pour la validation
+        # des références.
+        step_outputs: dict[str, set[ArtifactType]] = {
+            "__initial__": set(initial_inputs),
+        }
+        # Set des types disponibles à un instant t (latest seulement).
+        available: set[ArtifactType] = set(initial_inputs)
+
+        for i, step in enumerate(self.steps):
+            # 1. Toutes les entrées doivent être disponibles
+            missing = [t for t in step.input_types if t not in available]
+            if missing:
+                miss_str = ",".join(t.value for t in missing)
+                problems.append(
+                    f"étape {i} ({step.name}) demande {miss_str} "
+                    f"qui n'est ni dans les entrées initiales "
+                    f"ni produit par une étape antérieure"
+                )
+            # 2. Vérification des références ``inputs_from``
+            for ref_type, ref_step in step.inputs_from.items():
+                if ref_type not in step.input_types:
+                    problems.append(
+                        f"étape {i} ({step.name}) déclare "
+                        f"inputs_from[{ref_type.value}]={ref_step!r} "
+                        f"mais le module ne consomme pas ce type"
+                    )
+                    continue
+                if ref_step not in step_outputs:
+                    problems.append(
+                        f"étape {i} ({step.name}) référence "
+                        f"inputs_from[{ref_type.value}]={ref_step!r} "
+                        f"qui n'est pas une étape antérieure connue"
+                    )
+                    continue
+                if ref_type not in step_outputs[ref_step]:
+                    problems.append(
+                        f"étape {i} ({step.name}) référence "
+                        f"inputs_from[{ref_type.value}]={ref_step!r} "
+                        f"mais cette étape ne produit pas ce type"
+                    )
+            # 3. Mise à jour pour les étapes suivantes
+            available.update(step.output_types)
+            step_outputs[step.name] = set(step.output_types)
+            for out_type in step.output_types:
+                producers.setdefault(out_type, set()).add(step.name)
+        return problems
+
+    def is_valid(self, initial_inputs: tuple[ArtifactType, ...]) -> bool:
+        return not self.validate(initial_inputs)
+
+    def __repr__(self) -> str:
+        chain = " → ".join(str(s) for s in self.steps)
+        return f"PipelineSpec({self.name}: {chain})"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# StepResult + PipelineResult
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class StepResult:
+    """Résultat de l'exécution d'une étape sur un document.
+
+    Champs
+    ------
+    step_name:
+        Nom de l'étape (cf. ``PipelineStep.name``).
+    duration_seconds:
+        Temps d'exécution de ``module.process`` mesuré en wall-clock.
+    output_types:
+        Types effectivement présents dans la sortie (peut être un
+        sous-ensemble de ``module.output_types`` si le module a
+        omis un type — cas reporté ici comme info pour diagnostic).
+    junction_metrics:
+        Pour chaque type produit qui correspond à un ``GTLevel``
+        dont le document porte une GT : dictionnaire ``{type: dict
+        métriques}`` retourné par ``compute_at_junction``.
+    error:
+        ``None`` si l'étape s'est bien déroulée ; sinon message
+        d'erreur (le module a levé, l'entrée est manquante, ou la
+        validation des types a échoué).
+    """
+
+    step_name: str
+    duration_seconds: float
+    output_types: tuple[ArtifactType, ...]
+    junction_metrics: dict[str, dict[str, Any]] = field(default_factory=dict)
+    """Map ``{artifact_type_value: {metric_name: value}}``.
+
+    La clé est la valeur string du ``ArtifactType`` (ex. ``"text"``,
+    ``"alto"``) et non l'enum lui-même, pour faciliter la
+    sérialisation JSON.
+    """
+    error: Optional[str] = None
+
+
+@dataclass
+class PipelineResult:
+    """Résultat complet d'une exécution de pipeline sur un document.
+
+    On capture la durée totale, la durée par étape et les
+    métriques aux jonctions pour chaque artefact produit qui a une
+    GT correspondante.
+    """
+
+    pipeline_name: str
+    doc_id: str
+    steps: list[StepResult] = field(default_factory=list)
+    total_duration_seconds: float = 0.0
+    error: Optional[str] = None
+    """Erreur fatale au niveau pipeline (ex. validation des types
+    en amont avant la première étape).  ``None`` n'implique pas
+    qu'aucune étape n'a échoué — voir ``StepResult.error`` pour le
+    détail par étape."""
+
+    @property
+    def succeeded(self) -> bool:
+        """Vrai si la pipeline s'est exécutée jusqu'au bout sans
+        qu'aucune étape ne lève d'erreur."""
+        if self.error is not None:
+            return False
+        return all(s.error is None for s in self.steps)
+
+    @property
+    def failing_steps(self) -> list[str]:
+        """Noms des étapes ayant levé une erreur."""
+        return [s.step_name for s in self.steps if s.error is not None]
+
+    def junction_metrics_for(
+        self, artifact_type: ArtifactType,
+    ) -> Optional[dict[str, Any]]:
+        """Retourne les métriques de la **dernière** étape qui a
+        produit ``artifact_type``, ou ``None`` si aucune étape ne
+        l'a produit avec succès.
+
+        Utile pour comparer plusieurs pipelines qui produisent in
+        fine le même type (ex. deux DAG aboutissant à du texte
+        corrigé).
+        """
+        from picarones.domain.artifacts import LEGACY_VALUE_ALIASES
+        legacy_alias = LEGACY_VALUE_ALIASES.get(artifact_type.value)
+        for step in reversed(self.steps):
+            if step.error is not None:
+                continue
+            metrics = step.junction_metrics.get(artifact_type.value)
+            if metrics is None and legacy_alias is not None:
+                # Phase 4-bis : un caller legacy peut avoir construit
+                # le dict avec la clé pré-rewrite ("text" au lieu de
+                # "raw_text").  expand_legacy_keys synchronise les deux
+                # côtés sur les sites d'écriture du runner, mais des
+                # StepResult construits à la main par les tests ou par
+                # un caller externe peuvent encore avoir une seule
+                # clé — on tolère.
+                metrics = step.junction_metrics.get(legacy_alias)
+            if metrics is not None:
+                return metrics
+        return None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Exécuteur
+# ──────────────────────────────────────────────────────────────────────────
+
+
+class PipelineRunner:
+    """Exécute une ``PipelineSpec`` sur un document.
+
+    Sprint 63 — un seul document à la fois.  L'orchestration
+    corpus-wide et l'agrégation par pipeline sont reportées à un
+    sprint dédié.
+
+    Usage typique
+    -------------
+
+    >>> spec = PipelineSpec(
+    ...     name="ocr_then_rewrite",
+    ...     steps=[
+    ...         PipelineStep("ocr", my_ocr_module),
+    ...         PipelineStep("rewrite", my_llm_rewriter),
+    ...     ],
+    ... )
+    >>> runner = PipelineRunner()
+    >>> result = runner.run(spec, document, {ArtifactType.IMAGE: "/path/img.png"})
+    >>> result.succeeded
+    True
+    >>> result.junction_metrics_for(ArtifactType.TEXT)
+    {'cer': 0.05, 'wer': 0.12, ...}
+    """
+
+    @staticmethod
+    def run(
+        spec: PipelineSpec,
+        document: Document,
+        initial_inputs: dict[ArtifactType, Any],
+    ) -> PipelineResult:
+        """Exécute ``spec`` sur ``document`` à partir de
+        ``initial_inputs``.
+
+        Parameters
+        ----------
+        spec:
+            Spécification de la pipeline.
+        document:
+            Document du corpus, porteur de zéro ou plusieurs niveaux
+            de GT (Sprint 32).
+        initial_inputs:
+            Artefacts initiaux par type — typiquement
+            ``{ArtifactType.IMAGE: "/path/img.png"}`` pour une
+            pipeline qui démarre par un OCR.
+
+        Returns
+        -------
+        PipelineResult
+            Résultat complet : durée totale, résultat par étape,
+            métriques aux jonctions évaluées contre la GT.
+        """
+        result = PipelineResult(
+            pipeline_name=spec.name, doc_id=document.doc_id,
+        )
+
+        # Validation amont : si la pipeline est statiquement
+        # invalide, on n'exécute aucune étape.
+        problems = spec.validate(tuple(initial_inputs.keys()))
+        if problems:
+            result.error = " ; ".join(problems)
+            return result
+
+        # Sprint 66 — bag versionné : ``versioned[(type, src_step)]``
+        # contient l'artefact produit par ``src_step`` pour ``type``.
+        # ``src_step`` vaut ``"__initial__"`` pour les entrées
+        # initiales fournies par l'utilisateur.  ``latest[type]``
+        # désigne le nom de l'étape qui a produit la version la plus
+        # récente du type — utilisé en l'absence d'``inputs_from``
+        # explicite (rétrocompat Sprint 63).
+        versioned: dict[tuple[ArtifactType, str], Any] = {
+            (t, "__initial__"): v for t, v in initial_inputs.items()
+        }
+        latest: dict[ArtifactType, str] = {
+            t: "__initial__" for t in initial_inputs
+        }
+
+        pipeline_t0 = time.monotonic()
+        for step in spec.steps:
+            step_result = PipelineRunner._run_step(
+                step, versioned, latest, document,
+            )
+            result.steps.append(step_result)
+        result.total_duration_seconds = time.monotonic() - pipeline_t0
+        return result
+
+    @staticmethod
+    def _run_step(
+        step: PipelineStep,
+        versioned: dict[tuple[ArtifactType, str], Any],
+        latest: dict[ArtifactType, str],
+        document: Document,
+    ) -> StepResult:
+        # Sprint 66 — résolution des entrées : pour chaque type
+        # demandé, on consulte ``inputs_from`` ; sinon on prend la
+        # dernière version disponible (rétrocompat Sprint 63).
+        resolved: dict[ArtifactType, Any] = {}
+        missing: list[str] = []
+        for t in step.input_types:
+            src = step.inputs_from.get(t, latest.get(t))
+            if src is None:
+                missing.append(t.value)
+                continue
+            key = (t, src)
+            if key not in versioned:
+                # Référence explicite vers une étape qui n'a pas
+                # produit cet artefact (ex. l'étape source a échoué).
+                missing.append(f"{t.value}@{src}")
+                continue
+            resolved[t] = versioned[key]
+        if missing:
+            miss_str = ",".join(missing)
+            return StepResult(
+                step_name=step.name,
+                duration_seconds=0.0,
+                output_types=(),
+                error=f"entrée manquante : {miss_str}",
+            )
+        inputs_for_module = resolved
+        # Exécution chronométrée
+        t0 = time.monotonic()
+        try:
+            outputs = step.module.process(inputs_for_module)
+        except Exception as exc:  # noqa: BLE001
+            duration = time.monotonic() - t0
+            logger.warning(
+                "[pipeline_runner] étape '%s' a levé : %s",
+                step.name, exc,
+            )
+            return StepResult(
+                step_name=step.name,
+                duration_seconds=duration,
+                output_types=(),
+                error=f"{type(exc).__name__}: {exc}",
+            )
+        duration = time.monotonic() - t0
+
+        # Validation des sorties : le module est censé déclarer ses
+        # output_types, on vérifie qu'il les a tous produits.  Si
+        # ce n'est pas le cas, on remonte une erreur explicite mais
+        # on conserve les sorties effectivement présentes (utile
+        # pour le diagnostic).
+        if not isinstance(outputs, dict):
+            return StepResult(
+                step_name=step.name,
+                duration_seconds=duration,
+                output_types=(),
+                error=(
+                    f"le module a retourné {type(outputs).__name__}, "
+                    f"un dict[ArtifactType, Any] est attendu"
+                ),
+            )
+        produced = tuple(t for t in step.output_types if t in outputs)
+        missing_outputs = [t for t in step.output_types if t not in outputs]
+        error: Optional[str] = None
+        if missing_outputs:
+            miss_str = ",".join(t.value for t in missing_outputs)
+            error = f"sortie manquante : {miss_str}"
+
+        # Mise à jour du bag versionné : on stocke la sortie sous
+        # une clé (type, step.name) ET on met à jour ``latest`` pour
+        # que les étapes suivantes la récupèrent par défaut.
+        for t in produced:
+            versioned[(t, step.name)] = outputs[t]
+            latest[t] = step.name
+
+        # Évaluation aux jonctions : pour chaque type produit, si
+        # la GT du même niveau existe, on calcule les métriques.
+        junction_metrics: dict[str, dict[str, Any]] = {}
+        for at in produced:
+            gt_level = _artifact_type_to_gt_level(at)
+            if gt_level is None:
+                continue
+            gt_payload = document.get_gt(gt_level)
+            if gt_payload is None:
+                continue
+            try:
+                metrics = compute_at_junction(
+                    _gt_payload_to_value(gt_payload),
+                    outputs[at],
+                    (at, at),
+                )
+            except Exception as exc:  # noqa: BLE001
+                logger.warning(
+                    "[pipeline_runner] évaluation à la jonction %s "
+                    "a levé : %s",
+                    at.value, exc,
+                )
+                continue
+            if metrics:
+                junction_metrics[at.value] = metrics
+
+        # Phase 4-bis : double-clé pour rétrocompat.  Les tests
+        # legacy cherchent junction_metrics["text"] mais le runner
+        # peut produire junction_metrics["raw_text"] si l'enum est
+        # migré (ArtifactType.TEXT alias de RAW_TEXT, valeur
+        # "raw_text").  expand_legacy_keys ajoute la clé legacy
+        # ("text") à côté de la canonique ("raw_text") sans écraser.
+        from picarones.domain.artifacts import expand_legacy_keys
+        expand_legacy_keys(junction_metrics)
+
+        return StepResult(
+            step_name=step.name,
+            duration_seconds=duration,
+            output_types=produced,
+            junction_metrics=junction_metrics,
+            error=error,
+        )
+
+
+def _gt_payload_to_value(payload: Any) -> Any:
+    """Extrait la valeur exploitable d'un ``GTPayload`` typé.
+
+    Pour ``TextGT`` on veut juste la chaîne ; pour les autres
+    payloads on retourne le payload entier (la métrique sait quoi
+    en faire selon sa signature de types).
+    """
+    # Import paresseux pour éviter une dépendance cyclique
+    from picarones.evaluation.corpus import (
+        AltoGT, EntitiesGT, PageGT, ReadingOrderGT, TextGT,
+    )
+    if isinstance(payload, TextGT):
+        return payload.text
+    if isinstance(payload, EntitiesGT):
+        return payload.entities
+    if isinstance(payload, ReadingOrderGT):
+        return payload.region_order
+    if isinstance(payload, (AltoGT, PageGT)):
+        return payload
+    return payload
+
+
+__all__ = [
+    "PipelineRunner",
+    "PipelineResult",
+    "PipelineSpec",
+    "PipelineStep",
+    "StepResult",
+]

picarones/evaluation/pipeline_benchmark.py

@@ -0,0 +1,373 @@
+"""Orchestration corpus-wide d'une pipeline composée — Sprint 64
+(axe B).
+
+Phase 5.C.batch7 — module relocalisé depuis
+``picarones.measurements.pipeline_benchmark`` vers
+``picarones.evaluation.pipeline_benchmark``.  Le chemin legacy
+reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Sprint 64 — Étape 4 / axe B du plan d'évolution 2026 : suite directe
+du Sprint 63.  Le ``PipelineRunner`` exécute une pipeline sur **un**
+document ; ce module fournit l'orchestration sur un **corpus
+complet** et l'agrégation des résultats par étape.
+
+Philosophie inchangée
+---------------------
+Picarones reste un **banc d'essai**.  Aucun module métier n'est
+fourni — l'utilisateur amène ses propres ``BaseModule`` (Sprint 33).
+Cette infrastructure se contente d'orchestrer leur exécution sur un
+corpus, de mesurer le temps, de capturer les erreurs gracieusement,
+et d'agréger les métriques calculées aux jonctions GT-vs-sortie.
+
+Périmètre Sprint 64
+-------------------
+Inclus :
+
+- ``run_pipeline_benchmark(spec, corpus, initial_inputs_factory)``
+  qui itère séquentiellement sur les documents.
+- Agrégation par étape : ``StepAggregate`` avec n_succeeded /
+  n_failed, durées (total / mean / median), failing_doc_ids,
+  métriques agrégées par type d'artefact (mean / median sur les
+  métriques numériques uniquement), breakdown des types d'erreur.
+- ``PipelineBenchmarkResult`` : conteneur global avec liste des
+  ``PipelineResult`` par doc + liste des ``StepAggregate``.
+- Helper ``default_initial_inputs`` qui couvre le cas standard
+  ``IMAGE`` depuis ``Document.image_path``.
+
+Reporté à des sprints suivants :
+
+- Comparaison de N pipelines sur le même corpus (Sprint 65).
+- DAG branchant non séquentiel (Sprint 66).
+- Vue HTML dédiée aux pipelines composées (Sprint 67).
+- Parallélisation inter-documents (à arbitrer selon les besoins).
+"""
+
+from __future__ import annotations
+
+import logging
+import statistics
+import time
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional
+
+from picarones.evaluation.corpus import Corpus, Document
+from picarones.domain.artifacts import ArtifactType
+from picarones.evaluation.pipeline import (
+    PipelineResult,
+    PipelineRunner,
+    PipelineSpec,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Helpers : factory d'entrées initiales
+# ──────────────────────────────────────────────────────────────────────────
+
+InitialInputsFactory = Callable[[Document], dict[ArtifactType, Any]]
+
+
+def default_initial_inputs(document: Document) -> dict[ArtifactType, Any]:
+    """Factory d'entrées initiales par défaut : couvre le cas
+    « la pipeline démarre par un module qui consomme l'image ».
+
+    Retourne ``{ArtifactType.IMAGE: document.image_path}`` si
+    ``image_path`` est présent, sinon dict vide (la première étape
+    devra alors signaler « entrée manquante »).
+    """
+    if document.image_path:
+        return {ArtifactType.IMAGE: document.image_path}
+    return {}
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Agrégats
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class StepAggregate:
+    """Agrégat des résultats d'une étape sur tout le corpus.
+
+    Champs
+    ------
+    step_name:
+        Nom de l'étape (cf. ``PipelineStep.name``).
+    n_docs:
+        Nombre de documents pour lesquels l'étape a été tentée.
+    n_succeeded:
+        Nombre de documents pour lesquels l'étape s'est terminée
+        sans erreur (``StepResult.error is None``).
+    n_failed:
+        Nombre de documents pour lesquels l'étape a renvoyé une
+        erreur.
+    duration_seconds_total / mean / median:
+        Statistiques de durée sur les **étapes ayant réussi**
+        uniquement (les étapes en erreur peuvent avoir une durée
+        artificielle).
+    failing_doc_ids:
+        Liste des ``doc_id`` pour lesquels cette étape a échoué.
+    junction_metrics:
+        ``{artifact_type_value: {metric_name: {"mean": float,
+        "median": float, "n": int}}}`` — agrégé sur les documents
+        où la métrique a été calculée (n peut différer de
+        ``n_succeeded`` si la GT du type n'est pas portée par tous
+        les docs).
+    error_breakdown:
+        ``{type_d_erreur: count}`` où ``type_d_erreur`` est extrait
+        en heuristique depuis le message (``"missing_input"``,
+        ``"raised_exception"``, ``"missing_output"``,
+        ``"other"``).
+    """
+
+    step_name: str
+    n_docs: int = 0
+    n_succeeded: int = 0
+    n_failed: int = 0
+    duration_seconds_total: float = 0.0
+    duration_seconds_mean: float = 0.0
+    duration_seconds_median: float = 0.0
+    failing_doc_ids: list[str] = field(default_factory=list)
+    junction_metrics: dict[str, dict[str, dict[str, float]]] = field(
+        default_factory=dict,
+    )
+    error_breakdown: dict[str, int] = field(default_factory=dict)
+
+    @property
+    def success_rate(self) -> float:
+        if self.n_docs == 0:
+            return 0.0
+        return self.n_succeeded / self.n_docs
+
+
+@dataclass
+class PipelineBenchmarkResult:
+    """Résultat d'un benchmark de pipeline sur un corpus complet.
+
+    On capture la durée totale, les résultats par document
+    (utiles pour le rapport HTML par-doc des sprints suivants), et
+    l'agrégation par étape.
+    """
+
+    pipeline_name: str
+    corpus_name: str
+    n_docs: int = 0
+    per_doc_results: list[PipelineResult] = field(default_factory=list)
+    per_step_aggregates: list[StepAggregate] = field(default_factory=list)
+    total_duration_seconds: float = 0.0
+
+    @property
+    def n_pipelines_succeeded(self) -> int:
+        return sum(1 for r in self.per_doc_results if r.succeeded)
+
+    @property
+    def n_pipelines_failed(self) -> int:
+        return sum(1 for r in self.per_doc_results if not r.succeeded)
+
+    def aggregate_for_step(self, step_name: str) -> Optional[StepAggregate]:
+        for agg in self.per_step_aggregates:
+            if agg.step_name == step_name:
+                return agg
+        return None
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Classification des erreurs
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_ERROR_PATTERNS: tuple[tuple[str, str], ...] = (
+    ("entrée manquante",  "missing_input"),
+    ("sortie manquante",  "missing_output"),
+    ("Error",             "raised_exception"),  # RuntimeError, ValueError…
+)
+
+
+def _classify_error(message: str) -> str:
+    """Heuristique simple pour catégoriser une erreur d'étape.
+
+    On regarde des marqueurs lexicaux dans le message (les messages
+    sont produits par ``pipeline_runner._run_step`` qui les contrôle
+    entièrement, donc cette heuristique est stable).
+    """
+    if not message:
+        return "other"
+    for pattern, label in _ERROR_PATTERNS:
+        if pattern in message:
+            return label
+    return "other"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Agrégation
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _aggregate_step(
+    step_name: str, per_doc: list[tuple[str, Any]],
+) -> StepAggregate:
+    """Construit le ``StepAggregate`` pour une étape donnée.
+
+    ``per_doc`` est une liste de tuples ``(doc_id, step_result)`` où
+    ``step_result`` peut être ``None`` (cas où la pipeline a été
+    arrêtée en amont avant cette étape) ou un ``StepResult``.
+    """
+    agg = StepAggregate(step_name=step_name)
+    durations_succeeded: list[float] = []
+    metrics_by_type: dict[str, dict[str, list[float]]] = {}
+
+    for doc_id, sr in per_doc:
+        if sr is None:
+            # L'étape n'a même pas été exécutée (validation amont
+            # invalide, ou exécutée n'a pas atteint l'index — ne se
+            # produit pas en séquentiel mais peut arriver avec un
+            # DAG plus tard).  On compte ce cas comme échec
+            # explicite avec un type dédié.
+            agg.n_docs += 1
+            agg.n_failed += 1
+            agg.failing_doc_ids.append(doc_id)
+            agg.error_breakdown["pipeline_aborted"] = (
+                agg.error_breakdown.get("pipeline_aborted", 0) + 1
+            )
+            continue
+        agg.n_docs += 1
+        if sr.error is None:
+            agg.n_succeeded += 1
+            durations_succeeded.append(sr.duration_seconds)
+            # Collecte des métriques pour agrégation moyenne/médiane
+            for at_value, metrics in sr.junction_metrics.items():
+                slot = metrics_by_type.setdefault(at_value, {})
+                for mname, mvalue in metrics.items():
+                    if isinstance(mvalue, (int, float)) and not isinstance(
+                        mvalue, bool,
+                    ):
+                        slot.setdefault(mname, []).append(float(mvalue))
+        else:
+            agg.n_failed += 1
+            agg.failing_doc_ids.append(doc_id)
+            label = _classify_error(sr.error)
+            agg.error_breakdown[label] = (
+                agg.error_breakdown.get(label, 0) + 1
+            )
+
+    if durations_succeeded:
+        agg.duration_seconds_total = sum(durations_succeeded)
+        agg.duration_seconds_mean = statistics.fmean(durations_succeeded)
+        agg.duration_seconds_median = statistics.median(durations_succeeded)
+
+    for at_value, metrics in metrics_by_type.items():
+        agg.junction_metrics[at_value] = {
+            mname: {
+                "mean": statistics.fmean(values),
+                "median": statistics.median(values),
+                "n": len(values),
+            }
+            for mname, values in metrics.items()
+        }
+    # Phase 4-bis : double-clé legacy/canonique pour rétrocompat.
+    from picarones.domain.artifacts import expand_legacy_keys
+    expand_legacy_keys(agg.junction_metrics)
+    return agg
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Orchestrateur principal
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def run_pipeline_benchmark(
+    spec: PipelineSpec,
+    corpus: Corpus,
+    initial_inputs_factory: InitialInputsFactory = default_initial_inputs,
+) -> PipelineBenchmarkResult:
+    """Exécute ``spec`` sur tous les documents de ``corpus``.
+
+    Parameters
+    ----------
+    spec:
+        Spécification de la pipeline composée.  Toutes les étapes
+        sont des ``BaseModule`` fournis par l'utilisateur.
+    corpus:
+        Corpus chargé via ``Corpus.from_directory`` ou équivalent.
+    initial_inputs_factory:
+        Fonction qui produit, pour chaque document, les artefacts
+        d'entrée de la pipeline.  Par défaut : ``IMAGE`` depuis
+        ``document.image_path``.  L'utilisateur peut fournir une
+        factory personnalisée pour brancher d'autres sources
+        (par exemple ``ALTO`` pré-existant pour évaluer un
+        pipeline qui démarre par un re-segmenteur).
+
+    Returns
+    -------
+    PipelineBenchmarkResult
+        Résultat global avec ``per_doc_results``,
+        ``per_step_aggregates``, durée totale.
+
+    Comportement
+    ------------
+    L'orchestration est **séquentielle** par document.  Pour chaque
+    document, ``PipelineRunner.run`` est appelé ; quel que soit le
+    résultat (réussi, partiellement échoué, totalement invalide),
+    le résultat est ajouté à ``per_doc_results`` et le benchmark
+    continue avec le document suivant.
+
+    Si la spec est statiquement invalide (cf.
+    ``PipelineSpec.validate``), tous les documents auront un
+    ``PipelineResult.error`` non vide et aucune étape ne sera
+    exécutée — le résultat reste cohérent.
+    """
+    result = PipelineBenchmarkResult(
+        pipeline_name=spec.name, corpus_name=corpus.name,
+    )
+    documents = list(corpus.documents)
+    result.n_docs = len(documents)
+
+    benchmark_t0 = time.monotonic()
+    for doc in documents:
+        try:
+            initial = initial_inputs_factory(doc)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[pipeline_benchmark] factory a levé sur %s : %s",
+                doc.doc_id, exc,
+            )
+            # On crée un PipelineResult portant l'erreur factory
+            failed = PipelineResult(
+                pipeline_name=spec.name, doc_id=doc.doc_id,
+                error=f"initial_inputs_factory: {type(exc).__name__}: {exc}",
+            )
+            result.per_doc_results.append(failed)
+            continue
+        per_doc = PipelineRunner.run(spec, doc, initial)
+        result.per_doc_results.append(per_doc)
+    result.total_duration_seconds = time.monotonic() - benchmark_t0
+
+    # Agrégation par étape
+    step_names = [step.name for step in spec.steps]
+    for idx, step_name in enumerate(step_names):
+        per_doc_step: list[tuple[str, Any]] = []
+        for pr in result.per_doc_results:
+            if idx < len(pr.steps):
+                per_doc_step.append((pr.doc_id, pr.steps[idx]))
+            else:
+                # Pipeline a été arrêtée en amont : aucune étape de
+                # cet index n'existe.  On compte ça comme une
+                # absence d'étape (cf. ``_aggregate_step`` qui gère
+                # le ``None``).
+                per_doc_step.append((pr.doc_id, None))
+        result.per_step_aggregates.append(
+            _aggregate_step(step_name, per_doc_step),
+        )
+
+    return result
+
+
+__all__ = [
+    "InitialInputsFactory",
+    "PipelineBenchmarkResult",
+    "StepAggregate",
+    "default_initial_inputs",
+    "run_pipeline_benchmark",
+]

picarones/evaluation/pipeline_comparison.py

@@ -0,0 +1,307 @@
+"""Comparaison de N pipelines sur le même corpus — Sprint 65 (axe B).
+
+Phase 5.C.batch7 — module relocalisé depuis
+``picarones.measurements.pipeline_comparison`` vers
+``picarones.evaluation.pipeline_comparison``.  Le chemin legacy
+reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Sprint 65 — Étape 4 / axe B du plan d'évolution 2026 : suite directe
+des Sprints 63-64.  Le runner mono-document (Sprint 63) et
+l'orchestration corpus-wide (Sprint 64) permettent d'évaluer **une**
+pipeline composée ; ce sprint répond à la question typique BnF :
+
+    « OCR seul vs OCR+correcteur A vs OCR+correcteur B :
+      laquelle est la meilleure sur mon corpus, et de combien ? »
+
+Philosophie inchangée
+---------------------
+Picarones reste un **banc d'essai** — on juge des pipelines tierces
+sur le **même corpus** avec la **même GT**, en exposant des chiffres
+bruts comparatifs.  Aucun verdict imposé : le chercheur lit le
+ranking et la table de gain et conclut selon ses critères.
+
+Périmètre Sprint 65
+-------------------
+Inclus :
+
+- ``compare_pipelines(specs, corpus, factories=None)`` qui exécute
+  séquentiellement N pipelines sur le même corpus.
+- ``PipelineComparisonResult`` : conteneur avec
+  ``per_pipeline: dict[name → PipelineBenchmarkResult]``,
+  ``ranking_by_final_metric(artifact_type, metric_name,
+  higher_is_better)`` qui retourne ``[(pipeline_name, score), ...]``
+  trié, et ``gain_table(artifact_type, metric_name,
+  baseline_pipeline)`` qui retourne pour chaque pipeline le
+  ``{absolute, relative}`` vs baseline.
+- ``factories``: dict ``{pipeline_name: InitialInputsFactory}`` pour
+  personnaliser les entrées initiales par pipeline (utile pour
+  comparer une pipeline qui démarre par IMAGE et une qui démarre
+  par TEXT).
+- Garde-fou : noms de pipelines uniques exigés.
+
+Reporté à des sprints suivants :
+
+- DAG branchant non séquentiel (Sprint 66).
+- Vue HTML dédiée à la comparaison de pipelines (Sprint 67+).
+- Tests statistiques (Wilcoxon, Friedman, Nemenyi) sur les
+  pipelines composées — déjà disponibles côté OCR (Sprint 18) ;
+  l'application au cadre pipeline arrive plus tard.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+from picarones.evaluation.corpus import Corpus
+from picarones.domain.artifacts import ArtifactType
+from picarones.evaluation.pipeline_benchmark import (
+    InitialInputsFactory,
+    PipelineBenchmarkResult,
+    default_initial_inputs,
+    run_pipeline_benchmark,
+)
+from picarones.evaluation.pipeline import PipelineSpec
+
+logger = logging.getLogger(__name__)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Conteneur de résultats
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class PipelineComparisonResult:
+    """Résultat de la comparaison de N pipelines sur un corpus.
+
+    Champs
+    ------
+    corpus_name:
+        Nom du corpus (commun à toutes les pipelines comparées).
+    n_docs:
+        Nombre de documents du corpus.
+    per_pipeline:
+        Map ``{pipeline_name: PipelineBenchmarkResult}``.  L'ordre
+        d'insertion suit l'ordre des ``specs`` passées à
+        ``compare_pipelines`` ; on s'appuie sur le ``dict`` ordonné
+        de Python 3.7+.
+    total_duration_seconds:
+        Durée totale de la comparaison (sommes des durées par
+        pipeline + petit overhead).
+    """
+
+    corpus_name: str
+    n_docs: int = 0
+    per_pipeline: dict[str, PipelineBenchmarkResult] = field(
+        default_factory=dict,
+    )
+    total_duration_seconds: float = 0.0
+
+    def pipeline_names(self) -> list[str]:
+        """Retourne la liste des noms de pipelines dans leur ordre
+        d'insertion (= ordre de la comparaison initiale)."""
+        return list(self.per_pipeline.keys())
+
+    def _final_metric_value(
+        self,
+        pipeline_name: str,
+        artifact_type: ArtifactType,
+        metric_name: str,
+    ) -> Optional[float]:
+        """Retourne le ``mean`` de la métrique demandée à la
+        **dernière étape** de la pipeline qui a produit
+        ``artifact_type`` (avec succès sur ≥ 1 doc), ou ``None``
+        si la métrique n'est pas disponible.
+
+        Cohérent avec ``PipelineResult.junction_metrics_for`` du
+        Sprint 63 mais au niveau corpus-wide.
+        """
+        bench = self.per_pipeline.get(pipeline_name)
+        if bench is None:
+            return None
+        from picarones.domain.artifacts import LEGACY_VALUE_ALIASES
+        legacy_alias = LEGACY_VALUE_ALIASES.get(artifact_type.value)
+        for agg in reversed(bench.per_step_aggregates):
+            type_metrics = agg.junction_metrics.get(artifact_type.value)
+            if not type_metrics and legacy_alias is not None:
+                # Phase 4-bis : un caller (typiquement les tests
+                # ou un agrégateur tiers) peut avoir construit le
+                # dict avec la clé legacy ``"text"`` au lieu de la
+                # canonique ``"raw_text"``.  expand_legacy_keys
+                # synchronise les deux côtés sur les sites
+                # d'écriture du runner — ce fallback couvre le
+                # reste.
+                type_metrics = agg.junction_metrics.get(legacy_alias)
+            if not type_metrics:
+                continue
+            stats = type_metrics.get(metric_name)
+            if stats is None:
+                continue
+            return stats["mean"]
+        return None
+
+    def ranking_by_final_metric(
+        self,
+        artifact_type: ArtifactType,
+        metric_name: str,
+        higher_is_better: bool = False,
+    ) -> list[tuple[str, Optional[float]]]:
+        """Classe les pipelines par la valeur **finale** de
+        ``metric_name`` à la jonction ``artifact_type``.
+
+        Returns
+        -------
+        list[tuple[str, Optional[float]]]
+            Liste ``[(pipeline_name, mean_value)]`` triée :
+
+            - Les pipelines avec une valeur définie viennent en
+              premier, triées selon ``higher_is_better``.
+            - Les pipelines sans valeur (métrique absente) viennent
+              en queue, dans leur ordre d'insertion.
+        """
+        with_value: list[tuple[str, float]] = []
+        without_value: list[tuple[str, Optional[float]]] = []
+        for name in self.pipeline_names():
+            value = self._final_metric_value(name, artifact_type, metric_name)
+            if value is None:
+                without_value.append((name, None))
+            else:
+                with_value.append((name, value))
+        with_value.sort(
+            key=lambda pair: pair[1],
+            reverse=higher_is_better,
+        )
+        return [*with_value, *without_value]
+
+    def gain_table(
+        self,
+        artifact_type: ArtifactType,
+        metric_name: str,
+        baseline_pipeline: str,
+    ) -> dict[str, dict[str, Optional[float]]]:
+        """Calcule l'écart de chaque pipeline vs la baseline.
+
+        Returns
+        -------
+        dict
+            Map ``{pipeline_name: {"value", "absolute", "relative"}}``
+            où :
+
+            - ``value`` : valeur finale de la métrique pour cette
+              pipeline (``None`` si absente).
+            - ``absolute`` : ``value - baseline_value``
+              (``None`` si l'une des deux est absente).
+            - ``relative`` : ``(value - baseline_value) /
+              baseline_value`` (``None`` si baseline absente ou
+              égale à 0).
+
+        La baseline elle-même apparaît avec ``absolute == 0`` et
+        ``relative == 0``.
+        """
+        if baseline_pipeline not in self.per_pipeline:
+            raise KeyError(
+                f"baseline {baseline_pipeline!r} absente de la comparaison",
+            )
+        baseline_value = self._final_metric_value(
+            baseline_pipeline, artifact_type, metric_name,
+        )
+        out: dict[str, dict[str, Optional[float]]] = {}
+        for name in self.pipeline_names():
+            value = self._final_metric_value(
+                name, artifact_type, metric_name,
+            )
+            absolute: Optional[float]
+            relative: Optional[float]
+            if value is None or baseline_value is None:
+                absolute = None
+                relative = None
+            else:
+                absolute = value - baseline_value
+                relative = (
+                    (value - baseline_value) / baseline_value
+                    if baseline_value != 0 else None
+                )
+            out[name] = {
+                "value": value,
+                "absolute": absolute,
+                "relative": relative,
+            }
+        return out
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Orchestrateur
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def compare_pipelines(
+    specs: list[PipelineSpec],
+    corpus: Corpus,
+    factories: Optional[dict[str, InitialInputsFactory]] = None,
+) -> PipelineComparisonResult:
+    """Exécute N ``PipelineSpec`` sur le **même** ``corpus``.
+
+    Parameters
+    ----------
+    specs:
+        Liste de ``PipelineSpec``.  Les noms de pipelines doivent
+        être uniques (sinon ``ValueError``).
+    corpus:
+        Corpus partagé entre toutes les pipelines comparées —
+        c'est le point fort du sprint : même corpus, même GT, on
+        peut comparer apple-to-apple.
+    factories:
+        Optionnel.  Si fourni, dict ``{pipeline_name:
+        InitialInputsFactory}`` pour personnaliser les entrées
+        initiales par pipeline.  Les pipelines absentes du dict
+        utilisent ``default_initial_inputs`` (cas standard
+        ``IMAGE`` depuis ``Document.image_path``).
+
+    Returns
+    -------
+    PipelineComparisonResult
+        Conteneur avec ``per_pipeline`` indexé par nom et
+        utilitaires comparatifs (``ranking_by_final_metric``,
+        ``gain_table``).
+
+    Raises
+    ------
+    ValueError
+        Si deux ``PipelineSpec`` ont le même nom (impossible alors
+        de les distinguer dans le résultat).
+    """
+    names = [s.name for s in specs]
+    if len(set(names)) != len(names):
+        seen: set[str] = set()
+        duplicates: list[str] = []
+        for n in names:
+            if n in seen:
+                duplicates.append(n)
+            seen.add(n)
+        raise ValueError(
+            f"noms de pipelines non uniques : {sorted(set(duplicates))}",
+        )
+
+    factories = factories or {}
+    result = PipelineComparisonResult(
+        corpus_name=corpus.name,
+        n_docs=len(list(corpus.documents)),
+    )
+
+    t0 = time.monotonic()
+    for spec in specs:
+        factory = factories.get(spec.name, default_initial_inputs)
+        bench = run_pipeline_benchmark(spec, corpus, factory)
+        result.per_pipeline[spec.name] = bench
+    result.total_duration_seconds = time.monotonic() - t0
+    return result
+
+
+__all__ = [
+    "PipelineComparisonResult",
+    "compare_pipelines",
+]

picarones/measurements/builtin_hooks.py

@@ -267,7 +267,7 @@ def _searchability_hook(*, ground_truth, hypothesis, **_):
     profiles=_STANDARD_PROFILES,
 )
 def _numerical_sequences_hook(*, ground_truth, hypothesis, **_):
-    from picarones.measurements.numerical_sequences_hooks import (
+    from picarones.evaluation.metrics.numerical_sequences_hooks import (
         compute_numerical_sequence_metrics_adaptive,
     )
     return compute_numerical_sequence_metrics_adaptive(ground_truth, hypothesis)
@@ -567,7 +567,7 @@ def _aggregate_searchability(doc_results: list) -> Optional[dict]:
     profiles=_STANDARD_PROFILES,
 )
 def _aggregate_numerical_sequences(doc_results: list) -> Optional[dict]:
-    from picarones.measurements.numerical_sequences_hooks import (
+    from picarones.evaluation.metrics.numerical_sequences_hooks import (
         aggregate_numerical_sequence_metrics,
     )
     return aggregate_numerical_sequence_metrics(

picarones/measurements/numerical_sequences.py

@@ -1,422 +1,18 @@
-"""Précision sur séquences numériques — Sprint 85 (A.II.5b).
+"""``picarones.measurements.numerical_sequences`` — shim re-export (déprécié, suppression 2.0).
 
-Sprint 85 — A.II.5b du plan d'évolution 2026.
-
-Pourquoi ce module
-------------------
-Pour un économiste-historien, un éditeur de chartes ou un
-archiviste, la **fidélité aux séquences numériques** est un
-proxy direct de la qualité éditoriale.  Un OCR qui rate
-*« 1789 »* dans une charte révolutionnaire ou *« f. 12v »*
-dans une cote d'archives produit un corpus inutilisable pour la
-recherche fine, même si le CER global est respectable.
-
-Catégories couvertes
---------------------
-1. **Dates arabes** : ``1789``, ``1450``, ``1ᵉʳ janvier 1789``
-   (le module détecte les **années** sur 4 chiffres dans la
-   plage [1000-2099]).
-2. **Numéraux romains** : ``MDCLXVIII``, ``XIV``, ``Tome IV``.
-   Réutilise ``picarones.measurements.roman_numerals`` (Sprint 60).
-3. **Foliotation** : ``f. 12``, ``f. 12r``, ``fol. 24v``,
-   ``p. 5``, ``pp. 12-15``, ``n° 42``.
-4. **Montants** : ``12 livres``, ``5 sols``, ``8 deniers``,
-   ``100 £``, ``50 ₣``, ``20 €``, formes Ancien Régime
-   (``l.``, ``s.``, ``d.``).
-5. **Années régnales** : ``an III``, ``l'an V``, ``an de
-   grâce 1450``, ``an de la République``.
-
-Méthode
--------
-Pour chaque catégorie, on extrait les occurrences (regex
-spécialisée) en GT et en hypothèse.  On classe ensuite chaque
-GT en **3 statuts** :
-
-- ``strict_preserved`` : forme exacte présente dans
-  l'hypothèse (sensible à la casse seulement pour la
-  foliotation, sinon la convention est documentée par
-  catégorie) ;
-- ``value_preserved`` : la **valeur** apparaît même si la
-  forme diffère (ex. ``XIV`` GT et ``14`` hypothèse —
-  considéré comme valeur préservée mais forme non) ;
-- ``lost`` : aucune trace exploitable.
-
-Sortie
-------
-``compute_numerical_sequence_metrics(reference, hypothesis)``
-retourne :
-
-```
-{
-    "global_strict_score": float,        # ∈ [0, 1]
-    "global_value_score": float,         # ∈ [0, 1]
-    "n_total": int,
-    "per_category": {
-        "year": {"n_total": int, "strict": int, "value": int,
-                 "strict_score": float, "value_score": float,
-                 "lost_items": list[str]},
-        "roman": {...},
-        "foliation": {...},
-        "currency": {...},
-        "regnal": {...},
-    },
-}
-```
-
-Limites
--------
-- Les regex sont **conservatrices** : on rate quelques
-  formes rares plutôt que de produire des faux positifs (par
-  exemple, ``mil cinq cens`` en français médiéval n'est pas
-  détecté comme année — la couche calcul s'en tient aux
-  formes les plus reconnaissables).  Pour un corpus
-  spécifique, l'utilisateur peut composer ses propres
-  détecteurs et les passer via ``custom_detectors``.
-- ``value_preserved`` exige une équivalence de **valeur
-  numérique** : ``XIV`` ↔ ``14`` est OK pour les romains ;
-  ``f. 12v`` ↔ ``f. 12r`` n'est **pas** OK pour la
-  foliotation (recto/verso est une information distincte).
+Canonique : :mod:`picarones.evaluation.metrics.numerical_sequences`.
+Phase 5.C.batch7 du retrait du legacy.
 """
 
 from __future__ import annotations
 
-import logging
-import re
-from typing import Optional
-
-from picarones.evaluation.metric_registry import register_metric
-from picarones.domain.artifacts import ArtifactType
-from picarones.measurements.roman_numerals import (
-    detect_roman_numerals,
-    roman_to_int,
-)
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Constantes / catégories
-# ──────────────────────────────────────────────────────────────────────────
-
-
-CATEGORIES = ("year", "roman", "foliation", "currency", "regnal")
-
-
-# Dates arabes — 4 chiffres dans la plage [1000-2099].
-# On exige une frontière de mot pour ne pas attraper
-# « 12345 » (volume) ou « 0001 » (numéro de page).
-_RE_YEAR = re.compile(r"\b(1[0-9]{3}|20[0-9]{2})\b")
-
-
-# Foliotation : f. 12, f. 12r, fol. 24v, p. 5, pp. 12-15, n° 42
-# La capture conserve la forme intégrale (avec ponctuation et
-# r/v) parce que recto/verso est une information distincte.
-_RE_FOLIATION = re.compile(
-    r"\b(?:fol\.?|f\.|pp\.|p\.|n\.°|n°)\s*"  # préfixe : fol., f., pp., p., n°
-    r"(\d+(?:\s*-\s*\d+)?)"                  # nombre ou plage (12 / 12-15)
-    r"\s*([rvRV])?",                         # suffixe optionnel r/v
-    re.UNICODE,
-)
-
-
-# Montants : nombre suivi d'une unité monétaire.
-# On accepte espaces multiples mais pas de saut de ligne.
-_RE_CURRENCY = re.compile(
-    r"\b(\d+(?:[.,]\d+)?)\s*"                # montant (entier ou décimal)
-    r"(livres?|sols?|deniers?|��cus?|florins?|francs?|"
-    r"l\.|s\.|d\.|£|€|₣)"                    # unité
-    r"(?=\b|[\s,;.!?:]|$)",                  # frontière souple post-symbole
-    re.UNICODE | re.IGNORECASE,
-)
-
-
-# Années régnales : « an III », « an de grâce 1450 »,
-# « l'an V de la République ».
-# Capture le numéral (romain ou arabe).
-_RE_REGNAL = re.compile(
-    r"\b(?:l['’]\s*)?an\s+(?:de\s+(?:grâce|la\s+R[eé]publique)\s+)?"
-    r"([IVXLCDMivxlcdm]+|\d{1,4})\b",
-    re.UNICODE,
-)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Détection par catégorie
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _detect_years(text: str) -> list[tuple[str, int]]:
-    """Retourne [(forme, valeur)] pour chaque année 4 chiffres."""
-    if not text:
-        return []
-    return [(m.group(0), int(m.group(0))) for m in _RE_YEAR.finditer(text)]
+import warnings
 
+from picarones.evaluation.metrics.numerical_sequences import *  # noqa: F401, F403
 
-def _detect_romans_with_values(text: str) -> list[tuple[str, int]]:
-    """Numéraux romains accompagnés de leur valeur entière.
-    Délègue à ``roman_numerals.detect_roman_numerals`` (Sprint 60),
-    qui retourne ``(start, form, value)``.
-    """
-    if not text:
-        return []
-    out: list[tuple[str, int]] = []
-    for _start, form, value in detect_roman_numerals(text, min_length=2):
-        if value is not None:
-            out.append((form, value))
-    return out
-
-
-def _detect_foliations(text: str) -> list[tuple[str, str]]:
-    """Foliotation. Retourne [(forme_complète, clé_normalisée)] où la
-    clé inclut le suffixe r/v normalisé (recto/verso).
-    """
-    if not text:
-        return []
-    out: list[tuple[str, str]] = []
-    for m in _RE_FOLIATION.finditer(text):
-        full = m.group(0).strip()
-        nums = re.sub(r"\s+", "", m.group(1))  # ex : "12-15"
-        suffix = (m.group(2) or "").lower()
-        key = f"{nums}{suffix}"
-        out.append((full, key))
-    return out
-
-
-def _detect_currencies(text: str) -> list[tuple[str, tuple[str, str]]]:
-    """Montants. Clé = (montant_normalisé, unité_canonique).
-
-    L'unité canonique compresse les variantes (« livres » et
-    « livre » → « livre » ; « £ » reste « £ »).
-    """
-    if not text:
-        return []
-    canon = {
-        "livre": "livre", "livres": "livre", "l.": "livre",
-        "sol": "sol", "sols": "sol", "s.": "sol",
-        "denier": "denier", "deniers": "denier", "d.": "denier",
-        "écu": "écu", "écus": "écu",
-        "florin": "florin", "florins": "florin",
-        "franc": "franc", "francs": "franc",
-        "£": "£", "€": "€", "₣": "₣",
-    }
-    out: list[tuple[str, tuple[str, str]]] = []
-    for m in _RE_CURRENCY.finditer(text):
-        amount = m.group(1).replace(",", ".")
-        unit_raw = m.group(2).lower()
-        unit = canon.get(unit_raw, unit_raw)
-        out.append((m.group(0), (amount, unit)))
-    return out
-
-
-def _detect_regnal(text: str) -> list[tuple[str, int]]:
-    """Années régnales. Retourne [(forme, valeur_int)] avec la
-    valeur extraite (romain → int ou arabe → int).
-    """
-    if not text:
-        return []
-    out: list[tuple[str, int]] = []
-    for m in _RE_REGNAL.finditer(text):
-        numeral = m.group(1)
-        value: Optional[int]
-        if numeral.isdigit():
-            value = int(numeral)
-        else:
-            value = roman_to_int(numeral)
-        if value is not None:
-            out.append((m.group(0), value))
-    return out
-
-
-_DETECTORS = {
-    "year": _detect_years,
-    "roman": _detect_romans_with_values,
-    "foliation": _detect_foliations,
-    "currency": _detect_currencies,
-    "regnal": _detect_regnal,
-}
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul principal
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _classify_per_category(
-    gt_items: list,
-    hyp_items: list,
-    *,
-    form_extractor,
-    value_extractor,
-) -> dict:
-    """Pour chaque item GT, le classe en strict_preserved /
-    value_preserved / lost.
-
-    Multiplicité respectée : un item hypothèse ne peut servir
-    qu'à un seul match (forme prioritaire sur valeur).
-    """
-    hyp_used = [False] * len(hyp_items)
-    n_strict = 0
-    n_value = 0
-    lost: list[str] = []
-    # Première passe : matchs stricts (forme exacte)
-    matched: list[bool] = [False] * len(gt_items)
-    for gi, gt_item in enumerate(gt_items):
-        gt_form = form_extractor(gt_item)
-        for hi, hyp_item in enumerate(hyp_items):
-            if hyp_used[hi]:
-                continue
-            if form_extractor(hyp_item) == gt_form:
-                hyp_used[hi] = True
-                matched[gi] = True
-                n_strict += 1
-                break
-    # Deuxième passe : matchs sur valeur (forme différente)
-    for gi, gt_item in enumerate(gt_items):
-        if matched[gi]:
-            n_value += 1  # strict implique value
-            continue
-        gt_val = value_extractor(gt_item)
-        for hi, hyp_item in enumerate(hyp_items):
-            if hyp_used[hi]:
-                continue
-            if value_extractor(hyp_item) == gt_val:
-                hyp_used[hi] = True
-                matched[gi] = True
-                n_value += 1
-                break
-        if not matched[gi]:
-            lost.append(form_extractor(gt_item))
-    n_total = len(gt_items)
-    return {
-        "n_total": n_total,
-        "strict": n_strict,
-        "value": n_value,
-        "strict_score": n_strict / n_total if n_total else 0.0,
-        "value_score": n_value / n_total if n_total else 0.0,
-        "lost_items": lost,
-    }
-
-
-def compute_numerical_sequence_metrics(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-) -> dict:
-    """Calcule la précision sur séquences numériques.
-
-    Returns
-    -------
-    dict
-        Voir docstring du module.  Si ``reference`` est vide
-        ou ne contient aucune séquence détectée, retourne
-        ``{n_total: 0, ...}`` avec scores à 0 (pas None).
-    """
-    ref = reference or ""
-    hyp = hypothesis or ""
-
-    # Spécifications par catégorie : (gt_items, hyp_items,
-    # extractor de forme, extractor de valeur).
-    specs: dict[str, dict] = {}
-    # year : (form="1789", value=1789)
-    specs["year"] = {
-        "gt": _detect_years(ref),
-        "hyp": _detect_years(hyp),
-        "form": lambda it: it[0],
-        "value": lambda it: it[1],
-    }
-    # roman : (form="MDCLXVIII", value=1668)
-    specs["roman"] = {
-        "gt": _detect_romans_with_values(ref),
-        "hyp": _detect_romans_with_values(hyp),
-        "form": lambda it: it[0],
-        "value": lambda it: it[1],
-    }
-    # foliation : (form="f. 12r", value="12r")
-    specs["foliation"] = {
-        "gt": _detect_foliations(ref),
-        "hyp": _detect_foliations(hyp),
-        "form": lambda it: it[0],
-        "value": lambda it: it[1],
-    }
-    # currency : (form="12 livres", value=("12", "livre"))
-    specs["currency"] = {
-        "gt": _detect_currencies(ref),
-        "hyp": _detect_currencies(hyp),
-        "form": lambda it: it[0],
-        "value": lambda it: it[1],
-    }
-    # regnal : (form="an III", value=3)
-    specs["regnal"] = {
-        "gt": _detect_regnal(ref),
-        "hyp": _detect_regnal(hyp),
-        "form": lambda it: it[0],
-        "value": lambda it: it[1],
-    }
-
-    per_category: dict[str, dict] = {}
-    total = 0
-    total_strict = 0
-    total_value = 0
-    for cat, spec in specs.items():
-        breakdown = _classify_per_category(
-            spec["gt"], spec["hyp"],
-            form_extractor=spec["form"],
-            value_extractor=spec["value"],
-        )
-        per_category[cat] = breakdown
-        total += breakdown["n_total"]
-        total_strict += breakdown["strict"]
-        total_value += breakdown["value"]
-
-    return {
-        "n_total": total,
-        "global_strict_score": (
-            total_strict / total if total else 0.0
-        ),
-        "global_value_score": (
-            total_value / total if total else 0.0
-        ),
-        "per_category": per_category,
-    }
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement registre typé
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="numerical_sequence_strict_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Précision sur séquences numériques en mode strict (forme "
-        "préservée). Couvre années arabes, numéraux romains, "
-        "foliotation, montants Ancien Régime, années régnales."
-    ),
+warnings.warn(
+    "picarones.measurements.numerical_sequences is deprecated and will be removed in 2.0.  "
+    "Import from picarones.evaluation.metrics.numerical_sequences instead.",
+    DeprecationWarning,
+    stacklevel=2,
 )
-def numerical_sequence_strict_score(reference: str, hypothesis: str) -> float:
-    return compute_numerical_sequence_metrics(
-        reference, hypothesis,
-    )["global_strict_score"]
-
-
-@register_metric(
-    name="numerical_sequence_value_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Précision sur séquences numériques en mode valeur "
-        "(la valeur est préservée même si la forme diffère, "
-        "ex. XIV → 14)."
-    ),
-)
-def numerical_sequence_value_score(reference: str, hypothesis: str) -> float:
-    return compute_numerical_sequence_metrics(
-        reference, hypothesis,
-    )["global_value_score"]
-
-
-__all__ = [
-    "CATEGORIES",
-    "compute_numerical_sequence_metrics",
-    "numerical_sequence_strict_score",
-    "numerical_sequence_value_score",
-]

picarones/measurements/numerical_sequences_hooks.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 import logging
 from typing import Iterable, Optional
 
-from picarones.measurements.numerical_sequences import (
+from picarones.evaluation.metrics.numerical_sequences import (
     CATEGORIES,
     compute_numerical_sequence_metrics,
 )

picarones/measurements/philological_hooks.py

@@ -34,7 +34,7 @@ from picarones.measurements.abbreviations import compute_abbreviation_metrics
 from picarones.measurements.early_modern_typography import compute_early_modern_metrics
 from picarones.measurements.modern_archives import compute_modern_archives_metrics
 from picarones.measurements.mufi import compute_mufi_coverage
-from picarones.measurements.roman_numerals import compute_roman_numeral_metrics
+from picarones.evaluation.metrics.roman_numerals import compute_roman_numeral_metrics
 from picarones.measurements.unicode_blocks import compute_unicode_block_accuracy
 
 logger = logging.getLogger(__name__)
@@ -296,7 +296,7 @@ def _aggregate_modern_archives(per_doc: list[dict]) -> dict:
 
 
 def _aggregate_roman_numerals(per_doc: list[dict]) -> dict:
-    from picarones.measurements.roman_numerals import ALL_STATUSES, VALUE_PRESERVING_STATUSES
+    from picarones.evaluation.metrics.roman_numerals import ALL_STATUSES, VALUE_PRESERVING_STATUSES
 
     n_total = 0
     per_status: dict[str, int] = {s: 0 for s in ALL_STATUSES}

picarones/measurements/pipeline_benchmark.py

@@ -1,367 +1,18 @@
-"""Orchestration corpus-wide d'une pipeline composée — Sprint 64
-(axe B).
+"""``picarones.measurements.pipeline_benchmark`` — shim re-export (déprécié, suppression 2.0).
 
-Sprint 64 — Étape 4 / axe B du plan d'évolution 2026 : suite directe
-du Sprint 63.  Le ``PipelineRunner`` exécute une pipeline sur **un**
-document ; ce module fournit l'orchestration sur un **corpus
-complet** et l'agrégation des résultats par étape.
-
-Philosophie inchangée
----------------------
-Picarones reste un **banc d'essai**.  Aucun module métier n'est
-fourni — l'utilisateur amène ses propres ``BaseModule`` (Sprint 33).
-Cette infrastructure se contente d'orchestrer leur exécution sur un
-corpus, de mesurer le temps, de capturer les erreurs gracieusement,
-et d'agréger les métriques calculées aux jonctions GT-vs-sortie.
-
-Périmètre Sprint 64
--------------------
-Inclus :
-
-- ``run_pipeline_benchmark(spec, corpus, initial_inputs_factory)``
-  qui itère séquentiellement sur les documents.
-- Agrégation par étape : ``StepAggregate`` avec n_succeeded /
-  n_failed, durées (total / mean / median), failing_doc_ids,
-  métriques agrégées par type d'artefact (mean / median sur les
-  métriques numériques uniquement), breakdown des types d'erreur.
-- ``PipelineBenchmarkResult`` : conteneur global avec liste des
-  ``PipelineResult`` par doc + liste des ``StepAggregate``.
-- Helper ``default_initial_inputs`` qui couvre le cas standard
-  ``IMAGE`` depuis ``Document.image_path``.
-
-Reporté à des sprints suivants :
-
-- Comparaison de N pipelines sur le même corpus (Sprint 65).
-- DAG branchant non séquentiel (Sprint 66).
-- Vue HTML dédiée aux pipelines composées (Sprint 67).
-- Parallélisation inter-documents (à arbitrer selon les besoins).
+Canonique : :mod:`picarones.evaluation.pipeline_benchmark`.
+Phase 5.C.batch7 du retrait du legacy.
 """
 
 from __future__ import annotations
 
-import logging
-import statistics
-import time
-from dataclasses import dataclass, field
-from typing import Any, Callable, Optional
-
-from picarones.evaluation.corpus import Corpus, Document
-from picarones.domain.artifacts import ArtifactType
-from picarones.core.pipeline import (
-    PipelineResult,
-    PipelineRunner,
-    PipelineSpec,
-)
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Helpers : factory d'entrées initiales
-# ──────────────────────────────────────────────────────────────────────────
-
-InitialInputsFactory = Callable[[Document], dict[ArtifactType, Any]]
-
-
-def default_initial_inputs(document: Document) -> dict[ArtifactType, Any]:
-    """Factory d'entrées initiales par défaut : couvre le cas
-    « la pipeline démarre par un module qui consomme l'image ».
-
-    Retourne ``{ArtifactType.IMAGE: document.image_path}`` si
-    ``image_path`` est présent, sinon dict vide (la première étape
-    devra alors signaler « entrée manquante »).
-    """
-    if document.image_path:
-        return {ArtifactType.IMAGE: document.image_path}
-    return {}
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Agrégats
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@dataclass
-class StepAggregate:
-    """Agrégat des résultats d'une étape sur tout le corpus.
-
-    Champs
-    ------
-    step_name:
-        Nom de l'étape (cf. ``PipelineStep.name``).
-    n_docs:
-        Nombre de documents pour lesquels l'étape a été tentée.
-    n_succeeded:
-        Nombre de documents pour lesquels l'étape s'est terminée
-        sans erreur (``StepResult.error is None``).
-    n_failed:
-        Nombre de documents pour lesquels l'étape a renvoyé une
-        erreur.
-    duration_seconds_total / mean / median:
-        Statistiques de durée sur les **étapes ayant réussi**
-        uniquement (les étapes en erreur peuvent avoir une durée
-        artificielle).
-    failing_doc_ids:
-        Liste des ``doc_id`` pour lesquels cette étape a échoué.
-    junction_metrics:
-        ``{artifact_type_value: {metric_name: {"mean": float,
-        "median": float, "n": int}}}`` — agrégé sur les documents
-        où la métrique a été calculée (n peut différer de
-        ``n_succeeded`` si la GT du type n'est pas portée par tous
-        les docs).
-    error_breakdown:
-        ``{type_d_erreur: count}`` où ``type_d_erreur`` est extrait
-        en heuristique depuis le message (``"missing_input"``,
-        ``"raised_exception"``, ``"missing_output"``,
-        ``"other"``).
-    """
-
-    step_name: str
-    n_docs: int = 0
-    n_succeeded: int = 0
-    n_failed: int = 0
-    duration_seconds_total: float = 0.0
-    duration_seconds_mean: float = 0.0
-    duration_seconds_median: float = 0.0
-    failing_doc_ids: list[str] = field(default_factory=list)
-    junction_metrics: dict[str, dict[str, dict[str, float]]] = field(
-        default_factory=dict,
-    )
-    error_breakdown: dict[str, int] = field(default_factory=dict)
-
-    @property
-    def success_rate(self) -> float:
-        if self.n_docs == 0:
-            return 0.0
-        return self.n_succeeded / self.n_docs
-
-
-@dataclass
-class PipelineBenchmarkResult:
-    """Résultat d'un benchmark de pipeline sur un corpus complet.
-
-    On capture la durée totale, les résultats par document
-    (utiles pour le rapport HTML par-doc des sprints suivants), et
-    l'agrégation par étape.
-    """
-
-    pipeline_name: str
-    corpus_name: str
-    n_docs: int = 0
-    per_doc_results: list[PipelineResult] = field(default_factory=list)
-    per_step_aggregates: list[StepAggregate] = field(default_factory=list)
-    total_duration_seconds: float = 0.0
-
-    @property
-    def n_pipelines_succeeded(self) -> int:
-        return sum(1 for r in self.per_doc_results if r.succeeded)
-
-    @property
-    def n_pipelines_failed(self) -> int:
-        return sum(1 for r in self.per_doc_results if not r.succeeded)
+import warnings
 
-    def aggregate_for_step(self, step_name: str) -> Optional[StepAggregate]:
-        for agg in self.per_step_aggregates:
-            if agg.step_name == step_name:
-                return agg
-        return None
+from picarones.evaluation.pipeline_benchmark import *  # noqa: F401, F403
 
-
-# ──────────────────────────────────────────────────────────────────────────
-# Classification des erreurs
-# ──────────────────────────────────────────────────────────────────────────
-
-
-_ERROR_PATTERNS: tuple[tuple[str, str], ...] = (
-    ("entrée manquante",  "missing_input"),
-    ("sortie manquante",  "missing_output"),
-    ("Error",             "raised_exception"),  # RuntimeError, ValueError…
+warnings.warn(
+    "picarones.measurements.pipeline_benchmark is deprecated and will be removed in 2.0.  "
+    "Import from picarones.evaluation.pipeline_benchmark instead.",
+    DeprecationWarning,
+    stacklevel=2,
 )
-
-
-def _classify_error(message: str) -> str:
-    """Heuristique simple pour catégoriser une erreur d'étape.
-
-    On regarde des marqueurs lexicaux dans le message (les messages
-    sont produits par ``pipeline_runner._run_step`` qui les contrôle
-    entièrement, donc cette heuristique est stable).
-    """
-    if not message:
-        return "other"
-    for pattern, label in _ERROR_PATTERNS:
-        if pattern in message:
-            return label
-    return "other"
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Agrégation
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _aggregate_step(
-    step_name: str, per_doc: list[tuple[str, Any]],
-) -> StepAggregate:
-    """Construit le ``StepAggregate`` pour une étape donnée.
-
-    ``per_doc`` est une liste de tuples ``(doc_id, step_result)`` où
-    ``step_result`` peut être ``None`` (cas où la pipeline a été
-    arrêtée en amont avant cette étape) ou un ``StepResult``.
-    """
-    agg = StepAggregate(step_name=step_name)
-    durations_succeeded: list[float] = []
-    metrics_by_type: dict[str, dict[str, list[float]]] = {}
-
-    for doc_id, sr in per_doc:
-        if sr is None:
-            # L'étape n'a même pas été exécutée (validation amont
-            # invalide, ou exécutée n'a pas atteint l'index — ne se
-            # produit pas en séquentiel mais peut arriver avec un
-            # DAG plus tard).  On compte ce cas comme échec
-            # explicite avec un type dédié.
-            agg.n_docs += 1
-            agg.n_failed += 1
-            agg.failing_doc_ids.append(doc_id)
-            agg.error_breakdown["pipeline_aborted"] = (
-                agg.error_breakdown.get("pipeline_aborted", 0) + 1
-            )
-            continue
-        agg.n_docs += 1
-        if sr.error is None:
-            agg.n_succeeded += 1
-            durations_succeeded.append(sr.duration_seconds)
-            # Collecte des métriques pour agrégation moyenne/médiane
-            for at_value, metrics in sr.junction_metrics.items():
-                slot = metrics_by_type.setdefault(at_value, {})
-                for mname, mvalue in metrics.items():
-                    if isinstance(mvalue, (int, float)) and not isinstance(
-                        mvalue, bool,
-                    ):
-                        slot.setdefault(mname, []).append(float(mvalue))
-        else:
-            agg.n_failed += 1
-            agg.failing_doc_ids.append(doc_id)
-            label = _classify_error(sr.error)
-            agg.error_breakdown[label] = (
-                agg.error_breakdown.get(label, 0) + 1
-            )
-
-    if durations_succeeded:
-        agg.duration_seconds_total = sum(durations_succeeded)
-        agg.duration_seconds_mean = statistics.fmean(durations_succeeded)
-        agg.duration_seconds_median = statistics.median(durations_succeeded)
-
-    for at_value, metrics in metrics_by_type.items():
-        agg.junction_metrics[at_value] = {
-            mname: {
-                "mean": statistics.fmean(values),
-                "median": statistics.median(values),
-                "n": len(values),
-            }
-            for mname, values in metrics.items()
-        }
-    # Phase 4-bis : double-clé legacy/canonique pour rétrocompat.
-    from picarones.domain.artifacts import expand_legacy_keys
-    expand_legacy_keys(agg.junction_metrics)
-    return agg
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Orchestrateur principal
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def run_pipeline_benchmark(
-    spec: PipelineSpec,
-    corpus: Corpus,
-    initial_inputs_factory: InitialInputsFactory = default_initial_inputs,
-) -> PipelineBenchmarkResult:
-    """Exécute ``spec`` sur tous les documents de ``corpus``.
-
-    Parameters
-    ----------
-    spec:
-        Spécification de la pipeline composée.  Toutes les étapes
-        sont des ``BaseModule`` fournis par l'utilisateur.
-    corpus:
-        Corpus chargé via ``Corpus.from_directory`` ou équivalent.
-    initial_inputs_factory:
-        Fonction qui produit, pour chaque document, les artefacts
-        d'entrée de la pipeline.  Par défaut : ``IMAGE`` depuis
-        ``document.image_path``.  L'utilisateur peut fournir une
-        factory personnalisée pour brancher d'autres sources
-        (par exemple ``ALTO`` pré-existant pour évaluer un
-        pipeline qui démarre par un re-segmenteur).
-
-    Returns
-    -------
-    PipelineBenchmarkResult
-        Résultat global avec ``per_doc_results``,
-        ``per_step_aggregates``, durée totale.
-
-    Comportement
-    ------------
-    L'orchestration est **séquentielle** par document.  Pour chaque
-    document, ``PipelineRunner.run`` est appelé ; quel que soit le
-    résultat (réussi, partiellement échoué, totalement invalide),
-    le résultat est ajouté à ``per_doc_results`` et le benchmark
-    continue avec le document suivant.
-
-    Si la spec est statiquement invalide (cf.
-    ``PipelineSpec.validate``), tous les documents auront un
-    ``PipelineResult.error`` non vide et aucune étape ne sera
-    exécutée — le résultat reste cohérent.
-    """
-    result = PipelineBenchmarkResult(
-        pipeline_name=spec.name, corpus_name=corpus.name,
-    )
-    documents = list(corpus.documents)
-    result.n_docs = len(documents)
-
-    benchmark_t0 = time.monotonic()
-    for doc in documents:
-        try:
-            initial = initial_inputs_factory(doc)
-        except Exception as exc:  # noqa: BLE001
-            logger.warning(
-                "[pipeline_benchmark] factory a levé sur %s : %s",
-                doc.doc_id, exc,
-            )
-            # On crée un PipelineResult portant l'erreur factory
-            failed = PipelineResult(
-                pipeline_name=spec.name, doc_id=doc.doc_id,
-                error=f"initial_inputs_factory: {type(exc).__name__}: {exc}",
-            )
-            result.per_doc_results.append(failed)
-            continue
-        per_doc = PipelineRunner.run(spec, doc, initial)
-        result.per_doc_results.append(per_doc)
-    result.total_duration_seconds = time.monotonic() - benchmark_t0
-
-    # Agrégation par étape
-    step_names = [step.name for step in spec.steps]
-    for idx, step_name in enumerate(step_names):
-        per_doc_step: list[tuple[str, Any]] = []
-        for pr in result.per_doc_results:
-            if idx < len(pr.steps):
-                per_doc_step.append((pr.doc_id, pr.steps[idx]))
-            else:
-                # Pipeline a été arrêtée en amont : aucune étape de
-                # cet index n'existe.  On compte ça comme une
-                # absence d'étape (cf. ``_aggregate_step`` qui gère
-                # le ``None``).
-                per_doc_step.append((pr.doc_id, None))
-        result.per_step_aggregates.append(
-            _aggregate_step(step_name, per_doc_step),
-        )
-
-    return result
-
-
-__all__ = [
-    "InitialInputsFactory",
-    "PipelineBenchmarkResult",
-    "StepAggregate",
-    "default_initial_inputs",
-    "run_pipeline_benchmark",
-]

picarones/measurements/pipeline_comparison.py

@@ -1,301 +1,18 @@
-"""Comparaison de N pipelines sur le même corpus — Sprint 65 (axe B).
+"""``picarones.measurements.pipeline_comparison`` — shim re-export (déprécié, suppression 2.0).
 
-Sprint 65 — Étape 4 / axe B du plan d'évolution 2026 : suite directe
-des Sprints 63-64.  Le runner mono-document (Sprint 63) et
-l'orchestration corpus-wide (Sprint 64) permettent d'évaluer **une**
-pipeline composée ; ce sprint répond à la question typique BnF :
-
-    « OCR seul vs OCR+correcteur A vs OCR+correcteur B :
-      laquelle est la meilleure sur mon corpus, et de combien ? »
-
-Philosophie inchangée
----------------------
-Picarones reste un **banc d'essai** — on juge des pipelines tierces
-sur le **même corpus** avec la **même GT**, en exposant des chiffres
-bruts comparatifs.  Aucun verdict imposé : le chercheur lit le
-ranking et la table de gain et conclut selon ses critères.
-
-Périmètre Sprint 65
--------------------
-Inclus :
-
-- ``compare_pipelines(specs, corpus, factories=None)`` qui exécute
-  séquentiellement N pipelines sur le même corpus.
-- ``PipelineComparisonResult`` : conteneur avec
-  ``per_pipeline: dict[name → PipelineBenchmarkResult]``,
-  ``ranking_by_final_metric(artifact_type, metric_name,
-  higher_is_better)`` qui retourne ``[(pipeline_name, score), ...]``
-  trié, et ``gain_table(artifact_type, metric_name,
-  baseline_pipeline)`` qui retourne pour chaque pipeline le
-  ``{absolute, relative}`` vs baseline.
-- ``factories``: dict ``{pipeline_name: InitialInputsFactory}`` pour
-  personnaliser les entrées initiales par pipeline (utile pour
-  comparer une pipeline qui démarre par IMAGE et une qui démarre
-  par TEXT).
-- Garde-fou : noms de pipelines uniques exigés.
-
-Reporté à des sprints suivants :
-
-- DAG branchant non séquentiel (Sprint 66).
-- Vue HTML dédiée à la comparaison de pipelines (Sprint 67+).
-- Tests statistiques (Wilcoxon, Friedman, Nemenyi) sur les
-  pipelines composées — déjà disponibles côté OCR (Sprint 18) ;
-  l'application au cadre pipeline arrive plus tard.
+Canonique : :mod:`picarones.evaluation.pipeline_comparison`.
+Phase 5.C.batch7 du retrait du legacy.
 """
 
 from __future__ import annotations
 
-import logging
-import time
-from dataclasses import dataclass, field
-from typing import Optional
-
-from picarones.evaluation.corpus import Corpus
-from picarones.domain.artifacts import ArtifactType
-from picarones.measurements.pipeline_benchmark import (
-    InitialInputsFactory,
-    PipelineBenchmarkResult,
-    default_initial_inputs,
-    run_pipeline_benchmark,
-)
-from picarones.core.pipeline import PipelineSpec
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Conteneur de résultats
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@dataclass
-class PipelineComparisonResult:
-    """Résultat de la comparaison de N pipelines sur un corpus.
-
-    Champs
-    ------
-    corpus_name:
-        Nom du corpus (commun à toutes les pipelines comparées).
-    n_docs:
-        Nombre de documents du corpus.
-    per_pipeline:
-        Map ``{pipeline_name: PipelineBenchmarkResult}``.  L'ordre
-        d'insertion suit l'ordre des ``specs`` passées à
-        ``compare_pipelines`` ; on s'appuie sur le ``dict`` ordonné
-        de Python 3.7+.
-    total_duration_seconds:
-        Durée totale de la comparaison (sommes des durées par
-        pipeline + petit overhead).
-    """
-
-    corpus_name: str
-    n_docs: int = 0
-    per_pipeline: dict[str, PipelineBenchmarkResult] = field(
-        default_factory=dict,
-    )
-    total_duration_seconds: float = 0.0
-
-    def pipeline_names(self) -> list[str]:
-        """Retourne la liste des noms de pipelines dans leur ordre
-        d'insertion (= ordre de la comparaison initiale)."""
-        return list(self.per_pipeline.keys())
-
-    def _final_metric_value(
-        self,
-        pipeline_name: str,
-        artifact_type: ArtifactType,
-        metric_name: str,
-    ) -> Optional[float]:
-        """Retourne le ``mean`` de la métrique demandée à la
-        **dernière étape** de la pipeline qui a produit
-        ``artifact_type`` (avec succès sur ≥ 1 doc), ou ``None``
-        si la métrique n'est pas disponible.
-
-        Cohérent avec ``PipelineResult.junction_metrics_for`` du
-        Sprint 63 mais au niveau corpus-wide.
-        """
-        bench = self.per_pipeline.get(pipeline_name)
-        if bench is None:
-            return None
-        from picarones.domain.artifacts import LEGACY_VALUE_ALIASES
-        legacy_alias = LEGACY_VALUE_ALIASES.get(artifact_type.value)
-        for agg in reversed(bench.per_step_aggregates):
-            type_metrics = agg.junction_metrics.get(artifact_type.value)
-            if not type_metrics and legacy_alias is not None:
-                # Phase 4-bis : un caller (typiquement les tests
-                # ou un agrégateur tiers) peut avoir construit le
-                # dict avec la clé legacy ``"text"`` au lieu de la
-                # canonique ``"raw_text"``.  expand_legacy_keys
-                # synchronise les deux côtés sur les sites
-                # d'écriture du runner — ce fallback couvre le
-                # reste.
-                type_metrics = agg.junction_metrics.get(legacy_alias)
-            if not type_metrics:
-                continue
-            stats = type_metrics.get(metric_name)
-            if stats is None:
-                continue
-            return stats["mean"]
-        return None
+import warnings
 
-    def ranking_by_final_metric(
-        self,
-        artifact_type: ArtifactType,
-        metric_name: str,
-        higher_is_better: bool = False,
-    ) -> list[tuple[str, Optional[float]]]:
-        """Classe les pipelines par la valeur **finale** de
-        ``metric_name`` à la jonction ``artifact_type``.
+from picarones.evaluation.pipeline_comparison import *  # noqa: F401, F403
 
-        Returns
-        -------
-        list[tuple[str, Optional[float]]]
-            Liste ``[(pipeline_name, mean_value)]`` triée :
-
-            - Les pipelines avec une valeur définie viennent en
-              premier, triées selon ``higher_is_better``.
-            - Les pipelines sans valeur (métrique absente) viennent
-              en queue, dans leur ordre d'insertion.
-        """
-        with_value: list[tuple[str, float]] = []
-        without_value: list[tuple[str, Optional[float]]] = []
-        for name in self.pipeline_names():
-            value = self._final_metric_value(name, artifact_type, metric_name)
-            if value is None:
-                without_value.append((name, None))
-            else:
-                with_value.append((name, value))
-        with_value.sort(
-            key=lambda pair: pair[1],
-            reverse=higher_is_better,
-        )
-        return [*with_value, *without_value]
-
-    def gain_table(
-        self,
-        artifact_type: ArtifactType,
-        metric_name: str,
-        baseline_pipeline: str,
-    ) -> dict[str, dict[str, Optional[float]]]:
-        """Calcule l'écart de chaque pipeline vs la baseline.
-
-        Returns
-        -------
-        dict
-            Map ``{pipeline_name: {"value", "absolute", "relative"}}``
-            où :
-
-            - ``value`` : valeur finale de la métrique pour cette
-              pipeline (``None`` si absente).
-            - ``absolute`` : ``value - baseline_value``
-              (``None`` si l'une des deux est absente).
-            - ``relative`` : ``(value - baseline_value) /
-              baseline_value`` (``None`` si baseline absente ou
-              égale à 0).
-
-        La baseline elle-même apparaît avec ``absolute == 0`` et
-        ``relative == 0``.
-        """
-        if baseline_pipeline not in self.per_pipeline:
-            raise KeyError(
-                f"baseline {baseline_pipeline!r} absente de la comparaison",
-            )
-        baseline_value = self._final_metric_value(
-            baseline_pipeline, artifact_type, metric_name,
-        )
-        out: dict[str, dict[str, Optional[float]]] = {}
-        for name in self.pipeline_names():
-            value = self._final_metric_value(
-                name, artifact_type, metric_name,
-            )
-            absolute: Optional[float]
-            relative: Optional[float]
-            if value is None or baseline_value is None:
-                absolute = None
-                relative = None
-            else:
-                absolute = value - baseline_value
-                relative = (
-                    (value - baseline_value) / baseline_value
-                    if baseline_value != 0 else None
-                )
-            out[name] = {
-                "value": value,
-                "absolute": absolute,
-                "relative": relative,
-            }
-        return out
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Orchestrateur
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def compare_pipelines(
-    specs: list[PipelineSpec],
-    corpus: Corpus,
-    factories: Optional[dict[str, InitialInputsFactory]] = None,
-) -> PipelineComparisonResult:
-    """Exécute N ``PipelineSpec`` sur le **même** ``corpus``.
-
-    Parameters
-    ----------
-    specs:
-        Liste de ``PipelineSpec``.  Les noms de pipelines doivent
-        être uniques (sinon ``ValueError``).
-    corpus:
-        Corpus partagé entre toutes les pipelines comparées —
-        c'est le point fort du sprint : même corpus, même GT, on
-        peut comparer apple-to-apple.
-    factories:
-        Optionnel.  Si fourni, dict ``{pipeline_name:
-        InitialInputsFactory}`` pour personnaliser les entrées
-        initiales par pipeline.  Les pipelines absentes du dict
-        utilisent ``default_initial_inputs`` (cas standard
-        ``IMAGE`` depuis ``Document.image_path``).
-
-    Returns
-    -------
-    PipelineComparisonResult
-        Conteneur avec ``per_pipeline`` indexé par nom et
-        utilitaires comparatifs (``ranking_by_final_metric``,
-        ``gain_table``).
-
-    Raises
-    ------
-    ValueError
-        Si deux ``PipelineSpec`` ont le même nom (impossible alors
-        de les distinguer dans le résultat).
-    """
-    names = [s.name for s in specs]
-    if len(set(names)) != len(names):
-        seen: set[str] = set()
-        duplicates: list[str] = []
-        for n in names:
-            if n in seen:
-                duplicates.append(n)
-            seen.add(n)
-        raise ValueError(
-            f"noms de pipelines non uniques : {sorted(set(duplicates))}",
-        )
-
-    factories = factories or {}
-    result = PipelineComparisonResult(
-        corpus_name=corpus.name,
-        n_docs=len(list(corpus.documents)),
-    )
-
-    t0 = time.monotonic()
-    for spec in specs:
-        factory = factories.get(spec.name, default_initial_inputs)
-        bench = run_pipeline_benchmark(spec, corpus, factory)
-        result.per_pipeline[spec.name] = bench
-    result.total_duration_seconds = time.monotonic() - t0
-    return result
-
-
-__all__ = [
-    "PipelineComparisonResult",
-    "compare_pipelines",
-]
+warnings.warn(
+    "picarones.measurements.pipeline_comparison is deprecated and will be removed in 2.0.  "
+    "Import from picarones.evaluation.pipeline_comparison instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/measurements/pipeline_spec_loader.py

@@ -69,7 +69,7 @@ from typing import Any
 
 from picarones.domain.artifacts import ArtifactType
 from picarones.domain.module_protocol import BaseModule
-from picarones.core.pipeline import PipelineSpec, PipelineStep
+from picarones.evaluation.pipeline import PipelineSpec, PipelineStep
 
 logger = logging.getLogger(__name__)
 

picarones/measurements/roman_numerals.py

@@ -1,478 +1,18 @@
-"""Numéraux romains — Sprint 60.
+"""``picarones.measurements.roman_numerals`` — shim re-export (déprécié, suppression 2.0).
 
-Sprint 60 — Étape 3 / extension philologique transversale du plan
-d'évolution 2026.
-
-Pourquoi ce module
-------------------
-Les numéraux romains traversent **toutes les périodes patrimoniales**
-servies par Picarones :
-
-- **Médiéval** : minuscules avec ``j`` final pour le dernier ``i``
-  (``ij`` = 2, ``iij`` = 3, ``viij`` = 8, ``mcclxxxij`` = 1282).
-  Convention scribale standard dans les chartes et registres.
-- **Imprimé ancien** : majuscules (``Tome IV``, ``Chap. VII``).
-- **Moderne** : majuscules pour les souverains (``Louis XIV``) et
-  les siècles (``XIXᵉ siècle`` — la partie exposant ᵉ est gérée
-  par le Sprint 59 ``ordinals``, ce module ne traite que la partie
-  numérale ``XIX``).
-
-Quatre traitements possibles d'un numéral par l'OCR
-----------------------------------------------------
-Pour chaque numéral romain présent dans la GT, l'OCR peut :
-
-1. **Préserver strictement** : forme exacte gardée
-   (``mcclxxxij`` → ``mcclxxxij``).  Édition diplomatique idéale.
-2. **Préserver en changeant la casse** : la valeur est intacte mais
-   la convention typographique est modifiée
-   (``xiv`` → ``XIV``).  Modernisation typographique courante.
-3. **Préserver en supprimant le ``j`` final** :
-   (``mcclxxxij`` → ``mcclxxxii``).  Modernisation orthographique
-   médiévale → standard académique moderne.
-4. **Convertir en chiffres arabes** : la valeur est préservée mais
-   le système de numération est modernisé
-   (``XIV`` → ``14``).  Modernisation profonde, perte de
-   l'information typographique.
-5. **Perdre** : aucune trace de la valeur dans l'hypothèse.
-
-Ce module retourne un breakdown par statut pour que le chercheur
-juge lui-même la convention adoptée par chaque moteur, **sans
-classification automatique imposée**.
-
-Stratégie de découpage
-----------------------
-Cohérente avec NER (38), Flesch (52), Reading order F1 (53),
-Layout F1 (54), Bloc Unicode (55), Abréviations (56), MUFI (57),
-Imprimé ancien (58), Archives modernes (59) : couche de calcul
-pure d'abord ; câblage runner et HTML dans des sprints dédiés.
-
-Limites documentées
--------------------
-- Détection greedy par regex ``\\b[IVXLCDMivxlcdmj]+\\b`` puis
-  validation par parsing.  Les faux positifs restent possibles sur
-  des mots courts (``I`` pronom anglais, ``MM`` initiales, ``LL``).
-  Le paramètre ``min_length`` permet de filtrer les single-letter.
-- Pas de gestion des notations rares avec barre suscript pour
-  multiplier par 1000 (V̄ = 5000, X̄ = 10000) — usage très rare en
-  corpus patrimonial européen courant.
+Canonique : :mod:`picarones.evaluation.metrics.roman_numerals`.
+Phase 5.C.batch7 du retrait du legacy.
 """
 
 from __future__ import annotations
 
-import logging
-import re
-from typing import Optional
-
-from picarones.evaluation.metric_registry import register_metric
-from picarones.domain.artifacts import ArtifactType
-
-logger = logging.getLogger(__name__)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Table de conversion + parsing
-# ──────────────────────────────────────────────────────────────────────────
-
-ROMAN_VALUES: dict[str, int] = {
-    "I": 1,    "V": 5,    "X": 10,
-    "L": 50,   "C": 100,  "D": 500,  "M": 1000,
-}
-
-# Caractères acceptés en entrée (incluant minuscules + j médiéval).
-_ROMAN_CHARS = "IVXLCDMivxlcdmj"
-_ROMAN_RE = re.compile(rf"\b[{_ROMAN_CHARS}]+\b")
-
-
-def _normalize_roman(s: str) -> str:
-    """Normalise un numéral romain : majuscule + ``j`` final → ``i``.
-
-    Les manuscrits médiévaux notent traditionnellement le dernier
-    ``i`` d'une suite par ``j`` (« ij », « iij », « viij »…).  On
-    convertit pour pouvoir parser comme un numéral standard.
-    """
-    if not s:
-        return ""
-    upper = s.upper()
-    if upper.endswith("J"):
-        upper = upper[:-1] + "I"
-    return upper
-
-
-def _parse_normalized_roman(s: str) -> Optional[int]:
-    """Parse un numéral romain **après normalisation** (majuscule,
-    sans ``j`` médiéval).  Retourne ``None`` si la chaîne n'est pas
-    un numéral romain valide.
-
-    Validation : on parse en additionnant/soustrayant selon la règle
-    classique, puis on **regénère la forme standard** et on compare
-    pour rejeter les formes non canoniques (« IIII » au lieu de
-    « IV », « VV » au lieu de « X »).  Cette stricte validation
-    garantit qu'on ne compte pas des séquences absurdes comme
-    « XXXX » comme un numéral.
-
-    Note : les manuscrits médiévaux utilisent fréquemment « IIII »
-    pour 4 (notation soustractive plus tardive).  On accepte donc
-    aussi cette forme via une règle relâchée : tant que les valeurs
-    sont décroissantes ou suivent la règle soustractive standard,
-    on accepte.
-    """
-    if not s or not all(c in "IVXLCDM" for c in s):
-        return None
-    # Calcul par soustraction.
-    total = 0
-    prev_value = 0
-    for ch in reversed(s):
-        v = ROMAN_VALUES[ch]
-        if v < prev_value:
-            total -= v
-        else:
-            total += v
-        prev_value = v
-    if total <= 0:
-        return None
-    # Validation relâchée : on accepte les formes médiévales (IIII,
-    # VIIII) mais on rejette les vraiment absurdes (IIIII, VVVV).
-    if not _is_plausible_roman(s):
-        return None
-    return total
-
-
-def _is_plausible_roman(s: str) -> bool:
-    """Validation relâchée d'un numéral romain (majuscule).
-
-    On rejette :
-
-    - 5 caractères identiques d'affilée ou plus (« IIIII », « XXXXX »).
-    - Les répétitions de V, L, D (jamais répétés en notation
-      classique : « VV », « LL », « DD »).
-    - Les paires soustractives non standard.  En romain canonique,
-      seules sont valides : IV, IX, XL, XC, CD, CM.  Toute autre
-      combinaison « petit avant grand » est rejetée.  Cela élimine
-      les faux positifs sur des mots français comme « ici » (qui
-      formerait sinon « I + C » = 99) ou « IL » qui formerait 49.
-    """
-    if not s:
-        return False
-    # Pas de répétitions invalides
-    for forbidden in ("VV", "LL", "DD", "IIIII", "XXXXX", "CCCCC", "MMMMMM"):
-        if forbidden in s:
-            return False
-    # Paires soustractives autorisées (toutes les autres sont rejetées)
-    legal_subtractive = {"IV", "IX", "XL", "XC", "CD", "CM"}
-    for i in range(len(s) - 1):
-        a, b = s[i], s[i + 1]
-        if ROMAN_VALUES[a] < ROMAN_VALUES[b]:
-            if (a + b) not in legal_subtractive:
-                return False
-    return True
-
-
-def roman_to_int(s: Optional[str]) -> Optional[int]:
-    """Convertit une chaîne en numéral romain entier.  Tolère casse
-    et ``j`` médiéval final.  Retourne ``None`` si invalide.
-    """
-    if not s:
-        return None
-    return _parse_normalized_roman(_normalize_roman(s))
-
-
-def int_to_roman(n: int) -> str:
-    """Convertit un entier en numéral romain majuscule standard.
-
-    Utilise la notation classique (IV, IX, XL, XC, CD, CM) — pas la
-    forme médiévale relâchée.
-    """
-    if n <= 0:
-        raise ValueError("n must be positive")
-    pairs = [
-        (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
-        (100, "C"),  (90, "XC"),  (50, "L"),  (40, "XL"),
-        (10, "X"),   (9, "IX"),   (5, "V"),   (4, "IV"),
-        (1, "I"),
-    ]
-    out: list[str] = []
-    for value, symbol in pairs:
-        while n >= value:
-            out.append(symbol)
-            n -= value
-    return "".join(out)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Détection dans le texte
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def detect_roman_numerals(
-    text: Optional[str],
-    *,
-    min_length: int = 1,
-) -> list[tuple[int, str, int]]:
-    """Retourne les numéraux romains valides dans ``text``.
-
-    Forme : ``[(start_index, numeral_string, integer_value), ...]``
-    triée par index croissant.
+import warnings
 
-    Parameters
-    ----------
-    text:
-        Texte à analyser.
-    min_length:
-        Longueur minimale d'un numéral retenu.  Par défaut ``1``.
-        Mettre à ``2`` pour filtrer les single-letter ambigus (``I``
-        pronom, ``M`` initiale).
+from picarones.evaluation.metrics.roman_numerals import *  # noqa: F401, F403
 
-    Faux positifs connus
-    --------------------
-    - ``I`` (pronom anglais), ``M`` ou ``D`` en initiale d'une
-      personne ne peuvent pas être distingués sans NER.  Le chercheur
-      qui s'inquiète de ces faux positifs peut passer
-      ``min_length=2``.
-    """
-    if not text:
-        return []
-    found: list[tuple[int, str, int]] = []
-    for match in _ROMAN_RE.finditer(text):
-        s = match.group(0)
-        if len(s) < min_length:
-            continue
-        value = roman_to_int(s)
-        if value is None:
-            continue
-        found.append((match.start(), s, value))
-    return found
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Classification de la restitution dans l'hypothèse
-# ──────────────────────────────────────────────────────────────────────────
-
-# Statuts possibles, dans l'ordre de priorité (un numéral est
-# classé selon le premier statut qui s'applique).
-
-STATUS_STRICT_PRESERVED   = "strict_preserved"
-STATUS_CASE_CHANGED       = "case_changed"
-STATUS_J_DROPPED          = "j_dropped"
-STATUS_CONVERTED_TO_ARABIC = "converted_to_arabic"
-STATUS_LOST               = "lost"
-
-ALL_STATUSES = (
-    STATUS_STRICT_PRESERVED,
-    STATUS_CASE_CHANGED,
-    STATUS_J_DROPPED,
-    STATUS_CONVERTED_TO_ARABIC,
-    STATUS_LOST,
-)
-
-# Statuts qui indiquent une préservation de la valeur (par opposition
-# à la perte).
-VALUE_PRESERVING_STATUSES = frozenset({
-    STATUS_STRICT_PRESERVED,
-    STATUS_CASE_CHANGED,
-    STATUS_J_DROPPED,
-    STATUS_CONVERTED_TO_ARABIC,
-})
-
-
-def _classify_restitution(numeral: str, value: int, hyp: str) -> str:
-    """Classifie comment ``numeral`` (de valeur ``value``) est
-    restitué dans ``hyp`` selon les 5 statuts définis."""
-    # 1. Forme stricte présente
-    if re.search(r"(?<![A-Za-z])" + re.escape(numeral) + r"(?![A-Za-z])", hyp):
-        return STATUS_STRICT_PRESERVED
-    # 2. Variante de casse seule
-    swapped = numeral.swapcase()
-    if swapped != numeral and re.search(
-        r"(?<![A-Za-z])" + re.escape(swapped) + r"(?![A-Za-z])", hyp,
-    ):
-        return STATUS_CASE_CHANGED
-    # 3. ``j`` final remplacé par ``i`` (ou inverse)
-    if numeral.lower().endswith("j"):
-        no_j = numeral[:-1] + ("I" if numeral[-1] == "J" else "i")
-    elif numeral.lower().endswith("i"):
-        no_j = numeral[:-1] + ("J" if numeral[-1] == "I" else "j")
-    else:
-        no_j = numeral
-    if no_j != numeral and re.search(
-        r"(?<![A-Za-z])" + re.escape(no_j) + r"(?![A-Za-z])", hyp,
-    ):
-        return STATUS_J_DROPPED
-    # Variante de casse + j-flip combinés
-    no_j_swapped = no_j.swapcase()
-    if no_j_swapped != numeral and re.search(
-        r"(?<![A-Za-z])" + re.escape(no_j_swapped) + r"(?![A-Za-z])", hyp,
-    ):
-        return STATUS_J_DROPPED
-    # 4. Conversion en chiffres arabes
-    if re.search(r"(?<!\d)" + str(value) + r"(?!\d)", hyp):
-        return STATUS_CONVERTED_TO_ARABIC
-    # 5. Perdu
-    return STATUS_LOST
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Calcul de la métrique
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def compute_roman_numeral_metrics(
-    reference: Optional[str],
-    hypothesis: Optional[str],
-    *,
-    min_length: int = 1,
-) -> dict:
-    """Calcule la préservation des numéraux romains.
-
-    Pour chaque numéral romain dans la GT, on classifie sa
-    restitution dans l'hypothèse selon l'un des 5 statuts (forme
-    stricte / casse modifiée / j supprimé / conversion arabe / perdu).
-
-    Returns
-    -------
-    dict
-        ``{
-            "n_numerals_reference": int,
-            "n_strict_preserved": int,
-            "n_value_preserved": int,    # tous statuts sauf LOST
-            "global_strict_score": float,
-            "global_value_score": float,
-            "per_status": {status: count for status in ALL_STATUSES},
-            "per_numeral": [
-                {"index", "numeral", "value", "status"}
-            ],
-            "lost_numerals": [
-                {"index", "numeral", "value"}
-            ],
-        }``
-
-    Cas dégénérés
-    -------------
-    - GT vide ou sans numéral → tous compteurs à 0, scores à 0.0,
-      ``per_status`` initialisé à 0 sur tous les statuts.
-    - GT avec numéraux + hyp vide → tous classés ``lost``,
-      strict_score = value_score = 0.0.
-    """
-    ref = reference or ""
-    hyp = hypothesis or ""
-
-    detected = detect_roman_numerals(ref, min_length=min_length)
-    n_total = len(detected)
-    per_status_init = {status: 0 for status in ALL_STATUSES}
-
-    if n_total == 0:
-        return {
-            "n_numerals_reference": 0,
-            "n_strict_preserved": 0,
-            "n_value_preserved": 0,
-            "global_strict_score": 0.0,
-            "global_value_score": 0.0,
-            "per_status": per_status_init,
-            "per_numeral": [],
-            "lost_numerals": [],
-        }
-
-    per_status: dict[str, int] = dict(per_status_init)
-    per_numeral: list[dict] = []
-    lost: list[dict] = []
-    for index, numeral, value in detected:
-        status = _classify_restitution(numeral, value, hyp)
-        per_status[status] = per_status.get(status, 0) + 1
-        per_numeral.append({
-            "index": index,
-            "numeral": numeral,
-            "value": value,
-            "status": status,
-        })
-        if status == STATUS_LOST:
-            lost.append({"index": index, "numeral": numeral, "value": value})
-
-    n_strict = per_status[STATUS_STRICT_PRESERVED]
-    n_value = sum(per_status[s] for s in VALUE_PRESERVING_STATUSES)
-
-    return {
-        "n_numerals_reference": n_total,
-        "n_strict_preserved": n_strict,
-        "n_value_preserved": n_value,
-        "global_strict_score": n_strict / n_total,
-        "global_value_score": n_value / n_total,
-        "per_status": per_status,
-        "per_numeral": per_numeral,
-        "lost_numerals": lost,
-    }
-
-
-def roman_numeral_strict_score(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : taux global de préservation **stricte** des
-    numéraux romains ∈ [0, 1]."""
-    return compute_roman_numeral_metrics(
-        reference, hypothesis,
-    )["global_strict_score"]
-
-
-def roman_numeral_value_score(
-    reference: Optional[str], hypothesis: Optional[str],
-) -> float:
-    """Raccourci : taux global de préservation de la **valeur** des
-    numéraux romains (toute forme confondue : strict, case_changed,
-    j_dropped, arabe) ∈ [0, 1]."""
-    return compute_roman_numeral_metrics(
-        reference, hypothesis,
-    )["global_value_score"]
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Enregistrement dans le registre typé (Sprint 34)
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@register_metric(
-    name="roman_numeral_strict_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux de préservation stricte des numéraux romains "
-        "(forme exacte gardée : casse, j médiéval final). "
-        "Métrique transversale aux périodes médiévale, imprimé "
-        "ancien et moderne."
-    ),
-    higher_is_better=True,
-    tags={"text", "roman_numerals", "philology"},
-)
-def _registered_strict(reference: str, hypothesis: str) -> float:
-    return roman_numeral_strict_score(reference, hypothesis)
-
-
-@register_metric(
-    name="roman_numeral_value_score",
-    input_types=(ArtifactType.TEXT, ArtifactType.TEXT),
-    description=(
-        "Taux de préservation de la valeur numérique des numéraux "
-        "romains, indépendamment de la forme (strict, casse "
-        "changée, j supprimé, conversion en chiffres arabes). "
-        "Le breakdown per_status permet au chercheur de juger la "
-        "convention adoptée."
-    ),
-    higher_is_better=True,
-    tags={"text", "roman_numerals", "philology"},
+warnings.warn(
+    "picarones.measurements.roman_numerals is deprecated and will be removed in 2.0.  "
+    "Import from picarones.evaluation.metrics.roman_numerals instead.",
+    DeprecationWarning,
+    stacklevel=2,
 )
-def _registered_value(reference: str, hypothesis: str) -> float:
-    return roman_numeral_value_score(reference, hypothesis)
-
-
-__all__ = [
-    "ROMAN_VALUES",
-    "ALL_STATUSES",
-    "STATUS_STRICT_PRESERVED",
-    "STATUS_CASE_CHANGED",
-    "STATUS_J_DROPPED",
-    "STATUS_CONVERTED_TO_ARABIC",
-    "STATUS_LOST",
-    "VALUE_PRESERVING_STATUSES",
-    "compute_roman_numeral_metrics",
-    "detect_roman_numerals",
-    "int_to_roman",
-    "roman_numeral_strict_score",
-    "roman_numeral_value_score",
-    "roman_to_int",
-]

picarones/report/generator.py

@@ -290,7 +290,7 @@ class ReportGenerator:
         from picarones.reports_v2.html.renderers.searchability import (
             build_searchability_summary_html,
         )
-        from picarones.report.numerical_sequences_render import (
+        from picarones.reports_v2.html.renderers.numerical_sequences import (
             build_numerical_sequences_html,
         )
         # Sprint 87 — A.II.2 : lisibilité (delta Flesch).

picarones/report/numerical_sequences_render.py

@@ -1,149 +1,18 @@
-"""Rendu HTML « Précision sur séquences numériques » — Sprint 86.
+"""``picarones.report.numerical_sequences_render`` — shim re-export (déprécié, suppression 2.0).
 
-Suite directe ``picarones/core/numerical_sequences.py``
-(Sprint 85) + câblage runner Sprint 86.
-
-Pattern identique aux autres rendus : server-side, pas de JS,
-anti-injection systématique.
-
-Vue
----
-Tableau moteur × catégorie (year / roman / foliation / currency
-/ regnal) × score strict ; une ligne par moteur, une cellule
-colorée par cellule.  Une seconde ligne donne le score ``value``
-(en plus petit).  Catégorie omise si **aucun** moteur n'a de
-GT exploitable pour elle.
-
-Adaptative : ``""`` si aucun moteur n'a de
-``aggregated_numerical_sequences``.
+Canonique : :mod:`picarones.reports_v2.html.renderers.numerical_sequences`.
+Phase 5.C.batch7 du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from html import escape as _e
-from typing import Optional
-
-from picarones.measurements.numerical_sequences import CATEGORIES
-from picarones.reports_v2._helpers.render_helpers import color_traffic_light
-
-
-def _category_columns_with_signal(rows: list[dict]) -> list[str]:
-    """Ne garde que les catégories où ≥ 1 moteur a un n_total > 0."""
-    visible: list[str] = []
-    for cat in CATEGORIES:
-        for r in rows:
-            agg = r.get("aggregated_numerical_sequences") or {}
-            cat_data = (agg.get("per_category") or {}).get(cat) or {}
-            if (cat_data.get("n_total") or 0) > 0:
-                visible.append(cat)
-                break
-    return visible
-
-
-def build_numerical_sequences_html(
-    engines: list[dict],
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit la section HTML séquences numériques.
-
-    Returns
-    -------
-    str
-        ``""`` si aucun moteur n'a de signal.
-    """
-    rows = [
-        e for e in engines
-        if isinstance(e.get("aggregated_numerical_sequences"), dict)
-    ]
-    if not rows:
-        return ""
-    visible_cats = _category_columns_with_signal(rows)
-    if not visible_cats:
-        return ""
-    labels = labels or {}
-    title = labels.get(
-        "numseq_title", "Précision sur séquences numériques",
-    )
-    note = labels.get(
-        "numseq_note",
-        "Score strict (forme préservée) — la valeur entre "
-        "parenthèses est le score sur la valeur (XIV ↔ 14 "
-        "accepté). Foliotation : recto/verso non interchangeables.",
-    )
-    col_engine = labels.get("numseq_engine", "Moteur")
-    col_global = labels.get("numseq_global", "Global")
-    cat_label = {
-        "year": labels.get("numseq_cat_year", "Année"),
-        "roman": labels.get("numseq_cat_roman", "Romain"),
-        "foliation": labels.get("numseq_cat_foliation", "Foliation"),
-        "currency": labels.get("numseq_cat_currency", "Montant"),
-        "regnal": labels.get("numseq_cat_regnal", "Régnal"),
-    }
-
-    parts = [
-        '<div class="numseq-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>',
-        '<table style="border-collapse:collapse;width:100%;'
-        'font-size:.9rem">',
-        '<thead><tr>',
-        f'<th scope=\"col\" style="padding:.4rem .6rem;text-align:left;'
-        f'border-bottom:1px solid #ccc;font-weight:600">'
-        f'{_e(col_engine)}</th>',
-        f'<th scope=\"col\" style="padding:.4rem .6rem;text-align:right;'
-        f'border-bottom:1px solid #ccc;font-weight:600">'
-        f'{_e(col_global)}</th>',
-    ]
-    for cat in visible_cats:
-        parts.append(
-            f'<th scope=\"col\" style="padding:.4rem .6rem;text-align:right;'
-            f'border-bottom:1px solid #ccc;font-weight:600">'
-            f'{_e(cat_label.get(cat, cat))}</th>'
-        )
-    parts.append("</tr></thead><tbody>")
-
-    for engine in rows:
-        agg = engine["aggregated_numerical_sequences"]
-        name = engine.get("name") or "?"
-        per_cat = agg.get("per_category") or {}
-        global_strict = float(agg.get("global_strict_score") or 0.0)
-        global_value = float(agg.get("global_value_score") or 0.0)
-        n_total = int(agg.get("n_total") or 0)
-        global_color = color_traffic_light(global_strict)
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.4rem .6rem">{_e(str(name))}</td>'
-            f'<td style="padding:.4rem .6rem;text-align:right;'
-            f'background:{global_color};font-family:monospace;'
-            f'font-weight:600">'
-            f'{global_strict * 100:.1f}%'
-            f'<span style="font-size:.75rem;font-weight:400;'
-            f'opacity:.75"> ({global_value * 100:.0f}%, '
-            f'n={n_total})</span></td>'
-        )
-        for cat in visible_cats:
-            cat_data = per_cat.get(cat) or {}
-            n = int(cat_data.get("n_total") or 0)
-            if n == 0:
-                parts.append(
-                    '<td style="padding:.4rem .6rem;text-align:right;'
-                    'opacity:.4">—</td>'
-                )
-                continue
-            strict = float(cat_data.get("strict_score") or 0.0)
-            value = float(cat_data.get("value_score") or 0.0)
-            color = color_traffic_light(strict)
-            parts.append(
-                f'<td style="padding:.4rem .6rem;text-align:right;'
-                f'background:{color};font-family:monospace">'
-                f'{strict * 100:.0f}%'
-                f'<span style="font-size:.75rem;opacity:.75"> '
-                f'({value * 100:.0f}%, n={n})</span></td>'
-            )
-        parts.append("</tr>")
-    parts.append("</tbody></table></div>")
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.numerical_sequences import *  # noqa: F401, F403
 
-__all__ = ["build_numerical_sequences_html"]
+warnings.warn(
+    "picarones.report.numerical_sequences_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.numerical_sequences instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/pipeline_render.py

@@ -1,707 +1,18 @@
-"""Rendu HTML server-side d'un benchmark de pipeline composée
-(Sprint 67).
+"""``picarones.report.pipeline_render`` — shim re-export (déprécié, suppression 2.0).
 
-Suite directe Sprints 63-66 (axe B) — produit les blocs HTML qui
-exposent le résultat d'une pipeline composée.
-
-Pattern identique aux Sprints 41 (NER), 43 (calibration) et 62
-(philologie) : rendu **server-side**, pas de JavaScript,
-déterministe, anti-injection systématique via ``html.escape``.
-
-Vue distincte du rapport OCR historique
----------------------------------------
-Le rapport HTML OCR (``picarones/report/generator.py``) attend un
-``BenchmarkResult`` (axe A).  Pour les pipelines composées, on
-travaille avec ``PipelineBenchmarkResult`` (axe B, Sprint 64).
-
-Ce module fournit donc un rapport **autonome** : la fonction
-``build_pipeline_report_html`` produit un document HTML complet
-(``<!doctype html>...``) que l'utilisateur peut écrire directement
-sur disque, sans dépendre du générateur OCR.
-
-Sprint 67 — périmètre
----------------------
-Inclus :
-
-- ``build_pipeline_summary_html(bench)`` — encart résumé global
-  (corpus, n_docs, taux de succès, durée totale).
-- ``build_pipeline_steps_table_html(bench)`` — tableau par étape
-  (durée mean/median, n_succeeded/failed, error_breakdown,
-  métriques aux jonctions).
-- ``build_pipeline_report_html(bench, lang)`` — document HTML
-  complet à sauver sur disque.
-
-Reporté à Sprint 68 :
-
-- Rendu d'un ``PipelineComparisonResult`` (ranking entre N
-  pipelines + gain table).
-
-Toujours pas de classification automatique
-------------------------------------------
-On affiche les chiffres bruts ; le chercheur lit et conclut.
+Canonique : :mod:`picarones.reports_v2.html.renderers.pipeline`.
+Phase 5.C.batch7 du retrait du legacy.
 """
 
 from __future__ import annotations
 
-from dataclasses import dataclass
-from html import escape as _e
-from typing import Optional
-
-from picarones.domain.artifacts import ArtifactType
-from picarones.measurements.pipeline_benchmark import PipelineBenchmarkResult
-from picarones.measurements.pipeline_comparison import PipelineComparisonResult
-from picarones.reports_v2._helpers.render_helpers import color_traffic_light
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Helpers communs
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def _format_duration(seconds: float) -> str:
-    """Formate une durée en ms si < 1s, en s sinon."""
-    if seconds < 1.0:
-        return f"{seconds * 1000:.1f} ms"
-    if seconds < 60.0:
-        return f"{seconds:.2f} s"
-    minutes = int(seconds // 60)
-    rest = seconds - minutes * 60
-    return f"{minutes}min {rest:.1f}s"
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Encart résumé corpus-wide
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_pipeline_summary_html(
-    bench: PipelineBenchmarkResult,
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit l'encart résumé global du benchmark."""
-    labels = labels or {}
-    title = labels.get("pipeline_summary_title", "Résumé du benchmark")
-    pipeline_label = labels.get("pipeline_name_label", "Pipeline")
-    corpus_label = labels.get("pipeline_corpus_label", "Corpus")
-    n_docs_label = labels.get("pipeline_n_docs_label", "Documents")
-    succeeded_label = labels.get(
-        "pipeline_succeeded_label", "Pipelines réussies",
-    )
-    failed_label = labels.get("pipeline_failed_label", "Pipelines échouées")
-    duration_label = labels.get("pipeline_duration_label", "Durée totale")
-
-    success = bench.n_pipelines_succeeded
-    failed = bench.n_pipelines_failed
-    total = bench.n_docs
-    rate = success / total if total > 0 else 0.0
-    color = color_traffic_light(rate)
-
-    parts = [
-        '<div class="pipeline-summary" '
-        'style="margin:1rem 0;padding:.75rem;'
-        'background:var(--bg-secondary,#f7f7f7);border-radius:6px">',
-        f'<div style="font-weight:600;margin-bottom:.5rem">{_e(title)}</div>',
-        '<table style="border-collapse:collapse;font-size:.9rem">',
-    ]
-    rows = [
-        (pipeline_label, _e(bench.pipeline_name)),
-        (corpus_label, _e(bench.corpus_name)),
-        (n_docs_label, str(total)),
-        (
-            succeeded_label,
-            f'<span style="background:{color};padding:.1rem .4rem;'
-            f'border-radius:3px">{success} / {total}</span>',
-        ),
-        (failed_label, str(failed)),
-        (duration_label, _e(_format_duration(bench.total_duration_seconds))),
-    ]
-    for label, value in rows:
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.2rem .5rem;font-weight:500;'
-            f'color:#555">{_e(label)}</td>'
-            f'<td style="padding:.2rem .5rem">{value}</td>'
-            f'</tr>'
-        )
-    parts.append("</table></div>")
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Tableau par étape
-# ──────────────────────────────────────────────────────────────────────────
-
-
-def build_pipeline_steps_table_html(
-    bench: PipelineBenchmarkResult,
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Construit le tableau par étape de la pipeline.
-
-    Colonnes : nom de l'étape, n_succeeded, n_failed, taux de
-    succès (cellule colorée), durée mean/median, métriques aux
-    jonctions (mean) regroupées par type, error_breakdown
-    catégorisé.
-    """
-    if not bench.per_step_aggregates:
-        return ""
-    labels = labels or {}
-    title = labels.get("pipeline_steps_title", "Détail par étape")
-    name_label = labels.get("pipeline_step_name_label", "Étape")
-    succ_label = labels.get("pipeline_succeeded_label", "Réussies")
-    fail_label = labels.get("pipeline_failed_label", "Échouées")
-    rate_label = labels.get("pipeline_success_rate_label", "Taux succès")
-    dmean_label = labels.get("pipeline_duration_mean_label", "Durée moyenne")
-    dmedian_label = labels.get(
-        "pipeline_duration_median_label", "Durée médiane",
-    )
-    metrics_label = labels.get(
-        "pipeline_junction_metrics_label", "Métriques aux jonctions",
-    )
-    errors_label = labels.get("pipeline_error_breakdown_label", "Erreurs")
-
-    parts = [
-        '<div class="pipeline-steps" style="margin:1rem 0">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-        '<table style="border-collapse:collapse;font-size:.85rem;'
-        'width:100%">',
-        '<thead><tr>',
-    ]
-    for col in (
-        name_label, succ_label, fail_label, rate_label,
-        dmean_label, dmedian_label, metrics_label, errors_label,
-    ):
-        parts.append(
-            f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
-            f'border-bottom:1px solid #ccc;font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append("</tr></thead><tbody>")
-
-    for agg in bench.per_step_aggregates:
-        rate = agg.success_rate
-        rate_color = color_traffic_light(rate)
-        # Métriques aux jonctions : pour chaque type d'artefact,
-        # liste des métriques mean
-        metrics_cells: list[str] = []
-        for at_value, type_metrics in sorted(agg.junction_metrics.items()):
-            type_str = _e(at_value)
-            for mname, stats in sorted(type_metrics.items()):
-                mean = stats["mean"]
-                n = stats["n"]
-                metrics_cells.append(
-                    f'<div style="font-size:.8rem;line-height:1.3">'
-                    f'<code>{type_str}.{_e(mname)}</code>: '
-                    f'{mean:.3f} '
-                    f'<span style="opacity:.6">(n={n})</span></div>'
-                )
-        metrics_html = "".join(metrics_cells) or (
-            '<span style="opacity:.5">—</span>'
-        )
-        # Error breakdown
-        err_cells: list[str] = []
-        for label, count in sorted(agg.error_breakdown.items()):
-            err_cells.append(
-                f'<div style="font-size:.8rem;line-height:1.3">'
-                f'<code>{_e(label)}</code>: {count}</div>'
-            )
-        err_html = "".join(err_cells) or (
-            '<span style="opacity:.5">—</span>'
-        )
-
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.3rem .5rem;font-weight:500">'
-            f'{_e(agg.step_name)}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right">'
-            f'{agg.n_succeeded}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right">'
-            f'{agg.n_failed}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:center;'
-            f'background:{rate_color}">{rate * 100:.0f}%</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right">'
-            f'{_e(_format_duration(agg.duration_seconds_mean))}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right">'
-            f'{_e(_format_duration(agg.duration_seconds_median))}</td>'
-            f'<td style="padding:.3rem .5rem">{metrics_html}</td>'
-            f'<td style="padding:.3rem .5rem">{err_html}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table></div>")
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Document HTML autonome
-# ──────────────────────────────────────────────────────────────────────────
-
-
-_DOC_STYLES = """
-:root {
-  --bg-primary: #ffffff;
-  --bg-secondary: #f7f7f7;
-  --text-primary: #222;
-  --text-muted: #666;
-  --border: #ddd;
-}
-* { box-sizing: border-box; }
-body {
-  margin: 0;
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
-  background: var(--bg-primary);
-  color: var(--text-primary);
-  line-height: 1.5;
-}
-header {
-  padding: 1.5rem 2rem;
-  border-bottom: 1px solid var(--border);
-}
-header h1 { margin: 0 0 .3rem 0; font-size: 1.4rem; }
-header .subtitle { color: var(--text-muted); font-size: .9rem; }
-main { padding: 1rem 2rem 3rem 2rem; max-width: 1400px; margin: 0 auto; }
-table { border: 1px solid var(--border); }
-code { background: #f0f0f0; padding: 0 .2rem; border-radius: 2px; font-size: .85em; }
-.note {
-  font-size: .85rem;
-  color: var(--text-muted);
-  font-style: italic;
-  margin: .5rem 0 1.5rem 0;
-}
-"""
-
-
-def build_pipeline_report_html(
-    bench: PipelineBenchmarkResult,
-    labels: Optional[dict[str, str]] = None,
-    lang: str = "fr",
-) -> str:
-    """Construit un document HTML autonome pour un benchmark de
-    pipeline composée.
-
-    Le document est complet (``<!doctype html>...``) et peut être
-    sauvé directement sur disque par l'utilisateur :
-
-    >>> html = build_pipeline_report_html(bench)
-    >>> Path("rapport_pipeline.html").write_text(html)
-    """
-    labels = labels or {}
-    main_title = labels.get(
-        "pipeline_report_title", "Rapport de pipeline composée",
-    )
-    note = labels.get(
-        "pipeline_report_note",
-        "Données brutes par étape. L'outil mesure et agrège — il "
-        "ne classe pas la pipeline « bonne » ou « mauvaise ». "
-        "C'est au chercheur de juger les chiffres selon ses critères.",
-    )
-    summary = build_pipeline_summary_html(bench, labels)
-    steps = build_pipeline_steps_table_html(bench, labels)
-
-    title_text = f"{main_title} — {bench.pipeline_name}"
-    parts = [
-        "<!doctype html>",
-        f'<html lang="{_e(lang)}">',
-        "<head>",
-        '<meta charset="utf-8">',
-        '<meta name="viewport" content="width=device-width,initial-scale=1">',
-        f"<title>{_e(title_text)}</title>",
-        "<style>", _DOC_STYLES, "</style>",
-        "</head>",
-        "<body>",
-        "<header>",
-        f"<h1>{_e(title_text)}</h1>",
-        f'<div class="subtitle">{_e(bench.corpus_name)} — '
-        f'{bench.n_docs} {_e(labels.get("pipeline_docs_short", "docs"))}'
-        f'</div>',
-        "</header>",
-        "<main>",
-        f'<p class="note">{_e(note)}</p>',
-        summary,
-        steps,
-        "</main>",
-        "</body>",
-        "</html>",
-    ]
-    return "".join(parts)
-
-
-# ──────────────────────────────────────────────────────────────────────────
-# Sprint 68 — comparaison de N pipelines : ranking + gain table
-# ──────────────────────────────────────────────────────────────────────────
-
-
-@dataclass
-class RankingSpec:
-    """Spec d'un classement à afficher.
-
-    Décrit la jonction (``artifact_type``) et la métrique
-    (``metric_name``) à utiliser pour classer les pipelines.
-
-    Attributs
-    ---------
-    artifact_type:
-        Type d'artefact où la métrique est calculée (typiquement
-        ``ArtifactType.TEXT`` pour des métriques OCR).
-    metric_name:
-        Nom de la métrique dans le registre typé Sprint 34
-        (``"cer"``, ``"wer"``, ``"flesch_delta_fr"``, etc.).
-    higher_is_better:
-        ``False`` (défaut) pour les métriques d'erreur (CER, WER) ;
-        ``True`` pour les métriques de qualité (accuracy, F1,
-        coverage…).
-    label:
-        Libellé optionnel à afficher dans le tableau ; sinon
-        construit comme ``"<artifact_type>.<metric_name>"``.
-    """
-
-    artifact_type: ArtifactType
-    metric_name: str
-    higher_is_better: bool = False
-    label: Optional[str] = None
-
-    @property
-    def display_label(self) -> str:
-        if self.label:
-            return self.label
-        return f"{self.artifact_type.value}.{self.metric_name}"
-
-
-def _bg_for_rank(rank: int, total: int) -> str:
-    """Gradient vert (rang 1) → rouge (dernier rang).
-
-    Mapping : ``rank ∈ [1, total]`` → ``color_traffic_light`` avec
-    ``low_is_good=True`` (rang bas = bon).
-    """
-    if total <= 1:
-        return color_traffic_light(1.0)
-    return color_traffic_light(
-        float(rank), low_is_good=True, scale_min=1.0, scale_max=float(total),
-    )
-
-
-def build_pipeline_ranking_table_html(
-    comparison: PipelineComparisonResult,
-    ranking_spec: RankingSpec,
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Tableau de classement des pipelines selon une métrique finale.
-
-    Colonnes : rang, nom du pipeline, valeur de la métrique (mean
-    sur le corpus à la dernière jonction qui produit
-    ``artifact_type``).  Les pipelines sans valeur sont listés en
-    queue avec un tiret.
-    """
-    labels = labels or {}
-    title_template = labels.get(
-        "pipeline_ranking_title", "Classement par {label}",
-    )
-    title = title_template.format(label=ranking_spec.display_label)
-    rank_label = labels.get("pipeline_rank_label", "Rang")
-    name_label = labels.get("pipeline_name_label", "Pipeline")
-    value_label = labels.get("pipeline_value_label", "Valeur")
-
-    ranked = comparison.ranking_by_final_metric(
-        ranking_spec.artifact_type,
-        ranking_spec.metric_name,
-        higher_is_better=ranking_spec.higher_is_better,
-    )
-    if not ranked:
-        return ""
-
-    n_with_value = sum(1 for _name, v in ranked if v is not None)
-
-    parts = [
-        '<div class="pipeline-ranking" style="margin:1rem 0">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-        '<table style="border-collapse:collapse;font-size:.85rem">',
-        '<thead><tr>',
-    ]
-    for col in (rank_label, name_label, value_label):
-        parts.append(
-            f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
-            f'border-bottom:1px solid #ccc;font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append("</tr></thead><tbody>")
-
-    rank = 0
-    for name, value in ranked:
-        if value is None:
-            rank_str = "—"
-            value_str = "—"
-            rank_color = "#f0f0f0"
-        else:
-            rank += 1
-            rank_str = str(rank)
-            value_str = f"{value:.4f}"
-            rank_color = _bg_for_rank(rank, n_with_value)
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.3rem .5rem;text-align:center;'
-            f'background:{rank_color};font-weight:600">{rank_str}</td>'
-            f'<td style="padding:.3rem .5rem">{_e(name)}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right;'
-            f'font-family:monospace">{value_str}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table></div>")
-    return "".join(parts)
-
-
-def build_pipeline_gain_table_html(
-    comparison: PipelineComparisonResult,
-    ranking_spec: RankingSpec,
-    baseline_pipeline: str,
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Tableau gain vs baseline pour une métrique donnée.
-
-    Colonnes : pipeline, valeur, gain absolu, gain relatif.  La
-    baseline est marquée explicitement (cellule grisée).
-    Convention de couleur : vert si gain favorable selon
-    ``higher_is_better``, rouge sinon.
-    """
-    labels = labels or {}
-    title_template = labels.get(
-        "pipeline_gain_title", "Gain vs {baseline} sur {label}",
-    )
-    title = title_template.format(
-        baseline=baseline_pipeline,
-        label=ranking_spec.display_label,
-    )
-    name_label = labels.get("pipeline_name_label", "Pipeline")
-    value_label = labels.get("pipeline_value_label", "Valeur")
-    abs_label = labels.get("pipeline_gain_absolute_label", "Gain absolu")
-    rel_label = labels.get("pipeline_gain_relative_label", "Gain relatif")
-    baseline_label = labels.get(
-        "pipeline_baseline_marker", "(référence)",
-    )
-
-    try:
-        gains = comparison.gain_table(
-            ranking_spec.artifact_type,
-            ranking_spec.metric_name,
-            baseline_pipeline,
-        )
-    except KeyError:
-        return ""
-
-    parts = [
-        '<div class="pipeline-gain" style="margin:1rem 0">',
-        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
-        '<table style="border-collapse:collapse;font-size:.85rem">',
-        '<thead><tr>',
-    ]
-    for col in (name_label, value_label, abs_label, rel_label):
-        parts.append(
-            f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
-            f'border-bottom:1px solid #ccc;font-weight:600">'
-            f'{_e(col)}</th>'
-        )
-    parts.append("</tr></thead><tbody>")
-
-    for name, g in gains.items():
-        is_baseline = name == baseline_pipeline
-        value = g["value"]
-        absolute = g["absolute"]
-        relative = g["relative"]
-        # Formatage des cellules
-        value_str = "—" if value is None else f"{value:.4f}"
-        abs_str = "—" if absolute is None else f"{absolute:+.4f}"
-        rel_str = "—" if relative is None else f"{relative * 100:+.1f}%"
-        # Couleur du gain : vert si favorable, rouge sinon, gris pour
-        # la baseline.
-        if is_baseline:
-            gain_color = "#f0f0f0"
-        elif absolute is None or absolute == 0:
-            gain_color = "#f0f0f0"
-        else:
-            favorable = (
-                absolute > 0 if ranking_spec.higher_is_better else absolute < 0
-            )
-            gain_color = "#cfe8cf" if favorable else "#f4cfcf"
-        # Marqueur baseline
-        name_cell = _e(name)
-        if is_baseline:
-            name_cell += (
-                f' <span style="opacity:.6;font-size:.85em">'
-                f'{_e(baseline_label)}</span>'
-            )
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.3rem .5rem;font-weight:500">{name_cell}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right;'
-            f'font-family:monospace">{value_str}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right;'
-            f'font-family:monospace;background:{gain_color}">{abs_str}</td>'
-            f'<td style="padding:.3rem .5rem;text-align:right;'
-            f'font-family:monospace;background:{gain_color}">{rel_str}</td>'
-            f'</tr>'
-        )
-    parts.append("</tbody></table></div>")
-    return "".join(parts)
-
-
-def build_pipeline_comparison_summary_html(
-    comparison: PipelineComparisonResult,
-    labels: Optional[dict[str, str]] = None,
-) -> str:
-    """Encart de résumé global d'une comparaison de pipelines.
-
-    Affiche corpus, n_docs, durée totale, nombre de pipelines, et
-    pour chacune un mini-résumé n_succeeded / n_docs.
-    """
-    labels = labels or {}
-    title = labels.get(
-        "pipeline_comparison_summary_title", "Résumé de la comparaison",
-    )
-    corpus_label = labels.get("pipeline_corpus_label", "Corpus")
-    n_docs_label = labels.get("pipeline_n_docs_label", "Documents")
-    n_pipelines_label = labels.get(
-        "pipeline_n_pipelines_label", "Pipelines comparées",
-    )
-    duration_label = labels.get("pipeline_duration_label", "Durée totale")
-
-    parts = [
-        '<div class="pipeline-comparison-summary" '
-        'style="margin:1rem 0;padding:.75rem;'
-        'background:var(--bg-secondary,#f7f7f7);border-radius:6px">',
-        f'<div style="font-weight:600;margin-bottom:.5rem">{_e(title)}</div>',
-        '<table style="border-collapse:collapse;font-size:.9rem">',
-    ]
-    rows = [
-        (corpus_label, _e(comparison.corpus_name)),
-        (n_docs_label, str(comparison.n_docs)),
-        (n_pipelines_label, str(len(comparison.per_pipeline))),
-        (duration_label, _e(_format_duration(comparison.total_duration_seconds))),
-    ]
-    for label, value in rows:
-        parts.append(
-            f'<tr>'
-            f'<td style="padding:.2rem .5rem;font-weight:500;color:#555">'
-            f'{_e(label)}</td>'
-            f'<td style="padding:.2rem .5rem">{value}</td>'
-            f'</tr>'
-        )
-    parts.append("</table>")
-    # Mini-résumé par pipeline
-    if comparison.per_pipeline:
-        per_pipeline_label = labels.get(
-            "pipeline_per_pipeline_label", "Par pipeline",
-        )
-        parts.append(
-            f'<div style="margin-top:.6rem;font-size:.85rem">'
-            f'<span style="font-weight:500;color:#555">'
-            f'{_e(per_pipeline_label)} :</span>'
-        )
-        items: list[str] = []
-        for name, bench in comparison.per_pipeline.items():
-            items.append(
-                f'<code>{_e(name)}</code> '
-                f'({bench.n_pipelines_succeeded}/{bench.n_docs})'
-            )
-        parts.append(" — ".join(items))
-        parts.append("</div>")
-    parts.append("</div>")
-    return "".join(parts)
-
-
-def build_pipeline_comparison_report_html(
-    comparison: PipelineComparisonResult,
-    ranking_specs: Optional[list[RankingSpec]] = None,
-    baseline_pipeline: Optional[str] = None,
-    labels: Optional[dict[str, str]] = None,
-    lang: str = "fr",
-) -> str:
-    """Document HTML autonome pour une comparaison de N pipelines.
-
-    Parameters
-    ----------
-    comparison:
-        Résultat de ``compare_pipelines`` (Sprint 65).
-    ranking_specs:
-        Liste explicite des classements à afficher.  Pour chaque
-        spec, on rend un tableau de classement et, si
-        ``baseline_pipeline`` est fourni, un tableau de gain.
-        Si ``None`` ou vide, on affiche uniquement le résumé
-        global et les résumés par pipeline (sans verdict).
-    baseline_pipeline:
-        Pipeline de référence pour les tableaux de gain.  Si
-        ``None``, les tableaux de gain ne sont pas affichés.
-    labels:
-        Map i18n.
-    lang:
-        Code langue pour ``<html lang="…">``.
-
-    Returns
-    -------
-    str
-        Document HTML complet (``<!doctype html>`` + ``<html>``).
-    """
-    labels = labels or {}
-    main_title = labels.get(
-        "pipeline_comparison_report_title",
-        "Rapport de comparaison de pipelines",
-    )
-    note = labels.get(
-        "pipeline_comparison_report_note",
-        "Données comparatives brutes. L'outil mesure et classe — il "
-        "ne tranche pas le débat éditorial. C'est au chercheur de "
-        "lire les chiffres et de conclure selon ses critères.",
-    )
-    title_text = f"{main_title} — {comparison.corpus_name}"
-    summary = build_pipeline_comparison_summary_html(comparison, labels)
-
-    rankings_html: list[str] = []
-    for spec in (ranking_specs or []):
-        rankings_html.append(
-            build_pipeline_ranking_table_html(comparison, spec, labels),
-        )
-        if baseline_pipeline is not None:
-            rankings_html.append(
-                build_pipeline_gain_table_html(
-                    comparison, spec, baseline_pipeline, labels,
-                ),
-            )
-
-    parts = [
-        "<!doctype html>",
-        f'<html lang="{_e(lang)}">',
-        "<head>",
-        '<meta charset="utf-8">',
-        '<meta name="viewport" content="width=device-width,initial-scale=1">',
-        f"<title>{_e(title_text)}</title>",
-        "<style>", _DOC_STYLES, "</style>",
-        "</head>",
-        "<body>",
-        "<header>",
-        f"<h1>{_e(title_text)}</h1>",
-        f'<div class="subtitle">{len(comparison.per_pipeline)} '
-        f'{_e(labels.get("pipeline_n_pipelines_short", "pipelines"))} '
-        f'— {comparison.n_docs} '
-        f'{_e(labels.get("pipeline_docs_short", "docs"))}'
-        f'</div>',
-        "</header>",
-        "<main>",
-        f'<p class="note">{_e(note)}</p>',
-        summary,
-    ]
-    parts.extend(rankings_html)
-    parts.extend([
-        "</main>",
-        "</body>",
-        "</html>",
-    ])
-    return "".join(parts)
+import warnings
 
+from picarones.reports_v2.html.renderers.pipeline import *  # noqa: F401, F403
 
-__all__ = [
-    "build_pipeline_summary_html",
-    "build_pipeline_steps_table_html",
-    "build_pipeline_report_html",
-    "RankingSpec",
-    "build_pipeline_ranking_table_html",
-    "build_pipeline_gain_table_html",
-    "build_pipeline_comparison_summary_html",
-    "build_pipeline_comparison_report_html",
-]
+warnings.warn(
+    "picarones.report.pipeline_render is deprecated and will be removed in 2.0.  "
+    "Import from picarones.reports_v2.html.renderers.pipeline instead.",
+    DeprecationWarning,
+    stacklevel=2,
+)

picarones/report/views/pipeline.py

@@ -101,7 +101,7 @@ def build_pipeline_view_html(
     # Sous-section 1 : résumé + steps table
     if pipeline_benchmark is not None:
         try:
-            from picarones.report.pipeline_render import (
+            from picarones.reports_v2.html.renderers.pipeline import (
                 build_pipeline_steps_table_html,
                 build_pipeline_summary_html,
             )

picarones/reports_v2/html/renderers/numerical_sequences.py

@@ -0,0 +1,155 @@
+"""Rendu HTML « Précision sur séquences numériques » — Sprint 86.
+
+Phase 5.C.batch7 — module relocalisé depuis
+``picarones.report.numerical_sequences_render`` vers
+``picarones.reports_v2.html.renderers.numerical_sequences``.
+Le chemin legacy reste disponible via un shim avec
+``DeprecationWarning`` ; suppression prévue en 2.0.
+
+Suite directe ``picarones/core/numerical_sequences.py``
+(Sprint 85) + câblage runner Sprint 86.
+
+Pattern identique aux autres rendus : server-side, pas de JS,
+anti-injection systématique.
+
+Vue
+---
+Tableau moteur × catégorie (year / roman / foliation / currency
+/ regnal) × score strict ; une ligne par moteur, une cellule
+colorée par cellule.  Une seconde ligne donne le score ``value``
+(en plus petit).  Catégorie omise si **aucun** moteur n'a de
+GT exploitable pour elle.
+
+Adaptative : ``""`` si aucun moteur n'a de
+``aggregated_numerical_sequences``.
+"""
+
+from __future__ import annotations
+
+from html import escape as _e
+from typing import Optional
+
+from picarones.evaluation.metrics.numerical_sequences import CATEGORIES
+from picarones.reports_v2._helpers.render_helpers import color_traffic_light
+
+
+def _category_columns_with_signal(rows: list[dict]) -> list[str]:
+    """Ne garde que les catégories où ≥ 1 moteur a un n_total > 0."""
+    visible: list[str] = []
+    for cat in CATEGORIES:
+        for r in rows:
+            agg = r.get("aggregated_numerical_sequences") or {}
+            cat_data = (agg.get("per_category") or {}).get(cat) or {}
+            if (cat_data.get("n_total") or 0) > 0:
+                visible.append(cat)
+                break
+    return visible
+
+
+def build_numerical_sequences_html(
+    engines: list[dict],
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit la section HTML séquences numériques.
+
+    Returns
+    -------
+    str
+        ``""`` si aucun moteur n'a de signal.
+    """
+    rows = [
+        e for e in engines
+        if isinstance(e.get("aggregated_numerical_sequences"), dict)
+    ]
+    if not rows:
+        return ""
+    visible_cats = _category_columns_with_signal(rows)
+    if not visible_cats:
+        return ""
+    labels = labels or {}
+    title = labels.get(
+        "numseq_title", "Précision sur séquences numériques",
+    )
+    note = labels.get(
+        "numseq_note",
+        "Score strict (forme préservée) — la valeur entre "
+        "parenthèses est le score sur la valeur (XIV ↔ 14 "
+        "accepté). Foliotation : recto/verso non interchangeables.",
+    )
+    col_engine = labels.get("numseq_engine", "Moteur")
+    col_global = labels.get("numseq_global", "Global")
+    cat_label = {
+        "year": labels.get("numseq_cat_year", "Année"),
+        "roman": labels.get("numseq_cat_roman", "Romain"),
+        "foliation": labels.get("numseq_cat_foliation", "Foliation"),
+        "currency": labels.get("numseq_cat_currency", "Montant"),
+        "regnal": labels.get("numseq_cat_regnal", "Régnal"),
+    }
+
+    parts = [
+        '<div class="numseq-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>',
+        '<table style="border-collapse:collapse;width:100%;'
+        'font-size:.9rem">',
+        '<thead><tr>',
+        f'<th scope=\"col\" style="padding:.4rem .6rem;text-align:left;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(col_engine)}</th>',
+        f'<th scope=\"col\" style="padding:.4rem .6rem;text-align:right;'
+        f'border-bottom:1px solid #ccc;font-weight:600">'
+        f'{_e(col_global)}</th>',
+    ]
+    for cat in visible_cats:
+        parts.append(
+            f'<th scope=\"col\" style="padding:.4rem .6rem;text-align:right;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(cat_label.get(cat, cat))}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+
+    for engine in rows:
+        agg = engine["aggregated_numerical_sequences"]
+        name = engine.get("name") or "?"
+        per_cat = agg.get("per_category") or {}
+        global_strict = float(agg.get("global_strict_score") or 0.0)
+        global_value = float(agg.get("global_value_score") or 0.0)
+        n_total = int(agg.get("n_total") or 0)
+        global_color = color_traffic_light(global_strict)
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.4rem .6rem">{_e(str(name))}</td>'
+            f'<td style="padding:.4rem .6rem;text-align:right;'
+            f'background:{global_color};font-family:monospace;'
+            f'font-weight:600">'
+            f'{global_strict * 100:.1f}%'
+            f'<span style="font-size:.75rem;font-weight:400;'
+            f'opacity:.75"> ({global_value * 100:.0f}%, '
+            f'n={n_total})</span></td>'
+        )
+        for cat in visible_cats:
+            cat_data = per_cat.get(cat) or {}
+            n = int(cat_data.get("n_total") or 0)
+            if n == 0:
+                parts.append(
+                    '<td style="padding:.4rem .6rem;text-align:right;'
+                    'opacity:.4">—</td>'
+                )
+                continue
+            strict = float(cat_data.get("strict_score") or 0.0)
+            value = float(cat_data.get("value_score") or 0.0)
+            color = color_traffic_light(strict)
+            parts.append(
+                f'<td style="padding:.4rem .6rem;text-align:right;'
+                f'background:{color};font-family:monospace">'
+                f'{strict * 100:.0f}%'
+                f'<span style="font-size:.75rem;opacity:.75"> '
+                f'({value * 100:.0f}%, n={n})</span></td>'
+            )
+        parts.append("</tr>")
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+__all__ = ["build_numerical_sequences_html"]

picarones/reports_v2/html/renderers/pipeline.py

@@ -0,0 +1,713 @@
+"""Rendu HTML server-side d'un benchmark de pipeline composée
+(Sprint 67).
+
+Phase 5.C.batch7 — module relocalisé depuis
+``picarones.report.pipeline_render`` vers
+``picarones.reports_v2.html.renderers.pipeline``.  Le chemin legacy
+reste disponible via un shim avec ``DeprecationWarning`` ;
+suppression prévue en 2.0.
+
+Suite directe Sprints 63-66 (axe B) — produit les blocs HTML qui
+exposent le résultat d'une pipeline composée.
+
+Pattern identique aux Sprints 41 (NER), 43 (calibration) et 62
+(philologie) : rendu **server-side**, pas de JavaScript,
+déterministe, anti-injection systématique via ``html.escape``.
+
+Vue distincte du rapport OCR historique
+---------------------------------------
+Le rapport HTML OCR (``picarones/report/generator.py``) attend un
+``BenchmarkResult`` (axe A).  Pour les pipelines composées, on
+travaille avec ``PipelineBenchmarkResult`` (axe B, Sprint 64).
+
+Ce module fournit donc un rapport **autonome** : la fonction
+``build_pipeline_report_html`` produit un document HTML complet
+(``<!doctype html>...``) que l'utilisateur peut écrire directement
+sur disque, sans dépendre du générateur OCR.
+
+Sprint 67 — périmètre
+---------------------
+Inclus :
+
+- ``build_pipeline_summary_html(bench)`` — encart résumé global
+  (corpus, n_docs, taux de succès, durée totale).
+- ``build_pipeline_steps_table_html(bench)`` — tableau par étape
+  (durée mean/median, n_succeeded/failed, error_breakdown,
+  métriques aux jonctions).
+- ``build_pipeline_report_html(bench, lang)`` — document HTML
+  complet à sauver sur disque.
+
+Reporté à Sprint 68 :
+
+- Rendu d'un ``PipelineComparisonResult`` (ranking entre N
+  pipelines + gain table).
+
+Toujours pas de classification automatique
+------------------------------------------
+On affiche les chiffres bruts ; le chercheur lit et conclut.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from html import escape as _e
+from typing import Optional
+
+from picarones.domain.artifacts import ArtifactType
+from picarones.evaluation.pipeline_benchmark import PipelineBenchmarkResult
+from picarones.evaluation.pipeline_comparison import PipelineComparisonResult
+from picarones.reports_v2._helpers.render_helpers import color_traffic_light
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Helpers communs
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def _format_duration(seconds: float) -> str:
+    """Formate une durée en ms si < 1s, en s sinon."""
+    if seconds < 1.0:
+        return f"{seconds * 1000:.1f} ms"
+    if seconds < 60.0:
+        return f"{seconds:.2f} s"
+    minutes = int(seconds // 60)
+    rest = seconds - minutes * 60
+    return f"{minutes}min {rest:.1f}s"
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Encart résumé corpus-wide
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_pipeline_summary_html(
+    bench: PipelineBenchmarkResult,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit l'encart résumé global du benchmark."""
+    labels = labels or {}
+    title = labels.get("pipeline_summary_title", "Résumé du benchmark")
+    pipeline_label = labels.get("pipeline_name_label", "Pipeline")
+    corpus_label = labels.get("pipeline_corpus_label", "Corpus")
+    n_docs_label = labels.get("pipeline_n_docs_label", "Documents")
+    succeeded_label = labels.get(
+        "pipeline_succeeded_label", "Pipelines réussies",
+    )
+    failed_label = labels.get("pipeline_failed_label", "Pipelines échouées")
+    duration_label = labels.get("pipeline_duration_label", "Durée totale")
+
+    success = bench.n_pipelines_succeeded
+    failed = bench.n_pipelines_failed
+    total = bench.n_docs
+    rate = success / total if total > 0 else 0.0
+    color = color_traffic_light(rate)
+
+    parts = [
+        '<div class="pipeline-summary" '
+        'style="margin:1rem 0;padding:.75rem;'
+        'background:var(--bg-secondary,#f7f7f7);border-radius:6px">',
+        f'<div style="font-weight:600;margin-bottom:.5rem">{_e(title)}</div>',
+        '<table style="border-collapse:collapse;font-size:.9rem">',
+    ]
+    rows = [
+        (pipeline_label, _e(bench.pipeline_name)),
+        (corpus_label, _e(bench.corpus_name)),
+        (n_docs_label, str(total)),
+        (
+            succeeded_label,
+            f'<span style="background:{color};padding:.1rem .4rem;'
+            f'border-radius:3px">{success} / {total}</span>',
+        ),
+        (failed_label, str(failed)),
+        (duration_label, _e(_format_duration(bench.total_duration_seconds))),
+    ]
+    for label, value in rows:
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.2rem .5rem;font-weight:500;'
+            f'color:#555">{_e(label)}</td>'
+            f'<td style="padding:.2rem .5rem">{value}</td>'
+            f'</tr>'
+        )
+    parts.append("</table></div>")
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Tableau par étape
+# ──────────────────────────────────────────────────────────────────────────
+
+
+def build_pipeline_steps_table_html(
+    bench: PipelineBenchmarkResult,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Construit le tableau par étape de la pipeline.
+
+    Colonnes : nom de l'étape, n_succeeded, n_failed, taux de
+    succès (cellule colorée), durée mean/median, métriques aux
+    jonctions (mean) regroupées par type, error_breakdown
+    catégorisé.
+    """
+    if not bench.per_step_aggregates:
+        return ""
+    labels = labels or {}
+    title = labels.get("pipeline_steps_title", "Détail par étape")
+    name_label = labels.get("pipeline_step_name_label", "Étape")
+    succ_label = labels.get("pipeline_succeeded_label", "Réussies")
+    fail_label = labels.get("pipeline_failed_label", "Échouées")
+    rate_label = labels.get("pipeline_success_rate_label", "Taux succès")
+    dmean_label = labels.get("pipeline_duration_mean_label", "Durée moyenne")
+    dmedian_label = labels.get(
+        "pipeline_duration_median_label", "Durée médiane",
+    )
+    metrics_label = labels.get(
+        "pipeline_junction_metrics_label", "Métriques aux jonctions",
+    )
+    errors_label = labels.get("pipeline_error_breakdown_label", "Erreurs")
+
+    parts = [
+        '<div class="pipeline-steps" style="margin:1rem 0">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        '<table style="border-collapse:collapse;font-size:.85rem;'
+        'width:100%">',
+        '<thead><tr>',
+    ]
+    for col in (
+        name_label, succ_label, fail_label, rate_label,
+        dmean_label, dmedian_label, metrics_label, errors_label,
+    ):
+        parts.append(
+            f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+
+    for agg in bench.per_step_aggregates:
+        rate = agg.success_rate
+        rate_color = color_traffic_light(rate)
+        # Métriques aux jonctions : pour chaque type d'artefact,
+        # liste des métriques mean
+        metrics_cells: list[str] = []
+        for at_value, type_metrics in sorted(agg.junction_metrics.items()):
+            type_str = _e(at_value)
+            for mname, stats in sorted(type_metrics.items()):
+                mean = stats["mean"]
+                n = stats["n"]
+                metrics_cells.append(
+                    f'<div style="font-size:.8rem;line-height:1.3">'
+                    f'<code>{type_str}.{_e(mname)}</code>: '
+                    f'{mean:.3f} '
+                    f'<span style="opacity:.6">(n={n})</span></div>'
+                )
+        metrics_html = "".join(metrics_cells) or (
+            '<span style="opacity:.5">—</span>'
+        )
+        # Error breakdown
+        err_cells: list[str] = []
+        for label, count in sorted(agg.error_breakdown.items()):
+            err_cells.append(
+                f'<div style="font-size:.8rem;line-height:1.3">'
+                f'<code>{_e(label)}</code>: {count}</div>'
+            )
+        err_html = "".join(err_cells) or (
+            '<span style="opacity:.5">—</span>'
+        )
+
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.3rem .5rem;font-weight:500">'
+            f'{_e(agg.step_name)}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right">'
+            f'{agg.n_succeeded}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right">'
+            f'{agg.n_failed}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:center;'
+            f'background:{rate_color}">{rate * 100:.0f}%</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right">'
+            f'{_e(_format_duration(agg.duration_seconds_mean))}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right">'
+            f'{_e(_format_duration(agg.duration_seconds_median))}</td>'
+            f'<td style="padding:.3rem .5rem">{metrics_html}</td>'
+            f'<td style="padding:.3rem .5rem">{err_html}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Document HTML autonome
+# ──────────────────────────────────────────────────────────────────────────
+
+
+_DOC_STYLES = """
+:root {
+  --bg-primary: #ffffff;
+  --bg-secondary: #f7f7f7;
+  --text-primary: #222;
+  --text-muted: #666;
+  --border: #ddd;
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  line-height: 1.5;
+}
+header {
+  padding: 1.5rem 2rem;
+  border-bottom: 1px solid var(--border);
+}
+header h1 { margin: 0 0 .3rem 0; font-size: 1.4rem; }
+header .subtitle { color: var(--text-muted); font-size: .9rem; }
+main { padding: 1rem 2rem 3rem 2rem; max-width: 1400px; margin: 0 auto; }
+table { border: 1px solid var(--border); }
+code { background: #f0f0f0; padding: 0 .2rem; border-radius: 2px; font-size: .85em; }
+.note {
+  font-size: .85rem;
+  color: var(--text-muted);
+  font-style: italic;
+  margin: .5rem 0 1.5rem 0;
+}
+"""
+
+
+def build_pipeline_report_html(
+    bench: PipelineBenchmarkResult,
+    labels: Optional[dict[str, str]] = None,
+    lang: str = "fr",
+) -> str:
+    """Construit un document HTML autonome pour un benchmark de
+    pipeline composée.
+
+    Le document est complet (``<!doctype html>...``) et peut être
+    sauvé directement sur disque par l'utilisateur :
+
+    >>> html = build_pipeline_report_html(bench)
+    >>> Path("rapport_pipeline.html").write_text(html)
+    """
+    labels = labels or {}
+    main_title = labels.get(
+        "pipeline_report_title", "Rapport de pipeline composée",
+    )
+    note = labels.get(
+        "pipeline_report_note",
+        "Données brutes par étape. L'outil mesure et agrège — il "
+        "ne classe pas la pipeline « bonne » ou « mauvaise ». "
+        "C'est au chercheur de juger les chiffres selon ses critères.",
+    )
+    summary = build_pipeline_summary_html(bench, labels)
+    steps = build_pipeline_steps_table_html(bench, labels)
+
+    title_text = f"{main_title} — {bench.pipeline_name}"
+    parts = [
+        "<!doctype html>",
+        f'<html lang="{_e(lang)}">',
+        "<head>",
+        '<meta charset="utf-8">',
+        '<meta name="viewport" content="width=device-width,initial-scale=1">',
+        f"<title>{_e(title_text)}</title>",
+        "<style>", _DOC_STYLES, "</style>",
+        "</head>",
+        "<body>",
+        "<header>",
+        f"<h1>{_e(title_text)}</h1>",
+        f'<div class="subtitle">{_e(bench.corpus_name)} — '
+        f'{bench.n_docs} {_e(labels.get("pipeline_docs_short", "docs"))}'
+        f'</div>',
+        "</header>",
+        "<main>",
+        f'<p class="note">{_e(note)}</p>',
+        summary,
+        steps,
+        "</main>",
+        "</body>",
+        "</html>",
+    ]
+    return "".join(parts)
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# Sprint 68 — comparaison de N pipelines : ranking + gain table
+# ──────────────────────────────────────────────────────────────────────────
+
+
+@dataclass
+class RankingSpec:
+    """Spec d'un classement à afficher.
+
+    Décrit la jonction (``artifact_type``) et la métrique
+    (``metric_name``) à utiliser pour classer les pipelines.
+
+    Attributs
+    ---------
+    artifact_type:
+        Type d'artefact où la métrique est calculée (typiquement
+        ``ArtifactType.TEXT`` pour des métriques OCR).
+    metric_name:
+        Nom de la métrique dans le registre typé Sprint 34
+        (``"cer"``, ``"wer"``, ``"flesch_delta_fr"``, etc.).
+    higher_is_better:
+        ``False`` (défaut) pour les métriques d'erreur (CER, WER) ;
+        ``True`` pour les métriques de qualité (accuracy, F1,
+        coverage…).
+    label:
+        Libellé optionnel à afficher dans le tableau ; sinon
+        construit comme ``"<artifact_type>.<metric_name>"``.
+    """
+
+    artifact_type: ArtifactType
+    metric_name: str
+    higher_is_better: bool = False
+    label: Optional[str] = None
+
+    @property
+    def display_label(self) -> str:
+        if self.label:
+            return self.label
+        return f"{self.artifact_type.value}.{self.metric_name}"
+
+
+def _bg_for_rank(rank: int, total: int) -> str:
+    """Gradient vert (rang 1) → rouge (dernier rang).
+
+    Mapping : ``rank ∈ [1, total]`` → ``color_traffic_light`` avec
+    ``low_is_good=True`` (rang bas = bon).
+    """
+    if total <= 1:
+        return color_traffic_light(1.0)
+    return color_traffic_light(
+        float(rank), low_is_good=True, scale_min=1.0, scale_max=float(total),
+    )
+
+
+def build_pipeline_ranking_table_html(
+    comparison: PipelineComparisonResult,
+    ranking_spec: RankingSpec,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Tableau de classement des pipelines selon une métrique finale.
+
+    Colonnes : rang, nom du pipeline, valeur de la métrique (mean
+    sur le corpus à la dernière jonction qui produit
+    ``artifact_type``).  Les pipelines sans valeur sont listés en
+    queue avec un tiret.
+    """
+    labels = labels or {}
+    title_template = labels.get(
+        "pipeline_ranking_title", "Classement par {label}",
+    )
+    title = title_template.format(label=ranking_spec.display_label)
+    rank_label = labels.get("pipeline_rank_label", "Rang")
+    name_label = labels.get("pipeline_name_label", "Pipeline")
+    value_label = labels.get("pipeline_value_label", "Valeur")
+
+    ranked = comparison.ranking_by_final_metric(
+        ranking_spec.artifact_type,
+        ranking_spec.metric_name,
+        higher_is_better=ranking_spec.higher_is_better,
+    )
+    if not ranked:
+        return ""
+
+    n_with_value = sum(1 for _name, v in ranked if v is not None)
+
+    parts = [
+        '<div class="pipeline-ranking" style="margin:1rem 0">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        '<table style="border-collapse:collapse;font-size:.85rem">',
+        '<thead><tr>',
+    ]
+    for col in (rank_label, name_label, value_label):
+        parts.append(
+            f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+
+    rank = 0
+    for name, value in ranked:
+        if value is None:
+            rank_str = "—"
+            value_str = "—"
+            rank_color = "#f0f0f0"
+        else:
+            rank += 1
+            rank_str = str(rank)
+            value_str = f"{value:.4f}"
+            rank_color = _bg_for_rank(rank, n_with_value)
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.3rem .5rem;text-align:center;'
+            f'background:{rank_color};font-weight:600">{rank_str}</td>'
+            f'<td style="padding:.3rem .5rem">{_e(name)}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'font-family:monospace">{value_str}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+def build_pipeline_gain_table_html(
+    comparison: PipelineComparisonResult,
+    ranking_spec: RankingSpec,
+    baseline_pipeline: str,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Tableau gain vs baseline pour une métrique donnée.
+
+    Colonnes : pipeline, valeur, gain absolu, gain relatif.  La
+    baseline est marquée explicitement (cellule grisée).
+    Convention de couleur : vert si gain favorable selon
+    ``higher_is_better``, rouge sinon.
+    """
+    labels = labels or {}
+    title_template = labels.get(
+        "pipeline_gain_title", "Gain vs {baseline} sur {label}",
+    )
+    title = title_template.format(
+        baseline=baseline_pipeline,
+        label=ranking_spec.display_label,
+    )
+    name_label = labels.get("pipeline_name_label", "Pipeline")
+    value_label = labels.get("pipeline_value_label", "Valeur")
+    abs_label = labels.get("pipeline_gain_absolute_label", "Gain absolu")
+    rel_label = labels.get("pipeline_gain_relative_label", "Gain relatif")
+    baseline_label = labels.get(
+        "pipeline_baseline_marker", "(référence)",
+    )
+
+    try:
+        gains = comparison.gain_table(
+            ranking_spec.artifact_type,
+            ranking_spec.metric_name,
+            baseline_pipeline,
+        )
+    except KeyError:
+        return ""
+
+    parts = [
+        '<div class="pipeline-gain" style="margin:1rem 0">',
+        f'<div style="font-weight:600;margin-bottom:.4rem">{_e(title)}</div>',
+        '<table style="border-collapse:collapse;font-size:.85rem">',
+        '<thead><tr>',
+    ]
+    for col in (name_label, value_label, abs_label, rel_label):
+        parts.append(
+            f'<th scope=\"col\" style="padding:.3rem .5rem;text-align:left;'
+            f'border-bottom:1px solid #ccc;font-weight:600">'
+            f'{_e(col)}</th>'
+        )
+    parts.append("</tr></thead><tbody>")
+
+    for name, g in gains.items():
+        is_baseline = name == baseline_pipeline
+        value = g["value"]
+        absolute = g["absolute"]
+        relative = g["relative"]
+        # Formatage des cellules
+        value_str = "—" if value is None else f"{value:.4f}"
+        abs_str = "—" if absolute is None else f"{absolute:+.4f}"
+        rel_str = "—" if relative is None else f"{relative * 100:+.1f}%"
+        # Couleur du gain : vert si favorable, rouge sinon, gris pour
+        # la baseline.
+        if is_baseline:
+            gain_color = "#f0f0f0"
+        elif absolute is None or absolute == 0:
+            gain_color = "#f0f0f0"
+        else:
+            favorable = (
+                absolute > 0 if ranking_spec.higher_is_better else absolute < 0
+            )
+            gain_color = "#cfe8cf" if favorable else "#f4cfcf"
+        # Marqueur baseline
+        name_cell = _e(name)
+        if is_baseline:
+            name_cell += (
+                f' <span style="opacity:.6;font-size:.85em">'
+                f'{_e(baseline_label)}</span>'
+            )
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.3rem .5rem;font-weight:500">{name_cell}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'font-family:monospace">{value_str}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'font-family:monospace;background:{gain_color}">{abs_str}</td>'
+            f'<td style="padding:.3rem .5rem;text-align:right;'
+            f'font-family:monospace;background:{gain_color}">{rel_str}</td>'
+            f'</tr>'
+        )
+    parts.append("</tbody></table></div>")
+    return "".join(parts)
+
+
+def build_pipeline_comparison_summary_html(
+    comparison: PipelineComparisonResult,
+    labels: Optional[dict[str, str]] = None,
+) -> str:
+    """Encart de résumé global d'une comparaison de pipelines.
+
+    Affiche corpus, n_docs, durée totale, nombre de pipelines, et
+    pour chacune un mini-résumé n_succeeded / n_docs.
+    """
+    labels = labels or {}
+    title = labels.get(
+        "pipeline_comparison_summary_title", "Résumé de la comparaison",
+    )
+    corpus_label = labels.get("pipeline_corpus_label", "Corpus")
+    n_docs_label = labels.get("pipeline_n_docs_label", "Documents")
+    n_pipelines_label = labels.get(
+        "pipeline_n_pipelines_label", "Pipelines comparées",
+    )
+    duration_label = labels.get("pipeline_duration_label", "Durée totale")
+
+    parts = [
+        '<div class="pipeline-comparison-summary" '
+        'style="margin:1rem 0;padding:.75rem;'
+        'background:var(--bg-secondary,#f7f7f7);border-radius:6px">',
+        f'<div style="font-weight:600;margin-bottom:.5rem">{_e(title)}</div>',
+        '<table style="border-collapse:collapse;font-size:.9rem">',
+    ]
+    rows = [
+        (corpus_label, _e(comparison.corpus_name)),
+        (n_docs_label, str(comparison.n_docs)),
+        (n_pipelines_label, str(len(comparison.per_pipeline))),
+        (duration_label, _e(_format_duration(comparison.total_duration_seconds))),
+    ]
+    for label, value in rows:
+        parts.append(
+            f'<tr>'
+            f'<td style="padding:.2rem .5rem;font-weight:500;color:#555">'
+            f'{_e(label)}</td>'
+            f'<td style="padding:.2rem .5rem">{value}</td>'
+            f'</tr>'
+        )
+    parts.append("</table>")
+    # Mini-résumé par pipeline
+    if comparison.per_pipeline:
+        per_pipeline_label = labels.get(
+            "pipeline_per_pipeline_label", "Par pipeline",
+        )
+        parts.append(
+            f'<div style="margin-top:.6rem;font-size:.85rem">'
+            f'<span style="font-weight:500;color:#555">'
+            f'{_e(per_pipeline_label)} :</span>'
+        )
+        items: list[str] = []
+        for name, bench in comparison.per_pipeline.items():
+            items.append(
+                f'<code>{_e(name)}</code> '
+                f'({bench.n_pipelines_succeeded}/{bench.n_docs})'
+            )
+        parts.append(" — ".join(items))
+        parts.append("</div>")
+    parts.append("</div>")
+    return "".join(parts)
+
+
+def build_pipeline_comparison_report_html(
+    comparison: PipelineComparisonResult,
+    ranking_specs: Optional[list[RankingSpec]] = None,
+    baseline_pipeline: Optional[str] = None,
+    labels: Optional[dict[str, str]] = None,
+    lang: str = "fr",
+) -> str:
+    """Document HTML autonome pour une comparaison de N pipelines.
+
+    Parameters
+    ----------
+    comparison:
+        Résultat de ``compare_pipelines`` (Sprint 65).
+    ranking_specs:
+        Liste explicite des classements à afficher.  Pour chaque
+        spec, on rend un tableau de classement et, si
+        ``baseline_pipeline`` est fourni, un tableau de gain.
+        Si ``None`` ou vide, on affiche uniquement le résumé
+        global et les résumés par pipeline (sans verdict).
+    baseline_pipeline:
+        Pipeline de référence pour les tableaux de gain.  Si
+        ``None``, les tableaux de gain ne sont pas affichés.
+    labels:
+        Map i18n.
+    lang:
+        Code langue pour ``<html lang="…">``.
+
+    Returns
+    -------
+    str
+        Document HTML complet (``<!doctype html>`` + ``<html>``).
+    """
+    labels = labels or {}
+    main_title = labels.get(
+        "pipeline_comparison_report_title",
+        "Rapport de comparaison de pipelines",
+    )
+    note = labels.get(
+        "pipeline_comparison_report_note",
+        "Données comparatives brutes. L'outil mesure et classe — il "
+        "ne tranche pas le débat éditorial. C'est au chercheur de "
+        "lire les chiffres et de conclure selon ses critères.",
+    )
+    title_text = f"{main_title} — {comparison.corpus_name}"
+    summary = build_pipeline_comparison_summary_html(comparison, labels)
+
+    rankings_html: list[str] = []
+    for spec in (ranking_specs or []):
+        rankings_html.append(
+            build_pipeline_ranking_table_html(comparison, spec, labels),
+        )
+        if baseline_pipeline is not None:
+            rankings_html.append(
+                build_pipeline_gain_table_html(
+                    comparison, spec, baseline_pipeline, labels,
+                ),
+            )
+
+    parts = [
+        "<!doctype html>",
+        f'<html lang="{_e(lang)}">',
+        "<head>",
+        '<meta charset="utf-8">',
+        '<meta name="viewport" content="width=device-width,initial-scale=1">',
+        f"<title>{_e(title_text)}</title>",
+        "<style>", _DOC_STYLES, "</style>",
+        "</head>",
+        "<body>",
+        "<header>",
+        f"<h1>{_e(title_text)}</h1>",
+        f'<div class="subtitle">{len(comparison.per_pipeline)} '
+        f'{_e(labels.get("pipeline_n_pipelines_short", "pipelines"))} '
+        f'— {comparison.n_docs} '
+        f'{_e(labels.get("pipeline_docs_short", "docs"))}'
+        f'</div>',
+        "</header>",
+        "<main>",
+        f'<p class="note">{_e(note)}</p>',
+        summary,
+    ]
+    parts.extend(rankings_html)
+    parts.extend([
+        "</main>",
+        "</body>",
+        "</html>",
+    ])
+    return "".join(parts)
+
+
+__all__ = [
+    "build_pipeline_summary_html",
+    "build_pipeline_steps_table_html",
+    "build_pipeline_report_html",
+    "RankingSpec",
+    "build_pipeline_ranking_table_html",
+    "build_pipeline_gain_table_html",
+    "build_pipeline_comparison_summary_html",
+    "build_pipeline_comparison_report_html",
+]

tests/architecture/test_file_budgets.py

@@ -52,7 +52,9 @@ FILE_BUDGETS: dict[str, int] = {
     "picarones/report/generator.py": 500,                 # actuel 431
     # --- Fichiers métier larges.
     "picarones/measurements/robustness.py": 850,          # actuel 731
-    "picarones/report/pipeline_render.py": 815,           # actuel 707 (rétréci)
+    # Phase 5.C.batch7 : ``report/pipeline_render.py`` est désormais
+    # un shim ; canonique dans ``reports_v2/html/renderers/pipeline.py``.
+    "picarones/reports_v2/html/renderers/pipeline.py": 815,  # actuel 713
     # Phase 4-ter : ``core/results.py`` est désormais un shim
     # (≤ 25 l).  Le contenu canonique vit dans ``evaluation/`` ;
     # même budget pour la même raison historique (modèles
@@ -65,7 +67,9 @@ FILE_BUDGETS: dict[str, int] = {
     "picarones/measurements/history.py": 725,             # actuel 615
     "picarones/measurements/modern_archives.py": 700,     # actuel 599
     "picarones/measurements/builtin_hooks.py": 700,       # actuel 590
-    "picarones/core/pipeline.py": 675,                    # actuel 571
+    # Phase 5.C.batch7 : ``core/pipeline.py`` est désormais un shim ;
+    # canonique dans ``evaluation/pipeline.py``.
+    "picarones/evaluation/pipeline.py": 700,              # actuel 622
     "picarones/extras/importers/iiif.py": 675,            # actuel 567
     "picarones/extras/importers/gallica.py": 675,         # actuel 563
     "picarones/measurements/levers.py": 675,              # actuel 561 (re-export S10)
@@ -115,7 +119,10 @@ FILE_BUDGETS: dict[str, int] = {
     "picarones/evaluation/corpus.py": 600,                # actuel 533
     "picarones/fixtures.py": 600,                         # actuel 510
     "picarones/measurements/inter_engine.py": 575,        # actuel 484
-    "picarones/measurements/roman_numerals.py": 575,      # actuel 478
+    # Phase 5.C.batch7 : ``measurements/roman_numerals.py`` est
+    # désormais un shim ; canonique dans
+    # ``evaluation/metrics/roman_numerals.py``.
+    "picarones/evaluation/metrics/roman_numerals.py": 575,  # actuel 484
     "picarones/extras/importers/htr_united.py": 575,      # actuel 473 (re-export S11)
     # Sprint A14-S11 — d\xc3\xa9plac\xc3\xa9s depuis extras/importers/, l'ancien
     # emplacement est d\xc3\xa9sormais un re-export.
@@ -128,7 +135,10 @@ FILE_BUDGETS: dict[str, int] = {
     # même budget pour la même raison historique (centralise les
     # hooks document/corpus, croissance maîtrisée).
     "picarones/evaluation/metric_hooks.py": 500,          # actuel 427
-    "picarones/measurements/numerical_sequences.py": 500, # actuel 422
+    # Phase 5.C.batch7 : ``measurements/numerical_sequences.py`` est
+    # désormais un shim ; canonique dans
+    # ``evaluation/metrics/numerical_sequences.py``.
+    "picarones/evaluation/metrics/numerical_sequences.py": 500,  # actuel 428
     "picarones/measurements/normalization.py": 500,       # actuel 420 (re-export S9)
     # Sprint A14-S9 — déplacé depuis measurements/normalization.py.
     # L'ancien emplacement est désormais un re-export ; le contenu

tests/architecture/test_module_coverage.py

@@ -73,6 +73,17 @@ TEST_ONLY_BASELINE: frozenset[str] = frozenset({
     "specialization",
     "lexical_modernization",
     "robustness_projection",
+    # Phase 5.C.batch7 : 4 modules supplémentaires migrés vers
+    # ``evaluation/`` (``numerical_sequences``,
+    # ``pipeline_benchmark``, ``pipeline_comparison``) ou
+    # ``evaluation/metrics/`` (``numerical_sequences``).
+    # ``numerical_sequences_hooks`` n'est plus consommé en prod
+    # car son seul consommateur (le renderer) consomme désormais
+    # le canonique.
+    "numerical_sequences",
+    "numerical_sequences_hooks",
+    "pipeline_benchmark",
+    "pipeline_comparison",
 })
 
 

tests/core/test_public_api.py

@@ -420,25 +420,26 @@ class TestCercle1IsLean:
     # Tout module avec de la logique métier (calcul, orchestration)
     # appartient au Cercle 2 (``measurements/``) ou au Cercle 3
     # (``extras/``, ``report/``).
-    EXPECTED_CERCLE1 = {
-        "pipeline.py",
-        # Phase 1 du retrait du legacy a déplacé `facts.py`,
-        # `diff_utils.py` et `xml_utils.py` vers leurs canoniques
-        # (`domain/facts.py`, `evaluation/_diff_utils.py`,
-        # `formats/_xml_utils.py`).  Les fichiers `core/X.py`
-        # restent comme shims re-export avec DeprecationWarning
-        # (< 30 lignes), donc ne comptent plus comme "real_modules"
-        # au sens de ce test.
-        # Phase 4-bis a fait pareil pour `modules.py` (canonique :
-        # `domain/module_protocol.py` + `domain/artifacts.py`).
-        # Phase 4-ter a fait pareil pour `metric_registry.py`,
-        # `metric_hooks.py` (canonique : `evaluation/metric_*.py`),
-        # `metrics.py` (canonique : `evaluation/metric_result.py`)
-        # et `results.py` (canonique :
-        # `evaluation/benchmark_result.py`).
-        # Phase 4-quater a fait pareil pour `corpus.py`
-        # (canonique : `evaluation/corpus.py`).
-    }
+    EXPECTED_CERCLE1: set[str] = set()
+    # Phase 1 du retrait du legacy a déplacé `facts.py`,
+    # `diff_utils.py` et `xml_utils.py` vers leurs canoniques
+    # (`domain/facts.py`, `evaluation/_diff_utils.py`,
+    # `formats/_xml_utils.py`).  Les fichiers `core/X.py`
+    # restent comme shims re-export avec DeprecationWarning
+    # (< 30 lignes), donc ne comptent plus comme "real_modules"
+    # au sens de ce test.
+    # Phase 4-bis a fait pareil pour `modules.py` (canonique :
+    # `domain/module_protocol.py` + `domain/artifacts.py`).
+    # Phase 4-ter a fait pareil pour `metric_registry.py`,
+    # `metric_hooks.py` (canonique : `evaluation/metric_*.py`),
+    # `metrics.py` (canonique : `evaluation/metric_result.py`)
+    # et `results.py` (canonique :
+    # `evaluation/benchmark_result.py`).
+    # Phase 4-quater a fait pareil pour `corpus.py`
+    # (canonique : `evaluation/corpus.py`).
+    # Phase 5.C.batch7 a fait pareil pour `pipeline.py`
+    # (canonique : `evaluation/pipeline.py`).  Désormais
+    # ``core/`` ne contient plus que des shims < 30 lignes.
 
     def test_cercle1_files_lean(self):
         from pathlib import Path

tests/core/test_sprint63_pipeline_runner.py

@@ -28,7 +28,7 @@ from typing import Any
 
 from picarones.core.corpus import Document, GTLevel, TextGT
 from picarones.core.modules import ArtifactType, BaseModule
-from picarones.core.pipeline import (
+from picarones.evaluation.pipeline import (
     PipelineResult,
     PipelineRunner,
     PipelineSpec,

tests/core/test_sprint66_dag_branching.py

@@ -32,7 +32,7 @@ from typing import Any
 
 from picarones.core.corpus import Document, GTLevel, TextGT
 from picarones.core.modules import ArtifactType, BaseModule
-from picarones.core.pipeline import (
+from picarones.evaluation.pipeline import (
     PipelineRunner,
     PipelineSpec,
     PipelineStep,

tests/integration/test_alto_baseline.py

@@ -29,7 +29,7 @@ from picarones.measurements.alto_metrics import (
 from picarones.core.corpus import AltoGT, Document, GTLevel, TextGT
 from picarones.core.metric_registry import compute_at_junction, select_metrics
 from picarones.core.modules import ArtifactType, BaseModule
-from picarones.core.pipeline import (
+from picarones.evaluation.pipeline import (
     PipelineRunner,
     PipelineSpec,
     PipelineStep,

tests/integration/test_pipeline_ocr_to_alto.py

@@ -34,7 +34,7 @@ import pytest
 from picarones.core.corpus import AltoGT, Document, GTLevel, TextGT
 from picarones.core.metric_registry import select_metrics
 from picarones.core.modules import ArtifactType, BaseModule
-from picarones.core.pipeline import (
+from picarones.evaluation.pipeline import (
     PipelineRunner,
     PipelineSpec,
     PipelineStep,

tests/integration/test_sprint69_user_doc.py

@@ -153,7 +153,7 @@ class TestCodeSnippets:
         # Les imports doivent pointer vers les vrais modules
         # picarones.core.* et picarones.report.*
         assert "from picarones.core.modules import" in doc
-        assert "from picarones.core.pipeline import" in doc
-        assert "from picarones.measurements.pipeline_benchmark import" in doc
-        assert "from picarones.measurements.pipeline_comparison import" in doc
-        assert "from picarones.report.pipeline_render import" in doc
+        assert "from picarones.evaluation.pipeline import" in doc
+        assert "from picarones.evaluation.pipeline_benchmark import" in doc
+        assert "from picarones.evaluation.pipeline_comparison import" in doc
+        assert "from picarones.reports_v2.html.renderers.pipeline import" in doc

tests/measurements/test_sprint60_roman_numerals.py

@@ -23,7 +23,7 @@ import pytest
 
 from picarones.core.metric_registry import compute_at_junction, select_metrics
 from picarones.core.modules import ArtifactType
-from picarones.measurements.roman_numerals import (
+from picarones.evaluation.metrics.roman_numerals import (
     ALL_STATUSES,
     STATUS_CASE_CHANGED,
     STATUS_CONVERTED_TO_ARABIC,

tests/measurements/test_sprint64_pipeline_benchmark.py

@@ -31,13 +31,13 @@ from typing import Any
 
 from picarones.core.corpus import Corpus, Document, GTLevel, TextGT
 from picarones.core.modules import ArtifactType, BaseModule
-from picarones.measurements.pipeline_benchmark import (
+from picarones.evaluation.pipeline_benchmark import (
     PipelineBenchmarkResult,
     StepAggregate,
     default_initial_inputs,
     run_pipeline_benchmark,
 )
-from picarones.core.pipeline import PipelineSpec, PipelineStep
+from picarones.evaluation.pipeline import PipelineSpec, PipelineStep
 
 
 # ──────────────────────────────────────────────────────────────────────────

tests/measurements/test_sprint65_pipeline_comparison.py

@@ -33,11 +33,11 @@ import pytest
 
 from picarones.core.corpus import Corpus, Document, GTLevel, TextGT
 from picarones.core.modules import ArtifactType, BaseModule
-from picarones.measurements.pipeline_comparison import (
+from picarones.evaluation.pipeline_comparison import (
     PipelineComparisonResult,
     compare_pipelines,
 )
-from picarones.core.pipeline import PipelineSpec, PipelineStep
+from picarones.evaluation.pipeline import PipelineSpec, PipelineStep
 
 
 # ──────────────────────────────────────────────────────────────────────────

tests/measurements/test_sprint85_numerical_sequences.py

@@ -16,7 +16,7 @@ Couvre :
 
 from __future__ import annotations
 
-from picarones.measurements.numerical_sequences import (
+from picarones.evaluation.metrics.numerical_sequences import (
     CATEGORIES,
     _detect_currencies,
     _detect_foliations,

tests/report/test_sprint67_pipeline_html.py

@@ -21,11 +21,11 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
-from picarones.measurements.pipeline_benchmark import (
+from picarones.evaluation.pipeline_benchmark import (
     PipelineBenchmarkResult,
     StepAggregate,
 )
-from picarones.report.pipeline_render import (
+from picarones.reports_v2.html.renderers.pipeline import (
     build_pipeline_report_html,
     build_pipeline_steps_table_html,
     build_pipeline_summary_html,

tests/report/test_sprint68_pipeline_comparison_html.py

@@ -32,12 +32,12 @@ import json
 from pathlib import Path
 
 from picarones.core.modules import ArtifactType
-from picarones.measurements.pipeline_benchmark import (
+from picarones.evaluation.pipeline_benchmark import (
     PipelineBenchmarkResult,
     StepAggregate,
 )
-from picarones.measurements.pipeline_comparison import PipelineComparisonResult
-from picarones.report.pipeline_render import (
+from picarones.evaluation.pipeline_comparison import PipelineComparisonResult
+from picarones.reports_v2.html.renderers.pipeline import (
     RankingSpec,
     build_pipeline_comparison_report_html,
     build_pipeline_comparison_summary_html,

tests/report/test_sprint86_aii5_html.py

@@ -36,7 +36,7 @@ from picarones.measurements.searchability_hooks import (
     aggregate_searchability_metrics,
     compute_searchability_metrics,
 )
-from picarones.report.numerical_sequences_render import (
+from picarones.reports_v2.html.renderers.numerical_sequences import (
     build_numerical_sequences_html,
 )
 from picarones.reports_v2.html.renderers.searchability import (