fix(web): valider strictement les payloads Pydantic (max_length, Literal)

L'audit a identifié que ``picarones/web/models.py`` n'imposait
aucune borne aux strings ni aux listes — un payload de 1 Go sur
``char_exclude`` ou ``corpus_path`` passait la validation et
consommait de la mémoire pour rien. Les enums (``lang``,
``report_lang``, ``normalization_profile``) étaient typés ``str``
ouvert, donc ``"../../etc"`` était accepté avant d'être passé en
chaîne aux fonctions internes.

Fix : tous les champs ``str`` ont désormais une borne ``max_length``
proportionnée à leur usage attendu (constantes ``_MAX_PATH=1024``,
``_MAX_NAME=256``, ``_MAX_CHAR_EXCLUDE=256``, ``_MAX_PROMPT_FILENAME=256``).
Les listes (``engines``, ``competitors``) ont une borne
``max_length`` de 32. Les énumérations finies sont typées en
``Literal[...]`` pour rejeter au plus tôt :

- ``TesseractLang`` : 18 codes ISO (``fra``, ``lat``, ``eng``, …)
- ``ReportLang`` : ``fr`` ou ``en``
- ``NormalizationProfileId`` : 8 profils Unicode officiels

``BenchmarkRunRequest.competitors`` reçoit ``min_length=1`` —
Pydantic rejette désormais une liste vide en ``422 Unprocessable
Entity`` (code HTTP standard pour payload invalide), ce qui rend
caduque la vérification manuelle dans ``routers/benchmark.py``
(retirée). ``test_run_400_no_competitors`` mis à jour pour
attendre ``422`` au lieu de ``400`` — comportement plus correct
côté HTTP.

Pytest : 3354 passed, 2 skipped, 0 failed. Ruff : All checks passed.

https://claude.ai/code/session_01Hsd7kL8yeCbXn1mA7GQK9L

picarones/web/models.py

@@ -1,65 +1,120 @@
 """Modèles Pydantic partagés par les routers FastAPI.
 
-Ces schémas décrivent les payloads des requêtes ``POST`` consommées par
-plusieurs endpoints du serveur web. Les sortir d'``app.py`` permet à
-chaque routeur de les importer sans dépendance vers l'application
-elle-même.
+Ces schémas décrivent les payloads des requêtes ``POST`` consommées
+par plusieurs endpoints du serveur web. Les sortir d'``app.py``
+permet à chaque routeur de les importer sans dépendance vers
+l'application elle-même.
+
+Validation stricte
+------------------
+Tous les champs ``str`` ont une borne ``max_length`` proportionnée
+à leur usage attendu (chemin filesystem, identifiant HuggingFace,
+nom de rapport…) pour empêcher qu'un payload géant n'épuise la
+mémoire avant validation. Les énumérations finies (langue OCR,
+langue de rapport) sont typées en ``Literal[...]`` pour rejeter au
+plus tôt les valeurs invalides.
 """
 
 from __future__ import annotations
 
-from pydantic import BaseModel
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+# Bornes éditoriales — ajustées au plus large raisonnable, pas plus.
+_MAX_PATH = 1024
+"""Longueur max d'un chemin filesystem (limite POSIX généralement 4096)."""
+
+_MAX_NAME = 256
+"""Longueur max d'un identifiant ou nom court (rapport, label, dataset)."""
+
+_MAX_PROMPT_FILENAME = 256
+"""Nom de fichier prompt — ``"correction_medieval_french.txt"`` etc."""
+
+_MAX_CHAR_EXCLUDE = 256
+"""Liste de caractères à exclure (séparés par virgules)."""
+
+_MAX_ENGINE_LIST = 32
+"""Nombre max de moteurs OCR par requête legacy."""
+
+_MAX_COMPETITORS = 32
+"""Nombre max de concurrents composés par benchmark/run."""
+
+# Codes ISO Tesseract acceptés pour le paramètre ``lang`` de
+# ``BenchmarkRequest``. Liste explicite plutôt que ``str`` ouvert
+# pour rejeter au plus tôt une valeur fantaisiste qui transiterait
+# vers ``pytesseract`` en pure perte.
+TesseractLang = Literal[
+    "fra", "lat", "eng", "deu", "ita", "spa", "por", "nld", "cat",
+    "rum", "ell", "ara", "heb", "rus", "ukr", "pol", "ces", "swe",
+]
+
+ReportLang = Literal["fr", "en"]
+"""Langue du rapport HTML."""
+
+NormalizationProfileId = Literal[
+    "nfc", "caseless", "minimal",
+    "medieval_french", "early_modern_french",
+    "medieval_latin",
+    "early_modern_english", "medieval_english",
+]
+"""Identifiants des profils de normalisation Unicode disponibles."""
 
 
 class BenchmarkRequest(BaseModel):
-    corpus_path: str
-    engines: list[str] = ["tesseract"]
-    normalization_profile: str = "nfc"
-    char_exclude: str = ""
+    corpus_path: str = Field(min_length=1, max_length=_MAX_PATH)
+    engines: list[str] = Field(default=["tesseract"], max_length=_MAX_ENGINE_LIST)
+    normalization_profile: NormalizationProfileId = "nfc"
+    char_exclude: str = Field(default="", max_length=_MAX_CHAR_EXCLUDE)
     """Caractères à ignorer (séparés par virgule, ex: ``"',–"``)."""
-    output_dir: str = "./rapports/"
-    report_name: str = ""
-    lang: str = "fra"
-    report_lang: str = "fr"
+    output_dir: str = Field(default="./rapports/", max_length=_MAX_PATH)
+    report_name: str = Field(default="", max_length=_MAX_NAME)
+    lang: TesseractLang = "fra"
+    report_lang: ReportLang = "fr"
     """Langue du rapport HTML : ``fr`` ou ``en``."""
 
 
 class HTRUnitedImportRequest(BaseModel):
-    entry_id: str
-    output_dir: str = "./corpus/"
-    max_samples: int = 100
+    entry_id: str = Field(min_length=1, max_length=_MAX_NAME)
+    output_dir: str = Field(default="./corpus/", max_length=_MAX_PATH)
+    max_samples: int = Field(default=100, ge=1, le=10_000)
 
 
 class HuggingFaceImportRequest(BaseModel):
-    dataset_id: str
-    output_dir: str = "./corpus/"
-    split: str = "train"
-    max_samples: int = 100
+    dataset_id: str = Field(min_length=1, max_length=_MAX_NAME)
+    output_dir: str = Field(default="./corpus/", max_length=_MAX_PATH)
+    split: str = Field(default="train", max_length=_MAX_NAME)
+    max_samples: int = Field(default=100, ge=1, le=10_000)
 
 
 class CompetitorConfig(BaseModel):
-    name: str = ""
-    ocr_engine: str = ""
-    """Moteur OCR : ``tesseract``, ``mistral_ocr``, … ou ``corpus`` pour
-    utiliser l'OCR pré-calculé."""
-    ocr_model: str = ""
-    llm_provider: str = ""
-    llm_model: str = ""
-    pipeline_mode: str = ""
-    prompt_file: str = ""
+    name: str = Field(default="", max_length=_MAX_NAME)
+    ocr_engine: str = Field(default="", max_length=_MAX_NAME)
+    """Moteur OCR : ``tesseract``, ``mistral_ocr``, … ou ``corpus``
+    pour utiliser l'OCR pré-calculé."""
+    ocr_model: str = Field(default="", max_length=_MAX_NAME)
+    llm_provider: str = Field(default="", max_length=_MAX_NAME)
+    llm_model: str = Field(default="", max_length=_MAX_NAME)
+    pipeline_mode: str = Field(default="", max_length=_MAX_NAME)
+    prompt_file: str = Field(default="", max_length=_MAX_PROMPT_FILENAME)
 
 
 class BenchmarkRunRequest(BaseModel):
-    corpus_path: str
-    competitors: list[CompetitorConfig]
-    normalization_profile: str = "nfc"
-    char_exclude: str = ""
-    output_dir: str = "./rapports/"
-    report_name: str = ""
-    report_lang: str = "fr"
+    corpus_path: str = Field(min_length=1, max_length=_MAX_PATH)
+    competitors: list[CompetitorConfig] = Field(
+        min_length=1, max_length=_MAX_COMPETITORS,
+    )
+    normalization_profile: NormalizationProfileId = "nfc"
+    char_exclude: str = Field(default="", max_length=_MAX_CHAR_EXCLUDE)
+    output_dir: str = Field(default="./rapports/", max_length=_MAX_PATH)
+    report_name: str = Field(default="", max_length=_MAX_NAME)
+    report_lang: ReportLang = "fr"
 
 
 __all__ = [
+    "TesseractLang",
+    "ReportLang",
+    "NormalizationProfileId",
     "BenchmarkRequest",
     "HTRUnitedImportRequest",
     "HuggingFaceImportRequest",

picarones/web/routers/benchmark.py

@@ -110,11 +110,10 @@ async def api_benchmark_run(req: BenchmarkRunRequest, request: Request) -> dict:
         raise HTTPException(
             status_code=400, detail=f"Corpus non trouvé : {req.corpus_path}",
         )
-    if not req.competitors:
-        raise HTTPException(status_code=400, detail="Aucun concurrent défini.")
+    # ``competitors`` non vide est garanti par Pydantic ``min_length=1``.
 
-    # Sprint 24 — mode public : refuse les pipelines LLM mutualisés et
-    # les moteurs OCR cloud sollicités par n'importe quel concurrent.
+    # Mode public : refuse les pipelines LLM mutualisés et les moteurs
+    # OCR cloud sollicités par n'importe quel concurrent.
     try:
         for comp in req.competitors:
             assert_engines_allowed([comp.ocr_engine] if comp.ocr_engine else [])

tests/test_sprint6_web_interface.py

@@ -1127,7 +1127,9 @@ class TestFastAPIBenchmarkRun:
             "corpus_path": str(tmp_corpus),
             "competitors": [],
         })
-        assert r.status_code == 400
+        # Pydantic ``min_length=1`` rejette en 422 Unprocessable Entity
+        # (code HTTP standard pour payload invalide).
+        assert r.status_code == 422
 
     def test_run_missing_ocr_engine_accepted(self, client, tmp_corpus):
         """ocr_engine est désormais optionnel (vide = post-correction corpus)."""