Module IA YELY - CRNN fine-tune, API FastAPI, interface demo

.dockerignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+tests/
+logs/
+photos/
+train/
+docs/
+.env/

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+.pytest_cache/
+photos/
+logs/
+__pycache__/
+*.pyc
+*.tmp

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# libgl1/libglib nécessaires au runtime d'opencv-python-headless sur Debian slim
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+# CPU-only : évite de télécharger les wheels PyTorch CUDA (inutiles sur Hugging Face Spaces gratuit)
+RUN pip install --no-cache-dir --extra-index-url https://download.pytorch.org/whl/cpu -r requirements.txt
+
+COPY app/ app/
+COPY models/ models/
+
+# 7860 = port par défaut attendu par Hugging Face Spaces (Docker SDK)
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,119 @@
+---
+title: YELY AI Module
+emoji: ⛽
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+license: mit
+app_port: 7860
+short_description: Solution d'IA basée sur la vision par ordinateur
+---
+
+# YELY — Module IA de vérification pompiste
+
+Module autonome livré pour le cahier des charges YELY : lecture automatique
+du terminal de pompe (prix, volume, prix du litre), calcul et vérification
+de cohérence, exposés via une API.
+
+Contrairement à la version précédente du prototype (qui s'appuyait sur
+PaddleOCR/EasyOCR, des OCR génériques), ce module utilise un **modèle CRNN
+entraîné sur nos propres données** (`models/crnn_fuel_pump_best.pt`) —
+voir `docs/LIMITATIONS.md` pour un bilan honnête de sa précision actuelle
+et des pistes d'amélioration.
+
+## Structure
+
+```
+yely_ai_module/
+├── app/
+│   ├── main.py           # API FastAPI (/analyze)
+│   ├── preprocessing.py  # détection écran + découpage en lignes
+│   ├── recognizer.py     # chargement du CRNN + inférence
+│   ├── postprocess.py    # normalisation numérique, calculs, cohérence
+│   ├── rules.py          # moteur de règles métier (blocage/succès)
+│   └── config.py         # seuils configurables (config.yaml)
+├── models/
+│   └── crnn_fuel_pump_best.pt   # modèle sérialisé (livrable)
+├── train/                # scripts d'entraînement (reproductibilité)
+├── tests/                # tests unitaires (postprocess, règles)
+├── web/                  # interface web de démo (déploiement Vercel)
+├── docs/                 # documentation par module + limites identifiées
+├── Dockerfile            # déploiement Hugging Face Spaces
+└── requirements.txt
+```
+
+## Installation
+
+```bash
+cd yely_ai_module
+pip install -r requirements.txt
+```
+
+## Lancer l'API
+
+```bash
+uvicorn app.main:app --host 0.0.0.0 --port 8000
+```
+
+Ne pas utiliser `--reload` en usage normal : ça redémarre tout le worker
+(et donc recharge le modèle CRNN, ~30-60s) à chaque modification de fichier.
+
+## Appeler l'API
+
+```bash
+curl -X POST http://127.0.0.1:8000/analyze \
+  -F "image=@photo_pompe.jpg" \
+  -F "fuel_price=700" \
+  -F "driver_id=chauffeur-42" \
+  -F "pompiste_id=pompiste-7" \
+  -F "station_id=station-3"
+```
+
+### Réponse
+
+```json
+{
+  "success": true,
+  "image_quality": "valid",
+  "detected_liters": 14.28,
+  "detected_amount": 10000.0,
+  "fuel_price": 700.0,
+  "calculated_amount": 9996.0,
+  "calculated_liters": null,
+  "is_consistent": true,
+  "confidence_score": 0.93,
+  "message": "Données vérifiées avec succès.",
+  "driver_id": "chauffeur-42",
+  "pompiste_id": "pompiste-7",
+  "station_id": "station-3",
+  "transaction_datetime": "2026-07-05T20:00:00+00:00",
+  "photo_reference": "<uuid>.jpg"
+}
+```
+
+Champs conformes au §13 du cahier des charges. Le `fuel_price` fourni par
+l'appelant (système YELY) fait toujours autorité sur un prix lu à l'écran
+(règle métier n°1).
+
+## Tests
+
+```bash
+pytest tests/
+```
+
+## Ré-entraîner le modèle
+
+```bash
+cd train
+python prepare_doctr_dataset.py   # si le dataset a changé
+python finetune_doctr.py --epochs 60
+```
+
+Voir `docs/LIMITATIONS.md` avant de ré-entraîner : le principal facteur
+limitant est la diversité du jeu de données, pas les hyperparamètres.
+
+## Déploiement
+
+Voir `docs/WORKFLOW.md` §6 : frontend (`web/`) sur Vercel, API sur
+Hugging Face Spaces (ce dépôt, via le `Dockerfile` à la racine).

app/config.py

@@ -0,0 +1,48 @@
+"""Seuils métier configurables via config.yaml (optionnel) ou variables d'environnement.
+
+Recherche, dans l'ordre : argument explicite -> variable d'env CONFIG_PATH ->
+config.yaml à la racine du module -> valeurs par défaut.
+"""
+from dataclasses import dataclass
+from pathlib import Path
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+MODULE_ROOT = Path(__file__).resolve().parent.parent
+
+
+@dataclass
+class RuleConfig:
+    consistency_tolerance: float = 0.02
+    match_tolerance: float = 0.03
+    liters_upper_bound: float = 500.0
+    price_min: float = 200.0
+    price_max: float = 2000.0
+    business_confidence_threshold: float = 0.5
+    blur_threshold: float = 80.0
+    dark_threshold: float = 40.0
+    bright_threshold: float = 240.0
+
+
+def load_config(path: str | None = None) -> RuleConfig:
+    candidate = path or os.environ.get("CONFIG_PATH") or str(MODULE_ROOT / "config.yaml")
+    candidate_path = Path(candidate)
+
+    if not candidate_path.is_file():
+        return RuleConfig()
+
+    try:
+        import yaml
+        with open(candidate_path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f) or {}
+    except Exception as e:
+        logger.warning(f"Impossible de charger {candidate_path} : {e}. Utilisation des valeurs par défaut.")
+        return RuleConfig()
+
+    rules_data = data.get("rules", data) if isinstance(data, dict) else {}
+    defaults = RuleConfig()
+    known_fields = defaults.__dataclass_fields__.keys()
+    kwargs = {k: v for k, v in rules_data.items() if k in known_fields}
+    return RuleConfig(**{**defaults.__dict__, **kwargs})

app/main.py

@@ -0,0 +1,159 @@
+"""API YELY — module IA de vérification pompiste (modèle CRNN fine-tuné).
+
+Endpoint unique : POST /analyze
+  - image (fichier, requis)
+  - fuel_price (float, optionnel) : prix du litre configuré côté YELY
+  - driver_id, pompiste_id, station_id (str, optionnels) : traçabilité
+
+Réponse conforme au §9/§13 du cahier des charges YELY.
+"""
+import json
+import logging
+import os
+import shutil
+import tempfile
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+import cv2
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
+from .config import load_config
+from .preprocessing import detect_screen_region
+from .quality import estimate_image_quality
+from .recognizer import get_device, load_model, recognize_screen
+from .postprocess import process as postprocess_results
+from .rules import evaluate as evaluate_rules
+
+MODULE_ROOT = Path(__file__).resolve().parent.parent
+LOG_DIR = MODULE_ROOT / "logs"
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+PHOTOS_DIR = MODULE_ROOT / "photos"
+PHOTOS_DIR.mkdir(parents=True, exist_ok=True)
+
+logger = logging.getLogger("yely_ai_module")
+logger.setLevel(logging.INFO)
+_file_handler = logging.FileHandler(LOG_DIR / "api.log", encoding="utf-8")
+_file_handler.setFormatter(logging.Formatter("%(asctime)s | %(levelname)s | %(message)s"))
+logger.addHandler(_file_handler)
+
+app = FastAPI(title="YELY — Module IA pompiste (CRNN)")
+
+# Le frontend (Vercel) et l'API (Hugging Face Spaces) sont sur des domaines
+# différents : sans CORS, le navigateur bloquerait la lecture de la réponse
+# même si la requête aboutit côté serveur. ALLOWED_ORIGINS est une liste
+# d'origines séparées par des virgules (ex. "https://yely-demo.vercel.app").
+_allowed_origins = os.environ.get("ALLOWED_ORIGINS", "https://yely-demo.vercel.app")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"] if _allowed_origins == "*" else _allowed_origins.split(","),
+    allow_methods=["POST"],
+    allow_headers=["*"],
+)
+
+SUPPORTED_IMAGE_TYPES = {"image/jpeg", "image/png", "image/bmp", "image/webp", "image/tiff"}
+
+cfg = load_config()
+
+_model = None
+_device = None
+
+
+def _get_model():
+    global _model, _device
+    if _model is None:
+        _device = get_device()
+        _model = load_model(device=_device)
+        logger.info(f"Modèle CRNN chargé sur {_device}.")
+    return _model, _device
+
+
+@app.post("/analyze")
+async def analyze(
+    image: UploadFile = File(...),
+    fuel_price: float = Form(None),
+    driver_id: str = Form(None),
+    pompiste_id: str = Form(None),
+    station_id: str = Form(None),
+):
+    if image.content_type not in SUPPORTED_IMAGE_TYPES:
+        raise HTTPException(status_code=400, detail="Type d'image non supporté")
+
+    transaction_id = str(uuid.uuid4())
+    transaction_datetime = datetime.now(timezone.utc).isoformat()
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=Path(image.filename).suffix) as tmp:
+        tmp.write(await image.read())
+        tmp_path = tmp.name
+
+    try:
+        img_bgr = cv2.imread(tmp_path)
+        if img_bgr is None:
+            raise HTTPException(status_code=400, detail="Impossible de lire l'image")
+
+        try:
+            crop, (sx, sy, sw, sh) = detect_screen_region(img_bgr)
+            img_to_process = crop if sw < img_bgr.shape[1] * 0.95 else img_bgr
+
+            model, device = _get_model()
+            recognized = recognize_screen(model, img_to_process, device)
+
+            parsed = postprocess_results(recognized, fuel_price=fuel_price, cfg=cfg)
+            quality = estimate_image_quality(img_to_process, ocr_results=recognized, cfg=cfg)
+            gate = evaluate_rules(parsed, quality, fuel_price, cfg)
+        except HTTPException:
+            raise
+        except Exception:
+            logger.exception("Erreur interne lors du traitement de l'image")
+            return JSONResponse(status_code=500, content={
+                "success": False,
+                "message": "Erreur interne de traitement",
+                "transaction_datetime": transaction_datetime,
+            })
+
+        photo_reference = None
+        try:
+            photo_reference = f"{transaction_id}{Path(image.filename).suffix}"
+            shutil.copyfile(tmp_path, PHOTOS_DIR / photo_reference)
+        except Exception:
+            logger.warning(f"Impossible de sauvegarder la photo pour la transaction {transaction_id}", exc_info=True)
+            photo_reference = None
+
+        response = {
+            "success": gate["success"],
+            "image_quality": quality["image_quality"],
+            "detected_liters": parsed["detected_liters"],
+            "detected_amount": parsed["detected_amount"],
+            "fuel_price": parsed["fuel_price"],
+            "calculated_amount": parsed["calculated_amount"],
+            "calculated_liters": parsed["calculated_liters"],
+            "is_consistent": parsed["is_consistent"],
+            "confidence_score": gate["confidence_score"],
+            "message": gate["message"],
+            "driver_id": driver_id,
+            "pompiste_id": pompiste_id,
+            "station_id": station_id,
+            "transaction_datetime": transaction_datetime,
+            "photo_reference": photo_reference,
+        }
+
+        logger.info(json.dumps({
+            "request": {
+                "filename": image.filename,
+                "fuel_price": fuel_price,
+                "driver_id": driver_id,
+                "pompiste_id": pompiste_id,
+                "station_id": station_id,
+            },
+            "response": response,
+        }, ensure_ascii=False))
+
+        return JSONResponse(content=response)
+    finally:
+        try:
+            os.remove(tmp_path)
+        except Exception:
+            pass

app/postprocess.py

@@ -0,0 +1,107 @@
+"""Post-traitement métier des lectures du CRNN : normalisation numérique,
+calcul du montant/litres manquant, vérification de cohérence.
+
+Contrairement au pipeline OCR générique (qui doit deviner quel nombre
+correspond à quel champ par proximité de libellé ou par magnitude), le CRNN
+étiquette déjà chaque ligne lue ("prix" = montant, "volume" = litres,
+"prix_litre" = prix unitaire affiché) grâce au découpage positionnel — il
+n'y a donc pas d'ambiguïté champ/valeur à résoudre ici.
+"""
+from typing import Any, Dict, List, Optional
+import re
+
+from .config import RuleConfig, load_config
+
+NUMBER_RE = re.compile(r"[-+]?[0-9]+[\.,]?[0-9]*")
+
+
+def _norm_number(s: str) -> Optional[float]:
+    """Normalise un nombre lu par le CRNN (virgule/point, espaces) en float."""
+    if not s:
+        return None
+    s = s.strip().replace(" ", "").replace("\xa0", "")
+    m = NUMBER_RE.search(s)
+    if not m:
+        return None
+    s = m.group(0)
+    if "," in s and "." in s:
+        s = s.replace(",", "")
+    elif s.count(",") == 1 and s.count(".") == 0:
+        s = s.replace(",", ".")
+    try:
+        return float(s)
+    except ValueError:
+        return None
+
+
+def evaluate_consistency(liters: Optional[float], amount: Optional[float],
+                         price: Optional[float], tol: Optional[float] = None,
+                         cfg: Optional[RuleConfig] = None) -> Dict[str, Any]:
+    """Vérifie montant == litres x prix (§5.5/§10 du cahier des charges)."""
+    if cfg is None:
+        cfg = load_config()
+    if tol is None:
+        tol = cfg.consistency_tolerance
+
+    out = {"is_consistent": None, "calculated_amount": None, "calculated_liters": None}
+    if liters is not None and price is not None:
+        calc_amt = liters * price
+        out["calculated_amount"] = round(calc_amt, 2)
+        if amount is not None:
+            out["is_consistent"] = abs(amount - calc_amt) / max(1.0, calc_amt) <= tol
+    if amount is not None and price is not None and liters is None:
+        calc_l = amount / price if price != 0 else None
+        out["calculated_liters"] = round(calc_l, 2) if calc_l is not None else None
+    return out
+
+
+def process(recognized_fields: List[Dict[str, Any]],
+           fuel_price: Optional[float] = None,
+           cfg: Optional[RuleConfig] = None) -> Dict[str, Any]:
+    """Convertit les lignes lues par le CRNN en résultat métier structuré.
+
+    Args:
+        recognized_fields: sortie de `recognizer.recognize_screen` :
+            liste de {'field': 'prix'|'volume'|'prix_litre', 'text', 'confidence'}
+        fuel_price: prix du litre configuré côté YELY (fait toujours autorité
+            sur un prix lu à l'écran — règle métier n°1 du cahier des charges).
+    """
+    if cfg is None:
+        cfg = load_config()
+
+    by_field = {f["field"]: f for f in recognized_fields if f.get("field")}
+
+    amount_val = _norm_number(by_field.get("prix", {}).get("text", ""))
+    liters_val = _norm_number(by_field.get("volume", {}).get("text", ""))
+    screen_price_val = _norm_number(by_field.get("prix_litre", {}).get("text", ""))
+
+    # Le prix configuré côté YELY fait autorité ; le prix lu à l'écran n'est
+    # utilisé que si l'appelant n'en a fourni aucun.
+    price_val = fuel_price if fuel_price is not None else screen_price_val
+
+    evalr = evaluate_consistency(liters_val, amount_val, price_val, cfg=cfg)
+
+    confidences = [f["confidence"] for f in recognized_fields if f.get("confidence") is not None]
+    ocr_confidence = (sum(confidences) / len(confidences)) if confidences else None
+
+    raw_numbers = [(f["text"], v) for f, v in (
+        (by_field.get("prix", {}), amount_val),
+        (by_field.get("volume", {}), liters_val),
+        (by_field.get("prix_litre", {}), screen_price_val),
+    ) if v is not None]
+
+    return {
+        "detected_liters": liters_val,
+        "detected_amount": amount_val,
+        "fuel_price": price_val,
+        "calculated_amount": evalr["calculated_amount"],
+        "calculated_liters": evalr["calculated_liters"],
+        "is_consistent": evalr["is_consistent"],
+        "ocr_confidence": round(ocr_confidence, 2) if ocr_confidence is not None else None,
+        "field_confidences": {
+            "liters": by_field.get("volume", {}).get("confidence"),
+            "amount": by_field.get("prix", {}).get("confidence"),
+            "price": by_field.get("prix_litre", {}).get("confidence"),
+        },
+        "raw_numbers": raw_numbers,
+    }

app/preprocessing.py

@@ -0,0 +1,109 @@
+"""Prétraitement image : détection de l'écran LCD puis découpage en lignes
+de valeurs (prix / volume / prix du litre), avant reconnaissance CRNN.
+
+Cette étape reste indépendante du modèle de reconnaissance : elle correspond
+au travail de prétraitement/détection d'écran attendu par le cahier des
+charges (§6.1, §8.2/8.3), et reste identique quel que soit le moteur de
+lecture des chiffres utilisé en aval.
+"""
+import cv2
+import numpy as np
+from typing import List, Tuple
+
+
+FIELD_NAMES = ["prix", "volume", "prix_litre"]
+
+
+def detect_screen_region(img: np.ndarray) -> Tuple[np.ndarray, Tuple[int, int, int, int]]:
+    """Tente de localiser la zone de l'écran LCD dans l'image.
+
+    Retourne (crop, (x, y, w, h)) ou (img, (0,0,W,H)) si rien de convaincant
+    n'a été trouvé (l'appelant doit alors traiter l'image entière).
+    """
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) if len(img.shape) == 3 else img.copy()
+    blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+    edges = cv2.Canny(blurred, 30, 100)
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (15, 5))
+    closed = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
+    contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL,
+                                   cv2.CHAIN_APPROX_SIMPLE)
+    h_img, w_img = img.shape[:2]
+    best_rect, best_area = None, 0
+    for cnt in contours:
+        x, y, w, h = cv2.boundingRect(cnt)
+        area = w * h
+        if area > 0.02 * h_img * w_img and 1.0 < (w / max(h, 1)) < 8.0:
+            if area > best_area:
+                best_area = area
+                best_rect = (x, y, w, h)
+    if best_rect:
+        x, y, w, h = best_rect
+        pad = 10
+        x1 = max(0, x - pad); y1 = max(0, y - pad)
+        x2 = min(w_img, x + w + pad); y2 = min(h_img, y + h + pad)
+        return img[y1:y2, x1:x2], (x1, y1, x2 - x1, y2 - y1)
+    return img, (0, 0, w_img, h_img)
+
+
+def split_lcd_lines(lcd_crop: np.ndarray,
+                    n_lines: int = 3) -> Tuple[List[np.ndarray], List[Tuple[int, int]]]:
+    """Découpe le crop d'écran en `n_lines` bandes horizontales (une par
+    valeur affichée : prix, volume, prix du litre), par projection
+    horizontale des pixels sombres, avec repli sur un découpage proportionnel
+    si la projection ne trouve pas exactement le bon nombre de bandes.
+
+    NB : `n_lines=3` par défaut (et non 2) car la majorité des écrans du jeu
+    d'annotation affichent les trois valeurs (prix, volume, prix/litre) —
+    un défaut à 2 aurait systématiquement ignoré la troisième ligne.
+    """
+    gray = cv2.cvtColor(lcd_crop, cv2.COLOR_BGR2GRAY)
+    h, w = gray.shape
+
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+    enh = clahe.apply(gray)
+    _, bin_img = cv2.threshold(enh, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    if np.mean(bin_img) > 128:
+        bin_img = cv2.bitwise_not(bin_img)
+
+    row_sums = np.sum(bin_img == 255, axis=1).astype(np.float32)
+    smoothed = cv2.GaussianBlur(
+        row_sums.reshape(-1, 1), (1, max(3, h // 30) * 2 + 1), 0
+    ).flatten()
+    threshold = max(smoothed.max() * 0.08, 2)
+    active = smoothed > threshold
+
+    bands: List[Tuple[int, int]] = []
+    in_band = False
+    start = 0
+    for y in range(h):
+        if active[y] and not in_band:
+            start, in_band = y, True
+        elif not active[y] and in_band:
+            bands.append((start, y))
+            in_band = False
+    if in_band:
+        bands.append((start, h))
+
+    min_h = h * 0.06
+    bands = [(s, e) for s, e in bands if e - s >= min_h]
+    merged: List[Tuple[int, int]] = []
+    for band in bands:
+        if merged and band[0] - merged[-1][1] < h * 0.05:
+            merged[-1] = (merged[-1][0], band[1])
+        else:
+            merged.append(band)
+    bands = [tuple(band) for band in merged]
+
+    if len(bands) != n_lines:
+        band_h = h / n_lines
+        bands = [(int(i * band_h), int((i + 1) * band_h)) for i in range(n_lines)]
+
+    crops: List[np.ndarray] = []
+    normalized_bands: List[Tuple[int, int]] = []
+    for start_y, end_y in bands:
+        pad = max(2, int(h * 0.02))
+        y0 = max(0, start_y - pad)
+        y1 = min(h, end_y + pad)
+        crops.append(lcd_crop[y0:y1, :])
+        normalized_bands.append((y0, y1 - y0))
+    return crops, normalized_bands

app/quality.py

@@ -0,0 +1,58 @@
+"""Détection de la qualité de l'image (floue / sombre / surexposée / valide).
+
+Fonction indépendante du moteur de reconnaissance : elle s'applique à
+l'image (ou au crop d'écran) avant toute tentative de lecture des chiffres,
+conformément au §6.2 du cahier des charges.
+"""
+import cv2
+import numpy as np
+from typing import Dict, Any, Optional
+
+from .config import RuleConfig, load_config
+
+
+def estimate_image_quality(img: np.ndarray,
+                           ocr_results: Optional[list] = None,
+                           cfg: Optional[RuleConfig] = None) -> Dict[str, Any]:
+    """Estime la qualité de l'image et retourne un label + un score.
+
+    Heuristiques : variance du Laplacien (flou) et luminosité moyenne.
+    """
+    if cfg is None:
+        cfg = load_config()
+
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) if len(img.shape) == 3 else img.copy()
+    blur = cv2.Laplacian(gray, cv2.CV_64F).var()
+    mean_brightness = float(np.mean(gray))
+
+    # Le flou/la luminosité sont des propriétés intrinsèques de l'image et
+    # doivent être vérifiés avant le repli "unclear" (nombre de résultats),
+    # sinon une image nette et bien éclairée mais avec peu de détections
+    # serait à tort classée "unclear" plutôt que diagnostiquée correctement.
+    if blur < cfg.blur_threshold:
+        label = "blurry"
+    elif mean_brightness < cfg.dark_threshold:
+        label = "dark"
+    elif mean_brightness > cfg.bright_threshold:
+        label = "bright"
+    elif ocr_results is not None and len(ocr_results) < 2:
+        label = "unclear"
+    else:
+        label = "valid"
+
+    quality_score = 0.0
+    if label == "valid":
+        quality_score = 0.95
+    elif label == "unclear":
+        quality_score = 0.20
+    elif label in ("blurry", "dark", "bright"):
+        quality_score = 0.35
+    else:
+        quality_score = 0.50
+
+    return {
+        "image_quality": label,
+        "quality_score": round(min(1.0, quality_score), 2),
+        "blur_variance": round(blur, 2),
+        "brightness": round(mean_brightness, 2),
+    }

app/recognizer.py

@@ -0,0 +1,107 @@
+"""Chargement et inférence du modèle CRNN fine-tuné sur les écrans de pompe.
+
+C'est le "modèle IA développé" au sens du §8.4 du cahier des charges :
+un CRNN (crnn_vgg16_bn, doctr) fine-tuné sur nos propres données annotées
+(voir train/)
+"""
+import os
+from typing import Any, Dict, List, Optional, Tuple
+
+import cv2
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from .preprocessing import FIELD_NAMES, split_lcd_lines
+
+try:
+    from doctr.datasets import VOCABS
+    from doctr.models import crnn_vgg16_bn
+except Exception as exc:  # pragma: no cover - dépend de l'environnement
+    VOCABS = None
+    crnn_vgg16_bn = None
+    _DOCTR_IMPORT_ERROR = exc
+else:
+    _DOCTR_IMPORT_ERROR = None
+
+VOCAB = VOCABS["french"] if VOCABS is not None else None
+IMG_H = 32
+MODULE_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DEFAULT_MODEL_PATH = os.path.join(MODULE_ROOT, "models", "crnn_fuel_pump_best.pt")
+
+
+def get_device() -> torch.device:
+    return torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+def load_model(model_path: Optional[str] = None, device: Optional[torch.device] = None):
+    if model_path is None:
+        model_path = DEFAULT_MODEL_PATH
+
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"Modèle introuvable : {model_path}")
+
+    if crnn_vgg16_bn is None or VOCAB is None:
+        raise ImportError(
+            "python-doctr n'est pas installé (voir requirements.txt)."
+        ) from _DOCTR_IMPORT_ERROR
+
+    if device is None:
+        device = get_device()
+
+    model = crnn_vgg16_bn(pretrained=False, pretrained_backbone=False, vocab=VOCAB)
+    model.load_state_dict(torch.load(model_path, map_location=device))
+    return model.to(device).eval()
+
+
+def _resize_preserve_aspect(tensor: torch.Tensor, img_h: int) -> torch.Tensor:
+    """Redimensionne en conservant le ratio d'aspect (hauteur fixe). Doit
+    rester cohérent avec le prétraitement utilisé à l'entraînement
+    (train/finetune_doctr.py::_resize_preserve_aspect) : un écart entre les
+    deux dégrade silencieusement la précision du modèle.
+    """
+    _, h, w = tensor.shape
+    new_w = max(16, int(img_h * w / max(h, 1)))
+    resized = F.interpolate(
+        tensor.unsqueeze(0), size=(img_h, new_w),
+        mode="bilinear", align_corners=False,
+    ).squeeze(0)
+    mn, mx = resized.min(), resized.max()
+    if mx - mn > 0.01:
+        resized = (resized - mn) / (mx - mn)
+    return resized.unsqueeze(0)
+
+
+def preprocess_crop(crop_bgr: np.ndarray, img_h: int = IMG_H) -> torch.Tensor:
+    img = cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+    tensor = torch.from_numpy(img).permute(2, 0, 1)
+    return _resize_preserve_aspect(tensor, img_h)
+
+
+@torch.no_grad()
+def predict_line(model, crop_bgr: np.ndarray, device: torch.device) -> Tuple[str, float]:
+    tensor = preprocess_crop(crop_bgr)
+    out = model(tensor.to(device), return_preds=True)
+    preds = out.get("preds", [])
+    if not preds:
+        return "", 0.0
+    text, confidence = preds[0]
+    return text, max(float(confidence), 0.0)
+
+
+def recognize_screen(model, screen_crop: np.ndarray, device: torch.device,
+                     n_lines: int = 3) -> List[Dict[str, Any]]:
+    """Découpe le crop d'écran en lignes puis lit chaque valeur avec le CRNN.
+
+    Retourne une liste de {'field', 'text', 'confidence'} — un élément par
+    ligne détectée (prix / volume / prix_litre), dans l'ordre d'affichage.
+    """
+    line_crops, _ = split_lcd_lines(screen_crop, n_lines=n_lines)
+    results = []
+    for idx, crop in enumerate(line_crops):
+        if crop.size == 0:
+            continue
+        text, confidence = predict_line(model, crop, device)
+        field = FIELD_NAMES[idx] if idx < len(FIELD_NAMES) else f"ligne_{idx}"
+        results.append({"field": field, "text": text, "confidence": confidence})
+    return results

app/rules.py

@@ -0,0 +1,98 @@
+"""Porte de décision métier unifiée.
+
+Combine la sortie du parsing (`app.postprocess.process`) et de la qualité
+image (`app.quality.estimate_image_quality`) pour décider si une lecture
+peut être validée (règles 3/4/5/7 du cahier des charges) : un paiement ne
+doit jamais être validé si la photo est floue/illisible, si litres et
+montant sont incohérents, ou si la confiance du modèle est trop faible.
+"""
+from typing import Any, Dict, Optional
+
+from .config import RuleConfig, load_config
+
+
+def _compute_confidence_score(parsed: Dict[str, Any], quality: Dict[str, Any]) -> float:
+    ocr_confidence = parsed.get("ocr_confidence")
+    if ocr_confidence is None:
+        ocr_confidence = min(1.0, len(parsed.get("raw_numbers", [])) / 3.0)
+
+    quality_score = quality.get("quality_score", 0.0)
+    return round(min(1.0, ocr_confidence * 0.6 + quality_score * 0.4), 2)
+
+
+def evaluate(parsed: Dict[str, Any], quality: Dict[str, Any],
+            fuel_price: Optional[float] = None,
+            cfg: Optional[RuleConfig] = None) -> Dict[str, Any]:
+    """Retourne {'success': bool, 'message': str, 'confidence_score': float}.
+
+    Ordre des vérifications (le premier échec l'emporte) :
+      1. image non "valid" (floue/sombre/surexposée/peu exploitable) -> bloqué
+      2. aucune donnée numérique détectée -> bloqué
+      3. litres ET montant manquants, ou prix manquant -> bloqué
+      4. is_consistent est False ou None (quand vérifiable) -> bloqué
+      5. confidence_score sous le seuil -> bloqué
+      6. sinon -> succès
+    """
+    if cfg is None:
+        cfg = load_config()
+
+    confidence_score = _compute_confidence_score(parsed, quality)
+
+    image_quality = quality.get("image_quality")
+    if image_quality != "valid":
+        messages = {
+            "blurry": "Photo floue, veuillez reprendre la photo.",
+            "dark": "Image trop sombre, veuillez reprendre la photo.",
+            "bright": "Image surexposée (reflet), veuillez reprendre la photo.",
+            "unclear": "Image peu exploitable, veuillez reprendre la photo.",
+        }
+        return {
+            "success": False,
+            "message": messages.get(image_quality, "Image non exploitable, veuillez reprendre la photo."),
+            "confidence_score": confidence_score,
+        }
+
+    if not parsed.get("raw_numbers"):
+        return {
+            "success": False,
+            "message": "Aucune donnée détectée sur l'écran, veuillez reprendre la photo.",
+            "confidence_score": confidence_score,
+        }
+
+    liters = parsed.get("detected_liters")
+    amount = parsed.get("detected_amount")
+    price = parsed.get("fuel_price")
+    if liters is None and amount is None:
+        return {
+            "success": False,
+            "message": "Données insuffisantes (litres et montant non lisibles).",
+            "confidence_score": confidence_score,
+        }
+    if price is None:
+        return {
+            "success": False,
+            "message": "Prix du litre manquant, impossible de vérifier la cohérence.",
+            "confidence_score": confidence_score,
+        }
+
+    if liters is not None and amount is not None:
+        is_consistent = parsed.get("is_consistent")
+        if is_consistent is not True:
+            return {
+                "success": False,
+                "message": "Incohérence détectée entre montant, litres et prix.",
+                "confidence_score": confidence_score,
+            }
+
+    if confidence_score < cfg.business_confidence_threshold:
+        return {
+            "success": False,
+            "message": "Confiance de lecture insuffisante, vérification manuelle requise.",
+            "confidence_score": confidence_score,
+        }
+
+    return {
+        "success": True,
+        "message": "Données vérifiées avec succès.",
+        "confidence_score": confidence_score,
+    }

docs/API.md

@@ -0,0 +1,61 @@
+# API (`app/main.py`)
+
+## `POST /analyze`
+
+### Requête (`multipart/form-data`)
+
+| Champ | Type | Requis | Description |
+|---|---|---|---|
+| `image` | fichier | oui | photo du terminal de pompe (jpeg/png/bmp/webp/tiff) |
+| `fuel_price` | float | non | prix du litre configuré côté YELY — fait autorité sur celui lu à l'écran |
+| `driver_id` | string | non | identifiant chauffeur (issu du scan QR côté YELY) |
+| `pompiste_id` | string | non | identifiant pompiste |
+| `station_id` | string | non | identifiant station |
+
+Volontairement **pas** de paramètres techniques (seuil de confiance OCR,
+activer/désactiver la détection d'écran...) — contrairement au prototype
+précédent, ce endpoint n'expose que les champs métier attendus par le
+cahier des charges.
+
+### Réponse (`200`)
+
+Voir `README.md` pour un exemple complet. Tous les champs correspondent
+au §13 du cahier des charges — voir `docs/POSTPROCESS_RULES.md` pour le
+détail du calcul de chaque valeur, `docs/ARCHITECTURE.md` pour le
+pipeline complet.
+
+### Erreurs
+
+| Statut | Cas |
+|---|---|
+| `400` | type d'image non supporté, ou fichier illisible |
+| `500` | erreur interne inattendue pendant le traitement (journalisée dans `logs/api.log` avec la stack trace complète) |
+
+## Chargement du modèle
+
+Le CRNN est chargé **une seule fois** au premier appel (singleton
+`_get_model()`), pas à chaque requête — le chargement prend 30-90s sur CPU.
+Conséquence pratique : **ne pas lancer `uvicorn --reload` en usage normal**,
+chaque rechargement de code redémarre le worker et donc le modèle.
+
+## CORS
+
+`ALLOWED_ORIGINS` (variable d'environnement, origines séparées par des
+virgules) contrôle quels domaines peuvent appeler l'API depuis un
+navigateur — nécessaire car le frontend (Vercel) et l'API (Hugging Face
+Spaces) sont sur des domaines différents. Par défaut `"*"` (permissif,
+adapté à une démo) ; à restreindre au domaine Vercel réel en production.
+
+## Journalisation
+
+Chaque appel écrit une ligne JSON dans `logs/api.log` : requête (sans
+l'image elle-même) + réponse complète. C'est la base du suivi de
+performance — voir `docs/MONITORING.md`.
+
+## Traçabilité
+
+Chaque photo reçue est sauvegardée dans `photos/<transaction_id>.jpg`
+et référencée dans la réponse (`photo_reference`) — nécessaire pour
+qu'un contrôle a posteriori (station, YELY) puisse revérifier une
+transaction contestée, et c'est aussi la matière première de la boucle
+d'apprentissage continu (`docs/MONITORING.md`).

docs/ARCHITECTURE.md

@@ -0,0 +1,73 @@
+# Architecture du module IA
+
+## Vue d'ensemble
+
+```
+Photo du terminal
+      │
+      ▼
+┌─────────────────────┐
+│ preprocessing.py     │  détection de l'écran LCD (contours) puis
+│                      │  découpage en 3 lignes (prix / volume / prix_litre)
+└─────────┬────────────┘
+          ▼
+┌─────────────────────┐
+│ recognizer.py         │  CRNN fine-tuné : lit chaque ligne, renvoie
+│ (models/*.pt)         │  {field, text, confidence} par valeur
+└─────────┬────────────┘
+          ▼
+┌─────────────────────┐
+│ postprocess.py        │  normalise les nombres (virgule/point),
+│                       │  calcule la valeur manquante, vérifie
+│                       │  montant = litres × prix
+└─────────┬────────────┘
+          ▼
+┌─────────────────────┐        ┌─────────────────┐
+│ rules.py              │◄──────│ quality.py        │ flou / luminosité
+│ décide success/blocage │       └─────────────────┘
+└─────────┬────────────┘
+          ▼
+     réponse API (main.py)
+```
+
+## Pourquoi ce découpage en modules séparés
+
+Chaque étage a une responsabilité et une durée de vie différentes :
+
+- **preprocessing** et **quality** : de la vision par ordinateur classique
+  (OpenCV), aucune dépendance au modèle de reconnaissance. Réutilisable même
+  si on change de modèle IA demain.
+- **recognizer** : la seule brique qui dépend du modèle entraîné. Isolée
+  pour pouvoir la remplacer (nouvelle version du CRNN, ou un autre modèle)
+  sans toucher au reste.
+- **postprocess** : logique métier pure (aucune I/O, aucun modèle) — donc
+  entièrement testable sans charger le CRNN (voir `tests/test_postprocess.py`,
+  instantané).
+- **rules** : la décision finale (bloquer/valider) séparée du calcul, pour
+  pouvoir ajuster les seuils (`config.py`/`config.yaml`) sans toucher à la
+  logique de calcul.
+
+## Différence avec le prototype précédent (OCR générique)
+
+L'ancienne version du projet (racine du dépôt, `src/`, `api/`) utilisait
+PaddleOCR/EasyOCR : des modèles pré-entraînés génériques, avec toute une
+mécanique de variantes d'image et de repli entre moteurs pour compenser
+leur manque de spécialisation. Ce module utilise à la place un modèle
+**entraîné sur nos propres données** (voir `train/`), ce qui simplifie le
+post-traitement : le CRNN sait déjà quelle ligne correspond à quel champ
+(par position), il n'y a donc plus besoin d'heuristique de proximité de
+libellé ni de deviner "quel nombre est le montant" par magnitude — la
+principale source d'erreur du prototype précédent.
+
+## Fichiers clés
+
+| Fichier | Rôle |
+|---|---|
+| `app/preprocessing.py` | détection écran + découpage lignes |
+| `app/recognizer.py` | chargement CRNN + inférence |
+| `app/postprocess.py` | normalisation, calculs, cohérence |
+| `app/rules.py` | porte de décision succès/blocage |
+| `app/config.py` | seuils configurables |
+| `app/main.py` | API FastAPI |
+| `train/finetune_doctr.py` | entraînement du CRNN |
+| `docs/LIMITATIONS.md` | limites connues du modèle actuel |

docs/LIMITATIONS.md

@@ -0,0 +1,79 @@
+# Limites identifiées — modèle CRNN (§15 du cahier des charges)
+
+## Précision actuelle
+
+Le modèle CRNN (`crnn_vgg16_bn`, fine-tuné à partir des poids pré-entraînés
+Mindee) livré dans `models/crnn_fuel_pump_best.pt` atteint **70.2% de
+précision exacte par ligne** en validation (epoch 32, voir
+`train/models/v2/history.json`) — en progression depuis la version initiale
+à ~55% (`train/models/history.json`), grâce au correctif de redimensionnement
+(voir point 3) et à l'ajout de 3 images avec des valeurs inédites au jeu
+d'annotation. C'est encore en dessous du seuil de 90% visé initialement
+(`IMPLEMENTATION_PLAN.md`), mais un progrès net et mesuré sur un vrai
+jeu de validation (sans fuite train/val — voir point 4).
+
+## Causes identifiées
+
+1. **Diversité des valeurs quasi nulle dans le jeu de données.** 310
+   échantillons au total (155 images sources découpées en lignes), mais
+   seulement **30 valeurs distinctes** — 8 valeurs à elles seules
+   représentent ~89% du dataset (probablement des photos en rafale des
+   mêmes transactions). Le modèle a donc très peu d'occasions d'apprendre à
+   généraliser la lecture de chiffres inédits ; il est plus proche de la
+   mémorisation d'un nombre restreint de motifs que d'une reconnaissance de
+   caractères robuste.
+
+2. **Découpage ligne-par-ligne imprécis pour 86% des images sources.**
+   `annotator/dataset_lines/split_report.json` montre que seulement 22/154
+   images ont utilisé la détection précise par projection de texte ; 132/154
+   sont tombées sur le repli "proportionnel" (division en bandes de hauteur
+   égale), qui peut couper à travers les chiffres ou inclure du bruit —
+   corrompant l'alignement image↔label pour la majorité de l'entraînement.
+
+3. **Incohérence corrigée entre entraînement et inférence (resize).**
+   À l'entraînement, chaque crop était étiré de force à une largeur fixe de
+   256px sans préserver le ratio d'aspect (`train/finetune_doctr.py`,
+   `collate_fn`), alors qu'à l'inférence le ratio d'aspect était préservé
+   (`preprocess_crop`). Le modèle apprenait donc sur des chiffres déformés
+   différemment de ce qu'il voit réellement en production. **Corrigé** :
+   le redimensionnement d'entraînement préserve maintenant le ratio d'aspect
+   et complète par du padding, comme à l'inférence.
+
+4. **Fuite train/val corrigée.** Relancer `split_lines.py` après avoir
+   ajouté des annotations réassignait des images entre train et val (le
+   split dépend d'un tirage aléatoire sur la liste complète), mais les
+   anciens fichiers n'étaient pas supprimés avant d'écrire les nouveaux —
+   une même image pouvait donc se retrouver à la fois dans train ET val,
+   gonflant artificiellement l'accuracy de validation. **Corrigé** :
+   `split_lines.py` et `prepare_doctr_dataset.py` nettoient maintenant les
+   dossiers de sortie avant de régénérer. Le 70.2% actuel est mesuré après
+   ce correctif — donc fiable.
+
+## Toujours vrai malgré l'amélioration à 70.2%
+
+Le facteur limitant reste le même : le dataset est petit et peu diversifié
+en valeurs. 70.2% de lignes exactement correctes n'est pas suffisant pour
+une mise en production telle quelle — voir §"Recommandations" ci-dessous,
+qui restent d'actualité.
+
+## Recommandations pour dépasser 70%
+
+- **Collecter plus de transactions distinctes** (valeurs de prix/volume
+  variées, pas seulement plus de photos des mêmes tickets) — c'est le levier
+  le plus impactant, mais aussi le plus long à mettre en œuvre.
+- **Revoir le découpage des lignes** : ajuster les seuils de
+  `annotator/split_lines.py::_detect_text_bands` (actuellement 86% des
+  images tombent sur le repli proportionnel), ou annoter directement les
+  bounding box par valeur plutôt que par écran complet.
+- **Vérifier visuellement** `annotator/dataset_lines/review/review_sheet.jpg`
+  avant tout nouvel entraînement, pour écarter les crops mal découpés.
+- Envisager de la **data augmentation** (légères rotations, variations de
+  luminosité/contraste) pour compenser partiellement le manque de diversité.
+
+## Ce qui reste fiable indépendamment du modèle
+
+La détection d'écran, le contrôle qualité (flou/luminosité), le moteur de
+règles métier (cohérence montant/litres/prix, seuil de confiance, blocage)
+et l'API ne dépendent pas de la précision du CRNN — ce sont des composants
+séparés et testés indépendamment (voir `tests/`). Une amélioration future du
+modèle de reconnaissance s'intègre donc sans changer le reste du pipeline.

docs/POSTPROCESS_RULES.md

@@ -0,0 +1,77 @@
+# Post-traitement et moteur de règles (`app/postprocess.py`, `app/rules.py`)
+
+## `postprocess.py` — du texte brut aux valeurs métier
+
+### `_norm_number(s)`
+
+Normalise un nombre lu par le CRNN en `float` : retire les espaces,
+gère la virgule décimale française ("14,28" → 14.28) et les séparateurs de
+milliers quand virgule ET point sont présents ("17.500,00" → 17500.00).
+
+### `process(recognized_fields, fuel_price=None, cfg=None)`
+
+Point d'entrée principal. Contrairement à l'ancien pipeline OCR générique
+(`src/postprocess.py` à la racine du dépôt), **pas d'heuristique de
+classification** ici : le CRNN a déjà étiqueté chaque ligne par position
+(`field: "prix"|"volume"|"prix_litre"`), donc on normalise et calcule
+directement.
+
+**Règle la plus importante du fichier** :
+
+```python
+price_val = fuel_price if fuel_price is not None else screen_price_val
+```
+
+Le prix du litre **configuré côté YELY** (paramètre `fuel_price` de l'appelant)
+fait toujours autorité sur celui lu à l'écran. C'est la règle métier n°1 du
+cahier des charges ("le prix du litre doit être configurable depuis le
+système YELY"), et ça corrige un bug réel rencontré en session : sur
+certaines pompes, le libellé "Prix" désigne en fait le **montant total**,
+pas le prix unitaire — un ancien pipeline qui faisait confiance à la valeur
+lue à l'écran pour le prix unitaire pouvait donc confondre montant et prix,
+et bloquer un paiement pourtant cohérent.
+
+### `evaluate_consistency(liters, amount, price, tol, cfg)`
+
+Implémente la règle centrale du §5.5 : `montant = litres × prix`, avec une
+tolérance (`cfg.consistency_tolerance`, 2% par défaut — pour absorber les
+arrondis d'affichage pompe). Calcule aussi la valeur manquante quand une
+seule des deux (litres ou montant) est lisible (§5.4/§6.4/§6.5).
+
+## `rules.py` — décider succès ou blocage
+
+`evaluate(parsed, quality, fuel_price, cfg)` applique les vérifications du
+§5.6/§10 **dans un ordre précis, la première qui échoue l'emporte** :
+
+1. Qualité image non "valid" → bloqué (photo floue/sombre/surexposée)
+2. Aucune donnée numérique détectée → bloqué
+3. Litres ET montant manquants, ou prix manquant → bloqué
+4. Incohérence détectée (`is_consistent` pas `True`) → bloqué
+5. Score de confiance sous le seuil (`cfg.business_confidence_threshold`) → bloqué
+6. Sinon → succès
+
+Cet ordre est délibéré : par exemple, une image floue doit toujours
+produire le message "photo floue" même si, par coïncidence, des chiffres
+ont quand même été lus — le pompiste doit reprendre la photo, pas être
+induit en erreur par un résultat qui a l'air valide.
+
+### Score de confiance
+
+```python
+confidence_score = ocr_confidence * 0.6 + quality_score * 0.4
+```
+
+Combine la confiance moyenne du CRNN sur les champs lus et le score de
+qualité image. Simple et explicable (utile pour justifier une décision de
+blocage au pompiste), mais **pas appris** — une piste d'amélioration futur
+serait d'entraîner un petit modèle de calibration sur des données réelles
+de succès/échec, plutôt qu'une pondération fixe choisie à la main.
+
+## Pourquoi ces deux fichiers sont séparés
+
+`postprocess.py` ne fait aucune I/O et ne dépend d'aucun modèle : il se
+teste en quelques millisecondes (`tests/test_postprocess.py`, ~11 tests,
+aucun chargement du CRNN). `rules.py` encapsule uniquement la **décision**
+(les seuils métier) — on peut ajuster `config.yaml` sans toucher au calcul,
+et inversement changer une formule de calcul sans re-tester la logique de
+blocage.

docs/PREPROCESSING.md

@@ -0,0 +1,59 @@
+# Prétraitement (`app/preprocessing.py`)
+
+## `detect_screen_region(img)`
+
+Cherche automatiquement la zone rectangulaire de l'écran LCD dans la photo,
+avant tout traitement.
+
+**Méthode** : niveaux de gris → flou gaussien → détection de contours
+(Canny) → fermeture morphologique pour relier les segments → on garde le
+plus grand rectangle candidat dont le ratio largeur/hauteur est plausible
+pour un écran (entre 1.0 et 8.0) et dont l'aire dépasse 2% de l'image.
+
+**Limite connue et importante** : cette heuristique cherche "le plus grand
+rectangle contrasté", pas spécifiquement un écran LCD. Sur certaines
+photos, elle capture par erreur le bandeau de marque du carburant (ex.
+"Shell FuelSave Super") au lieu de l'écran numérique, parce que ce bandeau
+forme un rectangle net et contrasté lui aussi. Repéré concrètement pendant
+cette session sur `20260622_112333_023.jpg`/`024.jpg` : la détection
+automatique renvoyait le bandeau jaune, pas l'écran noir avec les chiffres.
+
+Si le pipeline ne trouve aucune donnée exploitable sur une photo qui en
+contient pourtant, **c'est le premier endroit à vérifier** — visualiser le
+crop retourné par cette fonction avant d'aller chercher plus loin.
+
+Si aucun rectangle plausible n'est trouvé, la fonction retourne l'image
+complète inchangée (charge alors au découpage en lignes de s'en sortir).
+
+## `split_lcd_lines(screen_crop, n_lines=3)`
+
+Découpe le crop d'écran en `n_lines` bandes horizontales, une par valeur
+affichée.
+
+**Méthode principale** : projection horizontale des pixels de texte
+(binarisation Otsu + CLAHE, puis comptage de pixels "actifs" par ligne) pour
+repérer automatiquement où sont les bandes de texte et où sont les espaces
+vides entre elles.
+
+**Repli** : si la projection ne trouve pas exactement `n_lines` bandes
+(image bruitée, reflet, contraste insuffisant), découpage en bandes de
+hauteur égale. **Ce repli est peu précis** — voir `docs/LIMITATIONS.md`,
+c'est la cause principale du plafond de précision actuel du modèle (86% du
+jeu d'entraînement est passé par ce repli plutôt que par la détection
+précise).
+
+**Pourquoi `n_lines=3` par défaut et pas 2** : la majorité des écrans du
+jeu d'annotation affichent trois valeurs (prix total, volume, prix du
+litre). Un défaut à 2 aurait systématiquement tronqué la troisième ligne —
+piège découvert en inspectant `src/fine_tuned_inference.py` (l'ancienne
+version, dans le prototype racine, avait ce défaut à 2).
+
+## `FIELD_NAMES = ["prix", "volume", "prix_litre"]`
+
+Associe chaque ligne découpée (dans l'ordre où elle apparaît, de haut en
+bas) à un nom de champ métier. Cet ordre correspond à la convention
+observée sur les pompes photographiées : **"Prix" en haut = montant total
+payé** (pas le prix unitaire, malgré le nom), **"Volume" au milieu = litres**,
+**"Prix Unitaire"/"Prix du litre" en bas = prix par litre**. Voir
+`docs/POSTPROCESS_RULES.md` pour pourquoi cette distinction a causé un bug
+réel (confusion montant/prix unitaire).

docs/RECOGNIZER.md

@@ -0,0 +1,59 @@
+# Reconnaissance CRNN (`app/recognizer.py`)
+
+## Le modèle
+
+`crnn_vgg16_bn` (bibliothèque [doctr](https://github.com/mindee/doctr)) :
+un CNN (VGG16) qui extrait des features le long de l'image, suivi d'un
+RNN qui prédit une séquence de caractères — architecture standard pour la
+reconnaissance de texte en une ligne (pas besoin de segmenter les
+caractères un par un).
+
+Poids de départ : pré-entraînés par Mindee sur des textes imprimés
+génériques, puis **fine-tunés** sur nos propres crops de lignes LCD
+(voir `docs/TRAINING.md`). C'est ce fine-tuning qui constitue le "modèle IA
+développé" attendu par le §8.4 du cahier des charges, par opposition à un
+OCR générique utilisé tel quel.
+
+## `load_model(model_path=None, device=None)`
+
+Charge les poids depuis `models/crnn_fuel_pump_best.pt` (chemin par défaut).
+Échoue explicitement (`FileNotFoundError`/`ImportError`) plutôt que de se
+rabattre silencieusement sur autre chose — un module de vérification de
+paiement ne doit pas tourner avec un modèle absent sans que ce soit visible.
+
+## `recognize_screen(model, screen_crop, device, n_lines=3)`
+
+1. Découpe l'écran en lignes (`preprocessing.split_lcd_lines`).
+2. Pour chaque ligne, dans l'ordre : prétraitement (`preprocess_crop`) puis
+   prédiction (`predict_line`).
+3. Associe chaque ligne à un champ (`prix`, `volume`, `prix_litre`) par sa
+   **position** (voir `FIELD_NAMES` dans `preprocessing.py`) — pas par
+   analyse du contenu. C'est la différence clé avec l'ancien pipeline OCR
+   générique, qui devait deviner quel nombre était quoi.
+
+Retourne une liste de `{"field": ..., "text": ..., "confidence": ...}`,
+un élément par ligne détectée.
+
+## `preprocess_crop` / `_resize_preserve_aspect` — le bug corrigé cette session
+
+Redimensionne chaque ligne à une hauteur fixe (32px) **en conservant le
+ratio d'aspect**, puis normalise les valeurs de pixels.
+
+**Pourquoi c'est écrit deux fois** (ici et dans `train/finetune_doctr.py`) :
+le modèle doit voir, à l'entraînement et à l'inférence, des images
+prétraitées de la **même façon**. Avant correction, l'entraînement étirait
+les images à une largeur fixe (déformant les chiffres), alors que
+l'inférence préservait le ratio — le modèle apprenait donc sur des formes
+différentes de celles qu'il voyait réellement en production. Si l'un des
+deux fichiers est modifié à l'avenir, vérifier que l'autre reste cohérent.
+
+## Limites connues
+
+- Le decoder CTC de doctr peut produire des caractères hors du vocabulaire
+  numérique attendu (ex. "9AAm" au lieu de "20000" observé pendant les
+  tests) quand la ligne d'entrée est trop bruitée/mal découpée — normal vu
+  la taille du jeu d'entraînement (voir `docs/LIMITATIONS.md`), pas un bug
+  de code.
+- Aucune contrainte n'est imposée sur le vocabulaire de sortie (le modèle
+  pourrait techniquement prédire des lettres) — une piste d'amélioration
+  serait de contraindre le décodage aux chiffres/virgule/point uniquement.

docs/TRAINING.md

@@ -0,0 +1,157 @@
+# Entraîner, annoter, évaluer le modèle CRNN
+
+Ce document explique comment lancer chacune des trois étapes : annoter de
+nouvelles images, ré-entraîner le modèle, évaluer sa précision. Les scripts
+utilisés vivent dans le dépôt d'origine (`annotator/`, `train/` à la racine),
+pas dans `yely_ai_module/` — ce dossier livrable embarque une copie de
+référence de `train/` pour la reproductibilité (voir §"Où ça vit" plus bas).
+
+## Vue d'ensemble du pipeline data → modèle
+
+```
+1. Annoter          annotator/annotate.py
+        │            (dessine le rectangle LCD + saisit prix/volume/prix_litre)
+        ▼
+   annotator/annotations/annotations.json  (+ crops dans annotations/crops/)
+        │
+2. Découper en lignes  annotator/split_lines.py
+        │            (1 image = 3 valeurs → 3 sous-images mono-ligne)
+        ▼
+   annotator/dataset_lines/{train,val}/
+        │
+3. Convertir au format doctr  train/prepare_doctr_dataset.py
+        ▼
+   annotator/dataset_doctr/{train,val}/  (images/ + labels.json)
+        │
+4. Entraîner  train/finetune_doctr.py
+        ▼
+   train/models/crnn_fuel_pump_best.pt  (+ history.json)
+        │
+5. Évaluer  train/test_model.py
+```
+
+## 1. Annoter de nouvelles images
+
+```bash
+cd annotator
+python annotate.py --images ../images/        # nouvelles photos
+python annotate.py --images ../images/ --resume   # reprendre où on s'était arrêté
+python annotate.py --review                    # voir un résumé des annotations existantes
+```
+
+Pour chaque image : dessiner un rectangle autour de l'écran LCD (clic +
+glisser), puis saisir dans le terminal les valeurs affichées (prix, volume,
+prix du litre). Voir `annotator/README.md` pour le détail des raccourcis.
+
+**Ce qui compte le plus pour améliorer le modèle** (voir `docs/LIMITATIONS.md`) :
+annoter des photos avec des **valeurs différentes** de celles déjà présentes,
+pas juste plus de photos des mêmes tickets. Utiliser
+`yely_ai_module/tools/check_seen_image.py` pour vérifier qu'une photo
+candidate n'est pas déjà (quasi-)présente dans le jeu annoté :
+
+```bash
+python yely_ai_module/tools/check_seen_image.py chemin/vers/nouvelle_photo.jpg
+```
+
+## 2. Régénérer le dataset d'entraînement
+
+**Toujours dans cet ordre**, et **jamais pendant qu'un entraînement tourne**
+(le chargement des images se fait à la volée pendant l'entraînement — les
+régénérer en même temps fait planter le script avec un `FileNotFoundError`,
+vécu concrètement pendant cette session) :
+
+```bash
+cd annotator
+python split_lines.py              # annotations.json -> dataset_lines/
+
+cd ../train
+python prepare_doctr_dataset.py    # dataset_lines/ -> dataset_doctr/
+```
+
+Les deux scripts nettoient maintenant leur dossier de sortie avant de
+régénérer (corrigé cette session — une même image pouvait sinon se
+retrouver à la fois en train et en val d'un run à l'autre, faussant
+l'évaluation).
+
+**Vérification recommandée avant d'entraîner** : ouvrir
+`annotator/dataset_lines/review/review_sheet.jpg`, qui montre un échantillon
+d'images découpées à côté du label attendu — permet de repérer un mauvais
+découpage avant de perdre du temps à entraîner dessus.
+
+## 3. Lancer l'entraînement
+
+```bash
+cd train
+python finetune_doctr.py                      # 80 epochs par défaut
+python finetune_doctr.py --epochs 60 --patience 12
+python finetune_doctr.py --from-scratch       # si pas de connexion internet (pas de poids pré-entraînés)
+```
+
+- Le modèle est sauvegardé dans `train/models/crnn_fuel_pump_best.pt` à
+  chaque fois que la perte de validation s'améliore (pas seulement à la fin) —
+  s'arrêter en cours de route (Ctrl+C, crash) ne perd donc pas tout.
+- `--patience N` : arrête l'entraînement si la perte de validation ne
+  s'améliore plus pendant N epochs (évite de continuer à surapprendre inutilement).
+- Sur CPU (pas de GPU disponible), compter ~1.5-3 min/epoch sur le jeu de
+  données actuel (~270 échantillons train). Un entraînement complet peut
+  donc prendre plusieurs heures — lancer en arrière-plan
+  (`... &` ou un terminal dédié) plutôt qu'en bloquant.
+- À la fin (ou à l'arrêt anticipé), `train/models/history.json` contient
+  la courbe complète (perte/accuracy par epoch) — sert de preuve pour le
+  rapport de test (§15 du cahier des charges).
+
+## 4. Évaluer le modèle
+
+```bash
+cd train
+python test_model.py                          # évalue sur tout le set de validation
+python test_model.py --image ../images/pompe.jpg   # teste une seule image
+```
+
+`test_model.py` calcule, sur le jeu de validation :
+- **Exact-match accuracy** : proportion de lignes lues à 100% correctement
+  (c'est la métrique citée dans `docs/LIMITATIONS.md`).
+- **CER** (Character Error Rate) et **WER** : à quel point une prédiction
+  fausse est "proche" de la bonne réponse (ex. "10000" lu "1O000" a un CER
+  faible même si l'exact-match échoue) — plus informatif que l'accuracy
+  seule pour juger si le modèle progresse.
+- La liste des erreurs (jusqu'à 15 affichées), utile pour repérer des
+  motifs d'erreur récurrents (un chiffre systématiquement confondu, une
+  ligne toujours mal découpée...).
+
+## Où ça vit (dépôt d'origine vs dossier livrable)
+
+- **Annotation et préparation du dataset** (`annotator/`) : uniquement à la
+  racine du dépôt d'origine, pas dupliqué dans `yely_ai_module/` (le jeu de
+  ~155 images sources n'est volontairement pas inclus dans le livrable).
+- **Entraînement** (`train/`) : présent aux deux endroits. La copie dans
+  `yely_ai_module/train/` est une référence pour la reproductibilité
+  (documentation technique) ; pour ré-entraîner réellement, utiliser la
+  version à la racine du dépôt, qui a accès à `annotator/dataset_doctr/`.
+- **Script `train/infer.py`** : ancien script d'inférence autonome
+  (antérieur à `yely_ai_module/app/recognizer.py`), gardé pour test rapide
+  en ligne de commande. Avait le même bug de découpage à 2 lignes (au lieu
+  de 3) que celui corrigé dans `preprocessing.py` — corrigé aussi. Pour
+  tester le pipeline réellement livré (avec règles métier, API), utiliser
+  `yely_ai_module/app/`, pas ce script.
+
+## Si le modèle donne de mauvais résultats en test manuel
+
+Avant de conclure "le modèle n'est pas bon", vérifier dans l'ordre :
+
+1. **Quel script a été utilisé ?** `train/infer.py` et `yely_ai_module/app/`
+   ont des logiques de détection d'écran différentes (`detect_lcd_region`
+   vs `detect_screen_region`) — l'un peut réussir là où l'autre échoue sur
+   la même photo.
+2. **La zone détectée est-elle la bonne ?** Les deux scripts peuvent
+   confondre le bandeau de marque ("Shell FuelSave...") avec l'écran LCD sur
+   certaines photos (voir `docs/PREPROCESSING.md`) — sauvegarder et regarder
+   le crop intermédiaire avant d'incriminer le CRNN.
+3. **La photo est-elle inédite ou proche du jeu d'entraînement ?**
+   (`tools/check_seen_image.py`) — le modèle est attendu comme moins bon sur
+   des valeurs qu'il n'a jamais vues, c'est documenté et mesuré
+   (`docs/LIMITATIONS.md`), pas une surprise.
+4. **Quelle précision réelle attendre ?** 70.2% exact-match sur les lignes
+   de validation (`train/models/v2/history.json`) — donc environ 3 lectures
+   sur 10 avec au moins un caractère faux sont *attendues* à ce stade, pas
+   un signe que quelque chose est cassé.

docs/WORKFLOW.md

@@ -0,0 +1,180 @@
+# Workflow — finalisation du module IA YELY
+
+Organisation recommandée pour arriver à un livrable démontrable : tests de
+type production, suivi des performances, apprentissage continu,
+documentation complète, interface web de démo, déploiement.
+
+## 1. Arborescence cible du dépôt
+
+```
+yely_ai_module/
+├── app/                    # code de production (déjà en place)
+├── models/                 # modèle(s) sérialisé(s) — voir §3 versioning
+├── train/                  # scripts d'entraînement (référence)
+├── tests/
+│   ├── test_postprocess.py     # ✅ fait
+│   ├── test_rules.py           # ✅ fait
+│   ├── test_api.py              # ✅ fait (mocké)
+│   └── test_integration.py      # à faire : vrai modèle, vraies images
+├── tools/
+│   └── check_seen_image.py      # ✅ fait
+├── monitoring/                  # à créer — §2
+│   ├── logger.py                 # log structuré prédiction + vérité terrain
+│   ├── metrics.py                 # calcul accuracy glissante, drift
+│   └── feedback.py                 # collecte des corrections pompiste
+├── docs/                         # à créer — §4
+│   ├── WORKFLOW.md                # ce fichier
+│   ├── LIMITATIONS.md             # ✅ fait
+│   ├── ARCHITECTURE.md
+│   ├── PREPROCESSING.md
+│   ├── RECOGNIZER.md
+│   ├── POSTPROCESS_RULES.md
+│   ├── API.md
+│   └── MONITORING.md
+├── web/                           # à créer — §5, interface de démo
+│   ├── index.html / app Next.js
+│   └── vercel.json
+└── requirements.txt
+```
+
+## 2. Tests "comme en production"
+
+Objectif : valider le comportement réel, pas seulement la logique unitaire.
+
+1. **Test d'intégration avec le vrai modèle** (`tests/test_integration.py`) :
+   envoyer une vraie photo à `recognize_screen` (pas de mock), vérifier que
+   la réponse a la bonne forme et un temps de réponse mesuré.
+2. **Test API bout-en-bout** : lancer `uvicorn`, envoyer une requête HTTP
+   réelle via `httpx`/`curl`, sur 3-5 photos couvrant les scénarios du
+   cahier des charges (§14) : nette/cohérente, floue, incohérente,
+   montant seul, litres seuls.
+3. **Test de charge léger** : mesurer le temps de réponse sur 10 requêtes
+   séquentielles (le modèle doit rester chargé en mémoire entre les
+   requêtes — vérifier qu'il n'y a pas de rechargement).
+4. **Rapport de test** (§15 du cahier des charges) : générer un tableau
+   photo → attendu → obtenu → écart, à partir des images du dossier
+   `Images datasetdiversifié/` (celles non utilisées à l'entraînement).
+
+## 3. Suivi des performances + apprentissage continu
+
+### Suivi (`monitoring/`)
+
+- Chaque appel à `/analyze` log déjà la requête/réponse dans `logs/api.log`.
+  À ajouter : un identifiant de version du modèle (`model_version`) dans
+  chaque entrée, pour pouvoir comparer les performances entre versions.
+- `monitoring/metrics.py` : script qui parcourt `logs/api.log` et calcule
+  périodiquement : taux de succès, distribution des `confidence_score`,
+  taux de blocage par cause (floue/incohérence/confiance).
+
+### Apprentissage continu (boucle de feedback)
+
+Le principe : chaque photo traitée par l'API est déjà sauvegardée
+(`photos/<uuid>.jpg`). Il manque la boucle qui transforme ces photos en
+nouvelles données d'entraînement :
+
+1. **Endpoint de correction** (`POST /feedback`) : le pompiste (ou un
+   contrôle a posteriori côté YELY) envoie `transaction_id` + les valeurs
+   réellement correctes. Stocké dans `monitoring/feedback.jsonl`.
+2. **Script de conversion** (`monitoring/feedback.py`) : transforme les
+   entrées corrigées en nouvelles entrées `annotations.json` (même format
+   que l'annotation manuelle), en réutilisant `photos/<uuid>.jpg` comme
+   image source.
+3. **Ré-entraînement périodique** : relancer `split_lines.py` →
+   `prepare_doctr_dataset.py` → `finetune_doctr.py` quand un nombre
+   suffisant de nouvelles corrections est accumulé (ex. tous les 50).
+   **Important** (retenu de cette session) : ne jamais modifier le dataset
+   pendant qu'un entraînement tourne (lecture disque à la volée) ; toujours
+   nettoyer `dataset_lines/`/`dataset_doctr/` avant de régénérer (déjà
+   corrigé).
+4. **Versioning des modèles** : chaque nouveau modèle entraîné va dans
+   `models/v<N>/`, avec son propre `history.json`. Le modèle "actif" utilisé
+   par l'API est un lien/chemin configurable (`CRNN_MODEL_PATH` en variable
+   d'environnement), pas une réécriture du fichier précédent — pour pouvoir
+   revenir en arrière si une nouvelle version est pire.
+
+## 4. Documentation (`docs/`)
+
+Un fichier par aspect, cible = qu'un lecteur qui n'a pas suivi le
+développement comprenne le rôle et les choix de chaque module :
+
+- `ARCHITECTURE.md` : schéma du pipeline complet (image → écran �� lignes →
+  CRNN → postprocess → rules → réponse), et pourquoi ce découpage.
+- `PREPROCESSING.md` : détection d'écran, découpage en lignes, limites
+  connues (cas où la détection choisit la mauvaise zone — voir l'incident
+  du bandeau de marque confondu avec l'écran).
+- `RECOGNIZER.md` : choix du CRNN, format d'entrée/sortie, le bug
+  resize corrigé et pourquoi c'était important.
+- `POSTPROCESS_RULES.md` : normalisation numérique, règle de priorité
+  `fuel_price` configuré > lu à l'écran, moteur de règles de blocage.
+- `API.md` : contrat de l'endpoint, exemples de requêtes/réponses.
+- `MONITORING.md` : comment lire les logs, comment fonctionne la boucle de
+  feedback.
+- `LIMITATIONS.md` : déjà fait — diversité du dataset, précision actuelle.
+
+## 5. Interface web de démo
+
+Objectif : une page simple, présentable en soutenance, qui appelle l'API et
+affiche le résultat de façon lisible pour un non-développeur (le formulaire
+technique `test_api_form.html` existant sert de base, mais mérite une
+version "présentation" séparée : moins de champs bruts, plus visuelle).
+
+Contenu minimal :
+- Upload/prise de photo (accepte l'appareil photo sur mobile via
+  `capture="environment"`).
+- Choix du prix du litre (pré-rempli, modifiable).
+- Affichage : bannière succès/bloqué, valeurs détectées, calculées, statut
+  de cohérence — pas le JSON brut par défaut (accessible en option).
+- Appel vers l'URL de l'API configurée (variable d'environnement au build).
+
+## 6. Déploiement
+
+**Frontend (`web/`) → Vercel** : parfaitement adapté (statique ou
+Next.js), pas de souci particulier.
+
+**API IA → PAS Vercel.** Point d'attention important avant d'aller plus
+loin : Vercel (Serverless Functions) limite la taille du build (~250 Mo
+décompressés) et le temps d'exécution par requête. Cette API embarque
+PyTorch + doctr + OpenCV, qui dépassent déjà largement cette taille à eux
+seuls, et l'inférence CRNN prend actuellement 60-100+ secondes par image
+(bien au-delà des temps d'exécution autorisés par Vercel, même sur les
+plans payants). Déployer tel quel sur Vercel échouera au build ou au
+timeout, pas juste "sera lent".
+
+**Décision retenue : Hugging Face Spaces (Docker SDK)** pour l'API.
+Gratuit, pensé pour les démos ML, pas de limite stricte de temps
+d'exécution comme Vercel, `Dockerfile` déjà préparé (`yely_ai_module/Dockerfile`).
+
+Étapes de déploiement (à faire manuellement, action externe) :
+1. Créer un Space sur huggingface.co → SDK "Docker" → visibilité au choix.
+2. Ajouter en tête de `yely_ai_module/README.md` le bloc de configuration
+   attendu par HF Spaces :
+   ```yaml
+   ---
+   title: YELY AI Module
+   emoji: ⛽
+   colorFrom: blue
+   colorTo: green
+   sdk: docker
+   app_port: 7860
+   ---
+   ```
+3. Pousser le contenu de `yely_ai_module/` (avec `models/crnn_fuel_pump_best.pt`
+   inclus) vers le dépôt git du Space.
+4. Noter l'URL publique du Space (`https://<user>-<space>.hf.space`) — c'est
+   l'URL que le frontend Vercel appellera pour `/analyze`.
+5. Ajouter `CORSMiddleware` dans `app/main.py` pour autoriser le domaine
+   Vercel du frontend (sinon le navigateur bloquera les réponses).
+
+## 7. Ordre d'exécution recommandé (vu le délai serré)
+
+1. Terminer l'entraînement en cours, figer le modèle livré.
+2. Tests d'intégration réels (§2.1-2.2) — valide que tout fonctionne
+   vraiment avant de documenter/déployer.
+3. Interface web de démo (§5) branchée sur l'API en local — utilisable pour
+   répéter la démo même sans déploiement cloud.
+4. Documentation (§4) — peut se faire en parallèle du reste.
+5. Déploiement (§6) — une fois l'hébergement de l'API décidé.
+6. Monitoring/apprentissage continu (§3) — le plus gros morceau, à
+   présenter comme "conçu et partiellement implémenté" si le temps manque
+   (c'est un livrable attendu — §8.6/§15 — mais l'essentiel du temps
+   restant doit sécuriser une démo qui fonctionne).

models/crnn_fuel_pump_best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bdb4de837296488ed28a749cc984a8a11d908348706c4d5961f28ef8878899a
+size 63304482

models/history.json

@@ -0,0 +1,426 @@
+{
+  "history": [
+    {
+      "epoch": 1,
+      "train_loss": 2.9120928364641525,
+      "val_loss": 2.3460725943247476,
+      "val_acc": 0.3191489361702128,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 2,
+      "train_loss": 1.9310398803037756,
+      "val_loss": 2.0164391001065574,
+      "val_acc": 0.3191489361702128,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 3,
+      "train_loss": 1.5905358405674206,
+      "val_loss": 1.807423174381256,
+      "val_acc": 0.3404255319148936,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 4,
+      "train_loss": 1.3240579349153183,
+      "val_loss": 1.5607381065686543,
+      "val_acc": 0.40425531914893614,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 5,
+      "train_loss": 1.1439797177034265,
+      "val_loss": 1.4377244412899017,
+      "val_acc": 0.425531914893617,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 6,
+      "train_loss": 0.9370511406484772,
+      "val_loss": 1.3487879733244579,
+      "val_acc": 0.48936170212765956,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 7,
+      "train_loss": 0.8480383823899662,
+      "val_loss": 1.2953779598077138,
+      "val_acc": 0.5106382978723404,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 8,
+      "train_loss": 0.7292340816382099,
+      "val_loss": 1.2790659566720326,
+      "val_acc": 0.5319148936170213,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 9,
+      "train_loss": 0.6626956646933275,
+      "val_loss": 1.207442099849383,
+      "val_acc": 0.574468085106383,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 10,
+      "train_loss": 0.6213903804035747,
+      "val_loss": 1.1846911311149597,
+      "val_acc": 0.5531914893617021,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 11,
+      "train_loss": 0.5165981354520601,
+      "val_loss": 1.1549755483865738,
+      "val_acc": 0.6170212765957447,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 12,
+      "train_loss": 0.5032322286244701,
+      "val_loss": 1.1022245561083157,
+      "val_acc": 0.6170212765957447,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 13,
+      "train_loss": 0.4294072784045163,
+      "val_loss": 1.1384087776144345,
+      "val_acc": 0.6170212765957447,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 14,
+      "train_loss": 0.39344385529265685,
+      "val_loss": 1.0891480594873428,
+      "val_acc": 0.6595744680851063,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 15,
+      "train_loss": 0.3947870174751562,
+      "val_loss": 1.0561534091830254,
+      "val_acc": 0.6382978723404256,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 16,
+      "train_loss": 0.3652436829665128,
+      "val_loss": 1.0487923547625542,
+      "val_acc": 0.6595744680851063,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 17,
+      "train_loss": 0.3264134029912598,
+      "val_loss": 1.015688605606556,
+      "val_acc": 0.6595744680851063,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 18,
+      "train_loss": 0.309357831857222,
+      "val_loss": 1.0396239832043648,
+      "val_acc": 0.6595744680851063,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 19,
+      "train_loss": 0.3051291299874292,
+      "val_loss": 1.0147636259595554,
+      "val_acc": 0.6595744680851063,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 20,
+      "train_loss": 0.27475875517462983,
+      "val_loss": 1.0161741822957993,
+      "val_acc": 0.6808510638297872,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 21,
+      "train_loss": 0.24898530515458653,
+      "val_loss": 1.000812940299511,
+      "val_acc": 0.6808510638297872,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 22,
+      "train_loss": 0.22601729357505546,
+      "val_loss": 1.01864734167854,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 23,
+      "train_loss": 0.22106353631790945,
+      "val_loss": 0.9843647293746471,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 24,
+      "train_loss": 0.21067261991693692,
+      "val_loss": 0.9799626593788465,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 25,
+      "train_loss": 0.198403762489119,
+      "val_loss": 1.0153791829943657,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 26,
+      "train_loss": 0.23490384497734554,
+      "val_loss": 0.970666674276193,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 27,
+      "train_loss": 0.2061745562207173,
+      "val_loss": 0.9808499614397684,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 28,
+      "train_loss": 0.17278411294169285,
+      "val_loss": 0.9578678918381532,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 29,
+      "train_loss": 0.17103130540207906,
+      "val_loss": 0.975345945606629,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 30,
+      "train_loss": 0.14729907297912767,
+      "val_loss": 0.9681643905738989,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 31,
+      "train_loss": 0.16524034897413323,
+      "val_loss": 0.9656790184477965,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 32,
+      "train_loss": 0.1521763262229369,
+      "val_loss": 0.9372376700242361,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 33,
+      "train_loss": 0.15467397811110406,
+      "val_loss": 0.9560814400513967,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 34,
+      "train_loss": 0.13949972199385657,
+      "val_loss": 0.9447329379618168,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 35,
+      "train_loss": 0.12902705441229045,
+      "val_loss": 0.9566328227519989,
+      "val_acc": 0.7021276595744681,
+      "lr": 5e-05
+    },
+    {
+      "epoch": 36,
+      "train_loss": 0.16284221629886067,
+      "val_loss": 0.9468842148780823,
+      "val_acc": 0.7021276595744681,
+      "lr": 2.5e-05
+    },
+    {
+      "epoch": 37,
+      "train_loss": 0.13035948549890342,
+      "val_loss": 0.9455590850363175,
+      "val_acc": 0.7021276595744681,
+      "lr": 2.5e-05
+    },
+    {
+      "epoch": 38,
+      "train_loss": 0.1562366568045143,
+      "val_loss": 0.9594765727718672,
+      "val_acc": 0.7021276595744681,
+      "lr": 2.5e-05
+    },
+    {
+      "epoch": 39,
+      "train_loss": 0.12504405479001648,
+      "val_loss": 0.9333067275583744,
+      "val_acc": 0.7021276595744681,
+      "lr": 2.5e-05
+    },
+    {
+      "epoch": 40,
+      "train_loss": 0.13936584319590645,
+      "val_loss": 0.9340925253927708,
+      "val_acc": 0.7021276595744681,
+      "lr": 2.5e-05
+    },
+    {
+      "epoch": 41,
+      "train_loss": 0.12360574594041442,
+      "val_loss": 0.9377497670551141,
+      "val_acc": 0.7021276595744681,
+      "lr": 2.5e-05
+    },
+    {
+      "epoch": 42,
+      "train_loss": 0.11103411624208093,
+      "val_loss": 0.9450751269857088,
+      "val_acc": 0.7021276595744681,
+      "lr": 2.5e-05
+    },
+    {
+      "epoch": 43,
+      "train_loss": 0.10658511809785576,
+      "val_loss": 0.9773282657066981,
+      "val_acc": 0.7021276595744681,
+      "lr": 1.25e-05
+    },
+    {
+      "epoch": 44,
+      "train_loss": 0.10607678348691586,
+      "val_loss": 0.9355429125328859,
+      "val_acc": 0.7021276595744681,
+      "lr": 1.25e-05
+    },
+    {
+      "epoch": 45,
+      "train_loss": 0.10428869187393609,
+      "val_loss": 0.9588954467326403,
+      "val_acc": 0.7021276595744681,
+      "lr": 1.25e-05
+    },
+    {
+      "epoch": 46,
+      "train_loss": 0.1177324857973658,
+      "val_loss": 0.9499378191928068,
+      "val_acc": 0.7021276595744681,
+      "lr": 1.25e-05
+    },
+    {
+      "epoch": 47,
+      "train_loss": 0.0943571002332165,
+      "val_loss": 0.9513349328190088,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 48,
+      "train_loss": 0.11425591779270154,
+      "val_loss": 0.942640719935298,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 49,
+      "train_loss": 0.11487811471006888,
+      "val_loss": 0.932662837828199,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 50,
+      "train_loss": 0.10698410742642249,
+      "val_loss": 0.9508347008377314,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 51,
+      "train_loss": 0.0994053436032332,
+      "val_loss": 0.9428594596683979,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 52,
+      "train_loss": 0.09451003673979465,
+      "val_loss": 0.9704437119265398,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 53,
+      "train_loss": 0.09321472450049922,
+      "val_loss": 0.9285884375373522,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 54,
+      "train_loss": 0.10263871913775802,
+      "val_loss": 0.9478914358963569,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 55,
+      "train_loss": 0.1034667265793199,
+      "val_loss": 0.9571116616328558,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 56,
+      "train_loss": 0.10305118007475839,
+      "val_loss": 0.9262590693930784,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 57,
+      "train_loss": 0.09248770906261224,
+      "val_loss": 0.9442655543486277,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 58,
+      "train_loss": 0.16216179406653872,
+      "val_loss": 0.9420440445343653,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 59,
+      "train_loss": 0.0958185838535428,
+      "val_loss": 0.9358861912041903,
+      "val_acc": 0.7021276595744681,
+      "lr": 6.25e-06
+    },
+    {
+      "epoch": 60,
+      "train_loss": 0.10177546147914494,
+      "val_loss": 0.9465262399365505,
+      "val_acc": 0.7021276595744681,
+      "lr": 3.125e-06
+    }
+  ],
+  "best_val_loss": 0.9262590693930784,
+  "best_val_acc": 0.7021276595744681
+}

requirements.txt

@@ -0,0 +1,15 @@
+# Vision par ordinateur (détection écran, prétraitement)
+opencv-python-headless>=4.8.0
+numpy>=1.24.0
+
+# Modèle IA (CRNN fine-tuné)
+python-doctr[torch]>=1.0.1
+
+# API
+fastapi>=0.112.0
+uvicorn[standard]>=0.23.0
+python-multipart>=0.0.6
+
+# Configuration & tests
+pyyaml>=6.0
+pytest>=7.4.0

tests/test_api.py

@@ -0,0 +1,81 @@
+import io
+import unittest
+from unittest.mock import patch
+
+import numpy as np
+import cv2
+from fastapi.testclient import TestClient
+
+from app import main
+
+
+def _fake_jpeg_bytes(color=(200, 200, 200), size=(300, 200)):
+    img = np.full((size[1], size[0], 3), color, dtype=np.uint8)
+    ok, buf = cv2.imencode(".jpg", img)
+    assert ok
+    return buf.tobytes()
+
+
+class TestAnalyzeEndpoint(unittest.TestCase):
+    def setUp(self):
+        self.client = TestClient(main.app)
+
+    def test_consistent_reading_returns_success(self):
+        fake_fields = [
+            {"field": "prix", "text": "10000", "confidence": 0.95},
+            {"field": "volume", "text": "14.28", "confidence": 0.9},
+            {"field": "prix_litre", "text": "700", "confidence": 0.85},
+        ]
+        fake_quality = {"image_quality": "valid", "quality_score": 0.95,
+                        "blur_variance": 500.0, "brightness": 120.0}
+        with patch.object(main, "_get_model", return_value=(None, None)), \
+             patch.object(main, "recognize_screen", return_value=fake_fields), \
+             patch.object(main, "estimate_image_quality", return_value=fake_quality):
+            resp = self.client.post(
+                "/analyze",
+                files={"image": ("pompe.jpg", _fake_jpeg_bytes(), "image/jpeg")},
+                data={"fuel_price": "700", "driver_id": "chauffeur-42"},
+            )
+        self.assertEqual(resp.status_code, 200)
+        body = resp.json()
+        self.assertTrue(body["success"])
+        self.assertEqual(body["detected_amount"], 10000.0)
+        self.assertAlmostEqual(body["detected_liters"], 14.28, places=2)
+        self.assertEqual(body["fuel_price"], 700.0)
+        self.assertEqual(body["driver_id"], "chauffeur-42")
+        self.assertIn("photo_reference", body)
+        # Champs techniques (moteur OCR, variante...) volontairement absents
+        # de la réponse — seuls les champs du cahier des charges sont exposés.
+        self.assertNotIn("ocr_engine", body)
+        self.assertNotIn("best_variant", body)
+
+    def test_inconsistent_reading_blocks(self):
+        fake_fields = [
+            {"field": "prix", "text": "10000", "confidence": 0.95},
+            {"field": "volume", "text": "20.00", "confidence": 0.9},
+        ]
+        fake_quality = {"image_quality": "valid", "quality_score": 0.95,
+                        "blur_variance": 500.0, "brightness": 120.0}
+        with patch.object(main, "_get_model", return_value=(None, None)), \
+             patch.object(main, "recognize_screen", return_value=fake_fields), \
+             patch.object(main, "estimate_image_quality", return_value=fake_quality):
+            resp = self.client.post(
+                "/analyze",
+                files={"image": ("pompe.jpg", _fake_jpeg_bytes(), "image/jpeg")},
+                data={"fuel_price": "875"},
+            )
+        body = resp.json()
+        self.assertFalse(body["success"])
+        self.assertIn("Incohérence", body["message"])
+
+    def test_unsupported_content_type_rejected(self):
+        resp = self.client.post(
+            "/analyze",
+            files={"image": ("pompe.txt", b"not an image", "text/plain")},
+            data={"fuel_price": "700"},
+        )
+        self.assertEqual(resp.status_code, 400)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_integration.py

@@ -0,0 +1,65 @@
+"""Tests d'intégration : vrai modèle CRNN, vraies images — pas de mock.
+
+Plus lents que les tests unitaires (chargement du modèle ~30-90s sur CPU) :
+à lancer séparément avec `pytest tests/test_integration.py -v`, pas dans la
+boucle de développement rapide.
+"""
+import os
+import unittest
+
+import numpy as np
+from PIL import Image
+
+from app.recognizer import load_model, get_device, recognize_screen
+from app.postprocess import process as postprocess_results
+from app.quality import estimate_image_quality
+from app.rules import evaluate as evaluate_rules
+from app.preprocessing import detect_screen_region
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Photo resserrée sur l'écran (pas besoin de détection d'écran) — voir
+# l'annotation ajoutée cette session : prix=10000, volume=14.28, prix_litre=700
+SAMPLE_IMAGE = os.path.join(
+    REPO_ROOT, "Images datasetdiversifié", "Images nettes", "20260622_121734_009.jpg"
+)
+
+
+def _imread(path):
+    img = Image.open(path).convert("RGB")
+    arr = np.array(img)
+    return arr[:, :, ::-1].copy()  # RGB -> BGR pour rester cohérent avec cv2
+
+
+@unittest.skipUnless(os.path.exists(SAMPLE_IMAGE), "image d'exemple absente de ce clone")
+class TestRealModelIntegration(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.device = get_device()
+        cls.model = load_model(device=cls.device)
+
+    def test_recognizes_known_screen(self):
+        img = _imread(SAMPLE_IMAGE)
+        crop, (x, y, w, h) = detect_screen_region(img)
+        img_to_process = crop if w < img.shape[1] * 0.95 else img
+
+        recognized = recognize_screen(self.model, img_to_process, self.device)
+        self.assertGreaterEqual(len(recognized), 1, "le CRNN n'a rien renvoyé")
+
+        parsed = postprocess_results(recognized, fuel_price=700)
+        quality = estimate_image_quality(img_to_process, ocr_results=recognized)
+        gate = evaluate_rules(parsed, quality, fuel_price=700)
+
+        print("\nrecognized:", recognized)
+        print("parsed:", parsed)
+        print("gate:", gate)
+
+        # On ne verrouille pas une exactitude parfaite (précision du modèle
+        # documentée dans docs/LIMITATIONS.md) : on vérifie que le pipeline
+        # tourne bout-en-bout et renvoie une structure exploitable.
+        self.assertIn(gate["success"], (True, False))
+        self.assertIsInstance(gate["confidence_score"], float)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_postprocess.py

@@ -0,0 +1,60 @@
+import unittest
+from app import postprocess
+
+
+class TestPostprocess(unittest.TestCase):
+    def test_all_three_fields_consistent(self):
+        recognized = [
+            {"field": "prix", "text": "10000", "confidence": 0.98},
+            {"field": "volume", "text": "14,28", "confidence": 0.95},
+            {"field": "prix_litre", "text": "700", "confidence": 0.90},
+        ]
+        res = postprocess.process(recognized, fuel_price=700)
+        self.assertEqual(res["detected_amount"], 10000.0)
+        self.assertAlmostEqual(res["detected_liters"], 14.28, places=2)
+        self.assertEqual(res["fuel_price"], 700.0)
+        self.assertTrue(res["is_consistent"])
+
+    def test_configured_fuel_price_overrides_screen_reading(self):
+        # Le prix configuré côté YELY doit toujours l'emporter sur celui lu
+        # à l'écran, même si le CRNN lit une valeur différente (mauvaise
+        # lecture ou écran mal calibré) — règle métier n°1.
+        recognized = [
+            {"field": "prix", "text": "10000", "confidence": 0.98},
+            {"field": "volume", "text": "14.28", "confidence": 0.95},
+            {"field": "prix_litre", "text": "650", "confidence": 0.40},
+        ]
+        res = postprocess.process(recognized, fuel_price=700)
+        self.assertEqual(res["fuel_price"], 700.0)
+
+    def test_liters_only_computes_amount(self):
+        recognized = [{"field": "volume", "text": "20.00", "confidence": 0.9}]
+        res = postprocess.process(recognized, fuel_price=875)
+        self.assertAlmostEqual(res["detected_liters"], 20.0, places=2)
+        self.assertIsNone(res["detected_amount"])
+        self.assertEqual(res["calculated_amount"], 17500.0)
+
+    def test_amount_only_computes_liters(self):
+        recognized = [{"field": "prix", "text": "10000", "confidence": 0.9}]
+        res = postprocess.process(recognized, fuel_price=875)
+        self.assertIsNone(res["detected_liters"])
+        self.assertEqual(res["detected_amount"], 10000.0)
+        self.assertAlmostEqual(res["calculated_liters"], 11.43, places=2)
+
+    def test_inconsistent_values_detected(self):
+        recognized = [
+            {"field": "prix", "text": "10000", "confidence": 0.9},
+            {"field": "volume", "text": "20.00", "confidence": 0.9},
+        ]
+        res = postprocess.process(recognized, fuel_price=875)
+        self.assertFalse(res["is_consistent"])
+
+    def test_no_recognized_fields(self):
+        res = postprocess.process([], fuel_price=875)
+        self.assertEqual(res["raw_numbers"], [])
+        self.assertIsNone(res["detected_liters"])
+        self.assertIsNone(res["detected_amount"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_rules.py

@@ -0,0 +1,52 @@
+import unittest
+from app import rules
+
+
+VALID_QUALITY = {"image_quality": "valid", "quality_score": 0.95}
+
+
+class TestRulesGate(unittest.TestCase):
+    def test_consistent_reading_succeeds(self):
+        parsed = {
+            "detected_liters": 14.28, "detected_amount": 10000.0, "fuel_price": 700.0,
+            "is_consistent": True, "ocr_confidence": 0.95, "raw_numbers": [("10000", 10000.0)],
+        }
+        gate = rules.evaluate(parsed, VALID_QUALITY, fuel_price=700.0)
+        self.assertTrue(gate["success"])
+
+    def test_blurry_image_blocks(self):
+        parsed = {"raw_numbers": [("1", 1.0)], "ocr_confidence": 0.9}
+        gate = rules.evaluate(parsed, {"image_quality": "blurry", "quality_score": 0.35})
+        self.assertFalse(gate["success"])
+        self.assertIn("floue", gate["message"])
+
+    def test_inconsistent_data_blocks(self):
+        parsed = {
+            "detected_liters": 20.0, "detected_amount": 10000.0, "fuel_price": 875.0,
+            "is_consistent": False, "ocr_confidence": 0.95, "raw_numbers": [("20", 20.0)],
+        }
+        gate = rules.evaluate(parsed, VALID_QUALITY, fuel_price=875.0)
+        self.assertFalse(gate["success"])
+        self.assertIn("Incohérence", gate["message"])
+
+    def test_missing_price_blocks(self):
+        parsed = {
+            "detected_liters": 20.0, "detected_amount": None, "fuel_price": None,
+            "is_consistent": None, "ocr_confidence": 0.9, "raw_numbers": [("20", 20.0)],
+        }
+        gate = rules.evaluate(parsed, VALID_QUALITY)
+        self.assertFalse(gate["success"])
+        self.assertIn("Prix du litre manquant", gate["message"])
+
+    def test_low_confidence_blocks(self):
+        parsed = {
+            "detected_liters": 14.28, "detected_amount": 10000.0, "fuel_price": 700.0,
+            "is_consistent": True, "ocr_confidence": 0.05, "raw_numbers": [("10000", 10000.0)],
+        }
+        gate = rules.evaluate(parsed, {"image_quality": "valid", "quality_score": 0.2}, fuel_price=700.0)
+        self.assertFalse(gate["success"])
+        self.assertIn("Confiance", gate["message"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tools/check_seen_image.py

@@ -0,0 +1,117 @@
+"""Vérifie si une image a déjà été utilisée pour l'entraînement/validation
+du CRNN (annotator/annotations/annotations.json), afin de choisir des photos
+réellement inédites pour les tests de démonstration.
+
+Compare par hash perceptuel (pHash) pour détecter aussi les quasi-doublons
+(même écran re-photographié, recadré, recompressé) — pas seulement les noms
+de fichiers identiques.
+
+Usage :
+    python tools/check_seen_image.py chemin/vers/photo.jpg [autre.jpg ...]
+"""
+import argparse
+import json
+import os
+import sys
+
+import numpy as np
+from PIL import Image
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+ANNOTATIONS_FILE = os.path.join(REPO_ROOT, "annotator", "annotations", "annotations.json")
+
+HASH_SIZE = 16
+SIMILARITY_THRESHOLD = 10  # distance de Hamming ; en dessous = quasi-identique
+
+
+def phash(image_path: str, hash_size: int = HASH_SIZE) -> np.ndarray:
+    img = Image.open(image_path).convert("L").resize(
+        (hash_size + 1, hash_size), Image.LANCZOS
+    )
+    pixels = np.asarray(img, dtype=np.float32)
+    diff = pixels[:, 1:] > pixels[:, :-1]
+    return diff.flatten()
+
+
+def hamming_distance(a: np.ndarray, b: np.ndarray) -> int:
+    return int(np.count_nonzero(a != b))
+
+
+def _index_repo_filenames() -> dict:
+    """Indexe une fois tous les fichiers image du dépôt par nom de fichier,
+    pour retrouver les sources annotées même quand `image_path` ne pointe
+    plus vers un chemin valide (dossiers déplacés/renommés)."""
+    exts = {".jpg", ".jpeg", ".png", ".bmp", ".webp", ".tiff"}
+    index: dict = {}
+    skip_dirs = {".git", ".env", "__pycache__", "node_modules", "dataset_lines",
+                "dataset_doctr", "crops", "outputs", "outputs_test", "photos"}
+    for root, dirs, files in os.walk(REPO_ROOT):
+        dirs[:] = [d for d in dirs if d not in skip_dirs]
+        for f in files:
+            if os.path.splitext(f)[1].lower() in exts:
+                index.setdefault(f, os.path.join(root, f))
+    return index
+
+
+def build_reference_hashes() -> dict:
+    """Calcule les hash de toutes les images sources annotées (introuvables
+    localement sont ignorées silencieusement)."""
+    if not os.path.exists(ANNOTATIONS_FILE):
+        raise FileNotFoundError(f"Introuvable : {ANNOTATIONS_FILE}")
+
+    ann = json.load(open(ANNOTATIONS_FILE, encoding="utf-8"))
+    filename_index = _index_repo_filenames()
+    ann_dir = os.path.dirname(ANNOTATIONS_FILE)
+
+    refs = {}
+    for name, entry in ann.items():
+        rel_path = entry.get("image_path", "")
+        candidates = [
+            os.path.normpath(os.path.join(ann_dir, rel_path)) if rel_path else None,
+            os.path.normpath(os.path.join(REPO_ROOT, "images", name)),
+            filename_index.get(name),
+        ]
+        for c in candidates:
+            if c and os.path.exists(c):
+                try:
+                    refs[name] = phash(c)
+                except Exception:
+                    pass
+                break
+    return refs
+
+
+def check_image(path: str, refs: dict) -> None:
+    try:
+        h = phash(path)
+    except Exception as e:
+        print(f"{path} : impossible de lire l'image ({e})")
+        return
+
+    best_name, best_dist = None, None
+    for name, ref_hash in refs.items():
+        d = hamming_distance(h, ref_hash)
+        if best_dist is None or d < best_dist:
+            best_dist, best_name = d, name
+
+    if best_dist is not None and best_dist <= SIMILARITY_THRESHOLD:
+        print(f"{os.path.basename(path)} : DEJA VU (proche de '{best_name}', "
+              f"distance={best_dist}/{len(h)}) -> ne pas utiliser pour tester la generalisation.")
+    else:
+        dist_info = f"(plus proche : '{best_name}', distance={best_dist})" if best_name else ""
+        print(f"{os.path.basename(path)} : INEDITE {dist_info} -> bon candidat pour le test.")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("images", nargs="+", help="Chemins des images à vérifier")
+    args = parser.parse_args()
+
+    refs = build_reference_hashes()
+    print(f"{len(refs)} images de référence indexées (annotations.json).\n")
+    for path in args.images:
+        check_image(path, refs)
+
+
+if __name__ == "__main__":
+    main()

train/finetune_doctr.py

@@ -0,0 +1,250 @@
+"""
+finetune_doctr.py
+------------------
+Fine-tuning de crnn_vgg16_bn (doctr) sur les valeurs LCD
+de pompes à carburant.
+
+Copie de référence pour la reproductibilité (documentation technique).
+Ce script attend le dataset généré par `annotator/` à la racine du dépôt
+d'origine (../annotator/dataset_doctr/) — il n'est pas autonome dans ce
+dossier livrable, qui ne contient volontairement pas les ~150 images
+sources annotées. Voir docs/LIMITATIONS.md pour le contexte du dataset.
+
+Dataset attendu (généré par prepare_doctr_dataset.py) :
+  annotator/dataset_doctr/
+    train/images/ + labels.json
+    val/images/   + labels.json
+
+Usage (depuis le dépôt d'origine, dossier train/) :
+  python finetune_doctr.py
+  python finetune_doctr.py --epochs 50 --lr 3e-5
+  python finetune_doctr.py --from-scratch   # si pas de connexion internet
+"""
+
+import os, json, argparse, time
+import torch
+from torch.utils.data import DataLoader
+from doctr.datasets import RecognitionDataset, VOCABS
+from doctr.models import crnn_vgg16_bn
+
+# ─── Chemins (depuis train/) ──────────────────────────────────────────────────
+DATASET_DIR = os.path.join("..", "annotator", "dataset_doctr")
+OUTPUT_DIR  = os.path.join("models", "v2")  # ne pas écraser models/crnn_fuel_pump_best.pt (baseline)
+VOCAB       = VOCABS["french"]   # contient 0-9, virgule, point
+
+
+# ─── Dataloader ───────────────────────────────────────────────────────────────
+
+IMG_H = 32
+
+IMG_W = 256
+
+def _resize_preserve_aspect(img, target_h: int, target_w: int):
+    """Redimensionne en conservant le ratio d'aspect (hauteur fixe, largeur au
+    prorata) puis complète par du padding noir jusqu'à target_w, au lieu
+    d'étirer l'image. C'est ce que fait déjà `preprocess_crop` à l'inférence
+    (src/fine_tuned_inference.py) : entraîner avec un étirement forcé alors
+    que l'inférence préserve le ratio créait un décalage systématique entre
+    les chiffres vus à l'entraînement (déformés) et en production (non
+    déformés), ce qui pénalisait la précision du modèle.
+    """
+    import torch.nn.functional as F
+
+    c, h, w = img.shape
+    new_w = max(1, min(target_w, round(target_h * w / max(h, 1))))
+    resized = F.interpolate(img.unsqueeze(0), size=(target_h, new_w),
+                            mode="bilinear", align_corners=False).squeeze(0)
+    if new_w < target_w:
+        pad = torch.zeros(c, target_h, target_w - new_w, dtype=resized.dtype)
+        resized = torch.cat([resized, pad], dim=2)
+    elif new_w > target_w:
+        resized = resized[:, :, :target_w]
+    return resized
+
+
+def collate_fn(batch):
+    """Redimensionne toutes les images à taille fixe pour le CRNN, en
+    préservant le ratio d'aspect (voir _resize_preserve_aspect)."""
+
+    imgs, targets = zip(*batch)
+
+    resized = [_resize_preserve_aspect(img, IMG_H, IMG_W) for img in imgs]
+
+    return torch.stack(resized, 0), list(targets)
+
+def build_loaders(batch_size: int):
+    paths = {
+        "train_img": os.path.join(DATASET_DIR, "train", "images"),
+        "train_lbl": os.path.join(DATASET_DIR, "train", "labels.json"),
+        "val_img":   os.path.join(DATASET_DIR, "val",   "images"),
+        "val_lbl":   os.path.join(DATASET_DIR, "val",   "labels.json"),
+    }
+    for k, p in paths.items():
+        if not os.path.exists(p):
+            raise FileNotFoundError(
+                f"❌ Introuvable : {p}\n"
+                f"   Lance d'abord : python prepare_doctr_dataset.py")
+
+    train_ds = RecognitionDataset(
+        img_folder=paths["train_img"], labels_path=paths["train_lbl"])
+    val_ds = RecognitionDataset(
+        img_folder=paths["val_img"], labels_path=paths["val_lbl"])
+
+    print(f"📦 Dataset : {len(train_ds)} train | {len(val_ds)} val")
+
+    trn = DataLoader(train_ds, batch_size=batch_size, shuffle=True,
+                     num_workers=0, collate_fn=collate_fn, drop_last=False)
+    val = DataLoader(val_ds, batch_size=batch_size, shuffle=False,
+                     num_workers=0, collate_fn=collate_fn)
+    return trn, val, len(train_ds), len(val_ds)
+
+
+# ─── Modèle ───────────────────────────────────────────────────────────────────
+
+def build_model(from_scratch: bool):
+    if from_scratch:
+        print("⚠️  Mode from-scratch (poids aléatoires).")
+        return crnn_vgg16_bn(
+            pretrained=False, pretrained_backbone=False, vocab=VOCAB)
+    try:
+        print("⬇️  Chargement des poids pré-entraînés Mindee...")
+        m = crnn_vgg16_bn(pretrained=True, vocab=VOCAB)
+        print("✅ Poids pré-entraînés chargés.")
+        return m
+    except Exception as e:
+        print(f"❌ Téléchargement échoué : {e}")
+        print("   Relance avec --from-scratch si pas de connexion internet.")
+        raise SystemExit(1)
+
+
+# ─── Évaluation ───────────────────────────────────────────────────────────────
+
+@torch.no_grad()
+def evaluate(model, loader, device):
+    model.eval()
+    total_loss = n_ok = n_tot = 0
+    samples = []
+
+    for imgs, targets in loader:
+        imgs = imgs.to(device)
+        out  = model(imgs, target=targets, return_preds=True)
+        total_loss += out["loss"].item()
+        for (pred, _), gt in zip(out["preds"], targets):
+            n_tot += 1
+            ok = pred.strip() == gt.strip()
+            if ok: n_ok += 1
+            if len(samples) < 8:
+                samples.append((gt, pred, "✅" if ok else "❌"))
+
+    return total_loss / max(len(loader), 1), n_ok / max(n_tot, 1), samples
+
+
+# ─── Entraînement ─────────────────────────────────────────────────────────────
+
+def train(epochs, lr, batch_size, from_scratch, patience):
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"🖥️  Device : {device}")
+
+    trn_loader, val_loader, n_trn, n_val = build_loaders(batch_size)
+    model = build_model(from_scratch)
+    model.to(device)
+
+    # LR faible car fine-tuning — on préserve les poids pré-entraînés
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
+        optimizer, mode="min", factor=0.5, patience=3)
+
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    best_loss = float("inf")
+    best_acc  = 0.0
+    no_improv = 0
+    history   = []
+
+    print(f"\n🚀 Fine-tuning : {epochs} epochs | lr={lr} | batch={batch_size}")
+    print("─" * 65)
+
+    for epoch in range(1, epochs + 1):
+        model.train()
+        t0 = time.time()
+        tr_loss = 0.0
+        nb = 0
+
+        for imgs, targets in trn_loader:
+            imgs = imgs.to(device)
+            optimizer.zero_grad()
+            out  = model(imgs, target=targets, return_preds=False)
+            loss = out["loss"]
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
+            optimizer.step()
+            tr_loss += loss.item()
+            nb += 1
+
+        avg_tr = tr_loss / max(nb, 1)
+        vl, acc, samples = evaluate(model, val_loader, device)
+        scheduler.step(vl)
+        cur_lr = optimizer.param_groups[0]["lr"]
+
+        print(f"Ep {epoch:3d}/{epochs} | "
+              f"train={avg_tr:.4f} | val={vl:.4f} | "
+              f"acc={acc:.1%} | lr={cur_lr:.1e} | {time.time()-t0:.0f}s")
+
+        # Afficher des exemples de prédictions toutes les 5 epochs
+        if epoch % 5 == 0 or epoch == 1:
+            print("  Exemples val :")
+            for gt, pred, status in samples:
+                print(f"    {status}  GT='{gt}'  →  PRED='{pred}'")
+
+        history.append({"epoch": epoch, "train_loss": avg_tr,
+                        "val_loss": vl, "val_acc": acc, "lr": cur_lr})
+
+        # Sauvegarder le meilleur modèle. Écrire dans un fichier temporaire
+        # puis renommer (os.replace, atomique) évite un crash Windows déjà
+        # observé (RuntimeError code 1224, fichier verrouillé pendant
+        # l'écriture directe — probablement un scan antivirus).
+        if vl < best_loss:
+            best_loss = vl
+            best_acc  = acc
+            no_improv = 0
+            best_path = os.path.join(OUTPUT_DIR, "crnn_fuel_pump_best.pt")
+            tmp_path = best_path + ".tmp"
+            torch.save(model.state_dict(), tmp_path)
+            os.replace(tmp_path, best_path)
+            print(f"  💾 Meilleur modèle → {best_path}")
+        else:
+            no_improv += 1
+
+        if no_improv >= patience:
+            print(f"\n⏹  Early stopping ({patience} epochs sans amélioration)")
+            break
+
+    # Sauvegarde finale + historique
+    final = os.path.join(OUTPUT_DIR, "crnn_fuel_pump_final.pt")
+    torch.save(model.state_dict(), final)
+    with open(os.path.join(OUTPUT_DIR, "history.json"), "w") as f:
+        json.dump({"history": history, "best_val_loss": best_loss,
+                   "best_val_acc": best_acc}, f, indent=2)
+
+    print("\n" + "=" * 65)
+    print(f"  ✅ Entraînement terminé")
+    print(f"  Meilleure val_acc  : {best_acc:.1%}")
+    print(f"  Meilleur modèle    : {best_path}")
+    print(f"  Modèle final       : {final}")
+    print("=" * 65)
+    print("\n👉 Prochaine étape : python test_model.py")
+
+
+# ─── Entrée ───────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--epochs",       type=int,   default=80)
+    parser.add_argument("--lr",           type=float, default=5e-5)
+    parser.add_argument("--batch-size",   type=int,   default=8)
+    parser.add_argument("--patience",     type=int,   default=8)
+    parser.add_argument("--from-scratch", action="store_true")
+    args = parser.parse_args()
+
+    os.chdir(os.path.dirname(os.path.abspath(__file__)))
+    train(args.epochs, args.lr, args.batch_size,
+          args.from_scratch, args.patience)

train/prepare_doctr_dataset.py

@@ -0,0 +1,89 @@
+"""
+prepare_doctr_dataset.py
+-------------------------
+Convertit dataset_lines/ vers le format doctr :
+  dataset_doctr/
+    train/images/ + labels.json
+    val/images/   + labels.json
+
+Copie de référence pour la reproductibilité (documentation technique) —
+attend l'arborescence annotator/ du dépôt d'origine, non incluse ici.
+
+Doit être lancé depuis le dossier train/ du dépôt d'origine :
+  cd train/
+  python prepare_doctr_dataset.py
+"""
+
+import os
+import json
+import shutil
+from pathlib import Path
+
+# Chemins depuis train/ → annotator/
+SOURCE_DIR = os.path.join("..", "annotator", "dataset_lines")
+TARGET_DIR = os.path.join("..", "annotator", "dataset_doctr")
+
+
+def convert_split(split: str) -> int:
+    src_images = os.path.join(SOURCE_DIR, split, "images")
+    src_labels = os.path.join(SOURCE_DIR, split, "labels")
+    dst_images = os.path.join(TARGET_DIR, split, "images")
+    os.makedirs(dst_images, exist_ok=True)
+
+    if not os.path.isdir(src_images):
+        print(f"  ⚠️  Introuvable : {src_images}")
+        return 0
+
+    labels_dict = {}
+    n_ok = n_skip = 0
+
+    for img_file in sorted(os.listdir(src_images)):
+        if not img_file.lower().endswith((".jpg", ".jpeg", ".png")):
+            continue
+        stem  = Path(img_file).stem
+        lbl_f = os.path.join(src_labels, f"{stem}.txt")
+        if not os.path.exists(lbl_f):
+            n_skip += 1
+            continue
+        text = open(lbl_f, encoding="utf-8").read().strip()
+        if not text:
+            n_skip += 1
+            continue
+        shutil.copy2(os.path.join(src_images, img_file),
+                     os.path.join(dst_images, img_file))
+        labels_dict[img_file] = text
+        n_ok += 1
+
+    out = os.path.join(TARGET_DIR, split, "labels.json")
+    with open(out, "w", encoding="utf-8") as f:
+        json.dump(labels_dict, f, indent=2, ensure_ascii=False)
+
+    print(f"  {split:6s} : {n_ok} images, {n_skip} ignorées → {out}")
+    return n_ok
+
+
+def show_vocab():
+    chars = set()
+    for split in ("train", "val"):
+        p = os.path.join(TARGET_DIR, split, "labels.json")
+        if os.path.exists(p):
+            for txt in json.load(open(p)).values():
+                chars.update(txt)
+    print(f"\n  Vocabulaire ({len(chars)} chars) : {''.join(sorted(chars))}")
+    print(f"  → Le vocab doctr 'french' couvre tous ces caractères ✅")
+
+
+if __name__ == "__main__":
+    if not os.path.isdir(SOURCE_DIR):
+        print(f"❌ Introuvable : {SOURCE_DIR}")
+        print(f"   Lance d'abord depuis annotator/ : python split_lines.py")
+        raise SystemExit(1)
+
+    print(f"🔄 Conversion {SOURCE_DIR} → {TARGET_DIR}\n")
+    n_train = convert_split("train")
+    n_val   = convert_split("val")
+    show_vocab()
+    print(f"\n✅ {n_train} train + {n_val} val prêts pour le fine-tuning")
+    print(f"\n👉 Prochaine étape :")
+    print(f"   pip install python-doctr[torch]")
+    print(f"   python finetune_doctr.py")

web/config.js

@@ -0,0 +1,9 @@
+// URL de l'API IA (Hugging Face Spaces une fois déployée).
+//
+// ATTENTION : l'URL "https://huggingface.co/spaces/<user>/<space>" est la
+// page web du Space sur le Hub, PAS l'API elle-même — un fetch() vers cette
+// URL ne touchera jamais le endpoint FastAPI. Les Spaces Docker sont servis
+// sur un sous-domaine dédié : https://<user>-<space-en-minuscules-tirets>.hf.space
+// Vérifier l'URL exacte en ouvrant le Space et en regardant l'adresse dans
+// la barre du navigateur une fois l'app chargée (ou l'onglet réseau).
+window.YELY_API_URL = "https://danielxdata-yely-ai-module.hf.space/analyze";

web/index.html

@@ -0,0 +1,253 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>YELY |  Démo module IA pompiste</title>
+  <style>
+    :root {
+      --bg: #0f172a;
+      --panel: #1e293b;
+      --panel-2: #273449;
+      --border: #334155;
+      --text: #e2e8f0;
+      --muted: #94a3b8;
+      --accent: #f59e0b;
+      --ok-bg: #052e1f;
+      --ok-border: #10b981;
+      --ok-text: #6ee7b7;
+      --ko-bg: #3b0d0d;
+      --ko-border: #ef4444;
+      --ko-text: #fca5a5;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      font-family: -apple-system, "Segoe UI", Roboto, Arial, sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      display: flex;
+      justify-content: center;
+      padding: 2rem 1rem;
+    }
+    .app { width: 100%; max-width: 480px; }
+    .brand { display: flex; align-items: center; gap: 0.6rem; margin-bottom: 0.25rem; }
+    .brand .dot { width: 10px; height: 10px; border-radius: 50%; background: var(--accent); }
+    .brand h1 { font-size: 1.3rem; margin: 0; }
+    .subtitle { color: var(--muted); font-size: 0.9rem; margin: 0 0 1.5rem; }
+
+    .card {
+      background: var(--panel);
+      border: 1px solid var(--border);
+      border-radius: 14px;
+      padding: 1.25rem;
+      margin-bottom: 1rem;
+    }
+
+    label { display: block; font-size: 0.85rem; color: var(--muted); margin: 0.9rem 0 0.3rem; }
+    label:first-child { margin-top: 0; }
+    input, select {
+      width: 100%;
+      padding: 0.65rem 0.75rem;
+      border-radius: 8px;
+      border: 1px solid var(--border);
+      background: var(--panel-2);
+      color: var(--text);
+      font-size: 1rem;
+    }
+    input[type="file"] { padding: 0.5rem; }
+
+    #preview {
+      display: none;
+      width: 100%;
+      max-height: 260px;
+      object-fit: contain;
+      border-radius: 10px;
+      margin-top: 0.75rem;
+      border: 1px solid var(--border);
+    }
+
+    button {
+      width: 100%;
+      margin-top: 1.25rem;
+      padding: 0.85rem;
+      border: none;
+      border-radius: 10px;
+      background: var(--accent);
+      color: #1a1200;
+      font-size: 1.05rem;
+      font-weight: 700;
+      cursor: pointer;
+    }
+    button:disabled { background: #4b5563; color: #9ca3af; cursor: not-allowed; }
+
+    .status { font-size: 0.85rem; color: var(--muted); text-align: center; margin-top: 0.75rem; min-height: 1.2em; }
+
+    .banner {
+      display: none;
+      border-radius: 12px;
+      padding: 1rem 1.1rem;
+      font-weight: 700;
+      font-size: 1.05rem;
+      margin-bottom: 1rem;
+      border: 1px solid;
+    }
+    .banner.ok { display: block; background: var(--ok-bg); border-color: var(--ok-border); color: var(--ok-text); }
+    .banner.ko { display: block; background: var(--ko-bg); border-color: var(--ko-border); color: var(--ko-text); }
+
+    .rows { display: flex; flex-direction: column; gap: 0.6rem; }
+    .row { display: flex; justify-content: space-between; align-items: baseline; padding: 0.5rem 0; border-bottom: 1px solid var(--border); }
+    .row:last-child { border-bottom: none; }
+    .row .k { color: var(--muted); font-size: 0.85rem; }
+    .row .v { font-weight: 700; font-size: 1.15rem; }
+    .row .v.small { font-size: 0.95rem; font-weight: 500; }
+
+    details { margin-top: 0.5rem; }
+    summary { cursor: pointer; color: var(--muted); font-size: 0.8rem; }
+    pre { background: #000; color: #a3e635; padding: 0.75rem; border-radius: 8px; overflow-x: auto; font-size: 0.75rem; }
+
+    .hint { color: var(--muted); font-size: 0.78rem; margin-top: 0.4rem; }
+  </style>
+</head>
+<body>
+  <div class="app">
+    <div class="brand"><span class="dot"></span><h1>YELY |  Vérification pompiste</h1></div>
+    <p class="subtitle">Démo du module IA : photo du terminal ->  lecture automatique ->  vérification de cohérence.</p>
+
+    <div id="banner" class="banner"></div>
+    <div id="resultCard" class="card" style="display:none;">
+      <div class="rows" id="resultRows"></div>
+      <details>
+        <summary>Détails techniques</summary>
+        <pre id="rawJson"></pre>
+      </details>
+    </div>
+
+    <form id="form" class="card">
+      <label>Photo du terminal de pompe</label>
+      <input type="file" id="image" accept="image/*" capture="environment" required />
+      <img id="preview" alt="Aperçu" />
+
+      <label>Prix du litre (FCFA)</label>
+      <input type="number" id="fuelPrice" value="700" step="0.01" />
+
+      <label>ID chauffeur (optionnel |  simulate le scan QR)</label>
+      <input type="text" id="driverId" placeholder="chauffeur-42" />
+
+      <label>ID pompiste / station (optionnel)</label>
+      <input type="text" id="pompisteId" placeholder="pompiste-7" />
+
+      <details style="margin-top: 0.9rem;">
+        <summary>Configuration (URL de l'API)</summary>
+        <label>URL du service</label>
+        <input type="text" id="apiUrl" />
+      </details>
+
+      <button type="submit" id="submitBtn">Analyser la photo</button>
+      <div class="status" id="status"></div>
+    </form>
+  </div>
+
+  <script src="config.js"></script>
+  <script>
+    const form = document.getElementById('form');
+    const submitBtn = document.getElementById('submitBtn');
+    const statusEl = document.getElementById('status');
+    const banner = document.getElementById('banner');
+    const resultCard = document.getElementById('resultCard');
+    const resultRows = document.getElementById('resultRows');
+    const rawJson = document.getElementById('rawJson');
+    const imageInput = document.getElementById('image');
+    const preview = document.getElementById('preview');
+    const apiUrlInput = document.getElementById('apiUrl');
+
+    apiUrlInput.value = localStorage.getItem('yely_api_url') ||   window.YELY_API_URL ||   '';
+
+    imageInput.addEventListener('change', () => {
+      if (imageInput.files.length > 0) {
+        preview.src = URL.createObjectURL(imageInput.files[0]);
+        preview.style.display = 'block';
+      } else {
+        preview.style.display = 'none';
+      }
+    });
+
+    function fmt(v) {
+      if (v === null ||   v === undefined ||   v === '') return '—';
+      if (typeof v === 'boolean') return v ? 'Oui' : 'Non';
+      return String(v);
+    }
+
+    function row(label, value, small) {
+      const div = document.createElement('div');
+      div.className = 'row';
+      div.innerHTML = `<span class="k">${label}</span><span class="v${small ? ' small' : ''}">${value}</span>`;
+      return div;
+    }
+
+    function renderSuccess(data) {
+      resultRows.innerHTML = '';
+      resultRows.appendChild(row('Litres détectés', fmt(data.detected_liters)));
+      resultRows.appendChild(row('Montant détecté', fmt(data.detected_amount)));
+      resultRows.appendChild(row('Prix du litre', fmt(data.fuel_price)));
+      resultRows.appendChild(row('Montant calculé', fmt(data.calculated_amount)));
+      resultRows.appendChild(row('Litres calculés', fmt(data.calculated_liters)));
+      resultRows.appendChild(row('Cohérent', fmt(data.is_consistent)));
+      resultRows.appendChild(row('Confiance', fmt(data.confidence_score), true));
+      resultRows.appendChild(row('Qualité image', fmt(data.image_quality), true));
+      resultCard.style.display = 'block';
+      rawJson.textContent = JSON.stringify(data, null, 2);
+    }
+
+    form.addEventListener('submit', async (event) => {
+      event.preventDefault();
+      if (imageInput.files.length === 0) return;
+
+      const apiUrl = apiUrlInput.value.trim();
+      localStorage.setItem('yely_api_url', apiUrl);
+      if (!apiUrl) {
+        statusEl.textContent = "Renseigne l'URL de l'API dans « Configuration ».";
+        return;
+      }
+
+      const formData = new FormData();
+      formData.append('image', imageInput.files[0]);
+      formData.append('fuel_price', document.getElementById('fuelPrice').value);
+      const driverId = document.getElementById('driverId').value.trim();
+      const pompisteId = document.getElementById('pompisteId').value.trim();
+      if (driverId) formData.append('driver_id', driverId);
+      if (pompisteId) formData.append('pompiste_id', pompisteId);
+
+      submitBtn.disabled = true;
+      submitBtn.textContent = 'Analyse en cours…';
+      banner.className = 'banner';
+      banner.textContent = '';
+      resultCard.style.display = 'none';
+      statusEl.textContent = 'Envoi de la photo…';
+
+      const t0 = performance.now();
+      try {
+        const res = await fetch(apiUrl, { method: 'POST', body: formData });
+        const elapsed = ((performance.now() - t0) / 1000).toFixed(1);
+        const data = await res.json();
+
+        statusEl.textContent = `Réponse en ${elapsed}s (HTTP ${res.status})`;
+
+        const success = res.ok && data.success === true;
+        banner.className = 'banner ' + (success ? 'ok' : 'ko');
+        banner.textContent = (success ? '✅ ' : '⛔ ') + (data.message ||   (success ? 'Validé.' : 'Bloqué.'));
+
+        renderSuccess(data);
+      } catch (err) {
+        statusEl.textContent = '';
+        banner.className = 'banner ko';
+        banner.textContent = "⛔ Impossible de contacter l'API (" + err.message + ").";
+      } finally {
+        submitBtn.disabled = false;
+        submitBtn.textContent = 'Analyser la photo';
+      }
+    });
+  </script>
+</body>
+</html>

web/vercel.json

@@ -0,0 +1,3 @@
+{
+  "cleanUrls": true
+}