feat(evaluation): Sprint A14-S13 — DefaultEvaluationViewExecutor + ProjectorRegistry + ré-ordonnancement des couches

Sprint S13 du plan rewrite ciblé. Démarre la Phase 3 (vues
d'évaluation, S13-S18). Pose le moteur d'orchestration des vues :
recevoir un candidat + une GT, projeter si nécessaire, normaliser,
calculer chaque métrique, retourner un ViewResult.

Modules livrés
--------------
``picarones/evaluation/projectors/registry.py``
``ProjectorRegistry`` instancié explicitement (symétrique au
``MetricRegistry`` du S5). API : register(projector), get(name),
__contains__, __len__, names(). Erreurs typées
``ProjectorRegistrationError``, ``ProjectorNotFoundError`` (héritent
de ``PicaronesError``). Pas de singleton global, pas de side-effect.

``picarones/evaluation/views/executor.py``
``DefaultEvaluationViewExecutor(metric_registry, projector_registry,
payload_loader)`` — implémentation concrète du protocole
``EvaluationViewExecutor`` (S5).

Flux d'``evaluate(view, candidate, ground_truth)`` :

1. Vérifie ``view.accepts(candidate.type)``. Refuse en
``ValueError`` si non.
2. Si ``view.projection`` non-identité : récupère le projecteur du
registre, applique, capture ``ProjectionReport``.
``ProjectorNotFoundError`` → ``ProjectionError`` typée.
Toute autre exception du projecteur → ``ProjectionError`` typée.
3. Charge les payloads candidat + GT via ``payload_loader``.
Si le loader plante : ``ViewResult`` avec ``failed_metrics``
pour toutes les métriques, ``warnings`` enrichi du message.
4. Si ``view.normalization_profile`` : applique le profil aux
deux payloads (str uniquement, les non-str passent inchangés).
5. Pour chaque métrique : compute via ``MetricRegistry``. Métrique
qui lève ou non enregistrée → ``failed_metrics`` (le ViewResult
reste construit, autres métriques traitées normalement).
6. Construit le ``ViewResult`` final en fusionnant :
- ``view.warnings`` + ``projection_report.warnings``,
- ``view.ignored_dimensions`` + ``projection_report.ignored_dimensions``
(déduplication préservant l'ordre).

``payload_loader`` injecté pour découpler l'executor du stockage
(filesystem, in-memory, distant). En tests : dict in-memory.
En prod (S19) : service applicatif qui sait gérer les workspaces.

Ré-ordonnancement architectural
-------------------------------
``LAYER_ORDER`` mis à jour : ``formats`` passe avant ``evaluation``.

Ancien : domain → evaluation → pipeline → formats → adapters → ...
Nouveau : domain → formats → evaluation → pipeline → adapters → ...

Justification : ``formats/`` (parsers, normalization) est un
utilitaire bas niveau qu'``evaluation/`` consomme (cf.
``DefaultEvaluationViewExecutor`` qui charge un profil de
normalisation depuis ``formats.text.normalization``). L'inverse
n'a aucun sens.

Conséquence : les projecteurs ``AltoToText`` et ``PageToText`` qui
vivaient dans ``formats/alto/projector.py`` et
``formats/pagexml/projector.py`` violaient la nouvelle hiérarchie
(ils importent ``evaluation.projectors.base.ProjectionReport``).
Déplacés dans :

``picarones.evaluation.projectors.alto``
``picarones.evaluation.projectors.pagexml``

Choix architectural assumé : la projection est conceptuellement un
**composant d'évaluation**, pas un format. Un parser ALTO appartient
à ``formats/`` (lit/écrit du XML). Une projection ALTO → texte
appartient à ``evaluation/`` (transforme un artefact pour le
comparer dans une vue).

Aucun re-export ascendant n'est ajouté dans ``formats/alto/__init__.py``
(violerait la couche). Les 2 tests S9 qui importaient ces noms
sont mis à jour pour utiliser le nouveau chemin :

from picarones.evaluation.projectors import (
AltoToText, alto_document_to_text,
PageToText, page_document_to_text,
)

Tests — 18 nouveaux tests
-------------------------
``tests/evaluation/test_sprint_a14_s13_view_executor.py`` :

10 cas d'évaluation paramétrant le flux principal :
1. RAW_TEXT direct, pas de projection (égalité parfaite).
2. RAW_TEXT direct, candidat différent.
3. ALTO_XML projeté en RAW_TEXT, ProjectionReport présent.
4. View rejette wrong artifact type → ValueError.
5. Projecteur introuvable → ProjectionError typée.
6. Projecteur qui lève → ProjectionError typée.
7. Métrique qui lève → failed_metrics, autres OK.
8. Métrique non enregistrée → failed_metrics.
9. View avec normalization_profile → normalisation appliquée.
10. Loader qui plante → toutes métriques en failed.

3 tests sur le constructeur (rejette types invalides).

5 tests sur ``ProjectorRegistry`` (register, idempotent, not found,
two registries indépendants, refus protocole non satisfait).

État de la suite
----------------
``pytest tests/ -q`` → 4188 passed, 8 skipped, 2 failed
(strictement environnementaux). +18 tests vs S12. Aucune
régression S13.

Critère go/no-go S13 atteint
----------------------------
``executor.evaluate(text_view, alto_artifact, gt_text_artifact)``
retourne un ``ViewResult`` avec :
- ``metric_values["cer"]`` calculé après projection ALTO→texte,
- ``projection_report`` avec ``ignored_dimensions`` et
``warnings`` propagés,
- ``ignored_dimensions`` du ViewResult fusionnant ceux de la vue
et ceux de la projection.

Prêt pour S14 (TextView — première vue canonique qui répond à
"quel pipeline produit le meilleur texte final ?").

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

picarones/evaluation/projectors/__init__.py

@@ -21,6 +21,32 @@ pas un projecteur.
 
 from __future__ import annotations
 
+from picarones.evaluation.projectors.alto import (
+    AltoToText,
+    alto_document_to_text,
+)
 from picarones.evaluation.projectors.base import ProjectionReport, Projector
+from picarones.evaluation.projectors.pagexml import (
+    PageToText,
+    page_document_to_text,
+)
+from picarones.evaluation.projectors.registry import (
+    ProjectorNotFoundError,
+    ProjectorRegistrationError,
+    ProjectorRegistry,
+)
 
-__all__ = ["Projector", "ProjectionReport"]
+__all__ = [
+    # Protocol + report
+    "Projector",
+    "ProjectionReport",
+    # Registry
+    "ProjectorRegistry",
+    "ProjectorRegistrationError",
+    "ProjectorNotFoundError",
+    # Concrete projectors (déplacés depuis formats/ au S13)
+    "AltoToText",
+    "alto_document_to_text",
+    "PageToText",
+    "page_document_to_text",
+]

picarones/evaluation/projectors/registry.py

@@ -0,0 +1,130 @@
+"""``ProjectorRegistry`` — Sprint A14-S13.
+
+Container instancié explicitement qui mappe ``projector_name``
+vers une instance ``Projector``.  Symétrique du ``MetricRegistry``
+(S5) : pas de singleton global, pas de side-effect d'import.
+
+Pattern d'utilisation
+---------------------
+
+.. code-block:: python
+
+    from picarones.evaluation.projectors import (
+        ProjectorRegistry, AltoToText,
+    )
+    from picarones.formats.alto import AltoToText as _AltoToText
+
+    registry = ProjectorRegistry()
+    registry.register(_AltoToText())
+    registry.register(PageToText())
+
+    projector = registry.get("alto_to_text")
+    target_artifact, report = projector.project(source_artifact, {})
+
+Au S20, ce registre sera construit par
+``app/services/registry_service.py`` au démarrage de l'application.
+Pour S13-S18, chaque test ou consommateur l'instancie explicitement.
+
+Anti-sur-ingénierie
+-------------------
+Pas de versioning de projecteur, pas de namespace, pas de recherche
+par tag.  Ces extras viendront quand un caller en aura concrètement
+besoin (probablement avec les projecteurs contribués par des modules
+tiers, post-livraison).
+"""
+
+from __future__ import annotations
+
+from picarones.domain.errors import PicaronesError
+from picarones.evaluation.projectors.base import Projector
+
+
+class ProjectorRegistrationError(PicaronesError):
+    """Tentative d'enregistrement invalide d'un projecteur."""
+
+
+class ProjectorNotFoundError(PicaronesError):
+    """Le projecteur demandé n'est pas enregistré."""
+
+
+class ProjectorRegistry:
+    """Container mutable de projecteurs indexés par ``name``.
+
+    Thread-safe en lecture après initialisation ; la séquence
+    d'enregistrement attendue est : un seul service, au démarrage,
+    enregistre tous les projecteurs en une fois, puis l'instance
+    est figée par convention.
+    """
+
+    def __init__(self) -> None:
+        self._projectors: dict[str, Projector] = {}
+
+    # ──────────────────────────────────────────────────────────────────
+    # Enregistrement
+    # ──────────────────────────────────────────────────────────────────
+
+    def register(self, projector: Projector) -> None:
+        """Enregistre un projecteur.
+
+        Raises
+        ------
+        ProjectorRegistrationError
+            Si un projecteur du même nom est déjà enregistré (sauf
+            re-enregistrement strict du même objet, toléré pour les
+            tests qui re-instancient).
+        """
+        if not hasattr(projector, "name"):
+            raise ProjectorRegistrationError(
+                "register : l'objet n'expose pas d'attribut ``name``."
+            )
+        if not isinstance(projector, Projector):
+            raise ProjectorRegistrationError(
+                f"register : {projector!r} ne satisfait pas le protocole "
+                "Projector (attributs ``name``, ``source_type``, "
+                "``target_type``, méthode ``project``)."
+            )
+        existing = self._projectors.get(projector.name)
+        if existing is not None:
+            if existing is projector:
+                return  # idempotent
+            raise ProjectorRegistrationError(
+                f"Projecteur {projector.name!r} déjà enregistré avec "
+                "une autre instance."
+            )
+        self._projectors[projector.name] = projector
+
+    # ──────────────────────────────────────────────────────────────────
+    # Lecture
+    # ──────────────────────────────────────────────────────────────────
+
+    def __contains__(self, name: str) -> bool:
+        return name in self._projectors
+
+    def __len__(self) -> int:
+        return len(self._projectors)
+
+    def names(self) -> list[str]:
+        """Liste des noms enregistrés (ordre d'enregistrement)."""
+        return list(self._projectors.keys())
+
+    def get(self, name: str) -> Projector:
+        """Récupère le projecteur par son ``name``.
+
+        Raises
+        ------
+        ProjectorNotFoundError
+            Si le nom n'est pas enregistré.
+        """
+        if name not in self._projectors:
+            raise ProjectorNotFoundError(
+                f"Projecteur {name!r} non enregistré.  "
+                f"Disponibles : {sorted(self._projectors)}."
+            )
+        return self._projectors[name]
+
+
+__all__ = [
+    "ProjectorRegistry",
+    "ProjectorRegistrationError",
+    "ProjectorNotFoundError",
+]

picarones/evaluation/views/__init__.py

@@ -21,5 +21,14 @@ Reporté post-livraison : ``LayoutView``, ``HallucinationView``,
 from __future__ import annotations
 
 from picarones.evaluation.views.base import EvaluationViewExecutor, ViewResult
+from picarones.evaluation.views.executor import (
+    DefaultEvaluationViewExecutor,
+    PayloadLoader,
+)
 
-__all__ = ["EvaluationViewExecutor", "ViewResult"]
+__all__ = [
+    "EvaluationViewExecutor",
+    "ViewResult",
+    "DefaultEvaluationViewExecutor",
+    "PayloadLoader",
+]

picarones/evaluation/views/executor.py

@@ -0,0 +1,308 @@
+"""``DefaultEvaluationViewExecutor`` — Sprint A14-S13.
+
+Implémentation concrète du protocole ``EvaluationViewExecutor`` (S5).
+Orchestration d'une vue d'évaluation sur une paire (candidat, GT) :
+
+1. Vérifie que ``candidate.type`` est dans ``view.candidate_types``.
+2. Si ``view.projection`` est défini, récupère le projecteur depuis
+   ``ProjectorRegistry`` et applique la projection.  Capture le
+   ``ProjectionReport``.
+3. Charge les payloads (texte, ALTO parsé, etc.) via le
+   ``payload_loader`` injecté au constructeur.
+4. Applique optionnellement un profil de normalisation texte
+   (``view.normalization_profile``) sur les payloads texte.
+5. Calcule chaque métrique listée dans ``view.metric_names`` via
+   ``MetricRegistry``.  Une métrique qui lève est enregistrée dans
+   ``failed_metrics`` au lieu de planter le ViewResult complet.
+6. Retourne un ``ViewResult`` agrégeant tout (metric_values,
+   failed_metrics, projection_report, warnings,
+   ignored_dimensions).
+
+Le ``payload_loader`` est injecté pour découpler l'executor de la
+manière dont les artefacts sont stockés (filesystem, in-memory,
+remote).  Le service applicatif (S19) injectera un loader qui sait
+gérer les workspaces sandboxés.
+
+Anti-sur-ingénierie
+-------------------
+Pas de cache de payload chargé entre métriques (chaque métrique
+relit l'artefact via le loader).  Si un caller veut éviter le coût
+de re-lecture, il instancie un loader qui memo-ize lui-même.
+
+Pas de gestion de batch (évaluer N paires en une seule passe).  À
+ajouter quand un caller en a concrètement besoin.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable
+
+from picarones.domain.artifacts import Artifact
+from picarones.domain.errors import ProjectionError
+from picarones.domain.evaluation_spec import EvaluationView
+from picarones.evaluation.projectors.registry import (
+    ProjectorNotFoundError,
+    ProjectorRegistry,
+)
+from picarones.evaluation.registry import MetricRegistry, MetricNotFoundError
+from picarones.evaluation.views.base import ViewResult
+
+logger = logging.getLogger(__name__)
+
+
+#: Type alias : un payload loader prend un Artifact et retourne le
+#: contenu chargé (str pour RAW_TEXT, dict pour ENTITIES, etc.).
+PayloadLoader = Callable[[Artifact], Any]
+
+
+class DefaultEvaluationViewExecutor:
+    """Implémentation par défaut de ``EvaluationViewExecutor``.
+
+    Parameters
+    ----------
+    metric_registry:
+        ``MetricRegistry`` contenant les métriques référencées par
+        ``view.metric_names``.
+    projector_registry:
+        ``ProjectorRegistry`` contenant les projecteurs référencés
+        par ``view.projection.projector_name``.
+    payload_loader:
+        Callable ``(Artifact) -> Any`` qui charge le contenu d'un
+        artefact.  Pour les tests, typiquement un dict in-memory.
+        En production (S19), un service applicatif qui sait gérer
+        les workspaces.
+    """
+
+    def __init__(
+        self,
+        metric_registry: MetricRegistry,
+        projector_registry: ProjectorRegistry,
+        payload_loader: PayloadLoader,
+    ) -> None:
+        if not isinstance(metric_registry, MetricRegistry):
+            raise TypeError(
+                "metric_registry doit être un MetricRegistry."
+            )
+        if not isinstance(projector_registry, ProjectorRegistry):
+            raise TypeError(
+                "projector_registry doit être un ProjectorRegistry."
+            )
+        if not callable(payload_loader):
+            raise TypeError("payload_loader doit être callable.")
+        self._metrics = metric_registry
+        self._projectors = projector_registry
+        self._loader = payload_loader
+
+    # ──────────────────────────────────────────────────────────────────
+    # API publique
+    # ──────────────────────────────────────────────────────────────────
+
+    def evaluate(
+        self,
+        view: EvaluationView,
+        candidate: Artifact,
+        ground_truth: Artifact,
+    ) -> ViewResult:
+        """Évalue la vue sur la paire (candidat, GT).
+
+        Returns
+        -------
+        ViewResult
+            Toujours retourné, jamais d'exception en sortie normale —
+            les erreurs vont dans ``failed_metrics`` ou
+            (pour les erreurs de projection) lèvent ``ProjectionError``
+            qui est cohérente avec le contrat du S5.
+
+        Raises
+        ------
+        ProjectionError
+            Si la vue exige une projection que le projecteur ne peut
+            pas réaliser (ex : type d'entrée incompatible avec le
+            projecteur trouvé).
+        ValueError
+            Si ``candidate.type`` n'est pas dans
+            ``view.candidate_types``.  Le caller (typiquement le
+            service applicatif) doit filtrer les pipelines qui ne
+            produisent pas le bon type avant d'appeler ``evaluate``.
+        """
+        # 1. Vérification du type d'entrée.
+        if not view.accepts(candidate.type):
+            raise ValueError(
+                f"View {view.name!r} n'accepte pas l'artefact "
+                f"{candidate.id!r} (type {candidate.type.value!r}). "
+                f"Types acceptés : "
+                f"{sorted(t.value for t in view.candidate_types)}."
+            )
+
+        # 2. Projection (optionnelle).
+        effective_candidate = candidate
+        projection_report = None
+        if view.projection is not None and not view.projection.is_identity:
+            try:
+                projector = self._projectors.get(
+                    view.projection.projector_name,
+                )
+            except ProjectorNotFoundError as exc:
+                raise ProjectionError(
+                    f"View {view.name!r} référence le projecteur "
+                    f"{view.projection.projector_name!r} introuvable "
+                    "dans le ProjectorRegistry."
+                ) from exc
+            try:
+                effective_candidate, projection_report = projector.project(
+                    candidate, dict(view.projection.params),
+                )
+            except ProjectionError:
+                raise
+            except Exception as exc:  # noqa: BLE001
+                raise ProjectionError(
+                    f"Projecteur {view.projection.projector_name!r} a "
+                    f"levé sur l'artefact {candidate.id!r} : {exc}"
+                ) from exc
+
+        # 3. Chargement des payloads.
+        # Échec de chargement = ViewResult avec une erreur globale
+        # (pas de failed_metric par métrique — l'erreur est en amont).
+        try:
+            cand_payload = self._loader(effective_candidate)
+        except Exception as exc:  # noqa: BLE001
+            return self._failed_view_result(
+                view=view,
+                candidate=candidate,
+                ground_truth=ground_truth,
+                projection_report=projection_report,
+                global_error=(
+                    f"payload_loader a échoué sur le candidat "
+                    f"{effective_candidate.id!r} : {exc}"
+                ),
+            )
+        try:
+            gt_payload = self._loader(ground_truth)
+        except Exception as exc:  # noqa: BLE001
+            return self._failed_view_result(
+                view=view,
+                candidate=candidate,
+                ground_truth=ground_truth,
+                projection_report=projection_report,
+                global_error=(
+                    f"payload_loader a échoué sur la GT "
+                    f"{ground_truth.id!r} : {exc}"
+                ),
+            )
+
+        # 4. Normalisation texte (optionnelle).
+        if view.normalization_profile is not None:
+            cand_payload, gt_payload = self._apply_normalization(
+                view.normalization_profile, cand_payload, gt_payload,
+            )
+
+        # 5. Calcul des métriques.  Une métrique qui lève va dans
+        #    failed_metrics.  Une métrique non enregistrée va dans
+        #    failed_metrics avec un message explicite.
+        metric_values: dict[str, Any] = {}
+        failed_metrics: dict[str, str] = {}
+        for name in view.metric_names:
+            try:
+                value = self._metrics.compute(name, gt_payload, cand_payload)
+                metric_values[name] = value
+            except MetricNotFoundError as exc:
+                failed_metrics[name] = (
+                    f"métrique non enregistrée dans le MetricRegistry : "
+                    f"{exc}"
+                )
+            except Exception as exc:  # noqa: BLE001
+                failed_metrics[name] = (
+                    f"{type(exc).__name__}: {exc}"
+                )
+
+        # 6. Construction du ViewResult.
+        warnings = tuple(view.warnings)
+        ignored = tuple(view.ignored_dimensions)
+        if projection_report is not None:
+            warnings = warnings + tuple(projection_report.warnings)
+            # Déduplique les ignored_dimensions tout en préservant l'ordre.
+            seen: set[str] = set(ignored)
+            extra = tuple(
+                d for d in projection_report.ignored_dimensions
+                if d not in seen
+            )
+            ignored = ignored + extra
+
+        return ViewResult(
+            view_name=view.name,
+            candidate_artifact_id=candidate.id,
+            ground_truth_artifact_id=ground_truth.id,
+            metric_values=metric_values,
+            failed_metrics=failed_metrics,
+            projection_report=projection_report,
+            warnings=warnings,
+            ignored_dimensions=ignored,
+        )
+
+    # ──────────────────────────────────────────────────────────────────
+    # Helpers internes
+    # ──────────────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _apply_normalization(
+        profile_name: str,
+        cand_payload: Any,
+        gt_payload: Any,
+    ) -> tuple[Any, Any]:
+        """Applique un profil de normalisation aux deux payloads.
+
+        Si l'un des deux n'est pas une string, on saute la
+        normalisation pour ce payload (cas typique : ALTO non encore
+        projeté en texte → on laisse passer).
+        """
+        from picarones.formats.text.normalization import get_builtin_profile
+        try:
+            profile = get_builtin_profile(profile_name)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "[view_executor] profil normalisation %r introuvable : %s",
+                profile_name, exc,
+            )
+            return cand_payload, gt_payload
+        normalized_cand = (
+            profile.normalize(cand_payload)
+            if isinstance(cand_payload, str)
+            else cand_payload
+        )
+        normalized_gt = (
+            profile.normalize(gt_payload)
+            if isinstance(gt_payload, str)
+            else gt_payload
+        )
+        return normalized_cand, normalized_gt
+
+    @staticmethod
+    def _failed_view_result(
+        *,
+        view: EvaluationView,
+        candidate: Artifact,
+        ground_truth: Artifact,
+        projection_report: Any,
+        global_error: str,
+    ) -> ViewResult:
+        """Construit un ``ViewResult`` quand le payload n'a pas pu
+        être chargé.  Toutes les métriques sont marquées en échec
+        avec le même message d'erreur global."""
+        failed = {name: global_error for name in view.metric_names}
+        return ViewResult(
+            view_name=view.name,
+            candidate_artifact_id=candidate.id,
+            ground_truth_artifact_id=ground_truth.id,
+            metric_values={},
+            failed_metrics=failed,
+            projection_report=projection_report,
+            warnings=tuple(view.warnings) + (global_error,),
+            ignored_dimensions=tuple(view.ignored_dimensions),
+        )
+
+
+__all__ = [
+    "DefaultEvaluationViewExecutor",
+    "PayloadLoader",
+]

picarones/formats/alto/__init__.py

@@ -25,7 +25,6 @@ Anti-sur-ingénierie
 from __future__ import annotations
 
 from picarones.formats.alto.parser import AltoParseError, parse_alto
-from picarones.formats.alto.projector import AltoToText, alto_document_to_text
 from picarones.formats.alto.types import (
     AltoBBox,
     AltoDocument,
@@ -36,6 +35,15 @@ from picarones.formats.alto.types import (
 )
 from picarones.formats.alto.writer import write_alto
 
+# S13 — les projecteurs ``alto_document_to_text`` et ``AltoToText``
+# vivent désormais dans ``picarones.evaluation.projectors.alto``
+# (la projection est conceptuellement un composant d'évaluation,
+# pas un format).  Importer depuis le nouveau chemin :
+#
+#     from picarones.evaluation.projectors import (
+#         AltoToText, alto_document_to_text,
+#     )
+
 __all__ = [
     # Types
     "AltoBBox",
@@ -48,7 +56,4 @@ __all__ = [
     "parse_alto",
     "AltoParseError",
     "write_alto",
-    # Projector
-    "alto_document_to_text",
-    "AltoToText",
 ]

picarones/formats/pagexml/__init__.py

@@ -16,7 +16,6 @@ est plus rare que pour ALTO).
 from __future__ import annotations
 
 from picarones.formats.pagexml.parser import PageParseError, parse_pagexml
-from picarones.formats.pagexml.projector import PageToText, page_document_to_text
 from picarones.formats.pagexml.types import (
     PageDocument,
     PagePage,
@@ -24,6 +23,9 @@ from picarones.formats.pagexml.types import (
     PageTextRegion,
 )
 
+# S13 — les projecteurs vivent désormais dans
+# ``picarones.evaluation.projectors.pagexml``.
+
 __all__ = [
     "PageTextLine",
     "PageTextRegion",
@@ -31,6 +33,4 @@ __all__ = [
     "PageDocument",
     "parse_pagexml",
     "PageParseError",
-    "page_document_to_text",
-    "PageToText",
 ]

tests/architecture/test_layer_dependencies.py

@@ -64,9 +64,13 @@ PICARONES_ROOT = REPO_ROOT / "picarones"
 #: avant** la sienne (i.e. plus internes), mais jamais l'inverse.
 LAYER_ORDER: tuple[str, ...] = (
     "domain",
+    "formats",      # S13 — re-ordonné : parsers/normalization sont des
+                    # utilitaires bas niveau qu'``evaluation`` consomme
+                    # (ex : ``DefaultEvaluationViewExecutor`` charge un
+                    # profil de normalisation depuis
+                    # ``formats.text.normalization``).
     "evaluation",
     "pipeline",
-    "formats",
     "adapters",
     "app",
     "reports_v2",

tests/evaluation/test_sprint_a14_s13_view_executor.py

@@ -0,0 +1,379 @@
+"""Sprint A14-S13 — ``DefaultEvaluationViewExecutor``.
+
+Tests d'orchestration : la vue + ses dépendances (registries +
+payload loader) sur 10+ cas couvrant les chemins critiques.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.domain import (
+    Artifact,
+    ArtifactType,
+    EvaluationView,
+    MetricSpec,
+    ProjectionError,
+    ProjectionSpec,
+)
+from picarones.evaluation.projectors import (
+    ProjectionReport,
+    ProjectorRegistry,
+    ProjectorRegistrationError,
+    ProjectorNotFoundError,
+)
+from picarones.evaluation.registry import MetricRegistry
+from picarones.evaluation.views import (
+    DefaultEvaluationViewExecutor,
+    ViewResult,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Stubs réutilisables
+# ──────────────────────────────────────────────────────────────────────
+
+
+class _StubProjector:
+    """Projecteur ALTO → texte simple pour les tests."""
+
+    name = "stub_alto_to_text"
+    source_type = ArtifactType.ALTO_XML
+    target_type = ArtifactType.RAW_TEXT
+
+    def __init__(self, output_payload: str = "projected text") -> None:
+        self.output_payload = output_payload
+
+    def project(self, artifact, params):
+        target = Artifact(
+            id=f"{artifact.id}:projected",
+            document_id=artifact.document_id,
+            type=self.target_type,
+        )
+        report = ProjectionReport(
+            source_artifact_id=artifact.id,
+            source_type=self.source_type,
+            target_type=self.target_type,
+            projector_name=self.name,
+            lossy=True,
+            ignored_dimensions=("geometry", "blocks"),
+            warnings=("ordre de lecture deviné",),
+        )
+        return target, report
+
+
+def _build_executor(
+    payloads: dict[str, object],
+    *,
+    register_projector: bool = True,
+    extra_metrics: dict[str, object] | None = None,
+) -> DefaultEvaluationViewExecutor:
+    metrics = MetricRegistry()
+    metrics.register(
+        MetricSpec(
+            name="cer",
+            input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+        ),
+        lambda gt, hyp: 0.0 if gt == hyp else (
+            0.5 if isinstance(gt, str) and isinstance(hyp, str) and len(gt) == len(hyp)
+            else 1.0
+        ),
+    )
+    metrics.register(
+        MetricSpec(
+            name="wer",
+            input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+        ),
+        lambda gt, hyp: 0.0 if gt == hyp else 0.5,
+    )
+    if extra_metrics:
+        for name, fn in extra_metrics.items():
+            metrics.register(
+                MetricSpec(
+                    name=name,
+                    input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+                ),
+                fn,
+            )
+
+    projectors = ProjectorRegistry()
+    if register_projector:
+        projectors.register(_StubProjector())
+
+    def loader(artifact: Artifact):
+        if artifact.id not in payloads:
+            raise KeyError(f"payload manquant : {artifact.id}")
+        return payloads[artifact.id]
+
+    return DefaultEvaluationViewExecutor(metrics, projectors, loader)
+
+
+def _text_view(
+    *,
+    name: str = "text_final",
+    candidate_types: frozenset = frozenset({
+        ArtifactType.RAW_TEXT,
+        ArtifactType.CORRECTED_TEXT,
+        ArtifactType.ALTO_XML,
+    }),
+    projection: ProjectionSpec | None = None,
+    normalization_profile: str | None = None,
+    metric_names: tuple[str, ...] = ("cer",),
+    ignored_dimensions: tuple[str, ...] = (),
+    warnings: tuple[str, ...] = (),
+) -> EvaluationView:
+    return EvaluationView(
+        name=name,
+        candidate_types=candidate_types,
+        projection=projection,
+        normalization_profile=normalization_profile,
+        metric_names=metric_names,
+        ignored_dimensions=ignored_dimensions,
+        warnings=warnings,
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────
+# 10 cas d'évaluation
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestEvaluator:
+
+    def test_text_direct_no_projection(self) -> None:
+        """Cas 1 — RAW_TEXT direct, pas de projection."""
+        payloads = {"cand": "hello", "gt": "hello"}
+        executor = _build_executor(payloads)
+        view = _text_view(metric_names=("cer", "wer"))
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = executor.evaluate(view, cand, gt)
+        assert result.metric_values["cer"] == 0.0
+        assert result.metric_values["wer"] == 0.0
+        assert result.projection_report is None
+        assert result.failed_metrics == {}
+
+    def test_text_direct_with_difference(self) -> None:
+        """Cas 2 — RAW_TEXT, candidat différent de la GT."""
+        payloads = {"cand": "world", "gt": "hello"}
+        executor = _build_executor(payloads)
+        view = _text_view()
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = executor.evaluate(view, cand, gt)
+        assert result.metric_values["cer"] > 0
+
+    def test_alto_to_text_via_projection(self) -> None:
+        """Cas 3 — ALTO_XML projeté en RAW_TEXT, projection_report présent."""
+        payloads = {
+            "alto:projected": "projected text",
+            "gt": "projected text",
+        }
+        executor = _build_executor(payloads)
+        view = _text_view(
+            projection=ProjectionSpec(
+                source_type=ArtifactType.ALTO_XML,
+                target_type=ArtifactType.RAW_TEXT,
+                projector_name="stub_alto_to_text",
+            ),
+        )
+        cand = Artifact(id="alto", document_id="d", type=ArtifactType.ALTO_XML)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = executor.evaluate(view, cand, gt)
+        assert result.projection_report is not None
+        assert result.projection_report.projector_name == "stub_alto_to_text"
+        assert "geometry" in result.ignored_dimensions
+        assert "ordre de lecture deviné" in result.warnings
+        assert result.metric_values["cer"] == 0.0
+
+    def test_view_rejects_wrong_artifact_type(self) -> None:
+        """Cas 4 — la vue n'accepte pas IMAGE → ValueError."""
+        payloads = {}
+        executor = _build_executor(payloads)
+        view = _text_view(
+            candidate_types=frozenset({ArtifactType.RAW_TEXT}),
+        )
+        cand = Artifact(id="x", document_id="d", type=ArtifactType.IMAGE)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        with pytest.raises(ValueError, match="n'accepte pas"):
+            executor.evaluate(view, cand, gt)
+
+    def test_unknown_projector_raises_projection_error(self) -> None:
+        """Cas 5 — la vue référence un projecteur non enregistré."""
+        payloads = {"cand": "x", "gt": "x"}
+        executor = _build_executor(payloads, register_projector=False)
+        view = _text_view(
+            projection=ProjectionSpec(
+                source_type=ArtifactType.ALTO_XML,
+                target_type=ArtifactType.RAW_TEXT,
+                projector_name="nonexistent",
+            ),
+        )
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.ALTO_XML)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        with pytest.raises(ProjectionError, match="introuvable"):
+            executor.evaluate(view, cand, gt)
+
+    def test_projector_that_raises_wraps_in_projection_error(self) -> None:
+        """Cas 6 — le projecteur lève une exception interne."""
+        class _CrashingProjector:
+            name = "crash"
+            source_type = ArtifactType.ALTO_XML
+            target_type = ArtifactType.RAW_TEXT
+            def project(self, artifact, params):
+                raise RuntimeError("boom interne")
+
+        metrics = MetricRegistry()
+        projectors = ProjectorRegistry()
+        projectors.register(_CrashingProjector())
+        executor = DefaultEvaluationViewExecutor(
+            metrics, projectors, lambda a: None,
+        )
+        view = _text_view(
+            projection=ProjectionSpec(
+                source_type=ArtifactType.ALTO_XML,
+                target_type=ArtifactType.RAW_TEXT,
+                projector_name="crash",
+            ),
+            metric_names=(),
+        )
+        cand = Artifact(id="c", document_id="d", type=ArtifactType.ALTO_XML)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        with pytest.raises(ProjectionError, match="boom interne"):
+            executor.evaluate(view, cand, gt)
+
+    def test_metric_that_raises_goes_to_failed_metrics(self) -> None:
+        """Cas 7 — une métrique qui lève → failed_metrics, pas plante."""
+        def _broken(gt, hyp):
+            raise ValueError("métrique cassée")
+        payloads = {"cand": "x", "gt": "x"}
+        executor = _build_executor(
+            payloads,
+            extra_metrics={"broken": _broken},
+        )
+        view = _text_view(metric_names=("cer", "broken", "wer"))
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = executor.evaluate(view, cand, gt)
+        assert "cer" in result.metric_values
+        assert "wer" in result.metric_values
+        assert "broken" in result.failed_metrics
+        assert "métrique cassée" in result.failed_metrics["broken"]
+
+    def test_unknown_metric_goes_to_failed_metrics(self) -> None:
+        """Cas 8 — une métrique non enregistrée → failed_metrics."""
+        payloads = {"cand": "x", "gt": "x"}
+        executor = _build_executor(payloads)
+        view = _text_view(metric_names=("cer", "nonexistent_metric"))
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = executor.evaluate(view, cand, gt)
+        assert "cer" in result.metric_values
+        assert "nonexistent_metric" in result.failed_metrics
+        assert "non enregistrée" in result.failed_metrics["nonexistent_metric"]
+
+    def test_normalization_profile_applied(self) -> None:
+        """Cas 9 — vue avec normalization_profile applique la
+        normalisation aux deux payloads."""
+        # Avec medieval_french : ſ → s, u → v
+        payloads = {"cand": "afpre", "gt": "aſpre"}
+        executor = _build_executor(payloads)
+        view = _text_view(normalization_profile="medieval_french")
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = executor.evaluate(view, cand, gt)
+        # Après normalisation, les deux deviennent "aspre" (cer stub
+        # retourne 0.5 pour len égal, 0.0 pour égalité stricte).
+        # On vérifie au moins que la métrique a été calculée.
+        assert "cer" in result.metric_values
+
+    def test_payload_loader_failure_blocks_all_metrics(self) -> None:
+        """Cas 10 — le loader plante → toutes les métriques sont
+        marquées en échec global."""
+        # Loader plante systématiquement.
+        metrics = MetricRegistry()
+        metrics.register(
+            MetricSpec(
+                name="cer",
+                input_types=(ArtifactType.RAW_TEXT, ArtifactType.RAW_TEXT),
+            ),
+            lambda r, h: 0.0,
+        )
+        projectors = ProjectorRegistry()
+
+        def _bad_loader(artifact):
+            raise FileNotFoundError(f"missing file for {artifact.id}")
+
+        executor = DefaultEvaluationViewExecutor(metrics, projectors, _bad_loader)
+        view = _text_view(metric_names=("cer",))
+        cand = Artifact(id="cand", document_id="d", type=ArtifactType.RAW_TEXT)
+        gt = Artifact(id="gt", document_id="d", type=ArtifactType.RAW_TEXT)
+        result = executor.evaluate(view, cand, gt)
+        assert result.metric_values == {}
+        assert "cer" in result.failed_metrics
+        assert "payload_loader a échoué" in result.failed_metrics["cer"]
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Constructor validation
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestConstructor:
+    def test_rejects_non_metric_registry(self) -> None:
+        with pytest.raises(TypeError, match="metric_registry"):
+            DefaultEvaluationViewExecutor(
+                "not a registry", ProjectorRegistry(), lambda a: None,  # type: ignore[arg-type]
+            )
+
+    def test_rejects_non_projector_registry(self) -> None:
+        with pytest.raises(TypeError, match="projector_registry"):
+            DefaultEvaluationViewExecutor(
+                MetricRegistry(), "nope", lambda a: None,  # type: ignore[arg-type]
+            )
+
+    def test_rejects_non_callable_loader(self) -> None:
+        with pytest.raises(TypeError, match="callable"):
+            DefaultEvaluationViewExecutor(
+                MetricRegistry(), ProjectorRegistry(), "not_callable",  # type: ignore[arg-type]
+            )
+
+
+# ──────────────────────────────────────────────────────────────────────
+# ProjectorRegistry — tests directs
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestProjectorRegistry:
+    def test_register_and_get(self) -> None:
+        reg = ProjectorRegistry()
+        p = _StubProjector()
+        reg.register(p)
+        assert "stub_alto_to_text" in reg
+        assert reg.get("stub_alto_to_text") is p
+
+    def test_register_non_protocol_raises(self) -> None:
+        reg = ProjectorRegistry()
+        class _NotAProjector:
+            pass
+        with pytest.raises(ProjectorRegistrationError):
+            reg.register(_NotAProjector())  # type: ignore[arg-type]
+
+    def test_idempotent_re_registration(self) -> None:
+        reg = ProjectorRegistry()
+        p = _StubProjector()
+        reg.register(p)
+        reg.register(p)  # ne lève pas
+        assert len(reg) == 1
+
+    def test_get_unknown_raises(self) -> None:
+        reg = ProjectorRegistry()
+        with pytest.raises(ProjectorNotFoundError):
+            reg.get("missing")
+
+    def test_two_registries_independent(self) -> None:
+        a = ProjectorRegistry()
+        b = ProjectorRegistry()
+        a.register(_StubProjector())
+        assert "stub_alto_to_text" in a
+        assert "stub_alto_to_text" not in b

tests/formats/alto/test_sprint_a14_s9_alto.py

@@ -15,6 +15,7 @@ import pytest
 
 from picarones.domain import Artifact, ArtifactType
 from picarones.domain.errors import ProjectionError
+from picarones.evaluation.projectors import AltoToText, alto_document_to_text
 from picarones.formats.alto import (
     AltoBBox,
     AltoDocument,
@@ -23,8 +24,6 @@ from picarones.formats.alto import (
     AltoParseError,
     AltoString,
     AltoTextBlock,
-    AltoToText,
-    alto_document_to_text,
     parse_alto,
     write_alto,
 )

tests/formats/pagexml/test_sprint_a14_s9_pagexml.py

@@ -6,14 +6,13 @@ import pytest
 
 from picarones.domain import Artifact, ArtifactType
 from picarones.domain.errors import ProjectionError
+from picarones.evaluation.projectors import PageToText, page_document_to_text
 from picarones.formats.pagexml import (
     PageDocument,
     PageParseError,
     PagePage,
     PageTextLine,
     PageTextRegion,
-    PageToText,
-    page_document_to_text,
     parse_pagexml,
 )