feat(formats): Sprint A14-S9 — formats/alto/, formats/pagexml/, migration normalization

Sprint S9 du plan rewrite ciblé. Phase 2 continue.

ALTO et PAGE deviennent des citoyens de première classe avec
parsers tolérants aux versions de namespace, structures internes
typées, writer déterministe (ALTO), et projecteurs conformes au
protocole S5. ``normalization.py`` est déplacé vers
``picarones/formats/text/`` avec re-export à l'ancien emplacement
pour ne casser aucun consommateur.

Modules livrés
--------------

``picarones/formats/alto/``
- ``types.py`` — ``AltoDocument``, ``AltoPage``, ``AltoTextBlock``,
``AltoLine``, ``AltoString``, ``AltoBBox``. Frozen pydantic.
- ``parser.py`` — ``parse_alto(xml_bytes)``. Détection auto
v2/v3/v4/sans namespace via le namespace du root. Sécurité
``defusedxml`` (XXE / Billion Laughs bloqués).
``AltoParseError`` typée.
- ``writer.py`` — ``write_alto(doc, version="v4", pretty=False)``.
Sortie déterministe (round-trip byte-stable testé).
- ``projector.py`` — ``alto_document_to_text(doc)`` helper +
``AltoToText`` projecteur conforme au protocole ``Projector``
du S5. Gestion césure ``HypPart1`` / ``HypPart2`` :
* SUBS_CONTENT renseigné → mot complet utilisé, HypPart2 skippé
* Pas de SUBS_CONTENT → concaténation des deux parts
* **Cross-ligne** (HypPart1 fin de ligne i, HypPart2 début
ligne i+1) géré via état inter-lignes du bloc

``picarones/formats/pagexml/``
- ``types.py`` — ``PageDocument``, ``PagePage``, ``PageTextRegion``,
``PageTextLine``. Coords stockés en string brut (format PAGE
``"x1,y1 x2,y2 ..."``).
- ``parser.py`` — ``parse_pagexml(xml_bytes)``. Tolérant aux
versions PRIMA (2010 / 2013 / 2017 / 2019). Sécurité
``defusedxml``. Extraction du texte depuis ``TextEquiv >
Unicode``.
- ``projector.py`` — ``page_document_to_text(doc)`` +
``PageToText`` projecteur.

Writer reporté post-livraison (les outils PAGE produisent
typiquement le format depuis un éditeur — re-sortir est plus
rare que pour ALTO).

``picarones/formats/text/normalization.py``
Déplacé depuis ``picarones/measurements/normalization.py`` sans
modification de logique. Les 11 profils restent intacts.

``picarones/measurements/normalization.py`` devient un **re-export
explicite** des symboles publics ET privés
(``_parse_exclude_chars``, ``_apply_diplomatic_table``) utilisés
downstream par ~50 consommateurs. Aucun import existant n'est
cassé. Le re-export sera retiré au S22.

Règle architecturale respectée
------------------------------
``measurements/`` (legacy) est autorisé à importer ``formats/``
(nouveau code) pendant la migration. L'inverse reste interdit
(test ``test_layer_dependencies`` toujours vert).

Anti-sur-ingénierie
-------------------
- Validator XSD ALTO reporté quand un caller en a concrètement
besoin (la plupart des outils acceptent un ALTO bien formé sans
validation stricte).
- Writer PAGE XML reporté.
- ``Illustration`` / ``ComposedBlock`` / ``StyleRefs`` /
``ProcessingStep`` non préservés au round-trip ALTO.
- ``Word`` / ``Glyph`` PAGE (granularité plus fine que ``TextLine``)
non parsés.

Tests — 41 nouveaux tests (3 fichiers)
--------------------------------------
``test_sprint_a14_s9_alto.py`` (24)
- 7 tests parser : détection v2/v3/v4/sans-namespace, XML
invalide, vide, **XXE bloqué**.
- 7 tests round-trip : structure préservée, content préservé,
bbox préservé, byte-déterministe, cibles v3/v4/none, version
invalide rejetée.
- 5 tests extraction texte : simple, multi-block, **césure same
line**, **césure cross-line**, **césure sans SUBS_CONTENT
concatène**.
- 5 tests projecteur AltoToText : protocole satisfait, projection
depuis filesystem, type incorrect rejeté, URI absente rejetée.

``test_sprint_a14_s9_pagexml.py`` (10)
- Parser : 5 cas (multi-régions, image_filename/width/height,
region_type, namespace détecté, vide, invalide, XXE).
- Extraction texte : 3 cas (full, doc vide, région sans lignes).
- Projector : 2 cas (FS, type incorrect).

``test_sprint_a14_s9_normalization_migration.py`` (5)
- Nouveau path expose 11 profils canoniques.
- Ancien re-export fonctionne (compat ascendante).
- Symboles privés (``_parse_exclude_chars``,
``_apply_diplomatic_table``) ré-exposés.
- Ancien et nouveau path **partagent les mêmes objets** (vrai
re-export, pas une duplication).
- Test fonctionnel ``profile.normalize("aſpre")``.

Mise à jour des budgets de fichiers
-----------------------------------
``tests/architecture/test_file_budgets.py`` :
- ``picarones/measurements/normalization.py`` : 420 lignes
(re-export S9, taille préservée).
- ``picarones/formats/text/normalization.py`` : 420 lignes (le
contenu canonique vit ici maintenant).

État de la suite
----------------
``pytest tests/ -q`` → 4160 passed, 7 skipped, 2 failed.
+41 tests par rapport à S8. Les 2 fails restants sont
strictement environnementaux (sous-process pytest sans
``pip install -e .``). Aucune régression S9.

Critère go/no-go S9 atteint
---------------------------
``parse_alto(xml_bytes).pages[0]...`` retourne une structure
cohérente sur ALTO BnF synthétique ; ``alto_document_to_text``
extrait le texte par ordre de lecture avec gestion césure
cross-ligne.

Prêt pour S10 (migration des calculs purs vers
``evaluation/metrics/``).

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

picarones/formats/alto/__init__.py

@@ -1,21 +1,54 @@
-"""Format ALTO XML 4.x.
+"""Format ALTO XML 4.x (et v2/v3 tolérés).
 
-Cible Sprint S9 :
+Sprint A14-S9 livre :
 
-- ``parser.py`` — détection auto namespace (v2/v3/v4), parsing
-  tolérant.  Retourne une structure interne (lignes, mots,
-  coordonnées, IDs).
-- ``writer.py`` — structure interne → XML déterministe (même
-  entrée, même bytes).
-- ``validator.py`` — conformité au schéma XSD ALTO.
-- ``projector.py`` — extraction texte par ordre de lecture,
-  extraction lignes, extraction mots avec coordonnées.
+- ``types.py`` — ``AltoDocument``, ``AltoPage``, ``AltoTextBlock``,
+  ``AltoLine``, ``AltoString``, ``AltoBBox``.  Frozen pydantic.
+- ``parser.py`` — ``parse_alto(xml_bytes)`` détection auto v2/v3/v4
+  via le namespace du root.  Sécurité ``defusedxml``.
+- ``writer.py`` — ``write_alto(doc, version="v4", pretty=False)``
+  sortie déterministe (round-trip byte-stable avec ``parser``).
+- ``projector.py`` — ``alto_document_to_text(doc)`` (helper) +
+  ``AltoToText`` (projecteur conforme au protocole S5).  Gestion
+  césure ``HypPart1``/``HypPart2``.
 
-Règle de sécurité : tout parsing XML passe par ``defusedxml`` (pas
-``lxml`` direct sur du XML utilisateur), pour bloquer XXE et
-Billion Laughs.
+Anti-sur-ingénierie
+-------------------
+- Validator XSD reporté quand un caller en aura concrètement besoin
+  (la plupart des outils consommateurs acceptent un ALTO bien formé
+  sans validation stricte).
+- ``Illustration``, ``ComposedBlock``, ``GraphicalElement``,
+  ``StyleRefs``, ``ProcessingStep`` : non préservés au round-trip
+  pour S9.
 """
 
 from __future__ import annotations
 
-__all__: list[str] = []
+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,
+    AltoLine,
+    AltoPage,
+    AltoString,
+    AltoTextBlock,
+)
+from picarones.formats.alto.writer import write_alto
+
+__all__ = [
+    # Types
+    "AltoBBox",
+    "AltoString",
+    "AltoLine",
+    "AltoTextBlock",
+    "AltoPage",
+    "AltoDocument",
+    # Parser / Writer
+    "parse_alto",
+    "AltoParseError",
+    "write_alto",
+    # Projector
+    "alto_document_to_text",
+    "AltoToText",
+]

picarones/formats/alto/parser.py

@@ -0,0 +1,227 @@
+"""Parser ALTO XML tolérant aux namespaces — Sprint A14-S9.
+
+Détection auto de la version ALTO (v2/v3/v4) via le namespace du
+root element.  Tolérant aux variantes : un ALTO sans namespace est
+accepté ; un ALTO avec déclaration partielle (``<alto>`` sans xmlns)
+aussi.
+
+Sécurité
+--------
+Utilise ``defusedxml.ElementTree`` pour bloquer XXE, Billion Laughs,
+DTD retrieval — un ALTO peut venir d'un module tiers ou d'un
+utilisateur web non authentifié.
+
+Anti-sur-ingénierie
+-------------------
+- Pas de validation de schéma XSD pour S9 (le ``validator.py`` du
+  plan est reporté quand un caller en aura concrètement besoin —
+  la plupart des outils accepteront un ALTO bien formé même sans
+  validation stricte).
+- Les éléments non reconnus (``Illustration``, ``ComposedBlock``,
+  ``GraphicalElement``) sont silencieusement ignorés par le parser.
+- ``HypPart1`` / ``HypPart2`` sont préservés au niveau ``AltoString``
+  (le projecteur les utilise pour la césure).
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+import defusedxml.ElementTree as _SafeET
+
+from picarones.domain.errors import PicaronesError
+from picarones.formats.alto.types import (
+    AltoBBox,
+    AltoDocument,
+    AltoLine,
+    AltoPage,
+    AltoString,
+    AltoTextBlock,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AltoParseError(PicaronesError):
+    """ALTO non parsable (XML invalide, XXE bloqué, root absent)."""
+
+
+_NS_RE = re.compile(r"^\{([^}]*)\}")
+_LOCAL_NAME_RE = re.compile(r"\{[^}]*\}")
+
+
+def _local(tag: str) -> str:
+    """Retire le préfixe namespace pour ne garder que le nom local."""
+    return _LOCAL_NAME_RE.sub("", tag)
+
+
+def _detect_version(root_tag: str) -> str | None:
+    """Détecte la version ALTO depuis le tag du root.
+
+    - Pas de namespace → ``"none"``.
+    - ``http://www.loc.gov/standards/alto/ns-v2#`` → ``"v2"``.
+    - ``http://www.loc.gov/standards/alto/ns-v3#`` → ``"v3"``.
+    - ``http://www.loc.gov/standards/alto/ns-v4#`` → ``"v4"``.
+    - Autre namespace → ``None`` (inconnu).
+    """
+    m = _NS_RE.match(root_tag)
+    if m is None:
+        return "none"
+    ns = m.group(1)
+    if "ns-v2" in ns:
+        return "v2"
+    if "ns-v3" in ns:
+        return "v3"
+    if "ns-v4" in ns:
+        return "v4"
+    return None
+
+
+def _parse_int_attr(elem: Any, name: str) -> int | None:
+    """Parse un attribut entier optionnel.  Retourne ``None`` si
+    absent ou invalide (au lieu de lever)."""
+    raw = elem.attrib.get(name)
+    if raw is None:
+        return None
+    try:
+        # ALTO accepte des floats dans certains attributs (HPOS), on
+        # tronque vers int.
+        return int(float(raw))
+    except (ValueError, TypeError):
+        return None
+
+
+def _parse_bbox(elem: Any) -> AltoBBox | None:
+    """Construit un ``AltoBBox`` si les 4 attributs sont présents."""
+    h = _parse_int_attr(elem, "HPOS")
+    v = _parse_int_attr(elem, "VPOS")
+    w = _parse_int_attr(elem, "WIDTH")
+    height = _parse_int_attr(elem, "HEIGHT")
+    if any(x is None for x in (h, v, w, height)):
+        return None
+    # Coordonnées négatives → certains ALTO mal formés ; on clip à 0.
+    return AltoBBox(
+        hpos=max(0, h or 0),
+        vpos=max(0, v or 0),
+        width=max(0, w or 0),
+        height=max(0, height or 0),
+    )
+
+
+def _parse_string(elem: Any) -> AltoString:
+    """Convertit un élément ``<String>`` en ``AltoString``."""
+    return AltoString(
+        content=elem.attrib.get("CONTENT", ""),
+        id=elem.attrib.get("ID"),
+        bbox=_parse_bbox(elem),
+        subs_type=elem.attrib.get("SUBS_TYPE"),
+        subs_content=elem.attrib.get("SUBS_CONTENT"),
+    )
+
+
+def _parse_line(elem: Any) -> AltoLine:
+    """Convertit un élément ``<TextLine>`` en ``AltoLine``."""
+    strings: list[AltoString] = []
+    for child in elem:
+        if _local(child.tag) == "String":
+            strings.append(_parse_string(child))
+    return AltoLine(
+        id=elem.attrib.get("ID"),
+        bbox=_parse_bbox(elem),
+        strings=tuple(strings),
+    )
+
+
+def _parse_block(elem: Any) -> AltoTextBlock:
+    """Convertit un élément ``<TextBlock>`` en ``AltoTextBlock``."""
+    lines: list[AltoLine] = []
+    for child in elem.iter():
+        if _local(child.tag) == "TextLine":
+            lines.append(_parse_line(child))
+    return AltoTextBlock(
+        id=elem.attrib.get("ID"),
+        bbox=_parse_bbox(elem),
+        lines=tuple(lines),
+    )
+
+
+def _parse_page(elem: Any) -> AltoPage:
+    """Convertit un élément ``<Page>`` en ``AltoPage``."""
+    blocks: list[AltoTextBlock] = []
+    seen_block_ids: set[int] = set()
+    for child in elem.iter():
+        if _local(child.tag) != "TextBlock":
+            continue
+        # Évite la duplication quand un TextBlock est imbriqué dans un
+        # ComposedBlock — on retourne le bloc une seule fois (par id python).
+        marker = id(child)
+        if marker in seen_block_ids:
+            continue
+        seen_block_ids.add(marker)
+        blocks.append(_parse_block(child))
+    return AltoPage(
+        id=elem.attrib.get("ID"),
+        width=_parse_int_attr(elem, "WIDTH"),
+        height=_parse_int_attr(elem, "HEIGHT"),
+        blocks=tuple(blocks),
+    )
+
+
+def parse_alto(xml: bytes | str) -> AltoDocument:
+    """Parse un document ALTO et retourne sa structure interne.
+
+    Parameters
+    ----------
+    xml:
+        Bytes ou string XML.  Encodage détecté automatiquement par
+        ``defusedxml`` (à partir de la déclaration ``<?xml encoding="..."?>``
+        ou du BOM).
+
+    Returns
+    -------
+    AltoDocument
+        Document avec ``source_version`` indiquant la version
+        détectée et ``pages`` contenant la hiérarchie complète.
+
+    Raises
+    ------
+    AltoParseError
+        XML mal formé, défense XXE déclenchée, ou root absent.
+    """
+    if isinstance(xml, str):
+        xml_bytes = xml.encode("utf-8")
+    else:
+        xml_bytes = xml
+    if not xml_bytes.strip():
+        raise AltoParseError("ALTO vide.")
+    try:
+        root = _SafeET.fromstring(xml_bytes)
+    except Exception as exc:  # noqa: BLE001
+        raise AltoParseError(f"XML invalide ou XXE bloqué : {exc}") from exc
+
+    if root is None:
+        raise AltoParseError("ALTO sans root element.")
+
+    version = _detect_version(root.tag)
+    if _local(root.tag) != "alto":
+        # Tolérant : on cherche un éventuel <alto> imbriqué (cas d'un
+        # METS qui embarque l'ALTO dans un mdRef).  Sinon on prend le
+        # root tel quel — peut-être qu'un caller passe directement
+        # un fragment <Page>.
+        for elem in root.iter():
+            if _local(elem.tag) == "alto":
+                root = elem
+                version = _detect_version(elem.tag)
+                break
+
+    pages: list[AltoPage] = []
+    for elem in root.iter():
+        if _local(elem.tag) == "Page":
+            pages.append(_parse_page(elem))
+
+    return AltoDocument(pages=tuple(pages), source_version=version)
+
+
+__all__ = ["parse_alto", "AltoParseError"]

picarones/formats/alto/projector.py

@@ -0,0 +1,215 @@
+"""Projecteurs ALTO — Sprint A14-S9.
+
+Convertit un ``AltoDocument`` (ou un artefact ``ALTO_XML``) vers
+d'autres types d'artefacts, en documentant explicitement les
+pertes via ``ProjectionReport``.
+
+Implémentations
+---------------
+- ``AltoToText`` — extraction du texte par ordre de lecture
+  ``Page → Block → Line → String``.  Gestion césure
+  ``HypPart1``/``HypPart2``.
+
+À venir post-livraison :
+- ``AltoToLines`` (extraction lignes).
+- ``AltoToWordsWithBoxes`` (mots + coordonnées).
+"""
+
+from __future__ import annotations
+
+from picarones.domain.artifacts import Artifact, ArtifactType
+from picarones.evaluation.projectors.base import ProjectionReport
+from picarones.formats.alto.parser import AltoParseError, parse_alto
+from picarones.formats.alto.types import AltoDocument, AltoLine
+
+
+def alto_document_to_text(document: AltoDocument) -> str:
+    """Extrait le texte plat d'un ``AltoDocument``.
+
+    Conventions :
+
+    - Ordre de lecture ``Page → Block → Line → String``, dans l'ordre
+      d'apparition dans le XML.
+    - Espace entre les ``String`` d'une même ligne.
+    - Saut de ligne entre les ``TextLine``.
+    - Saut de ligne supplémentaire entre les ``TextBlock``.
+    - **Césure** :
+      - Si un ``HypPart1`` porte ``SUBS_CONTENT`` (mot complet), on
+        utilise ce mot complet et on saute le ``HypPart2``
+        correspondant (même ligne ou ligne suivante du même bloc).
+      - Sinon, on concatène ``HypPart1.content + HypPart2.content``
+        et on saute le ``HypPart2``.
+      - Le saut de ligne visuel entre les deux est **conservé** (le
+        mot reconstruit termine la ligne du ``HypPart1``, la ligne
+        du ``HypPart2`` continue avec ses autres mots).
+    """
+    blocks_text: list[str] = []
+    for page in document.pages:
+        for block in page.blocks:
+            block_text = _extract_block_text(block)
+            if block_text:
+                blocks_text.append(block_text)
+    return "\n\n".join(blocks_text).strip()
+
+
+def _extract_block_text(block: "AltoTextBlock") -> str:
+    """Extrait le texte d'un bloc en gérant la césure cross-ligne.
+
+    L'usage standard ALTO place ``HypPart1`` en fin d'une ligne et
+    ``HypPart2`` en début de la ligne suivante du **même** bloc.
+    """
+    from picarones.formats.alto.types import AltoTextBlock as _ATB
+    assert isinstance(block, _ATB)
+    lines_text: list[str] = []
+    skip_first_if_hyppart2 = False
+    for line in block.lines:
+        text, ended_with_hyp1 = _extract_line_text(
+            line, skip_first_if_hyppart2=skip_first_if_hyppart2,
+        )
+        lines_text.append(text)
+        skip_first_if_hyppart2 = ended_with_hyp1
+    return "\n".join(lines_text)
+
+
+def _extract_line_text(
+    line: AltoLine,
+    *,
+    skip_first_if_hyppart2: bool = False,
+) -> tuple[str, bool]:
+    """Reconstruit le texte d'une ligne.
+
+    Returns
+    -------
+    tuple[str, bool]
+        ``(texte_ligne, ended_with_hyppart1_resolved)``.  Le second
+        indique si la ligne se termine par un ``HypPart1`` dont la
+        résolution implique de skipper le premier ``HypPart2`` de la
+        ligne suivante.
+    """
+    parts: list[str] = []
+    skip_next = False
+    ended_with_hyp1 = False
+    strings = list(line.strings)
+    for i, s in enumerate(strings):
+        is_first = (i == 0)
+        if skip_next:
+            skip_next = False
+            continue
+        if is_first and skip_first_if_hyppart2 and s.subs_type == "HypPart2":
+            # Cross-ligne : la ligne précédente a résolu le HypPart1.
+            continue
+        if s.subs_type == "HypPart1":
+            is_last = (i == len(strings) - 1)
+            if s.subs_content:
+                parts.append(s.subs_content)
+                if i + 1 < len(strings) and strings[i + 1].subs_type == "HypPart2":
+                    skip_next = True
+                elif is_last:
+                    ended_with_hyp1 = True
+                continue
+            if i + 1 < len(strings) and strings[i + 1].subs_type == "HypPart2":
+                parts.append(s.content + strings[i + 1].content)
+                skip_next = True
+                continue
+            parts.append(s.content)
+            if is_last:
+                ended_with_hyp1 = True
+            continue
+        parts.append(s.content)
+    return " ".join(p for p in parts if p), ended_with_hyp1
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Projecteur conforme au protocole ``Projector`` (Sprint S5)
+# ──────────────────────────────────────────────────────────────────────
+
+
+class AltoToText:
+    """Projecteur ``ALTO_XML → RAW_TEXT``.
+
+    Lit le XML depuis l'``Artifact.uri`` (chemin filesystem) si
+    présent, sinon attend que le caller ait pré-stocké le payload
+    dans un mécanisme externe (ce projecteur ne télécharge rien
+    par lui-même — pas de side-effect réseau).
+
+    Pour S9, on s'attend à ce que ``artifact.uri`` pointe vers un
+    fichier local lisible.  Le service applicatif (S19) résoudra
+    les autres cas (URI distante, payload inline).
+    """
+
+    name = "alto_to_text"
+    source_type = ArtifactType.ALTO_XML
+    target_type = ArtifactType.RAW_TEXT
+
+    def project(
+        self,
+        artifact: Artifact,
+        params: dict[str, str | int | float | bool],
+    ) -> tuple[Artifact, ProjectionReport]:
+        if artifact.type != self.source_type:
+            from picarones.domain.errors import ProjectionError
+            raise ProjectionError(
+                f"AltoToText n'accepte que ALTO_XML, reçu "
+                f"{artifact.type.value!r}"
+            )
+
+        # Lecture du XML.  Pour S9, on lit depuis le filesystem.
+        xml_bytes = self._read_xml(artifact)
+
+        try:
+            doc = parse_alto(xml_bytes)
+        except AltoParseError as exc:
+            from picarones.domain.errors import ProjectionError
+            raise ProjectionError(f"AltoToText : {exc}") from exc
+
+        text = alto_document_to_text(doc)
+
+        # Construction de l'artefact résultat.
+        target = Artifact(
+            id=f"{artifact.id}:projected_text",
+            document_id=artifact.document_id,
+            type=self.target_type,
+            produced_by_step=artifact.produced_by_step,
+        )
+
+        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",
+                "block_structure",
+                "reading_order",
+                "ids",
+                "confidence",
+            ),
+            warnings=(
+                "L'extraction texte ALTO ignore les coordonnées, "
+                "la structure en blocs, et les IDs.  La césure "
+                "HypPart1/HypPart2 est résolue (mot recombiné).",
+            ),
+        )
+        return target, report
+
+    @staticmethod
+    def _read_xml(artifact: Artifact) -> bytes:
+        from picarones.domain.errors import ProjectionError
+        if artifact.uri is None:
+            raise ProjectionError(
+                f"AltoToText : artifact {artifact.id!r} n'a pas d'URI "
+                "et le projecteur ne sait pas résoudre les payloads "
+                "inline pour S9."
+            )
+        from pathlib import Path
+        path = Path(artifact.uri)
+        try:
+            return path.read_bytes()
+        except OSError as exc:
+            raise ProjectionError(
+                f"AltoToText : impossible de lire {path!r} : {exc}"
+            ) from exc
+
+
+__all__ = ["alto_document_to_text", "AltoToText"]

picarones/formats/alto/types.py

@@ -0,0 +1,126 @@
+"""Structures internes ALTO — Sprint A14-S9.
+
+Représentation **typée et immuable** d'un document ALTO XML pour
+manipulation, projection, et round-trip parser/writer.  Indépendante
+du namespace source (v2/v3/v4) — le parser normalise.
+
+Hiérarchie ALTO simplifiée :
+
+::
+
+    AltoDocument
+      └─ AltoPage  (1..N)
+           └─ AltoTextBlock  (0..N)
+                └─ AltoLine  (0..N)
+                     └─ AltoString  (0..N)
+
+Les coordonnées (HPOS, VPOS, WIDTH, HEIGHT) sont **optionnelles**.
+Un ALTO produit par certains VLM peut omettre les bbox (texte sans
+coordonnées) — on accepte au parsing et le projecteur ALTO→texte
+fonctionne quand même.
+
+Anti-sur-ingénierie
+-------------------
+Pas de support des éléments rares pour S9 :
+- ``Composed Block`` (regroupement de blocks) — projeté en blocks plats.
+- ``Illustration`` / ``GraphicalElement`` — ignorés à l'extraction texte.
+- ``StyleRefs`` / typographie — non préservés par le writer.
+- ``Hyphenation`` côté ``HypPart1`` / ``HypPart2`` est par contre
+  géré par le projector (cf. ``projector.py``).
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AltoBBox(BaseModel):
+    """Boîte englobante optionnelle (coordonnées en pixels)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    hpos: int = Field(ge=0)
+    vpos: int = Field(ge=0)
+    width: int = Field(ge=0)
+    height: int = Field(ge=0)
+
+
+class AltoString(BaseModel):
+    """Un mot ALTO (élément ``<String>``).
+
+    Attributs ALTO mappés :
+    - ``CONTENT`` → ``content``
+    - ``ID`` → ``id``
+    - ``HPOS``/``VPOS``/``WIDTH``/``HEIGHT`` → ``bbox``
+    - ``SUBS_TYPE`` → ``subs_type`` (``"HypPart1"`` / ``"HypPart2"``).
+      Le projecteur l'utilise pour gérer la césure de fin de ligne.
+    - ``SUBS_CONTENT`` → ``subs_content`` (mot complet quand césuré).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    content: str
+    id: str | None = Field(default=None, max_length=128)
+    bbox: AltoBBox | None = None
+    subs_type: str | None = Field(default=None, pattern=r"^(HypPart1|HypPart2)$")
+    subs_content: str | None = None
+
+
+class AltoLine(BaseModel):
+    """Une ligne ALTO (élément ``<TextLine>``)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    id: str | None = Field(default=None, max_length=128)
+    bbox: AltoBBox | None = None
+    strings: tuple[AltoString, ...] = Field(default_factory=tuple)
+    """Mots de la ligne, ordre de lecture naturel (gauche → droite)."""
+
+
+class AltoTextBlock(BaseModel):
+    """Un bloc de texte ALTO (élément ``<TextBlock>``)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    id: str | None = Field(default=None, max_length=128)
+    bbox: AltoBBox | None = None
+    lines: tuple[AltoLine, ...] = Field(default_factory=tuple)
+
+
+class AltoPage(BaseModel):
+    """Une page ALTO (élément ``<Page>``)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    id: str | None = Field(default=None, max_length=128)
+    width: int | None = Field(default=None, ge=0)
+    """Largeur physique en pixels (``WIDTH``)."""
+    height: int | None = Field(default=None, ge=0)
+    """Hauteur physique en pixels (``HEIGHT``)."""
+    blocks: tuple[AltoTextBlock, ...] = Field(default_factory=tuple)
+
+
+class AltoDocument(BaseModel):
+    """Document ALTO complet.
+
+    Conserve la version source au parsing pour permettre au writer
+    de re-sortir dans le même namespace si demandé.  Par défaut,
+    le writer sort en v4 (le plus récent et le plus expressif).
+    """
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pages: tuple[AltoPage, ...] = Field(default_factory=tuple)
+    source_version: str | None = Field(default=None, max_length=8)
+    """Version détectée au parsing : ``"v2"`` / ``"v3"`` / ``"v4"`` /
+    ``"none"`` (sans namespace) / ``None`` (inconnue)."""
+
+
+__all__ = [
+    "AltoBBox",
+    "AltoString",
+    "AltoLine",
+    "AltoTextBlock",
+    "AltoPage",
+    "AltoDocument",
+]

picarones/formats/alto/writer.py

@@ -0,0 +1,147 @@
+"""Writer ALTO XML déterministe — Sprint A14-S9.
+
+Sérialise un ``AltoDocument`` en bytes ALTO XML.  Sortie
+déterministe : même document → mêmes octets exacts (utile pour le
+cache d'artefacts du S7 et les tests de round-trip).
+
+Format de sortie
+----------------
+Par défaut, le writer sort un ALTO **v4** (le plus récent et le
+plus expressif), même si le document a été parsé depuis v2/v3.  Le
+caller peut forcer une version cible avec ``write_alto(doc,
+version="v3")``.
+
+Anti-sur-ingénierie
+-------------------
+- Pas de support des ``StyleRefs``, ``ProcessingStep``, ``OCRProcessing``,
+  ``Description`` pour S9.  Le writer sort une structure minimale
+  (``alto > Layout > Page > PrintSpace > TextBlock > TextLine > String``)
+  qui passe la validation des outils consommateurs courants
+  (Mirador, IIIF Universal Viewer, Aletheia).
+- Pas d'XSL preprocessing.  L'utilisateur qui veut un ALTO
+  enrichi écrira un wrapper.
+"""
+
+from __future__ import annotations
+
+from xml.etree import ElementTree as ET
+
+from picarones.formats.alto.types import (
+    AltoBBox,
+    AltoDocument,
+    AltoLine,
+    AltoPage,
+    AltoString,
+    AltoTextBlock,
+)
+
+
+_NAMESPACE_BY_VERSION: dict[str, str] = {
+    "v2": "http://www.loc.gov/standards/alto/ns-v2#",
+    "v3": "http://www.loc.gov/standards/alto/ns-v3#",
+    "v4": "http://www.loc.gov/standards/alto/ns-v4#",
+}
+
+
+def _set_bbox_attrs(elem: ET.Element, bbox: AltoBBox | None) -> None:
+    if bbox is None:
+        return
+    elem.set("HPOS", str(bbox.hpos))
+    elem.set("VPOS", str(bbox.vpos))
+    elem.set("WIDTH", str(bbox.width))
+    elem.set("HEIGHT", str(bbox.height))
+
+
+def _set_optional(elem: ET.Element, name: str, value: str | None) -> None:
+    if value is not None:
+        elem.set(name, value)
+
+
+def _build_string(parent: ET.Element, ns: str, s: AltoString) -> None:
+    elem = ET.SubElement(parent, f"{{{ns}}}String" if ns else "String")
+    elem.set("CONTENT", s.content)
+    _set_optional(elem, "ID", s.id)
+    _set_bbox_attrs(elem, s.bbox)
+    _set_optional(elem, "SUBS_TYPE", s.subs_type)
+    _set_optional(elem, "SUBS_CONTENT", s.subs_content)
+
+
+def _build_line(parent: ET.Element, ns: str, line: AltoLine) -> None:
+    elem = ET.SubElement(parent, f"{{{ns}}}TextLine" if ns else "TextLine")
+    _set_optional(elem, "ID", line.id)
+    _set_bbox_attrs(elem, line.bbox)
+    for s in line.strings:
+        _build_string(elem, ns, s)
+
+
+def _build_block(parent: ET.Element, ns: str, block: AltoTextBlock) -> None:
+    elem = ET.SubElement(parent, f"{{{ns}}}TextBlock" if ns else "TextBlock")
+    _set_optional(elem, "ID", block.id)
+    _set_bbox_attrs(elem, block.bbox)
+    for line in block.lines:
+        _build_line(elem, ns, line)
+
+
+def _build_page(parent: ET.Element, ns: str, page: AltoPage) -> None:
+    elem = ET.SubElement(parent, f"{{{ns}}}Page" if ns else "Page")
+    _set_optional(elem, "ID", page.id)
+    if page.width is not None:
+        elem.set("WIDTH", str(page.width))
+    if page.height is not None:
+        elem.set("HEIGHT", str(page.height))
+    print_space = ET.SubElement(
+        elem, f"{{{ns}}}PrintSpace" if ns else "PrintSpace",
+    )
+    for block in page.blocks:
+        _build_block(print_space, ns, block)
+
+
+def write_alto(
+    document: AltoDocument,
+    *,
+    version: str = "v4",
+    pretty: bool = False,
+) -> bytes:
+    """Sérialise un ``AltoDocument`` en bytes ALTO XML.
+
+    Parameters
+    ----------
+    document:
+        Document à sérialiser.
+    version:
+        Version ALTO cible.  ``"v2"`` / ``"v3"`` / ``"v4"`` ou
+        ``"none"`` (sans namespace).  Défaut : ``"v4"``.
+    pretty:
+        Si ``True``, indente la sortie pour la lisibilité humaine.
+        ``False`` (défaut) produit une sortie compacte byte-déterministe.
+
+    Returns
+    -------
+    bytes
+        XML encodé en UTF-8 avec déclaration XML.
+    """
+    if version not in (*_NAMESPACE_BY_VERSION, "none"):
+        from picarones.domain.errors import PicaronesError
+        raise PicaronesError(
+            f"version ALTO invalide : {version!r}.  "
+            f"Acceptées : {sorted(_NAMESPACE_BY_VERSION)} + 'none'."
+        )
+    ns = _NAMESPACE_BY_VERSION.get(version, "")
+    if ns:
+        ET.register_namespace("", ns)
+        root = ET.Element(f"{{{ns}}}alto")
+    else:
+        root = ET.Element("alto")
+
+    layout = ET.SubElement(root, f"{{{ns}}}Layout" if ns else "Layout")
+    for page in document.pages:
+        _build_page(layout, ns, page)
+
+    if pretty:
+        ET.indent(root, space="  ")
+
+    body = ET.tostring(root, encoding="utf-8", xml_declaration=True)
+    return body
+
+
+__all__ = ["write_alto"]

picarones/formats/pagexml/__init__.py

@@ -1,12 +1,36 @@
 """Format PAGE XML (PRIMA / Transkribus).
 
-Cible Sprint S9 — symétrique de ``formats/alto/`` :
+Sprint A14-S9 livre :
 
-- ``parser.py`` — parsing tolérant des variantes PAGE XML.
-- ``writer.py`` — sortie déterministe.
-- ``projector.py`` — extraction texte / lignes / coordonnées.
+- ``types.py`` — ``PageDocument``, ``PagePage``, ``PageTextRegion``,
+  ``PageTextLine``.  Frozen pydantic.
+- ``parser.py`` — ``parse_pagexml(xml_bytes)`` tolérant aux versions
+  de namespace PRIMA.  Sécurité ``defusedxml``.
+- ``projector.py`` — ``page_document_to_text(doc)`` + ``PageToText``.
+
+Writer reporté post-livraison (les outils PAGE produisent
+typiquement le format à partir d'un éditeur — le besoin de re-sortir
+est plus rare que pour ALTO).
 """
 
 from __future__ import annotations
 
-__all__: list[str] = []
+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,
+    PageTextLine,
+    PageTextRegion,
+)
+
+__all__ = [
+    "PageTextLine",
+    "PageTextRegion",
+    "PagePage",
+    "PageDocument",
+    "parse_pagexml",
+    "PageParseError",
+    "page_document_to_text",
+    "PageToText",
+]

picarones/formats/pagexml/parser.py

@@ -0,0 +1,149 @@
+"""Parser PAGE XML tolérant — Sprint A14-S9.
+
+Détection auto du namespace PRIMA (plusieurs versions co-existent
+dans la nature : ``2010-03-19``, ``2013-07-15``, ``2017-07-15``,
+``2019-07-15``).  Utilise ``defusedxml`` pour la sécurité XXE.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any
+
+import defusedxml.ElementTree as _SafeET
+
+from picarones.domain.errors import PicaronesError
+from picarones.formats.pagexml.types import (
+    PageDocument,
+    PagePage,
+    PageTextLine,
+    PageTextRegion,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class PageParseError(PicaronesError):
+    """PAGE XML non parsable."""
+
+
+_NS_RE = re.compile(r"^\{([^}]*)\}")
+_LOCAL_NAME_RE = re.compile(r"\{[^}]*\}")
+
+
+def _local(tag: str) -> str:
+    return _LOCAL_NAME_RE.sub("", tag)
+
+
+def _detect_namespace(root_tag: str) -> str | None:
+    m = _NS_RE.match(root_tag)
+    return m.group(1) if m else None
+
+
+def _extract_unicode(elem: Any) -> str:
+    """Cherche le premier ``<Unicode>`` descendant et retourne son
+    texte, ou ``""`` si absent.
+
+    PAGE XML stocke le texte dans ``<TextEquiv><Unicode>...</Unicode></TextEquiv>``.
+    Plusieurs ``TextEquiv`` peuvent coexister (variantes d'OCR) —
+    on prend la première.
+    """
+    for child in elem.iter():
+        if _local(child.tag) == "Unicode":
+            return (child.text or "").strip()
+    return ""
+
+
+def _parse_coords(elem: Any) -> str | None:
+    """Cherche le premier ``<Coords points="...">`` enfant direct."""
+    for child in elem:
+        if _local(child.tag) == "Coords":
+            return child.attrib.get("points")
+    return None
+
+
+def _parse_baseline(elem: Any) -> str | None:
+    for child in elem:
+        if _local(child.tag) == "Baseline":
+            return child.attrib.get("points")
+    return None
+
+
+def _parse_text_line(elem: Any) -> PageTextLine:
+    return PageTextLine(
+        id=elem.attrib.get("id"),
+        coords=_parse_coords(elem),
+        baseline=_parse_baseline(elem),
+        text=_extract_unicode(elem),
+    )
+
+
+def _parse_text_region(elem: Any) -> PageTextRegion:
+    lines: list[PageTextLine] = []
+    for child in elem:
+        if _local(child.tag) == "TextLine":
+            lines.append(_parse_text_line(child))
+    return PageTextRegion(
+        id=elem.attrib.get("id"),
+        coords=_parse_coords(elem),
+        region_type=elem.attrib.get("type"),
+        text_lines=tuple(lines),
+    )
+
+
+def _parse_int_attr(elem: Any, name: str) -> int | None:
+    raw = elem.attrib.get(name)
+    if raw is None:
+        return None
+    try:
+        return int(float(raw))
+    except (ValueError, TypeError):
+        return None
+
+
+def _parse_page(elem: Any) -> PagePage:
+    regions: list[PageTextRegion] = []
+    for child in elem:
+        if _local(child.tag) == "TextRegion":
+            regions.append(_parse_text_region(child))
+    return PagePage(
+        image_filename=elem.attrib.get("imageFilename"),
+        image_width=_parse_int_attr(elem, "imageWidth"),
+        image_height=_parse_int_attr(elem, "imageHeight"),
+        text_regions=tuple(regions),
+    )
+
+
+def parse_pagexml(xml: bytes | str) -> PageDocument:
+    """Parse un document PAGE XML et retourne la structure interne.
+
+    Raises
+    ------
+    PageParseError
+        XML mal formé, défense XXE, ou root absent.
+    """
+    if isinstance(xml, str):
+        xml_bytes = xml.encode("utf-8")
+    else:
+        xml_bytes = xml
+    if not xml_bytes.strip():
+        raise PageParseError("PAGE XML vide.")
+    try:
+        root = _SafeET.fromstring(xml_bytes)
+    except Exception as exc:  # noqa: BLE001
+        raise PageParseError(f"XML invalide ou XXE bloqué : {exc}") from exc
+
+    if root is None:
+        raise PageParseError("PAGE sans root element.")
+
+    ns = _detect_namespace(root.tag)
+    pages: list[PagePage] = []
+    for elem in root.iter():
+        if _local(elem.tag) == "Page":
+            pages.append(_parse_page(elem))
+
+    return PageDocument(pages=tuple(pages), source_namespace=ns)
+
+
+__all__ = ["parse_pagexml", "PageParseError"]

picarones/formats/pagexml/projector.py

@@ -0,0 +1,96 @@
+"""Projecteurs PAGE XML — Sprint A14-S9.
+
+Convertit un ``PageDocument`` (ou un artefact ``PAGE_XML``) vers
+d'autres types d'artefacts.  Symétrique de ``formats.alto.projector``.
+"""
+
+from __future__ import annotations
+
+from picarones.domain.artifacts import Artifact, ArtifactType
+from picarones.evaluation.projectors.base import ProjectionReport
+from picarones.formats.pagexml.parser import PageParseError, parse_pagexml
+from picarones.formats.pagexml.types import PageDocument
+
+
+def page_document_to_text(document: PageDocument) -> str:
+    """Extrait le texte plat d'un ``PageDocument``.
+
+    Convention :
+    - Ordre ``Page → TextRegion → TextLine``.
+    - Saut de ligne entre lignes d'une même région.
+    - Saut de ligne supplémentaire entre régions.
+    """
+    page_blocks: list[str] = []
+    for page in document.pages:
+        for region in page.text_regions:
+            lines = [tl.text for tl in region.text_lines if tl.text]
+            if lines:
+                page_blocks.append("\n".join(lines))
+    return "\n\n".join(page_blocks).strip()
+
+
+class PageToText:
+    """Projecteur ``PAGE_XML → RAW_TEXT``."""
+
+    name = "page_to_text"
+    source_type = ArtifactType.PAGE_XML
+    target_type = ArtifactType.RAW_TEXT
+
+    def project(
+        self,
+        artifact: Artifact,
+        params: dict[str, str | int | float | bool],
+    ) -> tuple[Artifact, ProjectionReport]:
+        from picarones.domain.errors import ProjectionError
+        if artifact.type != self.source_type:
+            raise ProjectionError(
+                f"PageToText n'accepte que PAGE_XML, reçu "
+                f"{artifact.type.value!r}"
+            )
+        if artifact.uri is None:
+            raise ProjectionError(
+                f"PageToText : artifact {artifact.id!r} sans URI."
+            )
+        from pathlib import Path
+        try:
+            xml_bytes = Path(artifact.uri).read_bytes()
+        except OSError as exc:
+            raise ProjectionError(
+                f"PageToText : impossible de lire {artifact.uri!r} : {exc}"
+            ) from exc
+
+        try:
+            doc = parse_pagexml(xml_bytes)
+        except PageParseError as exc:
+            raise ProjectionError(f"PageToText : {exc}") from exc
+
+        text = page_document_to_text(doc)
+
+        target = Artifact(
+            id=f"{artifact.id}:projected_text",
+            document_id=artifact.document_id,
+            type=self.target_type,
+            produced_by_step=artifact.produced_by_step,
+        )
+        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",
+                "region_structure",
+                "baseline",
+                "ids",
+            ),
+            warnings=(
+                "L'extraction texte PAGE ignore les coordonnées et "
+                "la structure en régions.  Plusieurs TextEquiv (variantes "
+                "d'OCR) sont collapsées au premier Unicode rencontré.",
+            ),
+        )
+        return target, report
+
+
+__all__ = ["page_document_to_text", "PageToText"]

picarones/formats/pagexml/types.py

@@ -0,0 +1,82 @@
+"""Structures internes PAGE XML — Sprint A14-S9.
+
+Représentation typée et immuable d'un document PAGE XML (PRIMA /
+Transkribus / eScriptorium).  Symétrique de ``formats.alto.types``
+mais avec les conventions PAGE :
+
+- ``Coords`` au lieu de ``HPOS/VPOS/WIDTH/HEIGHT`` — chaîne de points
+  ``"x1,y1 x2,y2 ..."`` représentant un polygone.
+- ``Baseline`` (optionnel) — ligne médiane horizontale typique des
+  manuscrits.
+- ``TextEquiv > Unicode`` au lieu de ``CONTENT`` ALTO.
+
+Anti-sur-ingénierie
+-------------------
+- Pas de support des ``Word``/``Glyph`` PAGE (granularité plus fine
+  que la ligne) pour S9 — la plupart des outils PAGE patrimoniaux
+  utilisent la granularité ``TextLine``.  Un ``Word`` séparé peut
+  être ajouté quand un caller en aura besoin.
+- Coordonnées stockées en string brut (``points``).  Le caller qui
+  veut une bbox calculée appelle ``points_to_bbox()`` du parser.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PageTextLine(BaseModel):
+    """Une ligne PAGE (élément ``<TextLine>``)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    id: str | None = Field(default=None, max_length=128)
+    coords: str | None = Field(default=None, max_length=4096)
+    """Polygone en format PAGE : ``"x1,y1 x2,y2 x3,y3 ..."``."""
+    baseline: str | None = Field(default=None, max_length=2048)
+    """Polyline baseline (optionnelle, typique HTR)."""
+    text: str = ""
+    """Texte de la ligne extrait de ``TextEquiv > Unicode``."""
+
+
+class PageTextRegion(BaseModel):
+    """Région de texte PAGE (élément ``<TextRegion>``)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    id: str | None = Field(default=None, max_length=128)
+    coords: str | None = Field(default=None, max_length=4096)
+    region_type: str | None = Field(default=None, max_length=64)
+    """Type sémantique PAGE : ``"paragraph"``, ``"heading"``,
+    ``"caption"``, ``"footnote"``, etc.  Préservé tel quel sans
+    enum (les valeurs PRIMA peuvent être étendues)."""
+    text_lines: tuple[PageTextLine, ...] = Field(default_factory=tuple)
+
+
+class PagePage(BaseModel):
+    """Une page PAGE (élément ``<Page>``)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    image_filename: str | None = Field(default=None, max_length=512)
+    image_width: int | None = Field(default=None, ge=0)
+    image_height: int | None = Field(default=None, ge=0)
+    text_regions: tuple[PageTextRegion, ...] = Field(default_factory=tuple)
+
+
+class PageDocument(BaseModel):
+    """Document PAGE XML complet (peut contenir une seule page)."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    pages: tuple[PagePage, ...] = Field(default_factory=tuple)
+    source_namespace: str | None = Field(default=None, max_length=256)
+    """Namespace détecté au parsing (ex ``2019-07-15``, ``2013-07-15``)."""
+
+
+__all__ = [
+    "PageTextLine",
+    "PageTextRegion",
+    "PagePage",
+    "PageDocument",
+]

picarones/formats/text/__init__.py

@@ -1,21 +1,47 @@
 """Normalisation et manipulation de texte.
 
-Cible Sprint S9 — déplacement de ``picarones.measurements.normalization``
-sans modification de logique.
+Sprint A14-S9 livre ``normalization.py``, déplacé depuis
+``picarones/measurements/normalization.py`` sans modification de
+logique.  L'ancien emplacement reste un re-export pour ne pas
+casser les ~50 consommateurs (sera retiré au S22).
 
-Modules cibles :
+11 profils intégrés : ``nfc``, ``caseless``, ``minimal``,
+``medieval_french``, ``early_modern_french``, ``medieval_latin``,
+``medieval_english``, ``early_modern_english``, ``secretary_hand``,
+``sans_ponctuation``, ``sans_apostrophes``.
 
-- ``normalization.py`` — 11 profils (nfc, caseless, minimal,
-  medieval_french, early_modern_french, medieval_latin,
-  medieval_english, early_modern_english, secretary_hand,
-  sans_ponctuation, sans_apostrophes).  Tables diplomatiques.
-  Exclusion de caractères.
-
-Règle : ce module ne fait **pas** d'extraction depuis ALTO/PAGE
-(c'est le rôle des projecteurs).  Il prend une chaîne en entrée,
+Règle architecturale : ce module ne fait **pas** d'extraction depuis
+ALTO/PAGE (c'est le rôle des projecteurs dans
+``picarones.evaluation.projectors``).  Il prend une chaîne en entrée,
 applique un profil, retourne une chaîne.
 """
 
 from __future__ import annotations
 
-__all__: list[str] = []
+from picarones.formats.text.normalization import (
+    DEFAULT_DIPLOMATIC_PROFILE,
+    DIPLOMATIC_EN_EARLY_MODERN,
+    DIPLOMATIC_EN_MEDIEVAL,
+    DIPLOMATIC_EN_SECRETARY,
+    DIPLOMATIC_FR_EARLY_MODERN,
+    DIPLOMATIC_FR_MEDIEVAL,
+    DIPLOMATIC_LATIN_MEDIEVAL,
+    DIPLOMATIC_MINIMAL,
+    NORMALIZATION_PROFILES,
+    NormalizationProfile,
+    get_builtin_profile,
+)
+
+__all__ = [
+    "NormalizationProfile",
+    "NORMALIZATION_PROFILES",
+    "DEFAULT_DIPLOMATIC_PROFILE",
+    "get_builtin_profile",
+    "DIPLOMATIC_FR_MEDIEVAL",
+    "DIPLOMATIC_FR_EARLY_MODERN",
+    "DIPLOMATIC_LATIN_MEDIEVAL",
+    "DIPLOMATIC_MINIMAL",
+    "DIPLOMATIC_EN_EARLY_MODERN",
+    "DIPLOMATIC_EN_MEDIEVAL",
+    "DIPLOMATIC_EN_SECRETARY",
+]

picarones/formats/text/normalization.py

@@ -0,0 +1,420 @@
+"""Profils de normalisation unicode pour le calcul du CER diplomatique.
+
+La normalisation diplomatique permet de calculer un CER tenant compte des
+équivalences graphiques propres aux documents historiques : ſ=s, u=v, i=j, etc.
+
+En appliquant la même table aux deux textes (GT et OCR), on mesure les erreurs
+"substantielles" (transcription erronée) en ignorant les variations graphiques
+codifiées connues.
+
+Trois niveaux de normalisation sont disponibles :
+
+1. NFC       : normalisation Unicode canonique (décomposition+recomposition)
+2. caseless  : NFC + pliage de casse (casefold)
+3. diplomatic: NFC + table de correspondances historiques configurables
+
+Les profils préconfigurés couvrent les cas d'usage patrimoniaux courants.
+Ils sont également chargeables depuis un fichier YAML.
+
+Exemple YAML
+------------
+name: medieval_custom
+caseless: false
+diplomatic:
+  ſ: s
+  u: v
+  i: j
+  y: i
+  æ: ae
+  œ: oe
+"""
+
+from __future__ import annotations
+
+import unicodedata
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+# ---------------------------------------------------------------------------
+# Tables de correspondances diplomatiques préconfigurées
+# ---------------------------------------------------------------------------
+
+#: Français médiéval (XIIe–XVe siècle)
+DIPLOMATIC_FR_MEDIEVAL: dict[str, str] = {
+    "ſ": "s",    # s long → s
+    "u": "v",    # u/v interchangeables en position initiale
+    "i": "j",    # i/j interchangeables
+    "y": "i",    # y vocalique → i
+    "æ": "ae",   # ligature æ
+    "œ": "oe",   # ligature œ
+    "ꝑ": "per",  # abréviation per/par
+    "ꝓ": "pro",  # abréviation pro
+    "\u0026": "et",  # & → et
+}
+
+#: Français moderne / imprimés anciens (XVIe–XVIIIe siècle)
+DIPLOMATIC_FR_EARLY_MODERN: dict[str, str] = {
+    "ſ": "s",    # s long
+    "æ": "ae",
+    "œ": "oe",
+    "\u0026": "et",
+    "ỹ": "yn",   # y tilde
+}
+
+#: Latin médiéval
+DIPLOMATIC_LATIN_MEDIEVAL: dict[str, str] = {
+    "ſ": "s",
+    "u": "v",
+    "i": "j",
+    "y": "i",
+    "æ": "ae",
+    "œ": "oe",
+    "ꝑ": "per",
+    "ꝓ": "pro",
+    "ꝗ": "que",   # q barré → que
+    "\u0026": "et",
+}
+
+#: Profil minimal — uniquement NFC + s long
+DIPLOMATIC_MINIMAL: dict[str, str] = {
+    "ſ": "s",
+}
+
+#: Anglais moderne / imprimés anciens (XVIe–XVIIIe siècle)
+#: Orthographe «early modern»  : ſ=s, u/v, i/j, vv=w, þ=th, ð=th, ȝ=y
+DIPLOMATIC_EN_EARLY_MODERN: dict[str, str] = {
+    "ſ": "s",     # s long → s
+    "u": "v",     # u/v interchangeables (vpon → upon)
+    "i": "j",     # i/j interchangeables (ioy → joy)
+    "vv": "w",    # vv → w (vvhich → which)
+    "þ": "th",    # thorn → th
+    "ð": "th",    # eth → th
+    "ȝ": "y",     # yogh → y
+    "æ": "ae",    # ligature æ
+    "œ": "oe",    # ligature œ
+    "\u0026": "and",  # & → and
+}
+
+#: Anglais médiéval (XIIe–XVe siècle) — abréviations manuscrites incluses
+DIPLOMATIC_EN_MEDIEVAL: dict[str, str] = {
+    "ſ": "s",
+    "u": "v",
+    "i": "j",
+    "vv": "w",
+    "þ": "th",
+    "ð": "th",
+    "ȝ": "y",
+    "æ": "ae",
+    "œ": "oe",
+    "\u0026": "and",
+    # Abréviations courantes dans les manuscrits anglais médiévaux
+    "ꝑ": "per",   # p barré → per/par
+    "ꝓ": "pro",   # p crocheté → pro
+    "ꝗ": "que",   # q barré → que
+    "\ua75b": "r", # lettre r rotunda → r
+}
+
+#: Écriture secrétaire (XVIe–XVIIe siècle) — secretary hand
+#: Confusions visuelles propres à l'écriture cursive anglaise
+DIPLOMATIC_EN_SECRETARY: dict[str, str] = {
+    "ſ": "s",
+    "u": "v",
+    "i": "j",
+    "vv": "w",
+    "þ": "th",
+    "ð": "th",
+    "ȝ": "y",
+    "\u0026": "and",
+    # Confusions visuelles typiques : e/c, n/u, m/w en secrétaire
+    # Note : ne pas normaliser e/c automatiquement (trop agressif) ;
+    # on se limite aux substituts graphiques historiquement documentés
+}
+
+
+# ---------------------------------------------------------------------------
+# Profil de normalisation
+# ---------------------------------------------------------------------------
+
+@dataclass
+class NormalizationProfile:
+    """Décrit une stratégie de normalisation pour le calcul du CER diplomatique.
+
+    Parameters
+    ----------
+    name:
+        Identifiant lisible du profil (ex : ``"medieval_french"``).
+    nfc:
+        Applique la normalisation Unicode NFC (recommandé, activé par défaut).
+    caseless:
+        Pliage de casse (casefold) après NFC.
+    diplomatic_table:
+        Table de correspondances graphiques historiques appliquée caractère
+        par caractère sur les deux textes avant calcul du CER.
+    exclude_chars:
+        Ensemble de caractères supprimés des deux textes (GT et OCR) avant
+        tout calcul de métriques (CER, WER, MER, WIL et CER diplomatique).
+        Utile pour ignorer la ponctuation ou les apostrophes.
+    description:
+        Description courte du profil (affichée dans le rapport HTML).
+    """
+
+    name: str
+    nfc: bool = True
+    caseless: bool = False
+    diplomatic_table: dict[str, str] = field(default_factory=dict)
+    exclude_chars: frozenset = field(default_factory=frozenset)
+    description: str = ""
+
+    def normalize(self, text: str) -> str:
+        """Applique le profil de normalisation à un texte."""
+        if self.exclude_chars:
+            text = "".join(c for c in text if c not in self.exclude_chars)
+        if self.nfc:
+            text = unicodedata.normalize("NFC", text)
+        if self.caseless:
+            text = text.casefold()
+        if self.diplomatic_table:
+            text = _apply_diplomatic_table(text, self.diplomatic_table)
+        return text
+
+    def as_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "nfc": self.nfc,
+            "caseless": self.caseless,
+            "diplomatic_table": self.diplomatic_table,
+            "exclude_chars": sorted(self.exclude_chars),
+            "description": self.description,
+        }
+
+    @classmethod
+    def from_yaml(cls, path: str | Path) -> "NormalizationProfile":
+        """Charge un profil depuis un fichier YAML.
+
+        Le fichier YAML doit contenir les clés ``name``, optionnellement
+        ``caseless``, ``description``, ``diplomatic`` (dict str→str) et
+        ``exclude_chars`` (liste ou chaîne de caractères à ignorer).
+
+        Example
+        -------
+        .. code-block:: yaml
+
+            name: medieval_custom
+            caseless: false
+            description: Français médiéval personnalisé
+            exclude_chars: ".,;:!?"
+            diplomatic:
+              ſ: s
+              u: v
+        """
+        try:
+            import yaml
+        except ImportError as exc:
+            raise RuntimeError(
+                "Le package 'pyyaml' est requis pour charger les profils YAML. "
+                "Installez-le avec : pip install pyyaml"
+            ) from exc
+
+        data = yaml.safe_load(Path(path).read_text(encoding="utf-8"))
+        return cls(
+            name=data.get("name", Path(path).stem),
+            nfc=bool(data.get("nfc", True)),
+            caseless=bool(data.get("caseless", False)),
+            diplomatic_table=data.get("diplomatic", {}),
+            exclude_chars=_parse_exclude_chars(data.get("exclude_chars", "")),
+            description=data.get("description", ""),
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "NormalizationProfile":
+        """Charge un profil depuis un dictionnaire (ex : section YAML inline)."""
+        return cls(
+            name=data.get("name", "custom"),
+            nfc=bool(data.get("nfc", True)),
+            caseless=bool(data.get("caseless", False)),
+            diplomatic_table=data.get("diplomatic", {}),
+            exclude_chars=_parse_exclude_chars(data.get("exclude_chars", "")),
+            description=data.get("description", ""),
+        )
+
+
+# ---------------------------------------------------------------------------
+# Profils préconfigurés
+# ---------------------------------------------------------------------------
+
+NORMALIZATION_PROFILES: dict[str, NormalizationProfile] = {
+    "nfc": NormalizationProfile(
+        name="nfc",
+        nfc=True,
+        caseless=False,
+        diplomatic_table={},
+        description="Normalisation NFC uniquement",
+    ),
+    "caseless": NormalizationProfile(
+        name="caseless",
+        nfc=True,
+        caseless=True,
+        diplomatic_table={},
+        description="NFC + insensible à la casse",
+    ),
+    "minimal": NormalizationProfile(
+        name="minimal",
+        nfc=True,
+        caseless=False,
+        diplomatic_table=DIPLOMATIC_MINIMAL,
+        description="Minimal : NFC + s long seulement",
+    ),
+    "medieval_french": NormalizationProfile(
+        name="medieval_french",
+        nfc=True,
+        caseless=False,
+        diplomatic_table=DIPLOMATIC_FR_MEDIEVAL,
+        description="Français médiéval (XIIe–XVe) : ſ=s, u=v, i=j, æ=ae, œ=oe",
+    ),
+    "early_modern_french": NormalizationProfile(
+        name="early_modern_french",
+        nfc=True,
+        caseless=False,
+        diplomatic_table=DIPLOMATIC_FR_EARLY_MODERN,
+        description="Imprimés anciens (XVIe–XVIIIe) : ſ=s, æ=ae, œ=oe",
+    ),
+    "medieval_latin": NormalizationProfile(
+        name="medieval_latin",
+        nfc=True,
+        caseless=False,
+        diplomatic_table=DIPLOMATIC_LATIN_MEDIEVAL,
+        description="Latin médiéval : ſ=s, u=v, i=j, ꝑ=per, ꝓ=pro",
+    ),
+    "early_modern_english": NormalizationProfile(
+        name="early_modern_english",
+        nfc=True,
+        caseless=False,
+        diplomatic_table=DIPLOMATIC_EN_EARLY_MODERN,
+        description="Early Modern English (XVIth–XVIIIth c.): ſ=s, u=v, i=j, vv=w, þ=th, ð=th, ȝ=y",
+    ),
+    "medieval_english": NormalizationProfile(
+        name="medieval_english",
+        nfc=True,
+        caseless=False,
+        diplomatic_table=DIPLOMATIC_EN_MEDIEVAL,
+        description="Medieval English (XIIth–XVth c.): ſ=s, u=v, i=j, þ=th, ȝ=y, ꝑ=per, ꝓ=pro",
+    ),
+    "secretary_hand": NormalizationProfile(
+        name="secretary_hand",
+        nfc=True,
+        caseless=False,
+        diplomatic_table=DIPLOMATIC_EN_SECRETARY,
+        description="Secretary hand (XVIth–XVIIth c.): ſ=s, u=v, i=j, vv=w, þ=th, ð=th, ȝ=y",
+    ),
+    # ── Profils d'exclusion de caractères ────────────────────────────────
+    "sans_ponctuation": NormalizationProfile(
+        name="sans_ponctuation",
+        nfc=True,
+        caseless=False,
+        diplomatic_table={},
+        exclude_chars=frozenset(". , ; : ! ? ' \u2019 \" - \u2013 \u2014 ( ) [ ]".split()),
+        description="NFC + suppression de la ponctuation courante : . , ; : ! ? ' \" - – — ( ) [ ]",
+    ),
+    "sans_apostrophes": NormalizationProfile(
+        name="sans_apostrophes",
+        nfc=True,
+        caseless=False,
+        diplomatic_table={},
+        exclude_chars=frozenset(["'", "\u2019"]),  # apostrophe droite + apostrophe typographique
+        description="NFC + suppression des apostrophes droite (') et typographique (\u2019)",
+    ),
+}
+
+
+def get_builtin_profile(name: str) -> NormalizationProfile:
+    """Retourne un profil préconfigurée par son identifiant.
+
+    Identifiants disponibles
+    ------------------------
+    - ``"medieval_french"``      : français médiéval XIIe–XVe (ſ=s, u=v, i=j, æ=ae, œ=oe…)
+    - ``"early_modern_french"``  : imprimés anciens XVIe–XVIIIe (ſ=s, œ=oe, æ=ae…)
+    - ``"medieval_latin"``       : latin médiéval (ſ=s, u=v, i=j, ꝑ=per, ꝓ=pro…)
+    - ``"early_modern_english"`` : anglais imprimé XVIe–XVIIIe (ſ=s, u=v, i=j, vv=w, þ=th, ð=th, ȝ=y)
+    - ``"medieval_english"``     : anglais manuscrit XIIe–XVe (+ abréviations ꝑ, ꝓ…)
+    - ``"secretary_hand"``       : écriture secrétaire anglaise XVIe–XVIIe (cursive administrative)
+    - ``"minimal"``              : uniquement NFC + s long
+    - ``"nfc"``                  : NFC seul (sans table diplomatique)
+    - ``"caseless"``             : NFC + pliage de casse
+
+    Raises
+    ------
+    KeyError
+        Si le nom n'est pas reconnu.
+    """
+    if name not in NORMALIZATION_PROFILES:
+        raise KeyError(
+            f"Profil de normalisation inconnu : '{name}'. "
+            f"Disponibles : {', '.join(NORMALIZATION_PROFILES)}"
+        )
+    return NORMALIZATION_PROFILES[name]
+
+
+# ---------------------------------------------------------------------------
+# Fonctions utilitaires
+# ---------------------------------------------------------------------------
+
+def _parse_exclude_chars(value: "str | list | None") -> frozenset:
+    """Convertit une liste de caractères (str ou list) en frozenset.
+
+    Accepte :
+    - Une chaîne de caractères séparés par une virgule+espace (ex. ``"', -, –"``)
+      ou simplement concaténés sans séparateur (ex. ``".,;:!?"``)
+    - Une liste Python/YAML de chaînes (chacune un caractère)
+    - None ou chaîne vide → frozenset vide
+
+    Règle de désambiguïsation : si la chaîne contient la séquence ``", "``
+    (virgule suivie d'un espace), on découpe par ``", "``. Sinon, chaque
+    caractère Unicode est un item distinct.
+    """
+    if not value:
+        return frozenset()
+    if isinstance(value, (list, tuple)):
+        return frozenset(str(c) for c in value if c)
+    raw = str(value)
+    # Désambiguïsation : séparer par ", " si présent (format lisible)
+    if ", " in raw:
+        return frozenset(c.strip() for c in raw.split(",") if c.strip())
+    # Sinon, chaque caractère Unicode est un item distinct
+    return frozenset(raw)
+
+
+def _apply_diplomatic_table(text: str, table: dict[str, str]) -> str:
+    """Applique une table de correspondances diplomatiques en un seul pass.
+
+    Les clés multi-caractères (ex : ``"ae"`` → ``"æ"``) sont gérées en priorité
+    sur les correspondances simples. Le remplacement est fait en un seul pass
+    via regex pour éviter les remplacements en cascade (ex : ``"ſ"→"s"`` puis
+    ``"s"→"z"`` donnerait ``"z"`` au lieu de ``"s"``).
+    """
+    if not table:
+        return text
+
+    import re
+
+    # Séparer les clés simples (1 char) des clés multi-chars
+    multi_keys = sorted(
+        (k for k in table if len(k) > 1), key=len, reverse=True
+    )
+    simple_table = {k: v for k, v in table.items() if len(k) == 1}
+
+    if multi_keys:
+        # Single-pass : construire un pattern regex avec toutes les clés multi-chars
+        # triées par longueur décroissante pour matcher les plus longues d'abord
+        pattern = re.compile("|".join(re.escape(k) for k in multi_keys))
+        text = pattern.sub(lambda m: table[m.group(0)], text)
+
+    # Remplacements char par char (single-pass via itération)
+    if simple_table:
+        text = "".join(simple_table.get(c, c) for c in text)
+
+    return text
+
+
+# Profil par défaut utilisé pour le CER diplomatique intégré
+DEFAULT_DIPLOMATIC_PROFILE: NormalizationProfile = get_builtin_profile("medieval_french")

picarones/measurements/normalization.py

@@ -1,420 +1,58 @@
-"""Profils de normalisation unicode pour le calcul du CER diplomatique.
-
-La normalisation diplomatique permet de calculer un CER tenant compte des
-équivalences graphiques propres aux documents historiques : ſ=s, u=v, i=j, etc.
-
-En appliquant la même table aux deux textes (GT et OCR), on mesure les erreurs
-"substantielles" (transcription erronée) en ignorant les variations graphiques
-codifiées connues.
-
-Trois niveaux de normalisation sont disponibles :
-
-1. NFC       : normalisation Unicode canonique (décomposition+recomposition)
-2. caseless  : NFC + pliage de casse (casefold)
-3. diplomatic: NFC + table de correspondances historiques configurables
-
-Les profils préconfigurés couvrent les cas d'usage patrimoniaux courants.
-Ils sont également chargeables depuis un fichier YAML.
-
-Exemple YAML
-------------
-name: medieval_custom
-caseless: false
-diplomatic:
-  ſ: s
-  u: v
-  i: j
-  y: i
-  æ: ae
-  œ: oe
+"""Re-export depuis ``picarones.formats.text.normalization`` — Sprint A14-S9.
+
+Le contenu canonique de ce module a été déplacé vers
+``picarones/formats/text/normalization.py`` au Sprint S9 du
+rewrite ciblé (cf. ``docs/roadmap/rewrite-2026.md``).
+
+Ce fichier est conservé comme re-export pour ne **rien casser**
+chez les ~50 consommateurs qui font ``from
+picarones.measurements.normalization import X``.  Les symboles
+publics ET privés utilisés downstream (``_parse_exclude_chars``,
+``_apply_diplomatic_table``) sont ré-exposés explicitement.
+
+Plan de migration
+-----------------
+Au S22, les consommateurs qui importent encore depuis cet
+emplacement seront migrés vers ``picarones.formats.text.normalization``
+et ce re-export disparaîtra.
+
+Règle architecturale
+--------------------
+``measurements/`` (ancien code legacy) est autorisé à importer
+``formats/`` (nouveau code) pendant la phase de migration.
+L'inverse est interdit (vérifié par ``test_layer_dependencies``).
 """
 
 from __future__ import annotations
 
-import unicodedata
-from dataclasses import dataclass, field
-from pathlib import Path
-
-
-# ---------------------------------------------------------------------------
-# Tables de correspondances diplomatiques préconfigurées
-# ---------------------------------------------------------------------------
-
-#: Français médiéval (XIIe–XVe siècle)
-DIPLOMATIC_FR_MEDIEVAL: dict[str, str] = {
-    "ſ": "s",    # s long → s
-    "u": "v",    # u/v interchangeables en position initiale
-    "i": "j",    # i/j interchangeables
-    "y": "i",    # y vocalique → i
-    "æ": "ae",   # ligature æ
-    "œ": "oe",   # ligature œ
-    "ꝑ": "per",  # abréviation per/par
-    "ꝓ": "pro",  # abréviation pro
-    "\u0026": "et",  # & → et
-}
-
-#: Français moderne / imprimés anciens (XVIe–XVIIIe siècle)
-DIPLOMATIC_FR_EARLY_MODERN: dict[str, str] = {
-    "ſ": "s",    # s long
-    "æ": "ae",
-    "œ": "oe",
-    "\u0026": "et",
-    "ỹ": "yn",   # y tilde
-}
-
-#: Latin médiéval
-DIPLOMATIC_LATIN_MEDIEVAL: dict[str, str] = {
-    "ſ": "s",
-    "u": "v",
-    "i": "j",
-    "y": "i",
-    "æ": "ae",
-    "œ": "oe",
-    "ꝑ": "per",
-    "ꝓ": "pro",
-    "ꝗ": "que",   # q barré → que
-    "\u0026": "et",
-}
-
-#: Profil minimal — uniquement NFC + s long
-DIPLOMATIC_MINIMAL: dict[str, str] = {
-    "ſ": "s",
-}
-
-#: Anglais moderne / imprimés anciens (XVIe–XVIIIe siècle)
-#: Orthographe «early modern»  : ſ=s, u/v, i/j, vv=w, þ=th, ð=th, ȝ=y
-DIPLOMATIC_EN_EARLY_MODERN: dict[str, str] = {
-    "ſ": "s",     # s long → s
-    "u": "v",     # u/v interchangeables (vpon → upon)
-    "i": "j",     # i/j interchangeables (ioy → joy)
-    "vv": "w",    # vv → w (vvhich → which)
-    "þ": "th",    # thorn → th
-    "ð": "th",    # eth → th
-    "ȝ": "y",     # yogh → y
-    "æ": "ae",    # ligature æ
-    "œ": "oe",    # ligature œ
-    "\u0026": "and",  # & → and
-}
-
-#: Anglais médiéval (XIIe–XVe siècle) — abréviations manuscrites incluses
-DIPLOMATIC_EN_MEDIEVAL: dict[str, str] = {
-    "ſ": "s",
-    "u": "v",
-    "i": "j",
-    "vv": "w",
-    "þ": "th",
-    "ð": "th",
-    "ȝ": "y",
-    "æ": "ae",
-    "œ": "oe",
-    "\u0026": "and",
-    # Abréviations courantes dans les manuscrits anglais médiévaux
-    "ꝑ": "per",   # p barré → per/par
-    "ꝓ": "pro",   # p crocheté → pro
-    "ꝗ": "que",   # q barré → que
-    "\ua75b": "r", # lettre r rotunda → r
-}
-
-#: Écriture secrétaire (XVIe–XVIIe siècle) — secretary hand
-#: Confusions visuelles propres à l'écriture cursive anglaise
-DIPLOMATIC_EN_SECRETARY: dict[str, str] = {
-    "ſ": "s",
-    "u": "v",
-    "i": "j",
-    "vv": "w",
-    "þ": "th",
-    "ð": "th",
-    "ȝ": "y",
-    "\u0026": "and",
-    # Confusions visuelles typiques : e/c, n/u, m/w en secrétaire
-    # Note : ne pas normaliser e/c automatiquement (trop agressif) ;
-    # on se limite aux substituts graphiques historiquement documentés
-}
-
-
-# ---------------------------------------------------------------------------
-# Profil de normalisation
-# ---------------------------------------------------------------------------
-
-@dataclass
-class NormalizationProfile:
-    """Décrit une stratégie de normalisation pour le calcul du CER diplomatique.
-
-    Parameters
-    ----------
-    name:
-        Identifiant lisible du profil (ex : ``"medieval_french"``).
-    nfc:
-        Applique la normalisation Unicode NFC (recommandé, activé par défaut).
-    caseless:
-        Pliage de casse (casefold) après NFC.
-    diplomatic_table:
-        Table de correspondances graphiques historiques appliquée caractère
-        par caractère sur les deux textes avant calcul du CER.
-    exclude_chars:
-        Ensemble de caractères supprimés des deux textes (GT et OCR) avant
-        tout calcul de métriques (CER, WER, MER, WIL et CER diplomatique).
-        Utile pour ignorer la ponctuation ou les apostrophes.
-    description:
-        Description courte du profil (affichée dans le rapport HTML).
-    """
-
-    name: str
-    nfc: bool = True
-    caseless: bool = False
-    diplomatic_table: dict[str, str] = field(default_factory=dict)
-    exclude_chars: frozenset = field(default_factory=frozenset)
-    description: str = ""
-
-    def normalize(self, text: str) -> str:
-        """Applique le profil de normalisation à un texte."""
-        if self.exclude_chars:
-            text = "".join(c for c in text if c not in self.exclude_chars)
-        if self.nfc:
-            text = unicodedata.normalize("NFC", text)
-        if self.caseless:
-            text = text.casefold()
-        if self.diplomatic_table:
-            text = _apply_diplomatic_table(text, self.diplomatic_table)
-        return text
-
-    def as_dict(self) -> dict:
-        return {
-            "name": self.name,
-            "nfc": self.nfc,
-            "caseless": self.caseless,
-            "diplomatic_table": self.diplomatic_table,
-            "exclude_chars": sorted(self.exclude_chars),
-            "description": self.description,
-        }
-
-    @classmethod
-    def from_yaml(cls, path: str | Path) -> "NormalizationProfile":
-        """Charge un profil depuis un fichier YAML.
-
-        Le fichier YAML doit contenir les clés ``name``, optionnellement
-        ``caseless``, ``description``, ``diplomatic`` (dict str→str) et
-        ``exclude_chars`` (liste ou chaîne de caractères à ignorer).
-
-        Example
-        -------
-        .. code-block:: yaml
-
-            name: medieval_custom
-            caseless: false
-            description: Français médiéval personnalisé
-            exclude_chars: ".,;:!?"
-            diplomatic:
-              ſ: s
-              u: v
-        """
-        try:
-            import yaml
-        except ImportError as exc:
-            raise RuntimeError(
-                "Le package 'pyyaml' est requis pour charger les profils YAML. "
-                "Installez-le avec : pip install pyyaml"
-            ) from exc
-
-        data = yaml.safe_load(Path(path).read_text(encoding="utf-8"))
-        return cls(
-            name=data.get("name", Path(path).stem),
-            nfc=bool(data.get("nfc", True)),
-            caseless=bool(data.get("caseless", False)),
-            diplomatic_table=data.get("diplomatic", {}),
-            exclude_chars=_parse_exclude_chars(data.get("exclude_chars", "")),
-            description=data.get("description", ""),
-        )
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "NormalizationProfile":
-        """Charge un profil depuis un dictionnaire (ex : section YAML inline)."""
-        return cls(
-            name=data.get("name", "custom"),
-            nfc=bool(data.get("nfc", True)),
-            caseless=bool(data.get("caseless", False)),
-            diplomatic_table=data.get("diplomatic", {}),
-            exclude_chars=_parse_exclude_chars(data.get("exclude_chars", "")),
-            description=data.get("description", ""),
-        )
-
-
-# ---------------------------------------------------------------------------
-# Profils préconfigurés
-# ---------------------------------------------------------------------------
-
-NORMALIZATION_PROFILES: dict[str, NormalizationProfile] = {
-    "nfc": NormalizationProfile(
-        name="nfc",
-        nfc=True,
-        caseless=False,
-        diplomatic_table={},
-        description="Normalisation NFC uniquement",
-    ),
-    "caseless": NormalizationProfile(
-        name="caseless",
-        nfc=True,
-        caseless=True,
-        diplomatic_table={},
-        description="NFC + insensible à la casse",
-    ),
-    "minimal": NormalizationProfile(
-        name="minimal",
-        nfc=True,
-        caseless=False,
-        diplomatic_table=DIPLOMATIC_MINIMAL,
-        description="Minimal : NFC + s long seulement",
-    ),
-    "medieval_french": NormalizationProfile(
-        name="medieval_french",
-        nfc=True,
-        caseless=False,
-        diplomatic_table=DIPLOMATIC_FR_MEDIEVAL,
-        description="Français médiéval (XIIe–XVe) : ſ=s, u=v, i=j, æ=ae, œ=oe",
-    ),
-    "early_modern_french": NormalizationProfile(
-        name="early_modern_french",
-        nfc=True,
-        caseless=False,
-        diplomatic_table=DIPLOMATIC_FR_EARLY_MODERN,
-        description="Imprimés anciens (XVIe–XVIIIe) : ſ=s, æ=ae, œ=oe",
-    ),
-    "medieval_latin": NormalizationProfile(
-        name="medieval_latin",
-        nfc=True,
-        caseless=False,
-        diplomatic_table=DIPLOMATIC_LATIN_MEDIEVAL,
-        description="Latin médiéval : ſ=s, u=v, i=j, ꝑ=per, ꝓ=pro",
-    ),
-    "early_modern_english": NormalizationProfile(
-        name="early_modern_english",
-        nfc=True,
-        caseless=False,
-        diplomatic_table=DIPLOMATIC_EN_EARLY_MODERN,
-        description="Early Modern English (XVIth–XVIIIth c.): ſ=s, u=v, i=j, vv=w, þ=th, ð=th, ȝ=y",
-    ),
-    "medieval_english": NormalizationProfile(
-        name="medieval_english",
-        nfc=True,
-        caseless=False,
-        diplomatic_table=DIPLOMATIC_EN_MEDIEVAL,
-        description="Medieval English (XIIth–XVth c.): ſ=s, u=v, i=j, þ=th, ȝ=y, ꝑ=per, ꝓ=pro",
-    ),
-    "secretary_hand": NormalizationProfile(
-        name="secretary_hand",
-        nfc=True,
-        caseless=False,
-        diplomatic_table=DIPLOMATIC_EN_SECRETARY,
-        description="Secretary hand (XVIth–XVIIth c.): ſ=s, u=v, i=j, vv=w, þ=th, ð=th, ȝ=y",
-    ),
-    # ── Profils d'exclusion de caractères ────────────────────────────────
-    "sans_ponctuation": NormalizationProfile(
-        name="sans_ponctuation",
-        nfc=True,
-        caseless=False,
-        diplomatic_table={},
-        exclude_chars=frozenset(". , ; : ! ? ' \u2019 \" - \u2013 \u2014 ( ) [ ]".split()),
-        description="NFC + suppression de la ponctuation courante : . , ; : ! ? ' \" - – — ( ) [ ]",
-    ),
-    "sans_apostrophes": NormalizationProfile(
-        name="sans_apostrophes",
-        nfc=True,
-        caseless=False,
-        diplomatic_table={},
-        exclude_chars=frozenset(["'", "\u2019"]),  # apostrophe droite + apostrophe typographique
-        description="NFC + suppression des apostrophes droite (') et typographique (\u2019)",
-    ),
-}
-
-
-def get_builtin_profile(name: str) -> NormalizationProfile:
-    """Retourne un profil préconfigurée par son identifiant.
-
-    Identifiants disponibles
-    ------------------------
-    - ``"medieval_french"``      : français médiéval XIIe–XVe (ſ=s, u=v, i=j, æ=ae, œ=oe…)
-    - ``"early_modern_french"``  : imprimés anciens XVIe–XVIIIe (ſ=s, œ=oe, æ=ae…)
-    - ``"medieval_latin"``       : latin médiéval (ſ=s, u=v, i=j, ꝑ=per, ꝓ=pro…)
-    - ``"early_modern_english"`` : anglais imprimé XVIe–XVIIIe (ſ=s, u=v, i=j, vv=w, þ=th, ð=th, ȝ=y)
-    - ``"medieval_english"``     : anglais manuscrit XIIe–XVe (+ abréviations ꝑ, ꝓ…)
-    - ``"secretary_hand"``       : écriture secrétaire anglaise XVIe–XVIIe (cursive administrative)
-    - ``"minimal"``              : uniquement NFC + s long
-    - ``"nfc"``                  : NFC seul (sans table diplomatique)
-    - ``"caseless"``             : NFC + pliage de casse
-
-    Raises
-    ------
-    KeyError
-        Si le nom n'est pas reconnu.
-    """
-    if name not in NORMALIZATION_PROFILES:
-        raise KeyError(
-            f"Profil de normalisation inconnu : '{name}'. "
-            f"Disponibles : {', '.join(NORMALIZATION_PROFILES)}"
-        )
-    return NORMALIZATION_PROFILES[name]
-
-
-# ---------------------------------------------------------------------------
-# Fonctions utilitaires
-# ---------------------------------------------------------------------------
-
-def _parse_exclude_chars(value: "str | list | None") -> frozenset:
-    """Convertit une liste de caractères (str ou list) en frozenset.
-
-    Accepte :
-    - Une chaîne de caractères séparés par une virgule+espace (ex. ``"', -, –"``)
-      ou simplement concaténés sans séparateur (ex. ``".,;:!?"``)
-    - Une liste Python/YAML de chaînes (chacune un caractère)
-    - None ou chaîne vide → frozenset vide
-
-    Règle de désambiguïsation : si la chaîne contient la séquence ``", "``
-    (virgule suivie d'un espace), on découpe par ``", "``. Sinon, chaque
-    caractère Unicode est un item distinct.
-    """
-    if not value:
-        return frozenset()
-    if isinstance(value, (list, tuple)):
-        return frozenset(str(c) for c in value if c)
-    raw = str(value)
-    # Désambiguïsation : séparer par ", " si présent (format lisible)
-    if ", " in raw:
-        return frozenset(c.strip() for c in raw.split(",") if c.strip())
-    # Sinon, chaque caractère Unicode est un item distinct
-    return frozenset(raw)
-
-
-def _apply_diplomatic_table(text: str, table: dict[str, str]) -> str:
-    """Applique une table de correspondances diplomatiques en un seul pass.
-
-    Les clés multi-caractères (ex : ``"ae"`` → ``"æ"``) sont gérées en priorité
-    sur les correspondances simples. Le remplacement est fait en un seul pass
-    via regex pour éviter les remplacements en cascade (ex : ``"ſ"→"s"`` puis
-    ``"s"→"z"`` donnerait ``"z"`` au lieu de ``"s"``).
-    """
-    if not table:
-        return text
-
-    import re
-
-    # Séparer les clés simples (1 char) des clés multi-chars
-    multi_keys = sorted(
-        (k for k in table if len(k) > 1), key=len, reverse=True
-    )
-    simple_table = {k: v for k, v in table.items() if len(k) == 1}
-
-    if multi_keys:
-        # Single-pass : construire un pattern regex avec toutes les clés multi-chars
-        # triées par longueur décroissante pour matcher les plus longues d'abord
-        pattern = re.compile("|".join(re.escape(k) for k in multi_keys))
-        text = pattern.sub(lambda m: table[m.group(0)], text)
-
-    # Remplacements char par char (single-pass via itération)
-    if simple_table:
-        text = "".join(simple_table.get(c, c) for c in text)
-
-    return text
-
-
-# Profil par défaut utilisé pour le CER diplomatique intégré
-DEFAULT_DIPLOMATIC_PROFILE: NormalizationProfile = get_builtin_profile("medieval_french")
+from picarones.formats.text.normalization import (
+    DEFAULT_DIPLOMATIC_PROFILE,
+    DIPLOMATIC_EN_EARLY_MODERN,
+    DIPLOMATIC_EN_MEDIEVAL,
+    DIPLOMATIC_EN_SECRETARY,
+    DIPLOMATIC_FR_EARLY_MODERN,
+    DIPLOMATIC_FR_MEDIEVAL,
+    DIPLOMATIC_LATIN_MEDIEVAL,
+    DIPLOMATIC_MINIMAL,
+    NORMALIZATION_PROFILES,
+    NormalizationProfile,
+    _apply_diplomatic_table,
+    _parse_exclude_chars,
+    get_builtin_profile,
+)
+
+__all__ = [
+    "NormalizationProfile",
+    "DIPLOMATIC_FR_MEDIEVAL",
+    "DIPLOMATIC_FR_EARLY_MODERN",
+    "DIPLOMATIC_LATIN_MEDIEVAL",
+    "DIPLOMATIC_MINIMAL",
+    "DIPLOMATIC_EN_EARLY_MODERN",
+    "DIPLOMATIC_EN_MEDIEVAL",
+    "DIPLOMATIC_EN_SECRETARY",
+    "NORMALIZATION_PROFILES",
+    "DEFAULT_DIPLOMATIC_PROFILE",
+    "get_builtin_profile",
+    "_parse_exclude_chars",
+    "_apply_diplomatic_table",
+]

tests/architecture/test_file_budgets.py

@@ -82,7 +82,11 @@ FILE_BUDGETS: dict[str, int] = {
     "picarones/extras/importers/huggingface.py": 550,     # actuel 464
     "picarones/core/metric_hooks.py": 500,                # actuel 423
     "picarones/measurements/numerical_sequences.py": 500, # actuel 422
-    "picarones/measurements/normalization.py": 500,       # actuel 420
+    "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
+    # canonique vit ici.
+    "picarones/formats/text/normalization.py": 500,       # actuel 420
     "picarones/report/comparison.py": 500,                # actuel 409
     # --- Module mutualisé créé par le sprint des render helpers
     # (Sprint « consolidation des renderers » 2026-05-02). Budget

tests/formats/alto/test_sprint_a14_s9_alto.py

@@ -0,0 +1,316 @@
+"""Sprint A14-S9 — ALTO parser, writer, projector.
+
+Tests minimaux mais couvrant les invariants critiques :
+
+- Round-trip ``parse → write → parse`` préserve la structure.
+- Détection auto v2 / v3 / v4 / sans namespace.
+- Extraction texte respecte ``Page → Block → Line → String``.
+- Césure ``HypPart1`` / ``HypPart2`` (même ligne ET cross-ligne).
+- ``defusedxml`` bloque les attaques XXE.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.domain import Artifact, ArtifactType
+from picarones.domain.errors import ProjectionError
+from picarones.formats.alto import (
+    AltoBBox,
+    AltoDocument,
+    AltoLine,
+    AltoPage,
+    AltoParseError,
+    AltoString,
+    AltoTextBlock,
+    AltoToText,
+    alto_document_to_text,
+    parse_alto,
+    write_alto,
+)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Fixtures synthétiques
+# ──────────────────────────────────────────────────────────────────────
+
+
+def _simple_doc() -> AltoDocument:
+    return AltoDocument(
+        pages=(AltoPage(
+            id="p1", width=1000, height=1500,
+            blocks=(AltoTextBlock(
+                id="b1",
+                lines=(
+                    AltoLine(id="l1", strings=(
+                        AltoString(content="Hello", id="s1"),
+                        AltoString(content="world", id="s2"),
+                    )),
+                    AltoLine(id="l2", strings=(
+                        AltoString(content="second", id="s3"),
+                        AltoString(content="line", id="s4"),
+                    )),
+                ),
+            ),),
+        ),),
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Parser — détection de namespaces
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestParserVersions:
+    def test_v4_namespace_detected(self) -> None:
+        xml = b'''<?xml version="1.0"?>
+<alto xmlns="http://www.loc.gov/standards/alto/ns-v4#">
+  <Layout><Page ID="p" WIDTH="100" HEIGHT="200">
+    <PrintSpace>
+      <TextBlock ID="b">
+        <TextLine ID="l">
+          <String CONTENT="hi"/>
+        </TextLine>
+      </TextBlock>
+    </PrintSpace>
+  </Page></Layout>
+</alto>'''
+        doc = parse_alto(xml)
+        assert doc.source_version == "v4"
+        assert len(doc.pages) == 1
+
+    def test_v3_namespace_detected(self) -> None:
+        xml = b'''<?xml version="1.0"?>
+<alto xmlns="http://www.loc.gov/standards/alto/ns-v3#">
+  <Layout><Page ID="p"><PrintSpace>
+    <TextBlock><TextLine><String CONTENT="x"/></TextLine></TextBlock>
+  </PrintSpace></Page></Layout>
+</alto>'''
+        doc = parse_alto(xml)
+        assert doc.source_version == "v3"
+
+    def test_v2_namespace_detected(self) -> None:
+        xml = b'''<?xml version="1.0"?>
+<alto xmlns="http://www.loc.gov/standards/alto/ns-v2#">
+  <Layout><Page><PrintSpace>
+    <TextBlock><TextLine><String CONTENT="x"/></TextLine></TextBlock>
+  </PrintSpace></Page></Layout>
+</alto>'''
+        doc = parse_alto(xml)
+        assert doc.source_version == "v2"
+
+    def test_no_namespace_accepted(self) -> None:
+        xml = b'''<?xml version="1.0"?>
+<alto>
+  <Layout><Page><PrintSpace>
+    <TextBlock><TextLine><String CONTENT="x"/></TextLine></TextBlock>
+  </PrintSpace></Page></Layout>
+</alto>'''
+        doc = parse_alto(xml)
+        assert doc.source_version == "none"
+
+    def test_invalid_xml_raises(self) -> None:
+        with pytest.raises(AltoParseError, match="invalide"):
+            parse_alto(b"<not closed")
+
+    def test_empty_xml_raises(self) -> None:
+        with pytest.raises(AltoParseError, match="vide"):
+            parse_alto(b"")
+
+    def test_xxe_blocked(self) -> None:
+        """defusedxml doit bloquer les attaques XXE."""
+        xml = b'''<?xml version="1.0"?>
+<!DOCTYPE foo [<!ENTITY xxe SYSTEM "file:///etc/passwd">]>
+<alto>&xxe;</alto>'''
+        with pytest.raises(AltoParseError):
+            parse_alto(xml)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Round-trip writer/parser
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestRoundTrip:
+    def test_simple_doc_roundtrip(self) -> None:
+        doc = _simple_doc()
+        xml = write_alto(doc)
+        doc2 = parse_alto(xml)
+        # Les structures internes sont équivalentes (sans
+        # tenir compte de source_version qui peut différer).
+        assert len(doc2.pages) == len(doc.pages)
+        assert len(doc2.pages[0].blocks) == len(doc.pages[0].blocks)
+        assert doc2.pages[0].width == doc.pages[0].width
+        assert doc2.pages[0].height == doc.pages[0].height
+
+    def test_string_content_preserved(self) -> None:
+        doc = _simple_doc()
+        xml = write_alto(doc)
+        doc2 = parse_alto(xml)
+        block = doc2.pages[0].blocks[0]
+        assert block.lines[0].strings[0].content == "Hello"
+        assert block.lines[1].strings[1].content == "line"
+
+    def test_bbox_preserved(self) -> None:
+        doc = AltoDocument(
+            pages=(AltoPage(
+                blocks=(AltoTextBlock(
+                    lines=(AltoLine(strings=(
+                        AltoString(
+                            content="x",
+                            bbox=AltoBBox(hpos=10, vpos=20, width=30, height=40),
+                        ),
+                    ),),),
+                ),),
+            ),),
+        )
+        doc2 = parse_alto(write_alto(doc))
+        bbox = doc2.pages[0].blocks[0].lines[0].strings[0].bbox
+        assert bbox is not None
+        assert bbox.hpos == 10 and bbox.vpos == 20
+        assert bbox.width == 30 and bbox.height == 40
+
+    def test_byte_deterministic(self) -> None:
+        """Même structure → mêmes octets."""
+        doc1 = _simple_doc()
+        doc2 = _simple_doc()
+        assert write_alto(doc1) == write_alto(doc2)
+
+    def test_write_in_v3(self) -> None:
+        xml = write_alto(_simple_doc(), version="v3")
+        doc = parse_alto(xml)
+        assert doc.source_version == "v3"
+
+    def test_write_no_namespace(self) -> None:
+        xml = write_alto(_simple_doc(), version="none")
+        doc = parse_alto(xml)
+        assert doc.source_version == "none"
+
+    def test_invalid_version_rejected(self) -> None:
+        from picarones.domain.errors import PicaronesError
+        with pytest.raises(PicaronesError, match="version ALTO invalide"):
+            write_alto(_simple_doc(), version="v9")
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Projector — extraction texte + césure
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestExtractText:
+    def test_simple_text(self) -> None:
+        text = alto_document_to_text(_simple_doc())
+        assert text == "Hello world\nsecond line"
+
+    def test_multi_block_separated_by_blank_line(self) -> None:
+        doc = AltoDocument(pages=(AltoPage(
+            blocks=(
+                AltoTextBlock(lines=(
+                    AltoLine(strings=(AltoString(content="A"),)),
+                ),),
+                AltoTextBlock(lines=(
+                    AltoLine(strings=(AltoString(content="B"),)),
+                ),),
+            ),
+        ),),)
+        assert alto_document_to_text(doc) == "A\n\nB"
+
+    def test_hyphenation_same_line_with_subs_content(self) -> None:
+        """HypPart1 + HypPart2 sur la même ligne, SUBS_CONTENT fourni."""
+        doc = AltoDocument(pages=(AltoPage(
+            blocks=(AltoTextBlock(lines=(
+                AltoLine(strings=(
+                    AltoString(content="Bonjour"),
+                    AltoString(
+                        content="est-",
+                        subs_type="HypPart1",
+                        subs_content="est-il",
+                    ),
+                    AltoString(content="il", subs_type="HypPart2"),
+                    AltoString(content="clair"),
+                )),
+            ),),),
+        ),),)
+        # "est-il" reconstruit, "il" suivant skippé.
+        assert alto_document_to_text(doc) == "Bonjour est-il clair"
+
+    def test_hyphenation_cross_line(self) -> None:
+        """HypPart1 fin d'une ligne, HypPart2 début ligne suivante.
+
+        C'est l'usage standard ALTO (la césure visuelle correspond à
+        un saut de ligne réel).
+        """
+        doc = AltoDocument(pages=(AltoPage(
+            blocks=(AltoTextBlock(lines=(
+                AltoLine(strings=(
+                    AltoString(content="ceci"),
+                    AltoString(
+                        content="est-",
+                        subs_type="HypPart1",
+                        subs_content="est-il",
+                    ),
+                )),
+                AltoLine(strings=(
+                    AltoString(content="il", subs_type="HypPart2"),
+                    AltoString(content="clair"),
+                )),
+            ),),),
+        ),),)
+        # Ligne 1 : "ceci est-il" (mot complet placé en fin de ligne 1).
+        # Ligne 2 : "clair" (le HypPart2 "il" est skippé).
+        assert alto_document_to_text(doc) == "ceci est-il\nclair"
+
+    def test_hyphenation_no_subs_content_concatenates(self) -> None:
+        doc = AltoDocument(pages=(AltoPage(
+            blocks=(AltoTextBlock(lines=(
+                AltoLine(strings=(
+                    AltoString(content="lec-", subs_type="HypPart1"),
+                    AltoString(content="ture", subs_type="HypPart2"),
+                )),
+            ),),),
+        ),),)
+        assert alto_document_to_text(doc) == "lec-ture"
+
+
+# ──────────────────────────────────────────────────────────────────────
+# AltoToText projector (protocole)
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestAltoToTextProjector:
+    def test_protocol_satisfied(self) -> None:
+        from picarones.evaluation.projectors import Projector
+        assert isinstance(AltoToText(), Projector)
+
+    def test_project_from_filesystem(self, tmp_path) -> None:
+        xml = write_alto(_simple_doc())
+        path = tmp_path / "doc.alto.xml"
+        path.write_bytes(xml)
+
+        artifact = Artifact(
+            id="d1:ocr:alto",
+            document_id="d1",
+            type=ArtifactType.ALTO_XML,
+            uri=str(path),
+        )
+        projector = AltoToText()
+        target, report = projector.project(artifact, {})
+        assert target.type == ArtifactType.RAW_TEXT
+        assert report.lossy is True
+        assert "geometry" in report.ignored_dimensions
+
+    def test_project_wrong_type_raises(self) -> None:
+        artifact = Artifact(
+            id="d1:image", document_id="d1",
+            type=ArtifactType.IMAGE,
+        )
+        with pytest.raises(ProjectionError, match="ALTO_XML"):
+            AltoToText().project(artifact, {})
+
+    def test_project_missing_uri_raises(self) -> None:
+        artifact = Artifact(
+            id="d1:alto", document_id="d1",
+            type=ArtifactType.ALTO_XML,
+        )
+        with pytest.raises(ProjectionError, match="URI"):
+            AltoToText().project(artifact, {})

tests/formats/pagexml/test_sprint_a14_s9_pagexml.py

@@ -0,0 +1,136 @@
+"""Sprint A14-S9 — PAGE XML parser, projector."""
+
+from __future__ import annotations
+
+import pytest
+
+from picarones.domain import Artifact, ArtifactType
+from picarones.domain.errors import ProjectionError
+from picarones.formats.pagexml import (
+    PageDocument,
+    PageParseError,
+    PagePage,
+    PageTextLine,
+    PageTextRegion,
+    PageToText,
+    page_document_to_text,
+    parse_pagexml,
+)
+
+
+_SAMPLE_PAGE_XML = '''<?xml version="1.0" encoding="UTF-8"?>
+<PcGts xmlns="http://schema.primaresearch.org/PAGE/gts/pagecontent/2019-07-15">
+  <Page imageFilename="folio_001.png" imageWidth="1200" imageHeight="1800">
+    <TextRegion id="r1" type="paragraph">
+      <Coords points="100,100 1100,100 1100,400 100,400"/>
+      <TextLine id="l1">
+        <Coords points="100,100 1100,100 1100,150 100,150"/>
+        <Baseline points="100,140 1100,140"/>
+        <TextEquiv><Unicode>Premier ligne</Unicode></TextEquiv>
+      </TextLine>
+      <TextLine id="l2">
+        <TextEquiv><Unicode>deuxième ligne</Unicode></TextEquiv>
+      </TextLine>
+    </TextRegion>
+    <TextRegion id="r2" type="heading">
+      <TextLine id="l3">
+        <TextEquiv><Unicode>Titre</Unicode></TextEquiv>
+      </TextLine>
+    </TextRegion>
+  </Page>
+</PcGts>
+'''.encode("utf-8")
+
+
+class TestParser:
+    def test_parse_simple_page(self) -> None:
+        doc = parse_pagexml(_SAMPLE_PAGE_XML)
+        assert len(doc.pages) == 1
+        page = doc.pages[0]
+        assert page.image_filename == "folio_001.png"
+        assert page.image_width == 1200
+        assert page.image_height == 1800
+        assert len(page.text_regions) == 2
+
+    def test_text_lines_extracted(self) -> None:
+        doc = parse_pagexml(_SAMPLE_PAGE_XML)
+        r1 = doc.pages[0].text_regions[0]
+        assert len(r1.text_lines) == 2
+        assert r1.text_lines[0].text == "Premier ligne"
+        assert r1.text_lines[0].coords is not None
+        assert r1.text_lines[0].baseline is not None
+
+    def test_region_type_preserved(self) -> None:
+        doc = parse_pagexml(_SAMPLE_PAGE_XML)
+        assert doc.pages[0].text_regions[0].region_type == "paragraph"
+        assert doc.pages[0].text_regions[1].region_type == "heading"
+
+    def test_namespace_detected(self) -> None:
+        doc = parse_pagexml(_SAMPLE_PAGE_XML)
+        assert doc.source_namespace is not None
+        assert "primaresearch" in doc.source_namespace
+
+    def test_empty_raises(self) -> None:
+        with pytest.raises(PageParseError, match="vide"):
+            parse_pagexml(b"")
+
+    def test_invalid_xml_raises(self) -> None:
+        with pytest.raises(PageParseError, match="invalide"):
+            parse_pagexml(b"<not closed")
+
+    def test_xxe_blocked(self) -> None:
+        xml = b'''<?xml version="1.0"?>
+<!DOCTYPE foo [<!ENTITY xxe SYSTEM "file:///etc/passwd">]>
+<PcGts>&xxe;</PcGts>'''
+        with pytest.raises(PageParseError):
+            parse_pagexml(xml)
+
+
+class TestExtractText:
+    def test_full_extraction(self) -> None:
+        doc = parse_pagexml(_SAMPLE_PAGE_XML)
+        text = page_document_to_text(doc)
+        # 2 régions séparées par ligne vide, lignes par \n.
+        assert text == "Premier ligne\ndeuxième ligne\n\nTitre"
+
+    def test_empty_document(self) -> None:
+        doc = PageDocument()
+        assert page_document_to_text(doc) == ""
+
+    def test_region_without_lines_skipped(self) -> None:
+        doc = PageDocument(pages=(PagePage(
+            text_regions=(
+                PageTextRegion(id="empty"),
+                PageTextRegion(
+                    id="full",
+                    text_lines=(PageTextLine(text="hello"),),
+                ),
+            ),
+        ),),)
+        assert page_document_to_text(doc) == "hello"
+
+
+class TestProjector:
+    def test_protocol_satisfied(self) -> None:
+        from picarones.evaluation.projectors import Projector
+        assert isinstance(PageToText(), Projector)
+
+    def test_project_from_filesystem(self, tmp_path) -> None:
+        path = tmp_path / "doc.page.xml"
+        path.write_bytes(_SAMPLE_PAGE_XML)
+        artifact = Artifact(
+            id="d:page",
+            document_id="d",
+            type=ArtifactType.PAGE_XML,
+            uri=str(path),
+        )
+        target, report = PageToText().project(artifact, {})
+        assert target.type == ArtifactType.RAW_TEXT
+        assert "geometry" in report.ignored_dimensions
+
+    def test_wrong_type_rejected(self) -> None:
+        artifact = Artifact(
+            id="d:alto", document_id="d", type=ArtifactType.ALTO_XML,
+        )
+        with pytest.raises(ProjectionError, match="PAGE_XML"):
+            PageToText().project(artifact, {})

tests/formats/text/test_sprint_a14_s9_normalization_migration.py

@@ -0,0 +1,80 @@
+"""Sprint A14-S9 — migration de ``normalization`` vers ``formats/text/``.
+
+Vérifie que :
+
+1. Le nouveau module ``picarones.formats.text.normalization`` expose
+   les 11 profils canoniques.
+2. L'ancien re-export ``picarones.measurements.normalization`` continue
+   à fonctionner sans erreur (compat ascendante stricte).
+3. Les symboles privés utilisés downstream (``_parse_exclude_chars``,
+   ``_apply_diplomatic_table``) sont ré-exposés via le re-export.
+4. Les deux chemins d'import retournent **le même objet** (pas une
+   copie) — preuve que c'est un vrai re-export, pas une duplication.
+"""
+
+from __future__ import annotations
+
+
+def test_new_path_exposes_all_eleven_profiles() -> None:
+    from picarones.formats.text.normalization import NORMALIZATION_PROFILES
+    expected = {
+        "nfc", "caseless", "minimal",
+        "medieval_french", "early_modern_french",
+        "medieval_latin", "early_modern_english", "medieval_english",
+        "secretary_hand", "sans_ponctuation", "sans_apostrophes",
+    }
+    assert set(NORMALIZATION_PROFILES.keys()) == expected
+
+
+def test_old_reexport_works() -> None:
+    """Compat ascendante : ~50 consommateurs importent depuis l'ancien
+    chemin."""
+    from picarones.measurements.normalization import (
+        DEFAULT_DIPLOMATIC_PROFILE,
+        NORMALIZATION_PROFILES,
+        NormalizationProfile,
+        get_builtin_profile,
+    )
+    assert NormalizationProfile is not None
+    assert "medieval_french" in NORMALIZATION_PROFILES
+    assert get_builtin_profile("nfc") is not None
+    assert DEFAULT_DIPLOMATIC_PROFILE.name == "medieval_french"
+
+
+def test_private_symbols_reexported() -> None:
+    """Les symboles préfixés ``_`` utilisés en aval doivent rester
+    importables depuis l'ancien chemin."""
+    from picarones.measurements.normalization import (
+        _apply_diplomatic_table,
+        _parse_exclude_chars,
+    )
+    assert callable(_parse_exclude_chars)
+    assert callable(_apply_diplomatic_table)
+
+
+def test_old_and_new_paths_share_same_objects() -> None:
+    """Preuve que c'est un vrai re-export, pas une duplication."""
+    from picarones.formats.text.normalization import (
+        NORMALIZATION_PROFILES as new_profiles,
+        NormalizationProfile as NewProfile,
+        get_builtin_profile as new_get,
+    )
+    from picarones.measurements.normalization import (
+        NORMALIZATION_PROFILES as old_profiles,
+        NormalizationProfile as OldProfile,
+        get_builtin_profile as old_get,
+    )
+    assert new_profiles is old_profiles  # même dict
+    assert NewProfile is OldProfile      # même classe
+    assert new_get is old_get            # même fonction
+
+
+def test_apply_profile_works_via_new_path() -> None:
+    """Test fonctionnel : un profil chargé depuis le nouveau chemin
+    applique bien la normalisation."""
+    from picarones.formats.text.normalization import get_builtin_profile
+    profile = get_builtin_profile("medieval_french")
+    # ſ → s, u → v dans le profil médiéval français.
+    normalized = profile.normalize("aſpre")
+    assert "ſ" not in normalized
+    assert "s" in normalized