Sprint 4 — Adaptateurs API OCR, import IIIF, CER diplomatique

## Nouveautés

### Adaptateurs OCR distants
- `MistralOCREngine` : OCR via l'API Mistral AI (Pixtral)
- `GoogleVisionEngine` : Google Cloud Vision (SDK + REST avec GOOGLE_API_KEY)
- `AzureDocIntelEngine` : Azure Document Intelligence (SDK + REST polling async)

### Import IIIF
- `IIIFImporter` : import de corpus depuis manifestes IIIF v2/v3
- Parsing auto-détecté (v2/v3), sélecteur de pages flexible (1-10, 1,3,5, all)
- Téléchargement avec retry exponentiel, extraction GT si annotée dans le manifeste
- CLI : `picarones import iiif <url> --pages 1-10 --output ./corpus/`

### Normalisation diplomatique & CER diplomatique
- `NormalizationProfile` : NFC + caseless + table de correspondances historiques
- Profils préconfigurés : medieval_french, early_modern_french, medieval_latin, minimal
- `compute_metrics()` calcule désormais `cer_diplomatic` par défaut (profil médiéval)
- `aggregate_metrics()` agrège le CER diplomatique avec indication du profil utilisé
- Rapport HTML : colonne "CER diplo." dans le tableau de classement + badge dans les
panneaux de diff document avec indicateur delta (−X.X% avec normalisation)
- Textes GT de démo mis à jour avec graphies médiévales (ſ, &, u/v, i/j)

### Tests
- 103 nouveaux tests Sprint 4 (normalization, IIIF, moteurs API, CLI, rapport)
- Suite complète : 257 tests, 0 échec

https://claude.ai/code/session_017gXea9mxBQqDTAsSQd7aAq

picarones/cli.py

@@ -381,5 +381,110 @@ def demo_cmd(output: str, docs: int, json_output: str | None) -> None:
     click.echo(f"Ouvrez-le dans un navigateur : file://{path}")
 
 
+# ---------------------------------------------------------------------------
+# picarones import (groupe de sous-commandes)
+# ---------------------------------------------------------------------------
+
+@cli.group("import")
+def import_group() -> None:
+    """Importe un corpus depuis une source distante (IIIF, HuggingFace…)."""
+
+
+@import_group.command("iiif")
+@click.argument("manifest_url")
+@click.option(
+    "--pages", "-p",
+    default="all",
+    show_default=True,
+    help=(
+        "Pages à importer. Formats : '1-10', '1,3,5', '1-5,10,15-20', 'all'. "
+        "Les numéros sont 1-based (1 = première page du manifeste)."
+    ),
+)
+@click.option(
+    "--output", "-o",
+    default="./corpus_iiif/",
+    show_default=True,
+    type=click.Path(resolve_path=True),
+    help="Dossier de destination pour les images et les fichiers .gt.txt",
+)
+@click.option(
+    "--max-resolution",
+    default=0,
+    type=int,
+    show_default=True,
+    help="Résolution maximale des images téléchargées (largeur en pixels). 0 = max disponible.",
+)
+@click.option("--no-progress", is_flag=True, default=False, help="Désactive la barre de progression")
+@click.option("--verbose", "-v", is_flag=True, default=False, help="Mode verbeux")
+def import_iiif_cmd(
+    manifest_url: str,
+    pages: str,
+    output: str,
+    max_resolution: int,
+    no_progress: bool,
+    verbose: bool,
+) -> None:
+    """Importe un corpus depuis un manifeste IIIF (v2 ou v3).
+
+    MANIFEST_URL : URL du manifeste IIIF (Gallica, Bodleian, BL, BSB…)
+
+    Exemples :
+
+    \b
+        picarones import iiif https://gallica.bnf.fr/ark:/12148/xxx/manifest.json
+        picarones import iiif https://gallica.bnf.fr/ark:/12148/xxx/manifest.json --pages 1-10
+        picarones import iiif https://gallica.bnf.fr/ark:/12148/xxx/manifest.json --pages 1,3,5-8 --output ./mon_corpus/
+
+    Les images sont téléchargées dans le dossier de sortie.
+    Des fichiers .gt.txt vides (ou remplis si le manifeste contient des annotations
+    de transcription) sont créés à côté de chaque image.
+    """
+    _setup_logging(verbose)
+
+    from picarones.importers.iiif import IIIFImporter
+
+    click.echo(f"Manifeste IIIF : {manifest_url}")
+
+    try:
+        importer = IIIFImporter(manifest_url, max_resolution=max_resolution)
+        importer.load()
+
+        all_canvases = importer.parser.canvases()
+        click.echo(
+            f"Manifeste IIIF v{importer.parser.version} — "
+            f"titre : {importer.parser.label} — "
+            f"{len(all_canvases)} canvas disponibles"
+        )
+
+        selected = importer.list_canvases(pages)
+        click.echo(f"Pages sélectionnées : {len(selected)} sur {len(all_canvases)}")
+
+        corpus = importer.import_corpus(
+            pages=pages,
+            output_dir=output,
+            show_progress=not no_progress,
+        )
+
+    except (ValueError, RuntimeError) as exc:
+        click.echo(f"Erreur import IIIF : {exc}", err=True)
+        sys.exit(1)
+
+    click.echo(f"\n{len(corpus)} documents importés dans : {output}")
+
+    # Résumé
+    gt_filled = sum(1 for d in corpus.documents if d.ground_truth.strip())
+    if gt_filled:
+        click.echo(f"Transcriptions trouvées dans le manifeste : {gt_filled}/{len(corpus)}")
+    else:
+        click.echo(
+            "Aucune transcription dans le manifeste — "
+            "les fichiers .gt.txt sont vides (à remplir manuellement ou via OCR)."
+        )
+
+    click.echo(f"\nPour lancer un benchmark sur ce corpus :")
+    click.echo(f"  picarones run --corpus {output} --engines tesseract")
+
+
 if __name__ == "__main__":
     cli()

picarones/core/metrics.py

@@ -5,6 +5,8 @@ Métriques implémentées
 - CER brut                : distance d'édition caractère / longueur GT
 - CER normalisé NFC       : après normalisation Unicode NFC
 - CER sans casse          : insensible aux majuscules/minuscules
+- CER diplomatique        : après application d'une table de correspondances
+                            historiques (ſ=s, u=v, i=j…) — configurable
 - WER brut                : word error rate standard
 - WER normalisé           : après normalisation des espaces
 - MER                     : Match Error Rate (jiwer)
@@ -41,9 +43,6 @@ def _normalize_whitespace(text: str) -> str:
     return " ".join(text.split())
 
 
-# Transformations jiwer pour le CER (chaque char devient un "mot")
-_CHAR_TRANSFORM = jiwer.transforms.Compose([]) if _JIWER_AVAILABLE else None
-
 # Transformations jiwer pour le WER (normalisation légère des espaces)
 _WER_TRANSFORM = (
     jiwer.transforms.Compose(
@@ -62,7 +61,6 @@ def _cer_from_strings(reference: str, hypothesis: str) -> float:
     """CER brut : distance d'édition sur les caractères."""
     if not reference:
         return 0.0 if not hypothesis else 1.0
-    # jiwer.cer traite chaque caractère comme un token
     return jiwer.cer(reference, hypothesis)
 
 
@@ -84,9 +82,15 @@ class MetricsResult:
     reference_length: int
     hypothesis_length: int
     error: Optional[str] = None
+    cer_diplomatic: Optional[float] = None
+    """CER calculé après normalisation diplomatique (ſ=s, u=v, i=j…).
+    None si aucun profil diplomatique n'a été fourni à compute_metrics.
+    """
+    diplomatic_profile_name: Optional[str] = None
+    """Nom du profil de normalisation diplomatique utilisé."""
 
     def as_dict(self) -> dict:
-        return {
+        d = {
             "cer": round(self.cer, 6),
             "cer_nfc": round(self.cer_nfc, 6),
             "cer_caseless": round(self.cer_caseless, 6),
@@ -98,6 +102,10 @@ class MetricsResult:
             "hypothesis_length": self.hypothesis_length,
             "error": self.error,
         }
+        if self.cer_diplomatic is not None:
+            d["cer_diplomatic"] = round(self.cer_diplomatic, 6)
+            d["diplomatic_profile_name"] = self.diplomatic_profile_name
+        return d
 
     @property
     def cer_percent(self) -> float:
@@ -108,7 +116,11 @@ class MetricsResult:
         return round(self.wer * 100, 2)
 
 
-def compute_metrics(reference: str, hypothesis: str) -> MetricsResult:
+def compute_metrics(
+    reference: str,
+    hypothesis: str,
+    normalization_profile: "Optional[NormalizationProfile]" = None,  # noqa: F821
+) -> MetricsResult:
     """Calcule l'ensemble des métriques CER/WER pour une paire de textes.
 
     Parameters
@@ -117,6 +129,10 @@ def compute_metrics(reference: str, hypothesis: str) -> MetricsResult:
         Texte de vérité terrain (ground truth).
     hypothesis:
         Texte produit par le moteur OCR.
+    normalization_profile:
+        Profil de normalisation diplomatique optionnel.
+        Si fourni, calcule ``cer_diplomatic`` en plus des métriques standard.
+        Si None, utilise le profil medieval_french par défaut.
 
     Returns
     -------
@@ -151,6 +167,19 @@ def compute_metrics(reference: str, hypothesis: str) -> MetricsResult:
         mer = jiwer.mer(reference, hypothesis)
         wil = jiwer.wil(reference, hypothesis)
 
+        # CER diplomatique — utilise le profil fourni ou le profil médiéval par défaut
+        cer_diplomatic: Optional[float] = None
+        diplomatic_profile_name: Optional[str] = None
+        try:
+            from picarones.core.normalization import DEFAULT_DIPLOMATIC_PROFILE
+            profile = normalization_profile or DEFAULT_DIPLOMATIC_PROFILE
+            ref_diplo = profile.normalize(reference)
+            hyp_diplo = profile.normalize(hypothesis)
+            cer_diplomatic = _cer_from_strings(ref_diplo, hyp_diplo)
+            diplomatic_profile_name = profile.name
+        except Exception:  # noqa: BLE001
+            pass  # CER diplomatique non critique
+
         return MetricsResult(
             cer=cer_raw,
             cer_nfc=cer_nfc,
@@ -161,6 +190,8 @@ def compute_metrics(reference: str, hypothesis: str) -> MetricsResult:
             wil=wil,
             reference_length=len(reference),
             hypothesis_length=len(hypothesis),
+            cer_diplomatic=cer_diplomatic,
+            diplomatic_profile_name=diplomatic_profile_name,
         )
 
     except Exception as exc:  # noqa: BLE001
@@ -208,7 +239,28 @@ def aggregate_metrics(results: list[MetricsResult]) -> dict:
         values = [getattr(r, metric) for r in results if r.error is None]
         aggregated[metric] = _stats(values)
 
+    # CER diplomatique (optionnel — présent seulement si calculé)
+    diplo_values = [
+        r.cer_diplomatic for r in results
+        if r.error is None and r.cer_diplomatic is not None
+    ]
+    if diplo_values:
+        aggregated["cer_diplomatic"] = _stats(diplo_values)
+        # Nom du profil (même pour tous les docs d'un corpus)
+        profile_name = next(
+            (r.diplomatic_profile_name for r in results if r.diplomatic_profile_name),
+            None,
+        )
+        if profile_name:
+            aggregated["cer_diplomatic"]["profile"] = profile_name
+
     aggregated["document_count"] = len(results)
     aggregated["failed_count"] = sum(1 for r in results if r.error is not None)
 
     return aggregated
+
+
+# Import paresseux pour éviter les imports circulaires
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from picarones.core.normalization import NormalizationProfile

picarones/core/normalization.py

@@ -0,0 +1,286 @@
+"""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
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# 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",
+}
+
+
+# ---------------------------------------------------------------------------
+# 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.
+    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)
+    description: str = ""
+
+    def normalize(self, text: str) -> str:
+        """Applique le profil de normalisation à un texte."""
+        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,
+            "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`` et ``diplomatic`` (dict str→str).
+
+        Example
+        -------
+        .. code-block:: yaml
+
+            name: medieval_custom
+            caseless: false
+            description: Français médiéval personnalisé
+            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", {}),
+            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", {}),
+            description=data.get("description", ""),
+        )
+
+
+# ---------------------------------------------------------------------------
+# Profils préconfigurés
+# ---------------------------------------------------------------------------
+
+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…)
+    - ``"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.
+    """
+    profiles = {
+        "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",
+        ),
+        "minimal": NormalizationProfile(
+            name="minimal",
+            nfc=True,
+            caseless=False,
+            diplomatic_table=DIPLOMATIC_MINIMAL,
+            description="Minimal : NFC + s long seulement",
+        ),
+        "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",
+        ),
+    }
+    if name not in profiles:
+        raise KeyError(
+            f"Profil de normalisation inconnu : '{name}'. "
+            f"Disponibles : {', '.join(profiles)}"
+        )
+    return profiles[name]
+
+
+# ---------------------------------------------------------------------------
+# Fonctions utilitaires
+# ---------------------------------------------------------------------------
+
+def _apply_diplomatic_table(text: str, table: dict[str, str]) -> str:
+    """Applique une table de correspondances diplomatiques caractère par caractère.
+
+    Les clés multi-caractères (ex : ``"ae"`` → ``"æ"``) sont gérées en priorité
+    sur les correspondances simples.
+    """
+    if not table:
+        return text
+
+    # Séparer les clés simples (1 char) des clés multi-chars pour traitement ordonné
+    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}
+
+    result = text
+    # Remplacements multi-chars en premier (évite les conflits)
+    for key in multi_keys:
+        result = result.replace(key, table[key])
+
+    # Remplacements char par char
+    if simple_table:
+        result = "".join(simple_table.get(c, c) for c in result)
+
+    return result
+
+
+# Profil par défaut utilisé pour le CER diplomatique intégré
+DEFAULT_DIPLOMATIC_PROFILE: NormalizationProfile = get_builtin_profile("medieval_french")

picarones/engines/__init__.py

@@ -2,8 +2,18 @@
 
 from picarones.engines.base import BaseOCREngine, EngineResult
 from picarones.engines.tesseract import TesseractEngine
+from picarones.engines.mistral_ocr import MistralOCREngine
+from picarones.engines.google_vision import GoogleVisionEngine
+from picarones.engines.azure_doc_intel import AzureDocIntelEngine
 
-__all__ = ["BaseOCREngine", "EngineResult", "TesseractEngine"]
+__all__ = [
+    "BaseOCREngine",
+    "EngineResult",
+    "TesseractEngine",
+    "MistralOCREngine",
+    "GoogleVisionEngine",
+    "AzureDocIntelEngine",
+]
 
 try:
     from picarones.engines.pero_ocr import PeroOCREngine

picarones/engines/azure_doc_intel.py

@@ -0,0 +1,153 @@
+"""Adaptateur OCR — Azure Document Intelligence (anciennement Form Recognizer).
+
+Utilise l'API Azure Document Intelligence pour la reconnaissance de texte
+dans des documents historiques.
+
+Variables d'environnement requises :
+  - ``AZURE_DOC_INTEL_KEY``      : clé API Azure
+  - ``AZURE_DOC_INTEL_ENDPOINT`` : URL de l'endpoint (ex : https://moninstance.cognitiveservices.azure.com/)
+
+Documentation : https://learn.microsoft.com/azure/ai-services/document-intelligence/
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+from picarones.engines.base import BaseOCREngine
+
+
+class AzureDocIntelEngine(BaseOCREngine):
+    """Moteur OCR via Azure Document Intelligence.
+
+    Configuration
+    -------------
+    model_id : str
+        Modèle Azure à utiliser. Défaut : ``"prebuilt-read"`` (lecture générique).
+        Alternatives : ``"prebuilt-document"``, ``"prebuilt-layout"``
+        ou un modèle entraîné personnalisé.
+    locale : str
+        Paramètre de locale pour améliorer la précision (ex : ``"fr-FR"``).
+    api_version : str
+        Version de l'API Azure (défaut : ``"2024-02-29-preview"``).
+    """
+
+    @property
+    def name(self) -> str:
+        return "azure_doc_intel"
+
+    def version(self) -> str:
+        return self.config.get("api_version", "2024-02-29-preview")
+
+    def __init__(self, config: Optional[dict] = None) -> None:
+        super().__init__(config)
+        self._api_key = os.environ.get("AZURE_DOC_INTEL_KEY")
+        self._endpoint = (
+            os.environ.get("AZURE_DOC_INTEL_ENDPOINT", "").rstrip("/")
+            or self.config.get("endpoint", "").rstrip("/")
+        )
+        self._model_id: str = self.config.get("model_id", "prebuilt-read")
+        self._locale: str = self.config.get("locale", "fr-FR")
+        self._api_version: str = self.config.get("api_version", "2024-02-29-preview")
+
+    def _run_ocr(self, image_path: Path) -> str:
+        if not self._api_key:
+            raise RuntimeError(
+                "Clé API Azure manquante — définissez la variable d'environnement AZURE_DOC_INTEL_KEY"
+            )
+        if not self._endpoint:
+            raise RuntimeError(
+                "Endpoint Azure manquant — définissez la variable d'environnement AZURE_DOC_INTEL_ENDPOINT"
+            )
+
+        # Essai via SDK Azure si disponible, sinon REST direct
+        try:
+            return self._run_via_sdk(image_path)
+        except ImportError:
+            return self._run_via_rest(image_path)
+
+    def _run_via_sdk(self, image_path: Path) -> str:
+        from azure.ai.documentintelligence import DocumentIntelligenceClient
+        from azure.core.credentials import AzureKeyCredential
+
+        client = DocumentIntelligenceClient(
+            endpoint=self._endpoint,
+            credential=AzureKeyCredential(self._api_key),
+        )
+        with open(image_path, "rb") as f:
+            poller = client.begin_analyze_document(
+                model_id=self._model_id,
+                body=f,
+                locale=self._locale,
+                content_type="application/octet-stream",
+            )
+        result = poller.result()
+        return "\n".join(
+            line.content
+            for page in result.pages
+            for line in (page.lines or [])
+        )
+
+    def _run_via_rest(self, image_path: Path) -> str:
+        """Appel REST direct (sans SDK Azure)."""
+        image_bytes = image_path.read_bytes()
+        analyze_url = (
+            f"{self._endpoint}/documentintelligence/documentModels/"
+            f"{self._model_id}:analyze"
+            f"?api-version={self._api_version}&locale={self._locale}"
+        )
+
+        # Soumettre l'image
+        req = urllib.request.Request(
+            analyze_url,
+            data=image_bytes,
+            headers={
+                "Ocp-Apim-Subscription-Key": self._api_key,
+                "Content-Type": "application/octet-stream",
+            },
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                operation_url = resp.headers.get("Operation-Location", "")
+        except urllib.error.HTTPError as exc:
+            raise RuntimeError(
+                f"Azure Document Intelligence erreur {exc.code}: {exc.read().decode()}"
+            ) from exc
+
+        if not operation_url:
+            raise RuntimeError("Azure : pas d'Operation-Location dans la réponse")
+
+        # Polling du résultat (Azure est asynchrone)
+        headers = {"Ocp-Apim-Subscription-Key": self._api_key}
+        for attempt in range(30):
+            time.sleep(1 + attempt * 0.5)
+            poll_req = urllib.request.Request(operation_url, headers=headers)
+            with urllib.request.urlopen(poll_req, timeout=30) as resp:
+                result = json.loads(resp.read().decode("utf-8"))
+            status = result.get("status", "")
+            if status == "succeeded":
+                return self._extract_text_from_result(result)
+            if status in {"failed", "canceled"}:
+                raise RuntimeError(f"Azure Document Intelligence : analyse {status}")
+            # status == "running" → continuer à attendre
+
+        raise RuntimeError("Azure Document Intelligence : timeout — analyse trop longue")
+
+    @staticmethod
+    def _extract_text_from_result(result: dict) -> str:
+        """Extrait le texte brut depuis la réponse JSON Azure."""
+        pages = result.get("analyzeResult", {}).get("pages", [])
+        lines: list[str] = []
+        for page in pages:
+            for line in page.get("lines", []):
+                content = line.get("content", "")
+                if content:
+                    lines.append(content)
+        return "\n".join(lines)

picarones/engines/google_vision.py

@@ -0,0 +1,133 @@
+"""Adaptateur OCR — Google Cloud Vision API.
+
+Utilise l'API Google Cloud Vision pour la détection de texte dans des
+documents (méthode ``DOCUMENT_TEXT_DETECTION``, optimisée pour les textes
+denses et multilinguistiques).
+
+Authentification :
+  - Via service account JSON : variable d'environnement
+    ``GOOGLE_APPLICATION_CREDENTIALS`` → chemin vers le fichier JSON
+  - Via clé API simple : variable d'environnement ``GOOGLE_API_KEY``
+
+Le mode service account est recommandé pour la production.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+from picarones.engines.base import BaseOCREngine
+
+
+class GoogleVisionEngine(BaseOCREngine):
+    """Moteur OCR via l'API Google Cloud Vision.
+
+    Configuration
+    -------------
+    language_hints : list[str]
+        Suggestions de langue (ex : ``["fr"]``). Améliore la précision.
+    feature_type : str
+        Type de détection : ``"DOCUMENT_TEXT_DETECTION"`` (défaut, pour textes
+        denses) ou ``"TEXT_DETECTION"`` (pour textes courts).
+    """
+
+    @property
+    def name(self) -> str:
+        return "google_vision"
+
+    def version(self) -> str:
+        return "v1"
+
+    def __init__(self, config: Optional[dict] = None) -> None:
+        super().__init__(config)
+        self._api_key = os.environ.get("GOOGLE_API_KEY")
+        self._credentials_path = os.environ.get("GOOGLE_APPLICATION_CREDENTIALS")
+        self._language_hints: list[str] = self.config.get("language_hints", ["fr"])
+        self._feature_type: str = self.config.get("feature_type", "DOCUMENT_TEXT_DETECTION")
+
+    def _run_ocr(self, image_path: Path) -> str:
+        # Priorité : SDK google-cloud-vision si disponible, sinon REST direct
+        if self._credentials_path:
+            return self._run_via_sdk(image_path)
+        elif self._api_key:
+            return self._run_via_rest(image_path)
+        else:
+            raise RuntimeError(
+                "Authentification Google Vision manquante. Définissez "
+                "GOOGLE_APPLICATION_CREDENTIALS (service account JSON) "
+                "ou GOOGLE_API_KEY."
+            )
+
+    def _run_via_sdk(self, image_path: Path) -> str:
+        try:
+            from google.cloud import vision
+        except ImportError as exc:
+            raise RuntimeError(
+                "Le package 'google-cloud-vision' n'est pas installé. "
+                "Lancez : pip install google-cloud-vision"
+            ) from exc
+
+        client = vision.ImageAnnotatorClient()
+        image_bytes = image_path.read_bytes()
+        image = vision.Image(content=image_bytes)
+
+        if self._feature_type == "DOCUMENT_TEXT_DETECTION":
+            response = client.document_text_detection(
+                image=image,
+                image_context=vision.ImageContext(
+                    language_hints=self._language_hints
+                ),
+            )
+            return response.full_text_annotation.text
+        else:
+            response = client.text_detection(
+                image=image,
+                image_context=vision.ImageContext(
+                    language_hints=self._language_hints
+                ),
+            )
+            texts = response.text_annotations
+            return texts[0].description if texts else ""
+
+    def _run_via_rest(self, image_path: Path) -> str:
+        """Appel REST direct (sans SDK), avec clé API simple."""
+        image_b64 = base64.b64encode(image_path.read_bytes()).decode("ascii")
+        payload = {
+            "requests": [
+                {
+                    "image": {"content": image_b64},
+                    "features": [{"type": self._feature_type, "maxResults": 1}],
+                    "imageContext": {"languageHints": self._language_hints},
+                }
+            ]
+        }
+        url = f"https://vision.googleapis.com/v1/images:annotate?key={self._api_key}"
+        data = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            url, data=data,
+            headers={"Content-Type": "application/json"},
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                result = json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            raise RuntimeError(f"Google Vision API erreur {exc.code}: {exc.read().decode()}") from exc
+
+        responses = result.get("responses", [{}])
+        if not responses:
+            return ""
+        r = responses[0]
+        if "error" in r:
+            raise RuntimeError(f"Google Vision API erreur : {r['error']}")
+
+        if self._feature_type == "DOCUMENT_TEXT_DETECTION":
+            return r.get("fullTextAnnotation", {}).get("text", "")
+        else:
+            texts = r.get("textAnnotations", [])
+            return texts[0]["description"] if texts else ""

picarones/engines/mistral_ocr.py

@@ -0,0 +1,91 @@
+"""Adaptateur OCR — Mistral OCR (API vision Mistral AI).
+
+Utilise l'API Mistral pour la reconnaissance de texte sur documents
+patrimoniaux via le modèle multimodal Mistral.
+
+Clé API : variable d'environnement ``MISTRAL_API_KEY``.
+
+Documentation API : https://docs.mistral.ai/
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+from pathlib import Path
+from typing import Optional
+
+from picarones.engines.base import BaseOCREngine
+
+
+class MistralOCREngine(BaseOCREngine):
+    """Moteur OCR via l'API Mistral AI (modèle vision).
+
+    Configuration
+    -------------
+    model : str
+        Modèle Mistral à utiliser (défaut : ``"pixtral-12b-2409"``).
+        Les modèles multimodaux supportant la vision sont :
+        ``pixtral-12b-2409``, ``pixtral-large-latest``.
+    prompt : str
+        Prompt envoyé avec l'image. Défaut : instruction générique de transcription.
+    max_tokens : int
+        Limite de tokens en sortie (défaut : 4096).
+    """
+
+    @property
+    def name(self) -> str:
+        return "mistral_ocr"
+
+    def version(self) -> str:
+        return self.config.get("model", "pixtral-12b-2409")
+
+    def __init__(self, config: Optional[dict] = None) -> None:
+        super().__init__(config)
+        self._api_key = os.environ.get("MISTRAL_API_KEY")
+        self._model = self.config.get("model", "pixtral-12b-2409")
+        self._prompt = self.config.get(
+            "prompt",
+            "Transcris fidèlement le texte visible sur cette image de document "
+            "historique. Retourne uniquement le texte, sans commentaire.",
+        )
+        self._max_tokens = int(self.config.get("max_tokens", 4096))
+
+    def _run_ocr(self, image_path: Path) -> str:
+        if not self._api_key:
+            raise RuntimeError(
+                "Clé API Mistral manquante — définissez la variable d'environnement MISTRAL_API_KEY"
+            )
+        try:
+            from mistralai import Mistral
+        except ImportError as exc:
+            raise RuntimeError(
+                "Le package 'mistralai' n'est pas installé. Lancez : pip install mistralai"
+            ) from exc
+
+        # Encoder l'image en base64 avec media type correct
+        suffix = image_path.suffix.lower()
+        media_type = {
+            ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+            ".png": "image/png", ".tif": "image/tiff",
+            ".tiff": "image/tiff", ".webp": "image/webp",
+        }.get(suffix, "image/jpeg")
+
+        image_b64 = base64.b64encode(image_path.read_bytes()).decode("ascii")
+        image_url = f"data:{media_type};base64,{image_b64}"
+
+        client = Mistral(api_key=self._api_key)
+        response = client.chat.complete(
+            model=self._model,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": self._prompt},
+                        {"type": "image_url", "image_url": image_url},
+                    ],
+                }
+            ],
+            max_tokens=self._max_tokens,
+        )
+        return response.choices[0].message.content or ""

picarones/fixtures.py

@@ -24,18 +24,19 @@ from picarones.pipelines.over_normalization import detect_over_normalization
 # ---------------------------------------------------------------------------
 
 _GT_TEXTS = [
-    "Icy commence le prologue de maistre Jehan Froissart sus les croniques de France & d'Angleterre.",
-    "En l'an de grace mil trois cens soixante, regnoit en France le noble roy Jehan, filz du roy Phelippe de Valois.",
-    "Item ledit jour furent menez en ladicte ville de Paris plusieurs prisonniers sarasins & mahommetans.",
-    "Le chancellier du roy manda à tous les baillifs & seneschaulx que on feist crier & publier par tous les carrefours.",
-    "Cy après sensuyt la copie des lettres patentes données par nostre seigneur le roy à ses très chiers & feaulx.",
-    "Nous Charles, par la grace de Dieu roy de France, à tous ceulx qui ces presentes lettres verront, salut.",
-    "Savoir faisons que pour considéracion des bons & aggreables services que nostre amé & feal conseillier.",
-    "Donné à Paris, le vingt & deuxième jour du mois de juillet, l'an de grace mil quatre cens & troys.",
-    "Les dessus ditz ambassadeurs respondirent que leur seigneur & maistre estoit très joyeulx de ceste aliance.",
-    "Après lesquelles choses ainsi faictes & passées, le dit traictié fut ratiffié & confirmé de toutes parties.",
-    "Item, en ladicte année, fut faicte grant assemblée de gens d'armes tant à cheval que à pied.",
-    "Et pour ce que la chose est notoire & manifeste, nous avons fait mettre nostre scel à ces presentes.",
+    # Textes avec graphies médiévales incluant ſ, &, u/v — pour démontrer le CER diplomatique
+    "Icy commence le prologue de maiſtre Jehan Froiſſart ſus les croniques de France & d'Angleterre.",
+    "En l'an de grace mil trois cens ſoixante, regnoit en France le noble roy Jehan, filz du roy Phelippe de Valois.",
+    "Item ledit iour furent menez en ladicte ville de Paris pluſieurs priſonniers ſaraſins & mahommetans.",
+    "Le chancellier du roy manda à tous les baillifs & ſeneſchaulx que on feiſt crier & publier par tous les carrefours.",
+    "Cy après ſenſuyt la copie des lettres patentes données par noſtre ſeigneur le roy à ſes très chiers & feaulx.",
+    "Nous Charles, par la grace de Dieu roy de France, à tous ceulx qui ces preſentes lettres verront, ſalut.",
+    "Sauoir faiſons que pour conſidéracion des bons & aggreables ſeruices que noſtre amé & feal conſeillier.",
+    "Donné à Paris, le vingt & deuxième iour du mois de iuillet, l'an de grace mil quatre cens & troys.",
+    "Les deſſus ditz ambaſſadeurs reſpondirent que leur ſeigneur & maiſtre eſtoit très ioyeulx de ceſte aliance.",
+    "Après lesquelles choſes ainſi faictes & paſſées, le dit traictié fut ratiffié & confirmé de toutes parties.",
+    "Item, en ladicte année, fut faicte grant aſſemblée de gens d'armes tant à cheual que à pied.",
+    "Et pour ce que la choſe eſt notoire & manifeſte, nous auons fait mettre noſtre ſcel à ces preſentes.",
 ]
 
 # ---------------------------------------------------------------------------

picarones/importers/__init__.py

@@ -0,0 +1,5 @@
+"""Importeurs de corpus depuis des sources distantes (IIIF, HuggingFace, HTR-United…)."""
+
+from picarones.importers.iiif import IIIFImporter, import_iiif_manifest
+
+__all__ = ["IIIFImporter", "import_iiif_manifest"]

picarones/importers/iiif.py

@@ -0,0 +1,583 @@
+"""Import de corpus depuis des manifestes IIIF v2 et v3.
+
+Fonctionnement
+--------------
+1. Téléchargement et parsing du manifeste JSON (v2 ou v3 auto-détecté)
+2. Extraction de la liste des canvases (pages) avec leurs URL d'image
+3. Sélection optionnelle d'un sous-ensemble de pages (ex : ``--pages 1-10``)
+4. Téléchargement des images dans un dossier local
+5. Création de fichiers GT vides (``.gt.txt``) à remplir manuellement,
+   OU chargement des annotations de transcription si présentes dans le manifeste
+6. Construction et retour d'un objet ``Corpus``
+
+Compatibilité
+-------------
+- IIIF Image API v2 et v3
+- Manifestes Presentation API v2 et v3
+- Instances : Gallica (BnF), Bodleian, British Library, BSB, e-codices,
+  Europeana, et tout entrepôt IIIF-compliant
+
+Utilisation
+-----------
+>>> from picarones.importers.iiif import IIIFImporter
+>>> importer = IIIFImporter("https://gallica.bnf.fr/ark:/12148/xxx/manifest.json")
+>>> corpus = importer.import_corpus(pages="1-10", output_dir="./corpus/")
+>>> print(f"{len(corpus)} documents téléchargés")
+
+Ou via la fonction de commodité :
+>>> from picarones.importers.iiif import import_iiif_manifest
+>>> corpus = import_iiif_manifest("https://...", pages="1-5", output_dir="./corpus/")
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterator, Optional
+
+from picarones.core.corpus import Corpus, Document
+
+logger = logging.getLogger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Parsing du sélecteur de pages
+# ---------------------------------------------------------------------------
+
+def parse_page_selector(pages: str, total: int) -> list[int]:
+    """Parse un sélecteur de pages en liste d'indices 0-based.
+
+    Formats acceptés :
+    - ``"1-10"``        → pages 1 à 10 (1-based)
+    - ``"1,3,5"``       → pages 1, 3 et 5
+    - ``"1-5,10,15-20"`` → combinaison
+    - ``"all"`` / ``""`` → toutes les pages
+
+    Parameters
+    ----------
+    pages:
+        Sélecteur de pages en chaîne de caractères.
+    total:
+        Nombre total de pages dans le manifeste.
+
+    Returns
+    -------
+    list[int]
+        Indices 0-based des pages sélectionnées, triés et dédoublonnés.
+
+    Raises
+    ------
+    ValueError
+        Si la syntaxe est invalide ou les numéros hors bornes.
+    """
+    if not pages or pages.strip().lower() == "all":
+        return list(range(total))
+
+    indices: set[int] = set()
+    for part in pages.split(","):
+        part = part.strip()
+        if "-" in part:
+            m = re.fullmatch(r"(\d+)-(\d+)", part)
+            if not m:
+                raise ValueError(f"Sélecteur de pages invalide : '{part}'")
+            start, end = int(m.group(1)), int(m.group(2))
+            if start < 1 or end > total or start > end:
+                raise ValueError(
+                    f"Plage {start}-{end} hors bornes (1–{total})"
+                )
+            indices.update(range(start - 1, end))
+        else:
+            n = int(part)
+            if n < 1 or n > total:
+                raise ValueError(f"Page {n} hors bornes (1–{total})")
+            indices.add(n - 1)
+    return sorted(indices)
+
+
+# ---------------------------------------------------------------------------
+# Données d'un canvas IIIF
+# ---------------------------------------------------------------------------
+
+@dataclass
+class IIIFCanvas:
+    """Représente un canvas (page) dans un manifeste IIIF."""
+
+    index: int          # position 0-based dans le manifeste
+    label: str          # étiquette lisible (ex : "f. 1r", "Page 1")
+    image_url: str      # URL de l'image pleine résolution
+    width: Optional[int] = None
+    height: Optional[int] = None
+    transcription: Optional[str] = None  # texte GT si annoté dans le manifeste
+
+
+# ---------------------------------------------------------------------------
+# Parseur de manifeste IIIF
+# ---------------------------------------------------------------------------
+
+class IIIFManifestParser:
+    """Parse un manifeste IIIF Presentation API v2 ou v3."""
+
+    def __init__(self, manifest: dict) -> None:
+        self._manifest = manifest
+        self._version = self._detect_version()
+
+    def _detect_version(self) -> int:
+        """Détecte la version du manifeste (2 ou 3)."""
+        context = self._manifest.get("@context", "")
+        if isinstance(context, list):
+            context = " ".join(context)
+        if "presentation/3" in context or self._manifest.get("type") == "Manifest":
+            return 3
+        return 2
+
+    @property
+    def version(self) -> int:
+        return self._version
+
+    @property
+    def label(self) -> str:
+        """Titre du manifeste."""
+        raw = self._manifest.get("label", "")
+        return _extract_label(raw)
+
+    @property
+    def attribution(self) -> str:
+        raw = self._manifest.get("attribution", self._manifest.get("requiredStatement", ""))
+        return _extract_label(raw)
+
+    def canvases(self) -> list[IIIFCanvas]:
+        """Retourne la liste des canvases du manifeste."""
+        if self._version == 3:
+            return self._parse_v3_canvases()
+        return self._parse_v2_canvases()
+
+    def _parse_v2_canvases(self) -> list[IIIFCanvas]:
+        canvases: list[IIIFCanvas] = []
+        sequences = self._manifest.get("sequences", [])
+        if not sequences:
+            return canvases
+        raw_canvases = sequences[0].get("canvases", [])
+        for i, canvas in enumerate(raw_canvases):
+            label = _extract_label(canvas.get("label", f"canvas_{i+1}"))
+            # Image principale : images[0].resource.@id ou service
+            images = canvas.get("images", [])
+            image_url = ""
+            if images:
+                resource = images[0].get("resource", {})
+                image_url = _best_image_url_v2(resource, canvas)
+
+            # Annotations de transcription (OA annotations)
+            transcription = _extract_v2_transcription(canvas)
+
+            canvases.append(IIIFCanvas(
+                index=i,
+                label=label,
+                image_url=image_url,
+                width=canvas.get("width"),
+                height=canvas.get("height"),
+                transcription=transcription,
+            ))
+        return canvases
+
+    def _parse_v3_canvases(self) -> list[IIIFCanvas]:
+        canvases: list[IIIFCanvas] = []
+        items = self._manifest.get("items", [])
+        for i, canvas in enumerate(items):
+            label = _extract_label(canvas.get("label", f"canvas_{i+1}"))
+            image_url = _best_image_url_v3(canvas)
+            transcription = _extract_v3_transcription(canvas)
+            canvases.append(IIIFCanvas(
+                index=i,
+                label=label,
+                image_url=image_url,
+                width=canvas.get("width"),
+                height=canvas.get("height"),
+                transcription=transcription,
+            ))
+        return canvases
+
+
+# ---------------------------------------------------------------------------
+# Helpers extraction URL et label
+# ---------------------------------------------------------------------------
+
+def _extract_label(raw: object) -> str:
+    """Extrait une chaîne lisible depuis les différents formats de label IIIF."""
+    if isinstance(raw, str):
+        return raw
+    if isinstance(raw, list) and raw:
+        return _extract_label(raw[0])
+    if isinstance(raw, dict):
+        # IIIF v3 : {"fr": ["titre"], "en": ["title"]}
+        for lang in ("fr", "en", "none", "@value"):
+            val = raw.get(lang, "")
+            if val:
+                if isinstance(val, list):
+                    return val[0] if val else ""
+                return str(val)
+        # Fallback: première valeur
+        for v in raw.values():
+            return _extract_label(v)
+    return str(raw) if raw else ""
+
+
+def _best_image_url_v2(resource: dict, canvas: dict) -> str:
+    """Construit l'URL d'image optimale depuis une ressource IIIF v2."""
+    # 1. URL directe de la ressource
+    direct = resource.get("@id", "")
+    if direct and not direct.endswith("/info.json"):
+        return direct
+
+    # 2. Via le service IIIF Image API
+    service = resource.get("service", {})
+    if isinstance(service, list) and service:
+        service = service[0]
+    service_id = service.get("@id", service.get("id", ""))
+    if service_id:
+        return f"{service_id.rstrip('/')}/full/max/0/default.jpg"
+
+    return direct
+
+
+def _best_image_url_v3(canvas: dict) -> str:
+    """Extrait l'URL d'image depuis un canvas IIIF v3."""
+    items = canvas.get("items", [])
+    for annotation_page in items:
+        for annotation in annotation_page.get("items", []):
+            body = annotation.get("body", {})
+            if isinstance(body, list):
+                body = body[0] if body else {}
+            # URL directe
+            url = body.get("id", body.get("@id", ""))
+            if url and body.get("type", "") == "Image":
+                return url
+            # Via service IIIF Image API
+            service = body.get("service", [])
+            if isinstance(service, dict):
+                service = [service]
+            for svc in service:
+                svc_id = svc.get("id", svc.get("@id", ""))
+                if svc_id:
+                    return f"{svc_id.rstrip('/')}/full/max/0/default.jpg"
+            if url:
+                return url
+    return ""
+
+
+def _extract_v2_transcription(canvas: dict) -> Optional[str]:
+    """Tente d'extraire le texte GT depuis les annotations OA d'un canvas v2."""
+    other_content = canvas.get("otherContent", [])
+    for oc in other_content:
+        if not isinstance(oc, dict):
+            continue
+        motivation = oc.get("motivation", "")
+        if "transcrib" in motivation.lower() or "supplementing" in motivation.lower():
+            resources = oc.get("resources", [])
+            texts = []
+            for res in resources:
+                body = res.get("resource", {})
+                if body.get("@type") == "cnt:ContentAsText":
+                    texts.append(body.get("chars", ""))
+            if texts:
+                return "\n".join(texts)
+    return None
+
+
+def _extract_v3_transcription(canvas: dict) -> Optional[str]:
+    """Tente d'extraire le texte GT depuis les annotations d'un canvas v3."""
+    annotations = canvas.get("annotations", [])
+    for ann_page in annotations:
+        items = ann_page.get("items", [])
+        for ann in items:
+            motivation = ann.get("motivation", "")
+            if "transcrib" in motivation.lower() or "supplementing" in motivation.lower():
+                body = ann.get("body", {})
+                if isinstance(body, dict) and body.get("type") == "TextualBody":
+                    return body.get("value", "")
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Téléchargement avec retry
+# ---------------------------------------------------------------------------
+
+def _download_url(
+    url: str,
+    retries: int = 4,
+    backoff: float = 2.0,
+    timeout: int = 60,
+) -> bytes:
+    """Télécharge une URL avec retry exponentiel."""
+    headers = {
+        "User-Agent": "Picarones/1.0 (BnF OCR benchmark platform; https://github.com/bnf/picarones)"
+    }
+    last_exc: Optional[Exception] = None
+    for attempt in range(retries):
+        if attempt > 0:
+            wait = backoff ** attempt
+            logger.debug("Retry %d/%d dans %.1fs — %s", attempt, retries - 1, wait, url)
+            time.sleep(wait)
+        try:
+            req = urllib.request.Request(url, headers=headers)
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                return resp.read()
+        except (urllib.error.URLError, urllib.error.HTTPError) as exc:
+            last_exc = exc
+            logger.warning("Erreur téléchargement %s : %s", url, exc)
+    raise RuntimeError(f"Impossible de télécharger {url} après {retries} tentatives") from last_exc
+
+
+def _fetch_manifest(url: str) -> dict:
+    """Télécharge et parse un manifeste IIIF JSON."""
+    data = _download_url(url)
+    try:
+        return json.loads(data.decode("utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Manifeste IIIF invalide (JSON mal formé) : {url}") from exc
+
+
+# ---------------------------------------------------------------------------
+# Importeur principal
+# ---------------------------------------------------------------------------
+
+class IIIFImporter:
+    """Importe un corpus depuis un manifeste IIIF.
+
+    Parameters
+    ----------
+    manifest_url:
+        URL du manifeste IIIF (Presentation API v2 ou v3).
+    max_resolution:
+        Résolution maximale des images téléchargées (largeur en pixels).
+        0 = résolution maximale disponible.
+    """
+
+    def __init__(
+        self,
+        manifest_url: str,
+        max_resolution: int = 0,
+    ) -> None:
+        self.manifest_url = manifest_url
+        self.max_resolution = max_resolution
+        self._manifest: Optional[dict] = None
+        self._parser: Optional[IIIFManifestParser] = None
+
+    def load(self) -> "IIIFImporter":
+        """Télécharge et parse le manifeste."""
+        logger.info("Téléchargement du manifeste IIIF : %s", self.manifest_url)
+        self._manifest = _fetch_manifest(self.manifest_url)
+        self._parser = IIIFManifestParser(self._manifest)
+        logger.info(
+            "Manifeste chargé — version IIIF %d — titre : %s — %d canvas",
+            self._parser.version,
+            self._parser.label,
+            len(self._parser.canvases()),
+        )
+        return self
+
+    @property
+    def parser(self) -> IIIFManifestParser:
+        if self._parser is None:
+            self.load()
+        return self._parser  # type: ignore[return-value]
+
+    def list_canvases(self, pages: str = "all") -> list[IIIFCanvas]:
+        """Retourne la liste des canvases sélectionnés."""
+        all_canvases = self.parser.canvases()
+        indices = parse_page_selector(pages, len(all_canvases))
+        return [all_canvases[i] for i in indices]
+
+    def import_corpus(
+        self,
+        pages: str = "all",
+        output_dir: Optional[str | Path] = None,
+        show_progress: bool = True,
+    ) -> Corpus:
+        """Télécharge les images et construit un corpus Picarones.
+
+        Si les canvases contiennent des annotations de transcription (GT),
+        elles sont automatiquement sauvegardées dans les fichiers ``.gt.txt``.
+        Sinon, des fichiers ``.gt.txt`` vides sont créés.
+
+        Parameters
+        ----------
+        pages:
+            Sélecteur de pages (ex : ``"1-10"``, ``"1,3,5"``).
+        output_dir:
+            Dossier de destination pour les images et les GT.
+            Si None, le corpus est retourné en mémoire sans écriture disque.
+        show_progress:
+            Affiche une barre de progression tqdm.
+
+        Returns
+        -------
+        Corpus
+            Corpus prêt à être utilisé dans ``run_benchmark``.
+        """
+        canvases = self.list_canvases(pages)
+        if not canvases:
+            raise ValueError("Aucun canvas sélectionné.")
+
+        out_dir: Optional[Path] = Path(output_dir) if output_dir else None
+        if out_dir:
+            out_dir.mkdir(parents=True, exist_ok=True)
+
+        # Nom du corpus depuis le titre du manifeste
+        corpus_name = self.parser.label or "iiif_corpus"
+
+        documents: list[Document] = []
+        iterator: Iterator[IIIFCanvas] = iter(canvases)
+
+        if show_progress:
+            try:
+                from tqdm import tqdm
+                iterator = tqdm(canvases, desc="Import IIIF", unit="page")
+            except ImportError:
+                pass
+
+        for canvas in iterator:
+            doc_id = f"{_slugify(canvas.label) or f'canvas_{canvas.index+1:04d}'}"
+
+            if not canvas.image_url:
+                logger.warning("Canvas %s : pas d'URL d'image — ignoré.", canvas.label)
+                continue
+
+            # Ajuster la résolution si max_resolution est défini
+            image_url = self._adjust_resolution(canvas.image_url, canvas.width)
+
+            # Téléchargement de l'image
+            try:
+                image_bytes = _download_url(image_url)
+            except RuntimeError as exc:
+                logger.error("Canvas %s : erreur téléchargement : %s", canvas.label, exc)
+                continue
+
+            # Déterminer l'extension de l'image
+            ext = _guess_extension(image_url)
+
+            if out_dir:
+                # Sauvegarde sur disque
+                image_path = out_dir / f"{doc_id}{ext}"
+                image_path.write_bytes(image_bytes)
+
+                gt_path = out_dir / f"{doc_id}.gt.txt"
+                gt_text = canvas.transcription or ""
+                gt_path.write_text(gt_text, encoding="utf-8")
+
+                documents.append(Document(
+                    image_path=image_path,
+                    ground_truth=gt_text,
+                    doc_id=doc_id,
+                    metadata={"iiif_label": canvas.label, "canvas_index": canvas.index},
+                ))
+            else:
+                # Corpus en mémoire (image stockée comme chemin temporaire virtuel)
+                import tempfile
+                tmp = tempfile.NamedTemporaryFile(suffix=ext, delete=False)
+                tmp.write(image_bytes)
+                tmp.close()
+                documents.append(Document(
+                    image_path=Path(tmp.name),
+                    ground_truth=canvas.transcription or "",
+                    doc_id=doc_id,
+                    metadata={"iiif_label": canvas.label, "canvas_index": canvas.index},
+                ))
+
+        if not documents:
+            raise ValueError("Aucun document importé depuis le manifeste IIIF.")
+
+        logger.info("Import IIIF terminé : %d documents.", len(documents))
+
+        return Corpus(
+            name=corpus_name,
+            documents=documents,
+            source_path=self.manifest_url,
+            metadata={
+                "iiif_manifest_url": self.manifest_url,
+                "iiif_version": self.parser.version,
+                "iiif_attribution": self.parser.attribution,
+                "pages_selected": pages,
+            },
+        )
+
+    def _adjust_resolution(self, image_url: str, canvas_width: Optional[int]) -> str:
+        """Ajuste l'URL IIIF Image API pour respecter max_resolution."""
+        if not self.max_resolution or not canvas_width:
+            return image_url
+        if canvas_width <= self.max_resolution:
+            return image_url
+        # Remplacer /full/max/ ou /full/full/ par /full/{w},/
+        url = re.sub(
+            r"/full/(max|full)/",
+            f"/full/{self.max_resolution},/",
+            image_url,
+        )
+        return url
+
+
+# ---------------------------------------------------------------------------
+# Helpers utilitaires
+# ---------------------------------------------------------------------------
+
+def _slugify(text: str) -> str:
+    """Convertit un label IIIF en identifiant de fichier sûr."""
+    text = re.sub(r"[^\w\s-]", "", text.strip())
+    text = re.sub(r"[\s_-]+", "_", text)
+    return text[:60]
+
+
+def _guess_extension(url: str) -> str:
+    """Détermine l'extension de l'image depuis l'URL."""
+    url_lower = url.lower().split("?")[0]
+    for ext in (".jpg", ".jpeg", ".png", ".tif", ".tiff", ".webp"):
+        if url_lower.endswith(ext):
+            return ext
+    # Par défaut pour les URLs IIIF Image API
+    if "/default." in url_lower or "/native." in url_lower:
+        return ".jpg"
+    return ".jpg"
+
+
+# ---------------------------------------------------------------------------
+# Fonction de commodité
+# ---------------------------------------------------------------------------
+
+def import_iiif_manifest(
+    manifest_url: str,
+    pages: str = "all",
+    output_dir: Optional[str | Path] = None,
+    max_resolution: int = 0,
+    show_progress: bool = True,
+) -> Corpus:
+    """Importe un corpus depuis un manifeste IIIF en une seule ligne.
+
+    Parameters
+    ----------
+    manifest_url:
+        URL du manifeste IIIF (v2 ou v3).
+    pages:
+        Sélecteur de pages (ex : ``"1-10"``, ``"1,3,5"``). ``"all"`` par défaut.
+    output_dir:
+        Dossier de destination. Si None, corpus en mémoire.
+    max_resolution:
+        Résolution maximale (px). 0 = pas de limite.
+    show_progress:
+        Affiche une barre de progression.
+
+    Returns
+    -------
+    Corpus
+    """
+    importer = IIIFImporter(manifest_url, max_resolution=max_resolution)
+    importer.load()
+    return importer.import_corpus(
+        pages=pages,
+        output_dir=output_dir,
+        show_progress=show_progress,
+    )

picarones/report/generator.py

@@ -69,6 +69,7 @@ def _build_report_data(benchmark: BenchmarkResult, images_b64: dict[str, str]) -
     engines_summary = []
     for report in benchmark.engine_reports:
         agg = report.aggregated_metrics
+        diplo_agg = agg.get("cer_diplomatic", {})
         entry: dict = {
             "name": report.engine_name,
             "version": report.engine_version,
@@ -81,12 +82,20 @@ def _build_report_data(benchmark: BenchmarkResult, images_b64: dict[str, str]) -
             "cer_max":    _safe(agg.get("cer", {}).get("max")),
             "doc_count":  agg.get("document_count", 0),
             "failed":     agg.get("failed_count", 0),
+            # CER diplomatique (après normalisation historique : ſ=s, u=v, i=j…)
+            "cer_diplomatic": _safe(diplo_agg.get("mean")) if diplo_agg else None,
+            "cer_diplomatic_profile": diplo_agg.get("profile"),
             # Distribution pour l'histogramme : liste des CER individuels
             "cer_values": [
                 _safe(dr.metrics.cer)
                 for dr in report.document_results
                 if dr.metrics.error is None
             ],
+            "cer_diplomatic_values": [
+                _safe(dr.metrics.cer_diplomatic)
+                for dr in report.document_results
+                if dr.metrics.error is None and dr.metrics.cer_diplomatic is not None
+            ],
             # Champs pipeline OCR+LLM (vides pour les moteurs OCR seuls)
             "is_pipeline": report.is_pipeline,
             "pipeline_info": report.pipeline_info,
@@ -121,6 +130,7 @@ def _build_report_data(benchmark: BenchmarkResult, images_b64: dict[str, str]) -
                 "engine": engine_name,
                 "hypothesis": dr.hypothesis,
                 "cer": _safe(dr.metrics.cer),
+                "cer_diplomatic": _safe(dr.metrics.cer_diplomatic) if dr.metrics.cer_diplomatic is not None else None,
                 "wer": _safe(dr.metrics.wer),
                 "duration": dr.duration_seconds,
                 "error": dr.engine_error,
@@ -622,7 +632,8 @@ footer {{
           <tr>
             <th data-col="rank" class="sortable sorted" data-dir="asc">#<i class="sort-icon">↑</i></th>
             <th data-col="name" class="sortable">Concurrent<i class="sort-icon">↕</i></th>
-            <th data-col="cer"  class="sortable">CER<i class="sort-icon">↕</i></th>
+            <th data-col="cer"  class="sortable">CER exact<i class="sort-icon">↕</i></th>
+            <th data-col="cer_diplomatic" class="sortable" title="CER après normalisation diplomatique (ſ=s, u=v, i=j…) — mesure les erreurs substantielles en ignorant les variantes graphiques codifiées">CER diplo.<i class="sort-icon">↕</i></th>
             <th data-col="wer"  class="sortable">WER<i class="sort-icon">↕</i></th>
             <th data-col="mer"  class="sortable">MER<i class="sort-icon">↕</i></th>
             <th data-col="wil"  class="sortable">WIL<i class="sort-icon">↕</i></th>
@@ -906,6 +917,18 @@ function renderRanking() {{
       overNormCell = `<td><span class="${{cls}}" title="Classe 10 — ${{on.over_normalized_count}} mots corrects dégradés sur ${{on.total_correct_ocr_words}}">${{onPct}} %</span></td>`;
     }}
 
+    // CER diplomatique
+    let diploCerCell = '<td style="color:var(--text-muted)">—</td>';
+    if (e.cer_diplomatic !== null && e.cer_diplomatic !== undefined) {{
+      const dipC = cerColor(e.cer_diplomatic); const dipB = cerBg(e.cer_diplomatic);
+      const delta = e.cer - e.cer_diplomatic;
+      const deltaStr = delta > 0.001 ? ` <span style="font-size:.65rem;color:#059669">-${{(delta*100).toFixed(1)}}%</span>` : '';
+      const profileHint = e.cer_diplomatic_profile ? ` title="Profil : ${{esc(e.cer_diplomatic_profile)}}"` : '';
+      diploCerCell = `<td${{profileHint}}>
+        <span class="cer-badge" style="color:${{dipC}};background:${{dipB}}">${{pct(e.cer_diplomatic)}}</span>${{deltaStr}}
+      </td>`;
+    }}
+
     return `<tr>
       <td><span class="${{badgeClass}}">${{rank}}</span></td>
       <td>
@@ -918,6 +941,7 @@ function renderRanking() {{
         <span class="bar" style="width:${{barW}}px;background:${{cerC}}"></span>
         <span class="cer-badge" style="color:${{cerC}};background:${{cerB}}">${{pct(e.cer)}}</span>
       </td>
+      ${{diploCerCell}}
       <td>${{pct(e.wer)}}</td>
       <td>${{pct(e.mer)}}</td>
       <td>${{pct(e.wil)}}</td>
@@ -1109,12 +1133,23 @@ function loadDocument(docId) {{
         </div>`;
     }}
 
+    // CER diplomatique par document
+    let diplomaBadge = '';
+    if (er.cer_diplomatic !== null && er.cer_diplomatic !== undefined) {{
+      const dipC = cerColor(er.cer_diplomatic); const dipB = cerBg(er.cer_diplomatic);
+      const delta = er.cer - er.cer_diplomatic;
+      const deltaHint = delta > 0.001 ? ` (−${{(delta*100).toFixed(1)}}% avec normalisation)` : '';
+      diplomaBadge = `<span class="cer-badge" style="color:${{dipC}};background:${{dipB}};opacity:.85"
+        title="CER diplomatique (ſ=s, u=v, i=j…)${{deltaHint}}">diplo. ${{pct(er.cer_diplomatic)}}</span>`;
+    }}
+
     return `<div class="diff-panel">
       <div class="diff-panel-header">
         <span class="diff-panel-title">${{esc(er.engine)}}</span>
         ${{pipeTagPanel}}
         <span class="diff-panel-metrics">
           <span class="cer-badge" style="color:${{c}};background:${{bg}}">${{pct(er.cer)}}</span>
+          ${{diplomaBadge}}
           <span class="badge" style="background:#f1f5f9">WER ${{pct(er.wer)}}</span>
           ${{onBadge}}
           ${{errBadge}}

tests/test_sprint4_normalization_iiif.py

@@ -0,0 +1,834 @@
+"""Tests Sprint 4 : normalisation diplomatique, import IIIF, adaptateurs API OCR."""
+
+from __future__ import annotations
+
+import json
+import os
+import pytest
+
+from picarones.core.normalization import (
+    NormalizationProfile,
+    DIPLOMATIC_FR_MEDIEVAL,
+    DIPLOMATIC_FR_EARLY_MODERN,
+    DIPLOMATIC_LATIN_MEDIEVAL,
+    DIPLOMATIC_MINIMAL,
+    DEFAULT_DIPLOMATIC_PROFILE,
+    _apply_diplomatic_table,
+    get_builtin_profile,
+)
+from picarones.core.metrics import compute_metrics, aggregate_metrics, MetricsResult
+from picarones.importers.iiif import (
+    IIIFManifestParser,
+    IIIFCanvas,
+    parse_page_selector,
+    _extract_label,
+    _best_image_url_v2,
+    _best_image_url_v3,
+    _guess_extension,
+    _slugify,
+)
+
+
+# ===========================================================================
+# Tests NormalizationProfile
+# ===========================================================================
+
+class TestNormalizationProfile:
+
+    def test_default_nfc_only(self):
+        profile = NormalizationProfile(name="test")
+        assert profile.nfc is True
+        assert profile.caseless is False
+        assert profile.diplomatic_table == {}
+
+    def test_normalize_nfc(self):
+        profile = NormalizationProfile(name="nfc_only")
+        # NFD vs NFC : après NFC, les deux doivent être identiques
+        decomposed = "e\u0301"  # e + accent
+        assert profile.normalize(decomposed) == "\u00e9"  # é NFC
+
+    def test_normalize_caseless(self):
+        profile = NormalizationProfile(name="caseless", caseless=True)
+        assert profile.normalize("Bonjour MONDE") == "bonjour monde"
+
+    def test_normalize_diplomatic_table(self):
+        profile = NormalizationProfile(
+            name="test",
+            diplomatic_table={"ſ": "s", "u": "v"}
+        )
+        # "maiſon": ſ→s gives "maison", no u present → "maison"
+        assert profile.normalize("maiſon") == "maison"
+        # "uers" (vers ancien): u→v gives "vers"
+        assert profile.normalize("uers") == "vers"
+
+    def test_normalize_order_nfc_then_caseless_then_diplomatic(self):
+        """L'ordre est : NFC → caseless → table diplomatique."""
+        profile = NormalizationProfile(
+            name="combined",
+            caseless=True,
+            diplomatic_table={"ſ": "s"}
+        )
+        result = profile.normalize("Maiſon")
+        assert result == "maison"
+
+    def test_as_dict(self):
+        profile = NormalizationProfile(
+            name="medieval_french",
+            nfc=True,
+            caseless=False,
+            diplomatic_table={"ſ": "s"},
+            description="Test",
+        )
+        d = profile.as_dict()
+        assert d["name"] == "medieval_french"
+        assert d["diplomatic_table"] == {"ſ": "s"}
+        assert d["caseless"] is False
+
+    def test_from_dict(self):
+        data = {
+            "name": "custom",
+            "caseless": True,
+            "diplomatic": {"ſ": "s", "u": "v"},
+            "description": "Custom profile",
+        }
+        profile = NormalizationProfile.from_dict(data)
+        assert profile.name == "custom"
+        assert profile.caseless is True
+        assert profile.diplomatic_table == {"ſ": "s", "u": "v"}
+
+    def test_from_dict_defaults(self):
+        profile = NormalizationProfile.from_dict({})
+        assert profile.name == "custom"
+        assert profile.nfc is True
+        assert profile.caseless is False
+
+    def test_from_yaml(self, tmp_path):
+        yaml_content = "name: my_profile\ncaseless: false\ndiplomatic:\n  \u017f: s\n  u: v\n"
+        yaml_file = tmp_path / "profile.yaml"
+        yaml_file.write_text(yaml_content, encoding="utf-8")
+        try:
+            profile = NormalizationProfile.from_yaml(yaml_file)
+            assert profile.name == "my_profile"
+            assert profile.diplomatic_table == {"\u017f": "s", "u": "v"}
+        except RuntimeError as e:
+            if "pyyaml" in str(e):
+                pytest.skip("pyyaml non installé")
+            raise
+
+
+class TestApplyDiplomaticTable:
+
+    def test_simple_substitutions(self):
+        table = {"ſ": "s", "u": "v"}
+        # "maiſon": ſ→s gives "maison"; no u → "maison"
+        assert _apply_diplomatic_table("maiſon", table) == "maison"
+        # "uers": u→v gives "vers"
+        assert _apply_diplomatic_table("uers", table) == "vers"
+
+    def test_multi_char_key_priority(self):
+        """Les clés multi-chars sont appliquées avant les clés simples."""
+        table = {"ae": "X", "a": "Y"}
+        # "ae" doit être remplacé en "X" et non "Ye"
+        result = _apply_diplomatic_table("aeb", table)
+        assert result == "Xb"
+
+    def test_ampersand_to_et(self):
+        table = {"&": "et"}
+        assert _apply_diplomatic_table("noir & blanc", table) == "noir et blanc"
+
+    def test_empty_table(self):
+        assert _apply_diplomatic_table("hello", {}) == "hello"
+
+    def test_empty_text(self):
+        assert _apply_diplomatic_table("", {"a": "b"}) == ""
+
+
+class TestGetBuiltinProfile:
+
+    def test_medieval_french(self):
+        profile = get_builtin_profile("medieval_french")
+        assert profile.name == "medieval_french"
+        assert "ſ" in profile.diplomatic_table
+        assert profile.diplomatic_table["ſ"] == "s"
+
+    def test_early_modern_french(self):
+        profile = get_builtin_profile("early_modern_french")
+        assert "ſ" in profile.diplomatic_table
+
+    def test_medieval_latin(self):
+        profile = get_builtin_profile("medieval_latin")
+        assert "ꝑ" in profile.diplomatic_table
+
+    def test_minimal(self):
+        profile = get_builtin_profile("minimal")
+        assert "ſ" in profile.diplomatic_table
+        assert "u" not in profile.diplomatic_table
+
+    def test_nfc(self):
+        profile = get_builtin_profile("nfc")
+        assert profile.nfc is True
+        assert profile.diplomatic_table == {}
+
+    def test_caseless(self):
+        profile = get_builtin_profile("caseless")
+        assert profile.caseless is True
+
+    def test_unknown_raises_key_error(self):
+        with pytest.raises(KeyError, match="inexistant"):
+            get_builtin_profile("inexistant")
+
+    def test_default_profile_is_medieval_french(self):
+        assert DEFAULT_DIPLOMATIC_PROFILE.name == "medieval_french"
+
+
+# ===========================================================================
+# Tests CER diplomatique dans compute_metrics
+# ===========================================================================
+
+class TestDiplomaticCER:
+
+    def test_cer_diplomatic_computed_by_default(self):
+        """Le CER diplomatique est calculé par défaut avec le profil médiéval."""
+        result = compute_metrics("maiſon", "maison")
+        assert result.cer_diplomatic is not None
+        assert result.diplomatic_profile_name == "medieval_french"
+
+    def test_cer_diplomatic_lower_than_exact_for_long_s(self):
+        """
+        Avec ſ→s : le CER diplomatique doit être 0.0 pour "maiſon" vs "maison"
+        car après normalisation les deux deviennent "maivon" ou "maison".
+        """
+        # "maiſon" vs "maison" — différence uniquement sur ſ vs s
+        result = compute_metrics("maiſon", "maison")
+        # CER brut > 0 (ſ ≠ s, deux bytes UTF-8 vs un)
+        assert result.cer > 0.0
+        # CER diplomatique = 0 car ſ et s sont équivalents dans le profil médiéval
+        assert result.cer_diplomatic == pytest.approx(0.0)
+
+    def test_cer_diplomatic_in_as_dict(self):
+        result = compute_metrics("maiſon", "maison")
+        d = result.as_dict()
+        assert "cer_diplomatic" in d
+        assert "diplomatic_profile_name" in d
+
+    def test_cer_diplomatic_with_custom_profile(self):
+        from picarones.core.normalization import NormalizationProfile
+        profile = NormalizationProfile(
+            name="test_profile",
+            diplomatic_table={"ſ": "s"}
+        )
+        result = compute_metrics("maiſon", "maison", normalization_profile=profile)
+        assert result.cer_diplomatic == pytest.approx(0.0)
+        assert result.diplomatic_profile_name == "test_profile"
+
+    def test_cer_diplomatic_not_in_as_dict_when_none(self):
+        """Si le CER diplomatique n'a pas pu être calculé, il n'est pas dans as_dict."""
+        result = MetricsResult(
+            cer=0.1, cer_nfc=0.1, cer_caseless=0.1,
+            wer=0.1, wer_normalized=0.1, mer=0.1, wil=0.1,
+            reference_length=10, hypothesis_length=10,
+            cer_diplomatic=None, diplomatic_profile_name=None,
+        )
+        d = result.as_dict()
+        assert "cer_diplomatic" not in d
+
+    def test_aggregate_metrics_includes_diplomatic_cer(self):
+        """aggregate_metrics doit agréger cer_diplomatic quand disponible."""
+        results = [
+            MetricsResult(
+                cer=0.1, cer_nfc=0.1, cer_caseless=0.1,
+                wer=0.1, wer_normalized=0.1, mer=0.1, wil=0.1,
+                reference_length=10, hypothesis_length=10,
+                cer_diplomatic=0.05, diplomatic_profile_name="medieval_french",
+            ),
+            MetricsResult(
+                cer=0.2, cer_nfc=0.2, cer_caseless=0.2,
+                wer=0.2, wer_normalized=0.2, mer=0.2, wil=0.2,
+                reference_length=10, hypothesis_length=10,
+                cer_diplomatic=0.10, diplomatic_profile_name="medieval_french",
+            ),
+        ]
+        agg = aggregate_metrics(results)
+        assert "cer_diplomatic" in agg
+        assert agg["cer_diplomatic"]["mean"] == pytest.approx(0.075)
+        assert agg["cer_diplomatic"].get("profile") == "medieval_french"
+
+
+# ===========================================================================
+# Tests parse_page_selector
+# ===========================================================================
+
+class TestParsePageSelector:
+
+    def test_all(self):
+        assert parse_page_selector("all", 10) == list(range(10))
+
+    def test_empty_string(self):
+        assert parse_page_selector("", 5) == list(range(5))
+
+    def test_single_page(self):
+        assert parse_page_selector("3", 10) == [2]  # 0-based
+
+    def test_range(self):
+        assert parse_page_selector("1-5", 10) == [0, 1, 2, 3, 4]
+
+    def test_comma_list(self):
+        assert parse_page_selector("1,3,5", 10) == [0, 2, 4]
+
+    def test_combined(self):
+        result = parse_page_selector("1-3,5,8-9", 10)
+        assert result == [0, 1, 2, 4, 7, 8]
+
+    def test_deduplication(self):
+        result = parse_page_selector("1,1,2", 5)
+        assert result == [0, 1]
+
+    def test_sorted_output(self):
+        result = parse_page_selector("5,1,3", 10)
+        assert result == [0, 2, 4]
+
+    def test_page_out_of_range_raises(self):
+        with pytest.raises(ValueError):
+            parse_page_selector("15", 10)
+
+    def test_range_out_of_bounds_raises(self):
+        with pytest.raises(ValueError):
+            parse_page_selector("1-15", 10)
+
+    def test_invalid_syntax_raises(self):
+        with pytest.raises((ValueError, Exception)):
+            parse_page_selector("abc", 10)
+
+    def test_last_page(self):
+        assert parse_page_selector("10", 10) == [9]
+
+    def test_first_page(self):
+        assert parse_page_selector("1", 10) == [0]
+
+
+# ===========================================================================
+# Tests IIIFManifestParser — IIIF v2
+# ===========================================================================
+
+def _make_v2_manifest(num_canvases: int = 3, with_service: bool = False) -> dict:
+    """Fabrique un manifeste IIIF v2 minimal de test."""
+    canvases = []
+    for i in range(num_canvases):
+        resource: dict
+        if with_service:
+            resource = {
+                "@type": "dctypes:Image",
+                "service": {"@id": f"https://example.com/iiif/img{i+1}"},
+            }
+        else:
+            resource = {
+                "@type": "dctypes:Image",
+                "@id": f"https://example.com/images/img{i+1}.jpg",
+            }
+        canvases.append({
+            "@id": f"https://example.com/canvas/{i+1}",
+            "@type": "sc:Canvas",
+            "label": f"f. {i+1}r",
+            "width": 2000,
+            "height": 3000,
+            "images": [
+                {
+                    "@type": "oa:Annotation",
+                    "motivation": "sc:painting",
+                    "resource": resource,
+                    "on": f"https://example.com/canvas/{i+1}",
+                }
+            ],
+        })
+    return {
+        "@context": "http://iiif.io/api/presentation/2/context.json",
+        "@type": "sc:Manifest",
+        "@id": "https://example.com/manifest.json",
+        "label": "Manuscript de test",
+        "sequences": [
+            {
+                "@type": "sc:Sequence",
+                "canvases": canvases,
+            }
+        ],
+    }
+
+
+def _make_v3_manifest(num_canvases: int = 3) -> dict:
+    """Fabrique un manifeste IIIF v3 minimal de test."""
+    items = []
+    for i in range(num_canvases):
+        items.append({
+            "id": f"https://example.com/canvas/{i+1}",
+            "type": "Canvas",
+            "label": {"fr": [f"Page {i+1}"]},
+            "width": 1500,
+            "height": 2200,
+            "items": [
+                {
+                    "id": f"https://example.com/canvas/{i+1}/ap",
+                    "type": "AnnotationPage",
+                    "items": [
+                        {
+                            "id": f"https://example.com/canvas/{i+1}/ap/a",
+                            "type": "Annotation",
+                            "motivation": "painting",
+                            "body": {
+                                "id": f"https://example.com/images/{i+1}/full/max/0/default.jpg",
+                                "type": "Image",
+                                "format": "image/jpeg",
+                            },
+                            "target": f"https://example.com/canvas/{i+1}",
+                        }
+                    ],
+                }
+            ],
+        })
+    return {
+        "@context": "http://iiif.io/api/presentation/3/context.json",
+        "id": "https://example.com/manifest.json",
+        "type": "Manifest",
+        "label": {"fr": ["Manuscrit v3 de test"]},
+        "items": items,
+    }
+
+
+class TestIIIFManifestParserV2:
+
+    def test_version_detection(self):
+        manifest = _make_v2_manifest()
+        parser = IIIFManifestParser(manifest)
+        assert parser.version == 2
+
+    def test_canvases_count(self):
+        parser = IIIFManifestParser(_make_v2_manifest(5))
+        assert len(parser.canvases()) == 5
+
+    def test_canvas_label(self):
+        parser = IIIFManifestParser(_make_v2_manifest())
+        canvases = parser.canvases()
+        assert canvases[0].label == "f. 1r"
+        assert canvases[1].label == "f. 2r"
+
+    def test_canvas_image_url_direct(self):
+        parser = IIIFManifestParser(_make_v2_manifest())
+        canvases = parser.canvases()
+        assert canvases[0].image_url == "https://example.com/images/img1.jpg"
+
+    def test_canvas_image_url_via_service(self):
+        parser = IIIFManifestParser(_make_v2_manifest(with_service=True))
+        canvases = parser.canvases()
+        assert "/full/max/0/default.jpg" in canvases[0].image_url
+
+    def test_canvas_dimensions(self):
+        parser = IIIFManifestParser(_make_v2_manifest())
+        c = parser.canvases()[0]
+        assert c.width == 2000
+        assert c.height == 3000
+
+    def test_canvas_index(self):
+        parser = IIIFManifestParser(_make_v2_manifest(3))
+        canvases = parser.canvases()
+        for i, c in enumerate(canvases):
+            assert c.index == i
+
+    def test_label(self):
+        parser = IIIFManifestParser(_make_v2_manifest())
+        assert parser.label == "Manuscript de test"
+
+    def test_empty_sequences(self):
+        manifest = {
+            "@context": "http://iiif.io/api/presentation/2/context.json",
+            "@type": "sc:Manifest",
+            "label": "Empty",
+            "sequences": [],
+        }
+        parser = IIIFManifestParser(manifest)
+        assert parser.canvases() == []
+
+
+class TestIIIFManifestParserV3:
+
+    def test_version_detection(self):
+        manifest = _make_v3_manifest()
+        parser = IIIFManifestParser(manifest)
+        assert parser.version == 3
+
+    def test_canvases_count(self):
+        parser = IIIFManifestParser(_make_v3_manifest(4))
+        assert len(parser.canvases()) == 4
+
+    def test_canvas_label_from_language_map(self):
+        parser = IIIFManifestParser(_make_v3_manifest())
+        canvases = parser.canvases()
+        assert "Page 1" in canvases[0].label
+
+    def test_canvas_image_url(self):
+        parser = IIIFManifestParser(_make_v3_manifest())
+        canvases = parser.canvases()
+        assert "default.jpg" in canvases[0].image_url
+
+    def test_manifest_label_language_map(self):
+        parser = IIIFManifestParser(_make_v3_manifest())
+        assert "v3" in parser.label.lower() or "test" in parser.label.lower()
+
+    def test_type_manifest_triggers_v3(self):
+        """Un manifeste avec type == 'Manifest' est détecté comme v3."""
+        manifest = {"type": "Manifest", "items": []}
+        parser = IIIFManifestParser(manifest)
+        assert parser.version == 3
+
+
+class TestExtractLabel:
+
+    def test_string(self):
+        assert _extract_label("Page 1") == "Page 1"
+
+    def test_list(self):
+        assert _extract_label(["Page 1", "Page 2"]) == "Page 1"
+
+    def test_dict_fr(self):
+        assert _extract_label({"fr": ["Folio 1r"]}) == "Folio 1r"
+
+    def test_dict_en(self):
+        assert _extract_label({"en": ["Folio 1r"]}) == "Folio 1r"
+
+    def test_dict_none_key(self):
+        assert _extract_label({"none": ["Label"]}) == "Label"
+
+    def test_empty_string(self):
+        assert _extract_label("") == ""
+
+    def test_none_value(self):
+        result = _extract_label(None)
+        assert isinstance(result, str)
+
+
+class TestBestImageUrlV2:
+
+    def test_direct_id(self):
+        resource = {"@id": "https://example.com/img.jpg"}
+        url = _best_image_url_v2(resource, {})
+        assert url == "https://example.com/img.jpg"
+
+    def test_service_id(self):
+        resource = {
+            "@id": "https://example.com/info.json",
+            "service": {"@id": "https://example.com/iiif/img1"},
+        }
+        url = _best_image_url_v2(resource, {})
+        assert url == "https://example.com/iiif/img1/full/max/0/default.jpg"
+
+    def test_service_list(self):
+        resource = {
+            "service": [
+                {"@id": "https://example.com/iiif/img2"},
+            ]
+        }
+        url = _best_image_url_v2(resource, {})
+        assert url == "https://example.com/iiif/img2/full/max/0/default.jpg"
+
+
+class TestBestImageUrlV3:
+
+    def test_direct_body_image(self):
+        canvas = {
+            "items": [
+                {
+                    "type": "AnnotationPage",
+                    "items": [
+                        {
+                            "type": "Annotation",
+                            "motivation": "painting",
+                            "body": {
+                                "id": "https://example.com/img.jpg",
+                                "type": "Image",
+                            },
+                        }
+                    ],
+                }
+            ]
+        }
+        url = _best_image_url_v3(canvas)
+        assert url == "https://example.com/img.jpg"
+
+    def test_body_via_service(self):
+        canvas = {
+            "items": [
+                {
+                    "items": [
+                        {
+                            "body": {
+                                "type": "Image",
+                                "id": "",
+                                "service": [{"id": "https://example.com/iiif/3/img1"}],
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+        url = _best_image_url_v3(canvas)
+        assert "/full/max/0/default.jpg" in url
+
+    def test_empty_canvas(self):
+        url = _best_image_url_v3({})
+        assert url == ""
+
+
+class TestGuessExtension:
+
+    def test_jpg(self):
+        assert _guess_extension("https://example.com/img.jpg") == ".jpg"
+
+    def test_png(self):
+        assert _guess_extension("https://example.com/img.png") == ".png"
+
+    def test_tiff(self):
+        assert _guess_extension("https://example.com/img.tiff") == ".tiff"
+
+    def test_iiif_default(self):
+        # URL IIIF standard contient /default.jpg
+        url = "https://example.com/iiif/img/full/max/0/default.jpg"
+        assert _guess_extension(url) == ".jpg"
+
+    def test_unknown_defaults_to_jpg(self):
+        assert _guess_extension("https://example.com/resource/123") == ".jpg"
+
+
+class TestSlugify:
+
+    def test_simple(self):
+        assert _slugify("Page 1") == "Page_1"
+
+    def test_special_chars_removed(self):
+        result = _slugify("f. 1r (recto)")
+        assert "/" not in result
+        assert "." not in result
+
+    def test_max_length(self):
+        long_label = "x" * 100
+        assert len(_slugify(long_label)) <= 60
+
+    def test_empty(self):
+        assert _slugify("") == ""
+
+
+# ===========================================================================
+# Tests structure des nouveaux moteurs OCR (sans appel réseau)
+# ===========================================================================
+
+class TestMistralOCREngine:
+
+    def test_import(self):
+        from picarones.engines.mistral_ocr import MistralOCREngine
+        assert MistralOCREngine is not None
+
+    def test_name(self):
+        from picarones.engines.mistral_ocr import MistralOCREngine
+        engine = MistralOCREngine()
+        assert engine.name == "mistral_ocr"
+
+    def test_version_default_model(self):
+        from picarones.engines.mistral_ocr import MistralOCREngine
+        engine = MistralOCREngine()
+        assert "pixtral" in engine.version()
+
+    def test_version_custom_model(self):
+        from picarones.engines.mistral_ocr import MistralOCREngine
+        engine = MistralOCREngine({"model": "pixtral-large-latest"})
+        assert engine.version() == "pixtral-large-latest"
+
+    def test_missing_api_key_raises(self, monkeypatch, tmp_path):
+        from picarones.engines.mistral_ocr import MistralOCREngine
+        monkeypatch.delenv("MISTRAL_API_KEY", raising=False)
+        engine = MistralOCREngine()
+        # Créer un fichier image factice
+        img = tmp_path / "test.jpg"
+        img.write_bytes(b"\xff\xd8\xff")  # JPEG header minimal
+        with pytest.raises(RuntimeError, match="MISTRAL_API_KEY"):
+            engine._run_ocr(img)
+
+    def test_exported_from_engines(self):
+        from picarones.engines import MistralOCREngine
+        assert MistralOCREngine is not None
+
+
+class TestGoogleVisionEngine:
+
+    def test_import(self):
+        from picarones.engines.google_vision import GoogleVisionEngine
+        assert GoogleVisionEngine is not None
+
+    def test_name(self):
+        from picarones.engines.google_vision import GoogleVisionEngine
+        engine = GoogleVisionEngine()
+        assert engine.name == "google_vision"
+
+    def test_version(self):
+        from picarones.engines.google_vision import GoogleVisionEngine
+        engine = GoogleVisionEngine()
+        assert engine.version() == "v1"
+
+    def test_missing_credentials_raises(self, monkeypatch, tmp_path):
+        from picarones.engines.google_vision import GoogleVisionEngine
+        monkeypatch.delenv("GOOGLE_APPLICATION_CREDENTIALS", raising=False)
+        monkeypatch.delenv("GOOGLE_API_KEY", raising=False)
+        engine = GoogleVisionEngine()
+        img = tmp_path / "test.jpg"
+        img.write_bytes(b"\xff\xd8\xff")
+        with pytest.raises(RuntimeError):
+            engine._run_ocr(img)
+
+    def test_exported_from_engines(self):
+        from picarones.engines import GoogleVisionEngine
+        assert GoogleVisionEngine is not None
+
+
+class TestAzureDocIntelEngine:
+
+    def test_import(self):
+        from picarones.engines.azure_doc_intel import AzureDocIntelEngine
+        assert AzureDocIntelEngine is not None
+
+    def test_name(self):
+        from picarones.engines.azure_doc_intel import AzureDocIntelEngine
+        engine = AzureDocIntelEngine()
+        assert engine.name == "azure_doc_intel"
+
+    def test_missing_key_raises(self, monkeypatch, tmp_path):
+        from picarones.engines.azure_doc_intel import AzureDocIntelEngine
+        monkeypatch.delenv("AZURE_DOC_INTEL_KEY", raising=False)
+        monkeypatch.delenv("AZURE_DOC_INTEL_ENDPOINT", raising=False)
+        engine = AzureDocIntelEngine()
+        img = tmp_path / "test.jpg"
+        img.write_bytes(b"\xff\xd8\xff")
+        with pytest.raises(RuntimeError):
+            engine._run_ocr(img)
+
+    def test_exported_from_engines(self):
+        from picarones.engines import AzureDocIntelEngine
+        assert AzureDocIntelEngine is not None
+
+
+# ===========================================================================
+# Tests CLI — commande import iiif
+# ===========================================================================
+
+class TestCLIImportIIIF:
+
+    def test_import_group_exists(self):
+        from picarones.cli import cli
+        from click.testing import CliRunner
+        runner = CliRunner()
+        result = runner.invoke(cli, ["import", "--help"])
+        assert result.exit_code == 0
+
+    def test_import_iiif_command_exists(self):
+        from picarones.cli import cli
+        from click.testing import CliRunner
+        runner = CliRunner()
+        result = runner.invoke(cli, ["import", "iiif", "--help"])
+        assert result.exit_code == 0
+        assert "manifest_url" in result.output.lower() or "MANIFEST_URL" in result.output
+
+    def test_import_iiif_options(self):
+        from picarones.cli import cli
+        from click.testing import CliRunner
+        runner = CliRunner()
+        result = runner.invoke(cli, ["import", "iiif", "--help"])
+        assert "--pages" in result.output
+        assert "--output" in result.output
+
+    def test_import_iiif_requires_url(self):
+        from picarones.cli import cli
+        from click.testing import CliRunner
+        runner = CliRunner()
+        result = runner.invoke(cli, ["import", "iiif"])
+        # Sans URL, doit afficher une erreur
+        assert result.exit_code != 0
+
+
+# ===========================================================================
+# Tests fixtures Sprint 4 (CER diplomatique dans la démo)
+# ===========================================================================
+
+class TestFixturesDiplomaticCER:
+
+    def test_gt_texts_contain_medieval_graphies(self):
+        """Les textes GT de démo doivent contenir des graphies médiévales."""
+        from picarones.fixtures import _GT_TEXTS
+        all_gt = " ".join(_GT_TEXTS)
+        # Les GT doivent contenir au moins ſ, & ou æ/œ
+        has_medieval_chars = any(c in all_gt for c in ["ſ", "&", "æ", "œ"])
+        assert has_medieval_chars, "Les GT de démo doivent inclure des graphies médiévales pour illustrer le CER diplomatique"
+
+    def test_benchmark_results_have_diplomatic_cer(self):
+        """Les résultats du benchmark fictif doivent inclure le CER diplomatique."""
+        from picarones.fixtures import generate_sample_benchmark
+        bm = generate_sample_benchmark()
+        for engine_report in bm.engine_reports:
+            for doc_result in engine_report.document_results:
+                if doc_result.metrics.error is None:
+                    # Le CER diplomatique doit être calculé
+                    assert doc_result.metrics.cer_diplomatic is not None, (
+                        f"CER diplomatique manquant pour {engine_report.engine_name}"
+                    )
+                    break  # Un seul doc suffit pour vérifier
+
+    def test_diplomatic_cer_lower_for_medieval_graphies(self):
+        """Pour un texte avec ſ, le CER diplomatique doit être ≤ CER exact."""
+        result = compute_metrics(
+            "maiſon & jardin",  # GT avec graphies médiévales
+            "maison et jardin",  # OCR avec graphies modernisées
+        )
+        assert result.cer_diplomatic is not None
+        # CER diplomatique doit être inférieur ou égal au CER exact
+        assert result.cer_diplomatic <= result.cer
+
+
+# ===========================================================================
+# Tests rapport HTML Sprint 4 (CER diplomatique affiché)
+# ===========================================================================
+
+class TestReportDiplomaticCER:
+
+    def test_report_data_has_cer_diplomatic(self):
+        """_build_report_data doit inclure cer_diplomatic dans engines_summary."""
+        from picarones.fixtures import generate_sample_benchmark
+        from picarones.report.generator import _build_report_data
+
+        bm = generate_sample_benchmark()
+        data = _build_report_data(bm, images_b64={})
+
+        # Chaque entrée engines doit avoir cer_diplomatic (ou None)
+        assert "engines" in data
+        for engine_data in data["engines"]:
+            assert "cer_diplomatic" in engine_data, (
+                f"cer_diplomatic manquant dans {engine_data.get('name', '?')}"
+            )
+
+    def test_html_contains_cer_diplo_column(self, tmp_path):
+        """Le HTML généré doit contenir la colonne CER diplo."""
+        from picarones.fixtures import generate_sample_benchmark
+        from picarones.report.generator import ReportGenerator
+
+        bm = generate_sample_benchmark()
+        out = tmp_path / "report_test.html"
+        ReportGenerator(bm).generate(out)
+        html = out.read_text(encoding="utf-8")
+        assert "diplo" in html.lower() or "diplomatique" in html.lower(), (
+            "Le rapport HTML doit mentionner le CER diplomatique"
+        )
+
+    def test_html_contains_medieval_graphie_indicator(self, tmp_path):
+        """Le rapport doit mentionner les graphies médiévales (ſ=s ou u=v)."""
+        from picarones.fixtures import generate_sample_benchmark
+        from picarones.report.generator import ReportGenerator
+
+        bm = generate_sample_benchmark()
+        out = tmp_path / "report_test.html"
+        ReportGenerator(bm).generate(out)
+        html = out.read_text(encoding="utf-8")
+        # Le tooltip ou la légende doit mentionner les correspondances diplomatiques
+        assert "ſ=s" in html or "u=v" in html or "diplomatique" in html.lower()