fix(audit-2): 5 correctifs supplémentaires d'un 2e tour d'audit

3 agents Explore indépendants ont audité le commit 1e8b84c
(corrections du 1er audit). Ils ont trouvé que mon propre
correctif contenait des défauts. Cinq nouveaux fixes :

1. **CRITIQUE — _imports_target_relative bombe à retardement**
La fonction n'acceptait les imports relatifs QUE depuis
``MEASUREMENTS_DIR`` lui-même (check ``source_dir != …``).
Un sous-package ``measurements/narrative/foo.py`` qui ferait
``from .. import builtin_metrics`` n'était pas détecté → le
module classé à tort test-only. Pas activé aujourd'hui (aucun
import de cette forme), mais devient un bug silencieux dès
qu'un sous-package en utilise un.

Refactor : remonter ``node.level - 1`` parents depuis
``source_dir`` pour résoudre le package cible, puis comparer
à ``MEASUREMENTS_DIR``. Couvre désormais level=1, 2, 3, …

2. **MAJEURE — _test_only_modules sans mémoïsation**
Les 2 tests du fichier appellent la même fonction qui parse
l'AST de tous les fichiers prod (~12 s). Sans cache, on
parsait 2× pour rien (23 s par run).

``@functools.cache`` sur ``_test_only_modules``. Mesure :
23.1 s → 11.2 s par run (÷2.06 comme prévu).

3. **MINEURE — tests NaN/Inf placebos avec titres mensongers**
``test_nan_falls_back_to_red`` n'asserait que "ne crash pas
et hex valide" alors que le titre prétendait tester le rouge.
En réalité, ``min(1.0, NaN) = 1.0`` (Python propage NaN à
travers ``min``/``max``), donc NaN → vert max, pas rouge.

Renommé ``test_nan_propagates_to_green`` avec assertion
exacte sur ``GRADIENT_GREEN_RGB`` + cas inversé low_is_good.
Idem ``test_inverted_scale_returns_yellow_neutral`` qui
vérifie maintenant l'égalité exacte avec
``GRADIENT_YELLOW_RGB``. Plus de tests "non-crash".

4. **MINEURE — doc contradictoire sur les conventions**
La docstring affirmait "rouge/jaune/vert (échelle universelle
de qualité)" puis admettait dans la même section que ces
couleurs sont précisément non-universelles en daltonisme.
Reformulation : "convention historique pour vision trichromate
normale, **compromis d'accessibilité accepté**" + référence
à la palette Okabe-Ito de ``picarones.report.colors`` comme
dette de migration.

5. **MINEURE — logger trompeur si Pillow indisponible**
``encode_image_b64`` attrapait toutes les exceptions sous le
même message ``"échec d'encodage base64 de l'image …"``.
Si Pillow n'était pas installé, le log faisait croire à un
problème de fichier image alors que c'était l'environnement.

Split en deux ``try`` : le premier capture
``ImportError`` avec un message explicite "Pillow indisponible"
+ suggestion d'install ; le second garde le message générique
pour les vrais problèmes par image.

Suite : 3834 passed, 2 skipped (parité). 1 échec pré-existant.
ruff : All checks passed!

picarones/report/assets.py

@@ -49,13 +49,25 @@ def encode_image_b64(image_path: str, max_width: int = 1200) -> str:
     échoue (Pillow indisponible, format non géré, fichier corrompu).
     Logue un avertissement dans ce dernier cas — le rapport reste
     fonctionnel mais l'image manquera dans la galerie.
+
+    Distingue ``ImportError`` (Pillow non installée — problème
+    d'environnement) du reste (problème par image) pour aider au
+    diagnostic en logs de production.
     """
     p = Path(image_path)
     if not p.exists():
         return ""
     try:
         from PIL import Image
-
+    except ImportError as exc:
+        logger.warning(
+            "[report] Pillow indisponible : %s — toutes les images "
+            "du rapport seront omises. Installer ``pip install Pillow`` "
+            "ou ``pip install picarones[report]``.",
+            exc,
+        )
+        return ""
+    try:
         with Image.open(p) as img:
             if img.width > max_width:
                 ratio = max_width / img.width

picarones/report/render_helpers.py

@@ -37,12 +37,19 @@ maladresse) :
   (deltas signés) sont symétriques autour de 0 — la borne est la
   même des deux côtés.
 
-Le choix des couleurs reflète la sémantique métier : traffic-light
-utilise rouge/jaune/vert (échelle universelle de qualité), diverging
-utilise bleu/vert/orange par défaut (vert au centre = neutre,
-extrémités opposées sémantiquement, et ces 3 teintes restent
-distinguables en daltonisme deutéranope contrairement au
-rouge/vert).
+Le choix des couleurs reflète la sémantique métier :
+
+- **Traffic-light** rouge/jaune/vert : convention historique
+  largement comprise pour vision trichromate normale. **Compromis
+  d'accessibilité accepté** : la confusion rouge/vert affecte ~8 %
+  des hommes (deutéranopie/protanopie). Une migration vers la
+  palette Okabe-Ito de :mod:`picarones.report.colors` est tracée
+  comme dette dans un sprint dédié.
+- **Diverging** bleu/vert/orange par défaut : vert au centre =
+  neutre, extrémités opposées sémantiquement, et ces 3 teintes
+  restent distinguables en daltonisme deutéranope. Choix retenu
+  parce que les cellules diverging sont moins nombreuses et
+  qu'on a pu repartir de zéro en les écrivant.
 
 Palette
 -------

tests/architecture/test_module_coverage.py

@@ -38,6 +38,7 @@ Test ratchet :
 from __future__ import annotations
 
 import ast
+import functools
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parents[2]
@@ -107,24 +108,38 @@ def _imports_target_relative(
     node: ast.AST, module_name: str, source_dir: Path,
 ) -> bool:
     """True si ce nœud AST importe ``module_name`` via un import relatif
-    valide depuis le package ``measurements``.
+    qui pointe vers ``picarones/measurements/<module_name>``.
 
-    Couvre :
+    Couvre les imports relatifs depuis n'importe quel sous-dossier du
+    package ``measurements`` (y compris ``measurements/narrative/`` et
+    ``measurements/narrative/detectors/``) :
 
-    - ``from . import X`` (depuis ``measurements/__init__.py`` ou
-      tout autre module dans le package).
-    - ``from .X import Y``.
+    - ``from . import X`` (level=1) depuis ``measurements/foo.py``.
+    - ``from .X import Y`` (level=1, module=X) depuis le même.
+    - ``from .. import X`` (level=2) depuis ``measurements/sub/foo.py``.
+    - ``from ..X import Y`` (level=2, module=X) depuis le même.
+    - Idem pour level=3 et au-delà depuis sous-sous-packages.
+
+    L'ancien check ``source_dir == MEASUREMENTS_DIR`` ratait tous les
+    imports relatifs depuis les sous-packages — bombe à retardement
+    qui devient critique dès qu'un sous-package importe un voisin.
     """
     if not isinstance(node, ast.ImportFrom):
         return False
     if node.level < 1:
         return False
-    if source_dir != MEASUREMENTS_DIR:
+    # Remonter ``node.level - 1`` niveaux pour résoudre le package cible.
+    # Pour ``from . import X`` (level=1) on reste dans ``source_dir`` ;
+    # pour ``from ..X import Y`` (level=2) on remonte d'un niveau ; etc.
+    target_dir = source_dir
+    for _ in range(node.level - 1):
+        target_dir = target_dir.parent
+    if target_dir != MEASUREMENTS_DIR:
         return False
-    # ``from .X import …``
+    # ``from .X import …`` ou ``from ..X import …``
     if node.module == module_name:
         return True
-    # ``from . import X``
+    # ``from . import X`` ou ``from .. import X``
     if node.module is None:
         for alias in node.names:
             if alias.name == module_name:
@@ -163,7 +178,15 @@ def _has_production_consumer(module_name: str) -> bool:
     return False
 
 
+@functools.cache
 def _test_only_modules() -> frozenset[str]:
+    """Retourne les modules de ``measurements/`` sans consommateur prod.
+
+    Mémoïsée par ``functools.cache`` : les deux tests de ce fichier
+    appellent cette fonction (≈ 12 s par appel sur ~200 fichiers
+    Python), donc sans cache on parsait l'AST de tout le projet
+    deux fois pour rien.
+    """
     return frozenset(
         m for m in _measurements_modules()
         if not _has_production_consumer(m)

tests/report/test_render_helpers.py

@@ -75,14 +75,17 @@ class TestColorTrafficLight:
         assert len(c) == 7
         assert c == c.lower()
 
-    def test_nan_falls_back_to_red(self) -> None:
-        # max(0, min(1, NaN)) = NaN → mais ensuite f <= 0.5 est False, donc
-        # branche "yellow → green" avec t = (NaN - 0.5) / 0.5 = NaN.
-        # Le résultat est techniquement indéfini ; on vérifie au moins que
-        # la fonction ne crash pas et retourne un hex valide.
-        c = color_traffic_light(float("nan"))
-        assert c.startswith("#")
-        assert len(c) == 7
+    def test_nan_propagates_to_green(self) -> None:
+        # Vérification IEEE 754 : ``min(1.0, NaN)`` retourne ``1.0`` en
+        # Python (la comparaison avec NaN est False, donc Python retient
+        # le second argument).  ``max(0.0, 1.0) = 1.0``.  Donc f=1.0,
+        # branche ``f > 0.5`` → vert max.  Comportement déterministe et
+        # testable (pas un test placebo "ne crash pas").
+        assert _hex_to_rgb(color_traffic_light(float("nan"))) == GRADIENT_GREEN_RGB
+        # Avec low_is_good=True, l'inversion donne f=0 → rouge.
+        assert _hex_to_rgb(
+            color_traffic_light(float("nan"), low_is_good=True)
+        ) == GRADIENT_RED_RGB
 
     def test_inf_clamped_to_max(self) -> None:
         # +inf > scale_max → clamp à scale_max → vert (high_is_good)
@@ -90,12 +93,15 @@ class TestColorTrafficLight:
         # -inf < 0 → clamp à 0 → rouge
         assert _hex_to_rgb(color_traffic_light(float("-inf"))) == GRADIENT_RED_RGB
 
-    def test_inverted_scale_returns_yellow(self) -> None:
-        # scale_min > scale_max → span négatif → géré comme zero span.
-        # La fonction ne doit pas crash et retourne une couleur valide.
-        c = color_traffic_light(5.0, scale_min=10, scale_max=5)
-        assert c.startswith("#")
-        assert len(c) == 7
+    def test_inverted_scale_returns_yellow_neutral(self) -> None:
+        # scale_min > scale_max → span <= 0 → branche "zero span" → f=0.5
+        # → frontière exacte rouge/jaune/vert → jaune neutre.
+        assert _hex_to_rgb(
+            color_traffic_light(5.0, scale_min=10, scale_max=5)
+        ) == GRADIENT_YELLOW_RGB
+        # Idem pour scale_min == scale_max (déjà couvert par
+        # test_zero_span_returns_yellow plus haut, mais la cohérence
+        # de comportement est explicite ici).
 
 
 # ──────────────────────────────────────────────────────────────────