Upload 19 files

Dockerfile

@@ -8,6 +8,8 @@
 FROM python:3.12-slim
 
 ARG TORCH_VARIANT=gpu
+# Option explicite CUDA 12.4 ; la valeur par défaut conserve le choix de PyTorch du noyau.
+ARG VESUVIUS_CUDA12=0
 ENV PYTHONUNBUFFERED=1 \
     PYTHONDONTWRITEBYTECODE=1 \
     PIP_NO_CACHE_DIR=1 \
@@ -26,9 +28,11 @@ RUN apt-get update \
 RUN useradd -m -u 1000 user
 WORKDIR /home/user/app
 
-COPY --chown=user requirements.txt requirements-dev.txt ./
+COPY --chown=user requirements.txt requirements-dev.txt requirements-vesuvius.txt ./
 RUN if [ "$TORCH_VARIANT" = "cpu" ]; then \
         pip install --index-url https://download.pytorch.org/whl/cpu torch ; \
+    elif [ "$VESUVIUS_CUDA12" = "1" ]; then \
+        pip install --index-url https://download.pytorch.org/whl/cu124 "torch==2.6.0" ; \
     else \
         pip install "torch>=2.4,<2.16" ; \
     fi \

app.py

@@ -727,6 +727,9 @@ def mission_gpu_reason() -> str | None:
         return "une passe GRPO/DPO occupe le GPU"
     if TRAINER.running:
         return "l'entraînement continu occupe le GPU"
+    laboratory = globals().get("VESUVIUS")
+    if laboratory is not None and laboratory.gpu_active:
+        return "le laboratoire Vesuvius libère le GPU pour la mission"
     return None
 
 
@@ -886,7 +889,32 @@ def learn_configure(key, actif=None, seuil=None, max_passes_jour=None, phases=No
             if state["actif"] else "Apprentissage automatique éteint : aucune passe ne partira toute seule.")
 
 
-TRAINER.gate = lambda: "une mission utilise le GPU" if mission_active() else None
+# Laboratoire optionnel : initialisation légère, aucun I/O ni job au démarrage.
+VESUVIUS = None
+VESUVIUS_ERROR = ""
+try:
+    from src.controller import Controller as VesuviusController
+    VESUVIUS = VesuviusController(
+        busy=lambda: ("mission active" if mission_busy() else "entraînement actif" if training_active()
+                      else "modèle en génération" if service.models_in_use() else None),
+        preempt=lambda: mission_active() or training_active(),
+        gpu_context=service.model_in_use, concurrent_uses=service.models_in_use)
+    service.set_gpu_guard(lambda: "laboratoire Vesuvius : GPU réservé" if VESUVIUS.gpu_active
+                          else RL_BUSY if rl_reserved() else None)
+except Exception as exc:
+    VESUVIUS_ERROR = type(exc).__name__ + ": " + str(exc)
+
+# Conserve le branchement distant 4.13 s'il est déjà installé, sans l'imposer au noyau 4.12.
+try:
+    from agents.remote_executor import RemoteExecutor
+    if hasattr(PIPELINE, "candidate_observer"):
+        REMOTE_EXECUTOR = RemoteExecutor(DISCOVERY.registry)
+        PIPELINE.candidate_observer = REMOTE_EXECUTOR.check
+except ImportError:
+    pass
+
+TRAINER.gate = lambda: ("une mission utilise le GPU" if mission_active() else
+                       "laboratoire Vesuvius actif" if VESUVIUS is not None and VESUVIUS.gpu_active else None)
 
 
 with gr.Blocks(title="UNIQUE") as demo:
@@ -996,6 +1024,16 @@ with gr.Blocks(title="UNIQUE") as demo:
         sp_btn.click(selfplay_cmd, [sp_key, sp_limit, sp_per], [sp_msg, a_journal])
         rl_go.click(rl_start, [rl_key, rl_phases], rl_msg)
         rl_halt.click(rl_stop, rl_key, rl_msg)
+    if VESUVIUS is not None:
+        try:
+            from src.ui import build_tab as build_vesuvius_tab
+            build_vesuvius_tab(VESUVIUS, authorized)
+        except Exception as exc:
+            with gr.Tab("Laboratoire Vesuvius — indisponible"):
+                gr.Markdown("Extension désactivée : " + type(exc).__name__)
+    else:
+        with gr.Tab("Laboratoire Vesuvius — indisponible"):
+            gr.Markdown("Le module isolé n'a pas pu être chargé. Les autres onglets restent disponibles.")
     timer = gr.Timer(10)
     timer.tick(refresh, None, [status, pass_plot, loss_plot, history, console])
     timer.tick(agents_refresh, None, [agents_status, a_journal])

docs/VALIDATION_VESUVIUS_4.14.0.json

@@ -0,0 +1,69 @@
+{
+  "release": "4.14.0",
+  "date": "2026-11-13",
+  "tests": {
+    "laboratory": {
+      "tests": 22,
+      "failures": 0,
+      "errors": 0,
+      "skipped": 0
+    },
+    "unique_regression": {
+      "tests": 109,
+      "failures": 0,
+      "errors": 0,
+      "skipped": 0
+    }
+  },
+  "live_s3": {
+    "ok": true,
+    "shape": [
+      75784,
+      32693,
+      32693
+    ],
+    "chunks": [
+      128,
+      128,
+      128
+    ],
+    "dtype": "uint8",
+    "roi_shape": [
+      8,
+      8,
+      8
+    ],
+    "origin": [
+      37892,
+      16346,
+      16346
+    ],
+    "min": 33.0,
+    "max": 134.0,
+    "seconds": 8.105108438999991
+  },
+  "gpu_validation": "not_run_no_GPU_in_executor",
+  "persistence_validation": "path and mount refusal tested; actual Space /data restart persistence not tested",
+  "ui_validation": "Gradio tab built; isolated ASGI /lab/config returned 200; authorization callbacks tested",
+  "geometry_validation": "plane metric preserved; TIFXYZ XYZ/mask/scale/bbox exported; VC3D roundtrip not run",
+  "torch": "CPU microcycle and disjoint prediction executed; no ink quality claim",
+  "docker": "syntax inspected, image not built; docker executable unavailable",
+  "existing_core": "No agents/, engine/ or mouh/service.py files in archive. app glue adds priority guards and optional tab.",
+  "dependencies": {
+    "torch": "2.6.0+cpu",
+    "numpy": "2.5.4",
+    "scipy": "1.18.1",
+    "zarr": "2.18.7",
+    "s3fs": "2025.12.0",
+    "tifffile": "2026.11.8",
+    "gradio": "5.50.0",
+    "safetensors": "0.8.0"
+  },
+  "limits": [
+    "Not a validated full-scroll unrolling pipeline",
+    "No pretrained ink checkpoint supplied",
+    "Research exports have submission_ready=false",
+    "64x64 is an internal guard, not a general official rule",
+    "CUDA12 build option changes the global torch stack only if explicitly enabled"
+  ]
+}

docs/VESUVIUS_LAB.md

@@ -0,0 +1,66 @@
+# UNIQUE 4.14.0 — laboratoire Vesuvius isolé
+
+## Installation et portée
+
+Décompresser le lot et uploader tous ses fichiers à la racine du Space en conservant les dossiers, dans un seul commit. Le lot est fondé sur les sources du dépôt TARGET_SPACE lues le 13 novembre 2026, dont le manifeste annonce 4.12.3. Aucun fichier `agents/`, `engine/` ou `mouh/service.py` n'est remplacé. Si le branchement distant 4.13 est déjà installé, le crochet est conservé de manière optionnelle. Le laboratoire ne l'utilise jamais pour envoyer les volumes CT.
+
+L'onglet **Laboratoire Vesuvius 3D** est dans l'interface Gradio, accessible sur `/gradio/`. La page Symbioza et ses panneaux ne sont pas redessinés. Le chargement de l'onglet n'importe pas torch et ne démarre aucun calcul ni téléchargement.
+
+Le laboratoire est une base de recherche locale fonctionnelle : petites ROI Zarr, score spectral, surface candidate ou fournie, paramétrisation métrique, petit modèle hybride et paquets traçables. Il ne constitue ni un lecteur validé de textes anciens, ni un pipeline complet d'unrolling d'un rouleau, ni une méthode prête à gagner un prix.
+
+## Stockage obligatoire
+
+Le bouton **Vérifier /data et l'état du laboratoire** doit confirmer que `/data` est monté et accessible en écriture. Sans montage, tous les jobs refusent de démarrer ; aucun repli vers `/tmp`, le dépôt ou le disque éphémère n'est utilisé pour les artefacts du laboratoire.
+
+Tous les fichiers métier sont sous :
+
+- `/data/chunks/vesuvius/` : ROI, requêtes et résultats de jobs, logs, masques et prédictions ;
+- `/data/meshes/vesuvius/` : surfaces XYZ et charts UV ;
+- `/data/weights/vesuvius/` : checkpoints safetensors, suivi d'expériences et caches de bibliothèques du worker ;
+- `/data/submissions/vesuvius/` : paquets de recherche exportés.
+
+Les sous-dossiers `vesuvius` évitent de toucher les autres artefacts d'UNIQUE. Le cache de ROI est plafonné à 512 Mio ; les plus anciennes entrées de ce seul cache sont évincées. Une vérification de place libre bloque les nouveaux jobs sous 128 Mio disponibles. Les autres sorties se conservent jusqu'au nettoyage manuel.
+
+Le test local utilise un répertoire temporaire uniquement via l'argument explicite `require_mount=False` des tests. Le serveur et le worker de production utilisent toujours `Storage()` avec `/data` obligatoire. Le montage réel du Space et sa survie à un redémarrage doivent être contrôlés sur le Space ; ils ne sont pas déduits d'un test local.
+
+## GPU et isolation
+
+Chaque job tourne dans un nouveau sous-processus. Les tâches CPU sont limitées à un thread de calcul et lancées avec une priorité réduite. Les caches et temporaires du worker sont redirigés sous `/data`. Un job CPU a un budget de 120 secondes, un job CUDA de 45 secondes ; annulation et préemption peuvent ajouter jusqu'à trois secondes d'arrêt.
+
+Un microcycle CUDA démarre uniquement si aucune mission, passe d'entraînement ou génération d'UNIQUE n'est active. Il utilise le mécanisme existant `model_in_use` comme réservation, sans modifier son code. La garde GPU empêche un nouveau chargement concurrent du Codeur et le superviseur donne priorité à une nouvelle mission : il arrête le job du laboratoire, puis libère sa réservation. L'entraînement continu attend ce créneau court. L'onglet n'arrête et ne décharge jamais lui-même le modèle d'UNIQUE.
+
+Le microcycle prend bf16 sur CUDA quand PyTorch le supporte, sinon float32. Une A10G n'a pas été disponible dans l'environnement de validation : le chemin bf16/CUDA, l'utilisation réelle de VRAM et le démarrage de l'image complète restent à contrôler sur le Space. Aucun résultat CPU n'est présenté comme un benchmark A10G.
+
+Le Dockerfile conserve par défaut le choix de PyTorch du noyau. Pour reconstruire explicitement avec les roues CUDA 12.4 / PyTorch 2.6, utiliser l'argument de build `VESUVIUS_CUDA12=1`. Cette option change la pile globale PyTorch et demande une nouvelle validation du modèle principal. La valeur `0` évite cette modification implicite. Les versions de transformers, peft et trl ne sont pas modifiées ; les ajouts sont regroupés dans `requirements-vesuvius.txt`.
+
+## Parcours de recherche
+
+1. Vérifier `/data`, avec la clé d'administration existante. Tous les boutons qui déclenchent un traitement vérifient cette clé.
+2. Dans **Volume et footholds**, choisir le chemin S3, le tableau/niveau, l'origine `z,y,x`, une ROI de 2 à 64 voxels par axe et le pas isotrope exact du niveau choisi. Le chemin d'exemple provient du tutoriel officiel et a répondu lors du contrôle ; il n'est pas présenté comme un volume éligible à tous les prix.
+3. Copier le chemin `.npz` retourné dans le champ chunk. Le scanner FFT traite des fenêtres 2D et conserve le meilleur 1 % des candidats. Le score est une anisotropie spectrale ; il n'atteste ni une surface de papyrus ni de l'encre.
+4. Fournir, si disponible, une surface `H×W×3` en `.npy`, coordonnées `x,y,z` en voxels du niveau choisi, stockée sous `/data/meshes/vesuvius/`. Sans surface, le gradient produit un candidat non validé. La fenêtre est bornée à 64×64 points, puis l'aplatissement minimise les erreurs de longueur d'arête. Le résultat rapporte le maximum et le RMS de distorsion. Les plis sont refusés. Une isométrie exacte d'une surface courbe quelconque n'est pas garantie.
+5. Dans **Microcycles**, choisir reconstruction ou encre supervisée. Sans checkpoint initial, les poids sont explicitement aléatoires ; reprendre un checkpoint du laboratoire effectue un fine-tuning réel. Le modèle est un petit encodeur Conv3D, agrégation en profondeur et tête Conv2D. Le mode reconstruction réalise un débruitage masqué, pas une détection d'encre. Le mode encre exige un véritable masque annoté `.npy` H×W dans [0,1]. Aucun masque de vérité artificiel n'est créé par le programme.
+6. Pour prédire, charger une ROI disjointe. Les régions d'entraînement sont enregistrées dans le checkpoint et tout recouvrement est refusé, y compris en changeant de niveau du même volume lorsque la transformation n'est pas certifiée. Le seed, la loss, les versions des bibliothèques et l'empreinte du chunk sont enregistrés. La validation indépendante de la qualité des cartes d'encre reste à faire.
+7. Construire le chart de cette ROI de prédiction, puis exporter avec le mesh et la carte correspondants. Sans prédiction, l'image est un rendu de densité CT, clairement identifié comme tel. Une carte d'un autre chunk est refusée.
+
+Une panne S3 réutilise uniquement le cache de la requête exacte, avec sa date et `cache_fallback=true`. Sans cache exact, le job échoue proprement. Aucune donnée synthétique n'est substituée silencieusement à un scan réel. Les accès S3 sont anonymes, en lecture seule, limités au bucket public `vesuvius-challenge-open-data` ; aucun téléchargement de volume entier ni jeton HF transmis.
+
+## Export et règles officielles
+
+Chaque ZIP contient les TIFF float32 `x.tif`, `y.tif`, `z.tif`, un masque, `meta.json`, une PNG 16 bits, le rendu brut float32, une prévisualisation avec échelle et les paramètres de provenance. La géométrie est rééchantillonnée sur la même grille UV régulière que l'image. Le facteur `scale` exprime les pixels par voxel du niveau choisi. Les champs `format=tifxyz`, `type=seg`, `uuid`, `scale` et `bbox` suivent un exemple de métadonnées publiques officielles. Un aller-retour complet dans VC3D n'a pas été exécuté ici.
+
+Le rééchantillonnage jusqu'à 2048² pixels n'ajoute pas de résolution CT. L'échelle est calculée à partir du pas renseigné, pas d'une calibration inventée. Une barre de 1 cm est produite seulement si le champ physique le permet ; sinon une barre plus courte et sa longueur sont indiquées honnêtement. Un patch de 64 voxels à 2,4 µm ne couvre que 0,154 mm : lui attribuer une barre de 1 cm serait faux.
+
+Le champ `submission_ready` reste **false**. Les règles actuelles du Grand Prize exigent notamment des colonnes complètes, une géométrie TIFXYZ traçable, des images lisibles avec échelles de 1 cm, un panorama, une méthodologie reproductible et une évaluation indépendante sans recouvrement entraînement/prédiction. Ce petit laboratoire ne certifie ni la couverture d'un rouleau ni la lisibilité papyrologique. Il n'envoie rien aux organisateurs et ne publie aucun dataset ou checkpoint.
+
+La limite 64×64 est un garde-fou interne demandé pour le laboratoire, pas une limite réglementaire générale trouvée dans les règles actuelles. Une adaptation transductive sur la région à soumettre ne doit pas être confondue avec une validation admissible ; le verrou de recouvrement empêche cet usage dans ce pipeline.
+
+## Validation et sources
+
+Voir `VALIDATION_VESUVIUS_4.14.0.json` pour les résultats exacts, les versions de test et les limites. La compatibilité Gradio est vérifiée par construction de l'onglet et montage ASGI isolé. Le noyau n'est pas entièrement démarré avec son modèle GPU dans cet environnement.
+
+- Règles actuelles : https://scrollprize.org/prizes
+- Formats : https://scrollprize.org/data_segments
+- Données et échelle des volumes : https://scrollprize.org/from_ash_to_text
+- Tutoriel et volume d'exemple : https://github.com/ScrollPrize/villa/blob/main/scrollprize.org/docs/07_tutorial5.md
+- Exemple TIFXYZ lu : https://vesuvius-challenge-open-data.s3.amazonaws.com/PHerc0500P2/segments/20250716055236-z_dbg_gen_00356_inp_hr/mesh/intermediate/tifxyz_original/meta.json

mouh/learning/manifest.json

@@ -1,14 +1,14 @@
 {
-  "version": "v4.12.3",
+  "version": "v4.14.0",
   "files": {
-    "Dockerfile": "b3f4ddb914b0198d",
+    "Dockerfile": "f68259170ec47222",
     "README.md": "ed433a59c0e4fb6d",
     "agents/__init__.py": "c726c5c5cec54f5b",
     "agents/autonomy.py": "6c73a4b5b49aeed8",
     "agents/contract.py": "925f5ac350a90ea0",
     "agents/core.py": "24e49461b79764ba",
     "agents/mission.py": "9b760c2378774b7b",
-    "app.py": "ee5533191d8341be",
+    "app.py": "bad902c73a24d67d",
     "config.json": "e75d8b151c4de3d1",
     "engine/__init__.py": "9ed43b8c6346ad0e",
     "engine/exam.py": "b9d7eeac20ff9a12",
@@ -84,9 +84,9 @@
     "mouh/world.py": "b20550f63e2d7cc1",
     "pyproject.toml": "5dff2198898efe09",
     "requirements-dev.txt": "9a03d0d2ca94a0d2",
-    "requirements.txt": "8877a189d3a2a02c",
+    "requirements.txt": "f6e0d34c6f292b9a",
     "unique_ext/README.md": "0f0be41551e6bacb",
-    "unique_ext/__init__.py": "19c15e5686a9f625",
+    "unique_ext/__init__.py": "179aa19888358397",
     "unique_ext/backends/__init__.py": "e3b0c44298fc1c14",
     "unique_ext/backends/hf.py": "506d29e81c127e1e",
     "unique_ext/contracts.py": "4ce5632e921dfcdc",
@@ -138,7 +138,18 @@
     "agents/discovery.py": "9c688f744e888102",
     "agents/discovery_api.py": "ea8ba886909ef1ea",
     "agents/discovery_capabilities.py": "41a76670ed0553c1",
-    "config/spaces_curated.json": "9a9f54dceab9cfbf"
+    "config/spaces_curated.json": "9a9f54dceab9cfbf",
+    "src/__init__.py": "ef77ad4265bda616",
+    "src/controller.py": "b4c9586d5de615d3",
+    "src/exporter.py": "a6fdfcce4e1135f5",
+    "src/loader.py": "1d7ecba8594d015a",
+    "src/scanner.py": "3746e1d337810a54",
+    "src/storage.py": "e5feb00026c0dbc5",
+    "src/trainer.py": "3c0abcbc27d70514",
+    "src/ui.py": "2784fe94110157a8",
+    "src/unwrapper.py": "6f556fa3fb15fd9c",
+    "src/worker.py": "7104681fcf9e81cf",
+    "requirements-vesuvius.txt": "61384af45af4799c"
   },
   "removed": [
     "mouh/learning/autopilot.py",

requirements-vesuvius.txt

@@ -0,0 +1,7 @@
+# Dépendances optionnelles du laboratoire ; aucun changement de transformers/peft/trl.
+s3fs>=2024.6,<2026
+zarr>=2.18,<3
+numcodecs>=0.12,<0.16
+tifffile>=2024.8,<2027
+Pillow>=10,<12
+plotly>=5,<7

requirements.txt

@@ -25,3 +25,6 @@ manifold3d>=2.4,<4         # géométrie solide constructive (CSG)
 scikit-fem>=9.0,<13        # éléments finis (volumes, plaques)
 control>=0.10,<1           # automatique : fonctions de transfert, stabilité
 tetgen>=0.8,<1             # v4.9 : maillage en tétraèdres des pièces solides (atelier mécanique) ; roue abi3, numpy seul
+
+# Laboratoire Vesuvius, imports lourds uniquement dans les jobs manuels.
+-r requirements-vesuvius.txt

src/__init__.py

@@ -0,0 +1 @@
+"""Laboratoire Vesuvius isolé : aucun import lourd, accès disque ou réseau ici."""

src/controller.py

@@ -0,0 +1,89 @@
+"""Jobs manuels et préemptibles ; aucune tâche ni import torch au bootstrap."""
+from __future__ import annotations
+from contextlib import nullcontext
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+import threading
+import time
+import uuid
+
+from .storage import Storage
+
+
+class Controller:
+    def __init__(self, storage=None, busy=lambda:None, preempt=lambda:False,
+                 gpu_context=nullcontext, concurrent_uses=lambda:0):
+        self.storage=storage or Storage()
+        self.busy,self.preempt=busy,preempt
+        self.gpu_context,self.concurrent_uses=gpu_context,concurrent_uses
+        self.lock=threading.Lock();self.proc=None;self.gpu_active=False
+        self.state={'status':'idle','result':None,'error':'','gpu':False}
+        self._cancel=False
+
+    def status(self):
+        with self.lock:return dict(self.state)
+
+    def start(self, action, payload):
+        if action not in ('load','scan','unwrap','train','predict','export'):
+            raise ValueError('action inconnue')
+        with self.lock:
+            if self.state['status']=='running':raise RuntimeError('un job du laboratoire est déjà actif')
+            self.storage.initialize()
+            gpu=action=='train' and payload.get('device')=='cuda'
+            if gpu and self.busy():raise RuntimeError('GPU prioritaire occupé par UNIQUE : '+str(self.busy()))
+            job=uuid.uuid4().hex
+            request=self.storage.json('chunks',job+'.request.json',{'action':action,'payload':payload})
+            self.gpu_active=gpu;self._cancel=False
+            self.state={'status':'running','job':job,'action':action,'gpu':gpu,'result':None,'error':''}
+            thread=threading.Thread(target=self._run,args=(request,gpu),daemon=True,name='vesuvius-job')
+            thread.start()
+            return dict(self.state)
+
+    def _run(self, request, gpu):
+        context=self.gpu_context() if gpu else nullcontext()
+        result={'ok':False,'error':'job interrompu'}
+        try:
+            with context:
+                if gpu and self.concurrent_uses()>1:raise RuntimeError('une génération UNIQUE a priorité')
+                cache=self.storage.folder('weights')/'cache';cache.mkdir(exist_ok=True)
+                temp=self.storage.folder('chunks')/'tmp';temp.mkdir(exist_ok=True)
+                env=os.environ.copy()
+                env.update(TMPDIR=str(temp),TMP=str(temp),TEMP=str(temp),TORCH_HOME=str(cache),
+                    XDG_CACHE_HOME=str(cache),CUDA_CACHE_PATH=str(cache/'cuda'),HF_HOME=str(cache/'hf'),
+                    OMP_NUM_THREADS='1',OPENBLAS_NUM_THREADS='1',MKL_NUM_THREADS='1',PYTHONDONTWRITEBYTECODE='1',
+                    CUBLAS_WORKSPACE_CONFIG=':4096:8')
+                if not gpu:env['CUDA_VISIBLE_DEVICES']=''
+                log=request.with_suffix('.log')
+                with log.open('wb') as stream:
+                    self.proc=subprocess.Popen([sys.executable,'-m','src.worker',str(request)],
+                        cwd=str(Path(__file__).resolve().parent.parent),env=env,stdout=stream,stderr=subprocess.STDOUT,
+                        start_new_session=True)
+                    deadline=time.monotonic()+(45 if gpu else 120)
+                    while self.proc.poll() is None:
+                        if self._cancel or time.monotonic()>deadline or (gpu and self.preempt()):
+                            self.proc.terminate()
+                            try:self.proc.wait(timeout=3)
+                            except subprocess.TimeoutExpired:self.proc.kill();self.proc.wait()
+                            raise RuntimeError('job annulé, préempté par UNIQUE ou budget épuisé')
+                        time.sleep(0.2)
+                output=request.with_name(request.stem+'.result.json')
+                if output.is_file() and output.stat().st_size<1024**2:
+                    result=json.loads(output.read_text())
+                else:result={'ok':False,'error':'worker indisponible ; voir '+str(log)}
+        except Exception as exc:result={'ok':False,'error':type(exc).__name__+': '+str(exc)[:1000]}
+        finally:
+            with self.lock:
+                self.gpu_active=False;self.proc=None
+                self.state.update(status='done' if result.get('ok') else 'error',gpu=False,
+                                  result=result.get('result'),error=result.get('error',''))
+
+    def stop(self):
+        self._cancel=True
+        return 'Arrêt demandé au laboratoire uniquement.'
+
+    def diagnostic(self):
+        try:return {'storage':self.storage.initialize(),'job':self.status()}
+        except Exception as exc:return {'storage':{'ok':False,'error':str(exc)},'job':self.status()}

src/exporter.py

@@ -0,0 +1,90 @@
+"""Paquet de recherche traçable PNG + géométrie TIFXYZ + métadonnées."""
+import json
+import time
+import uuid
+import zipfile
+
+
+def export(storage, mesh_path, prediction_path=None, pixels=1024):
+    import numpy as np
+    from scipy.interpolate import LinearNDInterpolator
+    from scipy.ndimage import map_coordinates
+    from PIL import Image,ImageDraw
+    import tifffile
+    from .loader import read_chunk
+    from .trainer import overlaps
+    if not 64<=int(pixels)<=2048:raise ValueError('résolution de 64 à 2048 pixels par axe')
+    path=storage.checked(mesh_path,'meshes')
+    with np.load(path,allow_pickle=False) as data:
+        xyz=data['xyz'];uv=data['uv'];meta=json.loads(str(data['metadata']))
+    if xyz.shape[:2]!=uv.shape[:2] or max(xyz.shape[:2])>64 or meta['quality']['folds']:
+        raise ValueError('chart invalide')
+    if meta['quality']['max_relative_stretch']>0.15:raise ValueError('distorsion supérieure à 15 % : réviser la surface')
+    volume,chunk_meta=read_chunk(storage,meta['chunk'])
+    if chunk_meta['request']!=meta['request']:raise ValueError('provenance du chunk modifiée')
+    coordinates=xyz[...,::-1]-np.array(meta['request']['origin'])
+    if np.any(coordinates<0) or np.any(coordinates>np.array(volume.shape)-1):
+        raise ValueError('surface hors de la ROI chargée')
+    values=map_coordinates(volume.astype('float32'),coordinates.reshape(-1,3).T,order=1,mode='nearest').reshape(xyz.shape[:2])
+    prediction_meta=None
+    if prediction_path:
+        pp=storage.checked(prediction_path,'chunks')
+        with np.load(pp,allow_pickle=False) as data:
+            predicted=data['prediction'];prediction_meta=json.loads(str(data['metadata']))
+        if prediction_meta['request']!=meta['request'] or predicted.shape!=values.shape:
+            raise ValueError('prédiction et mesh ne correspondent pas')
+        if any(overlaps(meta['request'],r) for r in prediction_meta['training']['training_regions']):
+            raise ValueError('entraînement et export se recouvrent')
+        if not np.isfinite(predicted).all():raise ValueError('prédiction non finie')
+        values=predicted
+    low=uv.reshape(-1,2).min(0);high=uv.reshape(-1,2).max(0)
+    if np.min(high-low)<=1e-8:raise ValueError('chart sans étendue')
+    # Grille UV régulière ; la carte XYZ est rééchantillonnée pour conserver la correspondance.
+    n=int(pixels);xs=np.linspace(low[0],high[0],n);ys=np.linspace(low[1],high[1],n)
+    gx,gy=np.meshgrid(xs,ys)
+    interpolator=LinearNDInterpolator(uv.reshape(-1,2),np.c_[xyz.reshape(-1,3),values.ravel()])
+    mapped=interpolator(gx,gy);valid=np.isfinite(mapped).all(axis=-1)
+    if valid.sum()==0:raise ValueError('paramétrisation vide')
+    raw=np.where(valid,mapped[...,3],0)
+    lo,hi=np.percentile(raw[valid],[1,99])
+    normalized=np.where(valid,np.clip((raw-lo)/max(float(hi-lo),1e-6),0,1),0)
+    name='patch_'+uuid.uuid4().hex
+    folder=storage.path('submissions',name);folder.mkdir()
+    mesh=folder/(name+'.tifxyz');mesh.mkdir()
+    for i,axis in enumerate('xyz'):
+        tifffile.imwrite(mesh/(axis+'.tif'),np.where(valid,mapped[...,i],-1).astype('float32'))
+    Image.fromarray((valid*255).astype('uint8')).save(mesh/'mask.png')
+    tifffile.imwrite(mesh/'mask.tif',(valid*255).astype('uint8'))
+    tifffile.imwrite(folder/(name+'.raw.tif'),raw.astype('float32'))
+    image=Image.fromarray((normalized*65535).astype('uint16'));image.save(folder/(name+'.png'))
+    voxel_um=meta['request']['voxel_um'];um_per_pixel=float((high[0]-low[0])*voxel_um/(n-1))
+    possible_mm=float((high[0]-low[0])*voxel_um/1000)
+    bar_mm=float(10.0 if possible_mm>=12 else max(0.001,possible_mm/4))
+    bar_pixels=max(1,int(round(bar_mm*1000/um_per_pixel)))
+    preview=Image.fromarray((normalized*255).astype('uint8')).convert('RGB')
+    canvas=Image.new('RGB',(n,n+48),'black');canvas.paste(preview,(0,0));draw=ImageDraw.Draw(canvas)
+    draw.line((8,n+12,8+bar_pixels,n+12),fill='white',width=3)
+    draw.text((8,n+22),f'{bar_mm:g} mm',fill='white');canvas.save(folder/(name+'.scale.png'))
+    report={'schema':'unique-vesuvius-research/1','created_at':time.time(),'submission_ready':False,
+            'reasons':['local_patch_not_full_column','held_out_and_papyrological_validation_missing',
+                       'VC3D_roundtrip_not_certified'],
+            'source':meta['request'],'mesh':name+'.tifxyz','coordinate_units':'selected_level_voxels',
+            'axes':'xyz','shape':[n,n],'uv_bounds':[low.tolist(),high.tolist()],
+            'micrometres_per_pixel_x':um_per_pixel,
+            'scale_bar':{'length_mm':bar_mm,'pixels':bar_pixels,'official_1cm_fits':bar_mm==10},
+            'chunk_sha256':storage.digest(meta['chunk'],'chunks'),'geometry':meta['quality'],'surface_kind':meta['surface_kind'],
+            'render_kind':prediction_meta['kind'] if prediction_meta else 'CT_density_not_ink',
+            'prediction':prediction_meta,'mesh_sha256':storage.digest(path,'meshes'),
+            'note':'Une grande image rééchantillonnée ne crée pas de résolution CT supplémentaire.'}
+    valid_xyz=mapped[...,:3][valid]
+    (mesh/'meta.json').write_text(json.dumps({'format':'tifxyz','type':'seg','uuid':name,
+        'scale':[float((n-1)/(high[0]-low[0])),float((n-1)/(high[1]-low[1]))],
+        'bbox':[valid_xyz.min(0).tolist(),valid_xyz.max(0).tolist()],
+        'target_volume':meta['request']['uri']+'#vc-base-scale='+meta['request']['level'],
+        'coordinate_system':'selected_level_voxels','source':meta['request']},indent=2))
+    (folder/'metadata.json').write_text(json.dumps(report,ensure_ascii=False,allow_nan=False,indent=2))
+    archive=storage.path('submissions',name+'.zip')
+    with zipfile.ZipFile(archive,'w',zipfile.ZIP_DEFLATED) as z:
+        for file in sorted(folder.rglob('*')):
+            if file.is_file():z.write(file,str(file.relative_to(folder)))
+    return {'path':str(archive),'metadata':report,'image':str(folder/(name+'.scale.png'))}

src/loader.py

@@ -0,0 +1,101 @@
+"""Lecture S3 anonyme, ROI bornée, cache exact ; jamais de volume synthétique de repli."""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import math
+import re
+import time
+from urllib.parse import urlsplit
+
+
+def request_spec(uri, level, origin, shape, voxel_um):
+    p = urlsplit(str(uri))
+    if (p.scheme != 's3' or p.netloc != 'vesuvius-challenge-open-data' or p.query or p.fragment
+            or '..' in p.path.split('/') or not p.path.endswith(('.zarr', '.zarr/'))):
+        raise ValueError('seul le bucket public Vesuvius et un chemin .zarr sont autorisés')
+    if not re.fullmatch(r'[A-Za-z0-9_.-]{1,64}', str(level)) or str(level) in ('.','..'):
+        raise ValueError('niveau Zarr invalide')
+    if len(origin) != 3 or len(shape) != 3 or any(type(v) is not int or v < 0 for v in origin):
+        raise ValueError('origine attendue : trois entiers z,y,x positifs')
+    if any(type(v) is not int or not 2 <= v <= 64 for v in shape):
+        raise ValueError('ROI de 2 à 64 voxels par axe')
+    if not math.isfinite(float(voxel_um)) or not 0 < float(voxel_um) <= 1000:
+        raise ValueError('pas de voxel isotrope en µm requis')
+    return dict(uri=str(uri).rstrip('/'), level=str(level), origin=list(origin), shape=list(shape), voxel_um=float(voxel_um), axes='zyx')
+
+
+class Loader:
+    def __init__(self, storage, opener=None):
+        self.storage, self.opener = storage, opener or self.open_array
+
+    @staticmethod
+    def open_array(spec):
+        import s3fs
+        import zarr
+        fs = s3fs.S3FileSystem(anon=True, config_kwargs={'connect_timeout':5, 'read_timeout':8,
+                                'retries':{'max_attempts':1}}, default_fill_cache=False)
+        store = fs.get_mapper(spec['uri'], check=False)
+        # mode r : pas de création de métadonnées ni d'objets S3.
+        return zarr.open_array(store=store, path=spec['level'], mode='r')
+
+    def load(self, spec):
+        import numpy as np
+        self.storage.initialize()
+        spec = request_spec(spec['uri'], spec['level'], spec['origin'], spec['shape'], spec['voxel_um'])
+        key = hashlib.sha256(json.dumps(spec,sort_keys=True).encode()).hexdigest()[:24]
+        cache = self.storage.path('chunks', key+'.npz')
+        def cached():
+            with np.load(cache, allow_pickle=False) as saved:
+                volume = saved['volume']
+                metadata = json.loads(str(saved['metadata']))
+            if list(volume.shape) != spec['shape'] or metadata['request'] != spec:
+                raise ValueError('cache incompatible')
+            return volume, metadata
+        try:
+            array = self.opener(spec)
+            if len(array.shape) != 3 or any(o+n>s for o,n,s in zip(spec['origin'],spec['shape'],array.shape)):
+                raise ValueError('ROI hors volume ou axes non zyx : sélectionner un tableau 3D')
+            if array.dtype.kind not in 'uif' or math.prod(array.chunks)*array.dtype.itemsize > 64*1024**2:
+                raise ValueError('type ou chunk distant trop volumineux')
+            volume = np.asarray(array[tuple(slice(o,o+n) for o,n in zip(spec['origin'],spec['shape']))])
+            if not np.isfinite(volume).all():
+                raise ValueError('voxels non finis')
+            metadata = {'request':spec, 'source_shape':list(array.shape), 'loaded_at':time.time(),
+                        'provenance':'public_CT', 'cache_fallback':False}
+            tmp = cache.with_suffix('.tmp.npz')
+            np.savez_compressed(tmp, volume=volume, metadata=json.dumps(metadata))
+            tmp.replace(cache)
+            # Quota du laboratoire uniquement, les autres dossiers restent intacts.
+            entries = sorted(self.storage.folder('chunks').glob('*.npz'), key=lambda p:p.stat().st_mtime)
+            total = sum(p.stat().st_size for p in entries)
+            for p in entries:
+                if total <= 512*1024**2: break
+                if p != cache:
+                    total -= p.stat().st_size; p.unlink()
+        except ValueError:
+            raise
+        except Exception:
+            if not cache.is_file():
+                raise RuntimeError('S3 indisponible et aucun cache exact pour cette ROI') from None
+            volume, metadata = cached()
+            metadata = {**metadata, 'cache_fallback':True}
+        return {'path':str(cache), 'metadata':metadata, 'shape':list(volume.shape)}
+
+    async def load_async(self, spec):
+        return await asyncio.to_thread(self.load, spec)
+
+
+def read_chunk(storage, path):
+    import numpy as np
+    path = storage.checked(path, 'chunks')
+    if path.stat().st_size > 16*1024**2:
+        raise ValueError('chunk local trop volumineux')
+    with np.load(path, allow_pickle=False) as saved:
+        volume = saved['volume'].copy()
+        metadata = json.loads(str(saved['metadata']))
+    spec = request_spec(**{k:metadata['request'][k] for k in ('uri','level','origin','shape','voxel_um')})
+    if list(volume.shape) != spec['shape'] or not np.isfinite(volume).all():
+        raise ValueError('chunk incohérent')
+    return volume, metadata

src/scanner.py

@@ -0,0 +1,32 @@
+"""Score spectral d'anisotropie ; sélection top 1 %, pas une preuve d'encre."""
+import math
+
+
+def scan(volume, tile=16):
+    import numpy as np
+    volume = np.asarray(volume)
+    if volume.ndim != 3 or not np.isfinite(volume).all() or not 4 <= int(tile) <= 64:
+        raise ValueError('volume ou taille de fenêtre invalide')
+    tile = int(tile)
+    if min(volume.shape[1:]) < tile:
+        raise ValueError('fenêtre plus grande que la ROI')
+    scores=[]
+    fy,fx=np.meshgrid(np.fft.fftshift(np.fft.fftfreq(tile)),np.fft.fftshift(np.fft.fftfreq(tile)),indexing='ij')
+    radius=fx*fx+fy*fy
+    band=(radius>0.01)&(radius<0.2)
+    window=np.outer(np.hanning(tile),np.hanning(tile))
+    for z in range(volume.shape[0]):
+        for y in range(0,volume.shape[1]-tile+1,max(1,tile//2)):
+            for x in range(0,volume.shape[2]-tile+1,max(1,tile//2)):
+                patch=volume[z,y:y+tile,x:x+tile].astype('float32')
+                variance=float(np.var(patch))
+                power=np.abs(np.fft.fftshift(np.fft.fft2((patch-patch.mean())*window)))**2*band
+                energy=float(power.sum())
+                if energy<=1e-12 or variance<=1e-12: continue
+                tensor=np.array([[np.sum(power*fx*fx),np.sum(power*fx*fy)],[np.sum(power*fx*fy),np.sum(power*fy*fy)]])
+                eigen=np.linalg.eigvalsh(tensor)
+                score=float((eigen[1]-eigen[0])/(eigen.sum()+1e-12))
+                scores.append({'zyx':[z,y+tile//2,x+tile//2],'score':score,'variance':variance,'window':tile})
+    scores.sort(key=lambda v:(-v['score'],v['zyx']))
+    return {'method':'FFT_anisotropy', 'ink_detected':False,'candidates':len(scores),
+            'selected':scores[:max(1,math.ceil(len(scores)*0.01))] if scores else []}

src/storage.py

@@ -0,0 +1,73 @@
+"""Tous les artefacts du laboratoire restent dans les quatre dossiers /data."""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import uuid
+
+
+class Storage:
+    KINDS = ('chunks', 'meshes', 'weights', 'submissions')
+
+    def __init__(self, root=Path('/data'), require_mount=True):
+        self.root = Path(root).resolve()
+        self.require_mount = require_mount
+        if require_mount and self.root != Path('/data'):
+            raise ValueError('le laboratoire exige /data')
+
+    def folder(self, kind):
+        if kind not in self.KINDS:
+            raise ValueError('catégorie inconnue')
+        path = self.root / kind / 'vesuvius'
+        if not path.resolve().is_relative_to(self.root):
+            raise ValueError('lien symbolique hors /data')
+        return path
+
+    def initialize(self):
+        if self.require_mount and not os.path.ismount(self.root):
+            raise RuntimeError('/data non monté : laboratoire indisponible, aucun repli local')
+        for kind in self.KINDS:
+            self.folder(kind).mkdir(parents=True, exist_ok=True)
+        if shutil.disk_usage(self.root).free < 128*1024**2:
+            raise RuntimeError('moins de 128 Mio disponibles sur /data')
+        probe = self.folder('chunks') / ('.probe-'+uuid.uuid4().hex)
+        try:
+            probe.write_bytes(b'unique-vesuvius')
+            if probe.read_bytes() != b'unique-vesuvius':
+                raise OSError('lecture après écriture incorrecte')
+        finally:
+            probe.unlink(missing_ok=True)
+        return {'root': str(self.root), 'mounted': os.path.ismount(self.root), 'writable': True}
+
+    def path(self, kind, name):
+        if not re.fullmatch(r'[A-Za-z0-9_.-]{1,160}', str(name)) or name in ('.', '..'):
+            raise ValueError('nom invalide')
+        return self.checked(self.folder(kind)/name, kind)
+
+    def checked(self, path, kind):
+        path = Path(path).resolve()
+        if not path.is_relative_to(self.folder(kind).resolve()):
+            raise ValueError('artefact hors du dossier autorisé')
+        return path
+
+    def json(self, kind, name, value):
+        path = self.path(kind, name)
+        tmp = path.with_name('.'+path.name+'.'+uuid.uuid4().hex)
+        try:
+            tmp.write_text(json.dumps(value, ensure_ascii=False, allow_nan=False, indent=2), encoding='utf-8')
+            tmp.replace(path)
+        finally:
+            tmp.unlink(missing_ok=True)
+        return path
+
+    def digest(self, path, kind):
+        path = self.checked(path, kind)
+        h = hashlib.sha256()
+        with path.open('rb') as f:
+            for block in iter(lambda:f.read(1024*1024), b''):
+                h.update(block)
+        return h.hexdigest()

src/trainer.py

@@ -0,0 +1,110 @@
+"""Petit encodeur 3D/2D, adaptation isolée et journal de régions disjointes."""
+from __future__ import annotations
+import json
+import time
+import uuid
+
+
+def overlaps(a,b):
+    if a['uri']!=b['uri']: return False
+    # Sans transformation inter-niveaux certifiée, même volume/niveau différent est refusé.
+    if a['level']!=b['level']: return True
+    return all(x<y+m and y<x+n for x,n,y,m in zip(a['origin'],a['shape'],b['origin'],b['shape']))
+
+
+def build_model():
+    import torch.nn as nn
+    class Hybrid(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.volume=nn.Sequential(nn.Conv3d(1,8,3,padding=1),nn.GELU(),nn.Conv3d(8,8,3,padding=1),nn.GELU())
+            self.sheet=nn.Sequential(nn.Conv2d(8,8,3,padding=1),nn.GELU(),nn.Conv2d(8,1,1))
+        def forward(self,x):return self.sheet(self.volume(x).mean(dim=2))
+    return Hybrid()
+
+
+def train(storage, chunk_path, steps=4, mode='reconstruction', mask_path=None, checkpoint=None, device='cpu'):
+    import numpy as np
+    import torch
+    from safetensors.torch import load_file,save_file
+    from .loader import read_chunk
+    if mode not in ('reconstruction','ink_supervised') or not 1<=int(steps)<=32:
+        raise ValueError('mode ou budget de microcycle invalide')
+    volume,metadata=read_chunk(storage,chunk_path)
+    torch.set_num_threads(1)
+    with torch.random.fork_rng(devices=[0] if device=='cuda' else []):
+        torch.manual_seed(0)
+        torch.use_deterministic_algorithms(True)
+        if device=='cuda':
+            if not torch.cuda.is_available():raise RuntimeError('CUDA indisponible')
+            if torch.cuda.mem_get_info()[0]<1024**3:raise RuntimeError('moins de 1 Gio de VRAM libre')
+        model=build_model().to(device)
+        history=[];initial='random'
+        if checkpoint:
+            path=storage.checked(checkpoint,'weights')
+            if path.stat().st_size>16*1024**2:raise ValueError('checkpoint trop volumineux')
+            prior=json.loads(path.with_suffix('.json').read_text())
+            if prior['mode']!=mode:raise ValueError('objectif du checkpoint incompatible')
+            model.load_state_dict(load_file(str(path),device=device))
+            history=list(prior['training_regions']);initial=str(path)
+        normalized=volume.astype('float32')
+        lo,hi=np.percentile(normalized,[1,99]);normalized=np.clip((normalized-lo)/max(float(hi-lo),1e-6),0,1).astype("float32")
+        x=torch.from_numpy(normalized[None,None]).to(device)
+        if mode=='ink_supervised':
+            if not mask_path:raise ValueError('masque d’encre annoté requis pour un objectif supervisé')
+            path=storage.checked(mask_path,'chunks')
+            if path.stat().st_size>1024**2:raise ValueError('masque trop volumineux')
+            mask=np.load(path,allow_pickle=False)
+            if mask.shape!=volume.shape[1:] or not np.isfinite(mask).all() or np.min(mask)<0 or np.max(mask)>1:
+                raise ValueError('masque attendu H×W dans [0,1]')
+            target=torch.from_numpy(mask.astype('float32')[None,None]).to(device)
+        else:target=x.mean(dim=2)
+        optimizer=torch.optim.AdamW(model.parameters(),lr=1e-3)
+        bf16=device=='cuda' and torch.cuda.is_bf16_supported()
+        loss_fn=torch.nn.BCEWithLogitsLoss() if mode=='ink_supervised' else torch.nn.MSELoss()
+        loss_values=[]
+        model.train()
+        for _ in range(int(steps)):
+            optimizer.zero_grad(set_to_none=True)
+            # Dénoyautage masqué pour la reconstruction ; jamais présenté comme une carte d'encre.
+            inp=x*(torch.rand_like(x)>0.15) if mode=='reconstruction' else x
+            with torch.autocast(device_type=device,dtype=torch.bfloat16,enabled=bf16):
+                output=model(inp);loss=loss_fn(output,target)
+            if not torch.isfinite(loss):raise RuntimeError('loss non finie')
+            loss.backward();optimizer.step();loss_values.append(float(loss.detach().cpu()))
+        name=uuid.uuid4().hex
+        path=storage.path('weights',name+'.safetensors')
+        save_file({k:v.detach().cpu().contiguous() for k,v in model.state_dict().items()},str(path))
+        history.append(metadata['request'])
+        result={'mode':mode,'seed':0,'steps':int(steps),'loss':loss_values,'device':device,
+                'precision':'bf16' if bf16 else 'float32','initialization':initial,'training_regions':history,
+                'held_out_evaluated':False,'ink_quality_measured':False,'created_at':time.time(),
+                'architecture':'tiny_hybrid_3d_2d_v1','torch_version':torch.__version__,'numpy_version':np.__version__,
+                'training_chunk_sha256':storage.digest(chunk_path,'chunks'),'normalization':{'low':float(lo),'high':float(hi)}}
+        storage.json('weights',name+'.json',result)
+        return {'path':str(path),'report':result}
+
+
+def predict(storage, chunk_path, checkpoint):
+    import numpy as np
+    import torch
+    from safetensors.torch import load_file
+    from .loader import read_chunk
+    volume,metadata=read_chunk(storage,chunk_path)
+    path=storage.checked(checkpoint,'weights')
+    if path.stat().st_size>16*1024**2:raise ValueError('checkpoint trop volumineux')
+    report=json.loads(path.with_suffix('.json').read_text())
+    if any(overlaps(metadata['request'],region) for region in report['training_regions']):
+        raise ValueError('région de prédiction en recouvrement avec un entraînement : refus')
+    model=build_model();model.load_state_dict(load_file(str(path),device='cpu'));model.eval()
+    lo,hi=report['normalization']['low'],report['normalization']['high']
+    x=np.clip((volume.astype('float32')-lo)/max(hi-lo,1e-6),0,1).astype("float32")
+    with torch.inference_mode():out=model(torch.from_numpy(x[None,None]))
+    if report['mode']=='ink_supervised':out=out.sigmoid()
+    out=out.squeeze().numpy()
+    name=uuid.uuid4().hex
+    target=storage.path('chunks',name+'.prediction.npz')
+    np.savez_compressed(target,prediction=out,metadata=json.dumps({'request':metadata['request'],
+        'checkpoint':str(path),'checkpoint_sha256':storage.digest(path,'weights'),'training':report,
+        'kind':'ink_probability_unvalidated' if report['mode']=='ink_supervised' else 'reconstruction_not_ink'}))
+    return {'path':str(target),'kind':report['mode'],'held_out_evaluated':False}

src/ui.py

@@ -0,0 +1,88 @@
+"""Onglet additionnel, callbacks authentifiés ; calculs hors du serveur Gradio."""
+import json
+import importlib.util
+
+
+def build_tab(controller, authorized):
+    import gradio as gr
+    with gr.Tab('Laboratoire Vesuvius 3D'):
+        gr.Markdown('## Vesuvius — laboratoire de recherche\n'
+            'Jobs manuels et isolés. Les modèles et les missions UNIQUE restent prioritaires. '
+            'Une structure FFT ou une reconstruction ne prouve pas la présence d’encre. '
+            'Les exports de patch sont des paquets de recherche, pas des soumissions complètes.')
+        key=gr.Textbox(label='Clé d’administration UNIQUE_ADMIN_KEY',type='password')
+        status=gr.JSON(label='État du job et artefacts')
+        def call(action,payload,secret):
+            if not authorized(secret):return {'error':'clé d’administration requise'}
+            try:return controller.start(action,payload)
+            except Exception as exc:return {'error':str(exc)}
+        def diagnostic(secret):
+            return controller.diagnostic() if authorized(secret) else {'error':'clé requise'}
+        check=gr.Button('Vérifier /data et l’état du laboratoire')
+        check.click(diagnostic,key,status)
+        with gr.Tabs():
+            with gr.Tab('Volume et footholds'):
+                uri=gr.Textbox(label='Volume S3 public .zarr',value='s3://vesuvius-challenge-open-data/PHercParis4/volumes/20260411134726-2.400um-0.2m-78keV-masked.zarr')
+                gr.Markdown('Exemple de volume de recherche publié ; vérifier son pas et son niveau dans le catalogue officiel.')
+                level=gr.Textbox(label='Tableau / niveau Zarr',value='0')
+                origin=gr.Textbox(label='Origine z,y,x (voxels du niveau choisi)',value='37892,16346,16346')
+                size=gr.Number(label='Côté de la ROI (2–64)',value=32,precision=0)
+                voxel=gr.Number(label='Pas isotrope du niveau choisi (µm)',value=2.4)
+                fetch=gr.Button('Lire cette ROI S3')
+                def load(secret,u,l,o,n,v):
+                    try:payload={'uri':u,'level':l,'origin':[int(i.strip()) for i in o.split(',')],
+                                 'shape':[int(n)]*3,'voxel_um':float(v)}
+                    except Exception:return {'error':'origine ou taille invalide'}
+                    return call('load',payload,secret)
+                fetch.click(load,[key,uri,level,origin,size,voxel],status)
+                chunk=gr.Textbox(label='Chemin du chunk .npz affiché dans le résultat (/data/chunks/vesuvius/...)')
+                scan=gr.Button('FFT 2D — top 1 % des candidats')
+                scan.click(lambda k,c:call('scan',{'chunk':c,'tile':16},k),[key,chunk],status)
+            with gr.Tab('Surface et aplatissement'):
+                surface=gr.Textbox(label='Surface XYZ .npy sous /data/meshes/vesuvius (facultative)')
+                gr.Markdown('Sans surface fournie : estimation par gradient, explicitement non validée. '
+                            'Fenêtre interne ≤64×64, distorsion mesurée ; aucune isométrie parfaite garantie.')
+                unwrap=gr.Button('Construire le chart local')
+                unwrap.click(lambda k,c,s:call('unwrap',{'chunk':c,'surface':s},k),[key,chunk,surface],status)
+                mesh=gr.Textbox(label='Chemin du mesh .npz produit (/data/meshes/vesuvius/...)')
+                plot=gr.Plot(label='Surface 3D — coordonnées du niveau choisi')
+                preview=gr.Button('Afficher le mesh 3D')
+                def show(secret,path):
+                    if not authorized(secret):return None
+                    try:
+                        import numpy as np
+                        import plotly.graph_objects as go
+                        with np.load(controller.storage.checked(path,'meshes'),allow_pickle=False) as data:xyz=data['xyz']
+                        if xyz.shape[0]>64 or xyz.shape[1]>64:return None
+                        fig=go.Figure(go.Surface(x=xyz[...,0],y=xyz[...,1],z=xyz[...,2],colorscale='Viridis'))
+                        fig.update_layout(scene={'aspectmode':'data'},margin=dict(l=0,r=0,t=0,b=0))
+                        return fig
+                    except Exception:return None
+                preview.click(show,[key,mesh],plot)
+            with gr.Tab('Microcycles et prédictions'):
+                gr.Markdown('Petit modèle 3D/2D initialisé aléatoirement, ou repris depuis un checkpoint du laboratoire. '
+                            'La reconstruction auto-supervisée n’est pas une détection d’encre. '
+                            'Une prédiction sur une région d’entraînement est refusée.')
+                mode=gr.Dropdown(['reconstruction','ink_supervised'],value='reconstruction',label='Objectif')
+                mask=gr.Textbox(label='Masque .npy H×W annoté, dans /data/chunks/vesuvius (mode supervisé)')
+                checkpoint=gr.Textbox(label='Checkpoint .safetensors dans /data/weights/vesuvius (optionnel pour entraîner)')
+                steps=gr.Slider(1,32,value=4,step=1,label='Pas du microcycle')
+                device=gr.Dropdown(['cpu','cuda'],value='cpu',label='Calcul — CUDA refuse si UNIQUE est occupé')
+                train=gr.Button('Lancer le microcycle')
+                train.click(lambda k,c,m,ma,cp,s,d:call('train',{'chunk':c,'mode':m,'mask':ma,
+                    'checkpoint':cp,'steps':int(s),'device':d},k),[key,chunk,mode,mask,checkpoint,steps,device],status)
+                predict=gr.Button('Prédire une autre ROI, disjointe')
+                predict.click(lambda k,c,cp:call('predict',{'chunk':c,'checkpoint':cp},k),[key,chunk,checkpoint],status)
+            with gr.Tab('Export de recherche'):
+                prediction=gr.Textbox(label='Prédiction .prediction.npz correspondante (facultative ; sinon rendu CT)')
+                pixels=gr.Dropdown([256,512,1024,2048],value=1024,label='Pixels de sortie (rééchantillonnage)')
+                export=gr.Button('Exporter PNG, TIFXYZ et provenance en ZIP')
+                export.click(lambda k,m,p,n:call('export',{'mesh':m,'prediction':p,'pixels':int(n)},k),
+                             [key,mesh,prediction,pixels],status)
+                gr.Markdown('Le ZIP reste dans `/data/submissions/vesuvius/`. '
+                            'La conformité Grand Prize n’est pas certifiée : colonnes complètes, validation tenue à part '
+                            'et vérification VC3D restent nécessaires. Aucun envoi aux organisateurs.')
+        halt=gr.Button('Arrêter le job du laboratoire')
+        halt.click(lambda k:{'message':controller.stop()} if authorized(k) else {'error':'clé requise'},key,status)
+        timer=gr.Timer(2)
+        timer.tick(lambda k:controller.status() if authorized(k) else {'status':'lecture protégée'},key,status)

src/unwrapper.py

@@ -0,0 +1,78 @@
+"""Surface candidate et paramétrisation métrique locale avec distorsion mesurée."""
+import json
+import uuid
+
+
+def candidate_surface(volume, origin):
+    import numpy as np
+    from scipy.ndimage import gaussian_filter
+    # Candidat géométrique seulement : cette heuristique ne segmente pas un rouleau entier.
+    smooth=gaussian_filter(volume.astype('float32'),1)
+    z=np.abs(np.gradient(smooth,axis=0)).argmax(axis=0).astype('float32')
+    z=gaussian_filter(z,1)
+    y,x=np.indices(z.shape,dtype='float32')
+    return np.stack([x+origin[2],y+origin[1],z+origin[0]],axis=-1)
+
+
+def flatten(xyz, iterations=30):
+    import numpy as np
+    from scipy.optimize import least_squares
+    from scipy.sparse import lil_matrix
+    xyz=np.asarray(xyz,dtype='float64')
+    if xyz.ndim!=3 or xyz.shape[-1]!=3 or not 2<=min(xyz.shape[:2]) or max(xyz.shape[:2])>64 or not np.isfinite(xyz).all():
+        raise ValueError('surface finie H×W×3 requise ; fenêtre interne maximale 64×64')
+    h,w=xyz.shape[:2]; points=xyz.reshape(-1,3)
+    center=points-points.mean(0)
+    _,_,basis=np.linalg.svd(center,full_matrices=False)
+    uv=center@basis[:2].T
+    # Oriente le chart selon les axes de la grille.
+    if uv[w-1,0]<uv[0,0]: uv[:,0]*=-1
+    if uv[(h-1)*w,1]<uv[0,1]: uv[:,1]*=-1
+    uv-=uv[0]
+    edges=[]
+    for y in range(h):
+        for x in range(w):
+            a=y*w+x
+            if x+1<w:edges.append((a,a+1))
+            if y+1<h:edges.append((a,a+w))
+            if y+1<h and x+1<w:edges.extend([(a,a+w+1),(a+1,a+w)])
+    edge=np.array(edges); lengths=np.linalg.norm(points[edge[:,0]]-points[edge[:,1]],axis=1)
+    if np.min(lengths)<=1e-8: raise ValueError('arêtes dégénérées')
+    anchor=uv[0].copy(); direction=uv[w-1,1]
+    def residual(flat):
+        u=flat.reshape(-1,2)
+        dist=np.linalg.norm(u[edge[:,0]]-u[edge[:,1]],axis=1)
+        return np.r_[(dist-lengths)/lengths, (u[0]-anchor)*10, (u[w-1,1]-direction)*10]
+    sparsity=lil_matrix((len(edges)+3,2*h*w),dtype=int)
+    for i,(a,b) in enumerate(edges):sparsity[i,[2*a,2*a+1,2*b,2*b+1]]=1
+    sparsity[-3,0]=1;sparsity[-2,1]=1;sparsity[-1,2*(w-1)+1]=1
+    fit=least_squares(residual,uv.ravel(),jac_sparsity=sparsity.tocsr(),max_nfev=max(1,min(int(iterations),60)),ftol=1e-5,xtol=1e-5,gtol=1e-5)
+    uv=fit.x.reshape(h,w,2)
+    metric=residual(fit.x)[:-3]
+    a=uv[:-1,1:]-uv[:-1,:-1]; b=uv[1:,:-1]-uv[:-1,:-1]
+    cross=a[...,0]*b[...,1]-a[...,1]*b[...,0]
+    folds=bool(np.any(np.abs(cross)<1e-8) or (np.any(cross>0) and np.any(cross<0)))
+    report={'method':'local_edge_length_least_squares','max_relative_stretch':float(np.max(np.abs(metric))),
+            'rms_relative_stretch':float(np.sqrt(np.mean(metric**2))), 'folds':folds,
+            'converged':bool(fit.success),'isometry_guaranteed':False,'window':[h,w]}
+    return uv.astype('float32'),report
+
+
+def unwrap(storage, chunk_path, surface_path=None):
+    import numpy as np
+    from .loader import read_chunk
+    volume,metadata=read_chunk(storage,chunk_path)
+    if surface_path:
+        path=storage.checked(surface_path,'meshes')
+        if path.stat().st_size>128000:raise ValueError('surface trop volumineuse')
+        xyz=np.load(path,allow_pickle=False)
+        kind='provided_surface'
+    else:
+        xyz=candidate_surface(volume,metadata['request']['origin']);kind='unreviewed_gradient_candidate'
+    uv,quality=flatten(xyz)
+    if quality['folds']:raise ValueError('pli ou dégénérescence détectée dans le chart')
+    artifact=storage.path('meshes',uuid.uuid4().hex+'.npz')
+    np.savez_compressed(artifact,xyz=xyz.astype('float32'),uv=uv,
+                        metadata=json.dumps({'chunk':str(chunk_path),'request':metadata['request'],
+                                             'surface_kind':kind,'quality':quality}))
+    return {'path':str(artifact),'quality':quality,'surface_kind':kind}

src/worker.py

@@ -0,0 +1,50 @@
+"""Entrée de calcul séparée du serveur UNIQUE ; requête et résultat sur /data."""
+import json
+import os
+from pathlib import Path
+import sys
+import traceback
+
+from .storage import Storage
+
+
+def execute(storage, action, payload):
+    if action=='load':
+        from .loader import Loader
+        return Loader(storage).load(payload)
+    if action=='scan':
+        from .loader import read_chunk
+        from .scanner import scan
+        return scan(read_chunk(storage,payload['chunk'])[0],payload.get('tile',16))
+    if action=='unwrap':
+        from .unwrapper import unwrap
+        return unwrap(storage,payload['chunk'],payload.get('surface') or None)
+    if action=='train':
+        from .trainer import train
+        return train(storage,payload['chunk'],payload.get('steps',4),payload.get('mode','reconstruction'),
+                     payload.get('mask') or None,payload.get('checkpoint') or None,payload.get('device','cpu'))
+    if action=='predict':
+        from .trainer import predict
+        return predict(storage,payload['chunk'],payload['checkpoint'])
+    if action=='export':
+        from .exporter import export
+        return export(storage,payload['mesh'],payload.get('prediction') or None,payload.get('pixels',1024))
+    raise ValueError('action inconnue')
+
+
+def main():
+    storage=Storage()
+    storage.initialize()
+    request=storage.checked(sys.argv[1],'chunks')
+    data=json.loads(request.read_text())
+    try:
+        if hasattr(os,'nice'):os.nice(10)
+        result={'ok':True,'result':execute(storage,data['action'],data['payload'])}
+    except Exception as exc:
+        result={'ok':False,'error':type(exc).__name__+': '+str(exc)[:1000]}
+        traceback.print_exc()
+    storage.json('chunks',request.stem+'.result.json',result)
+    return 0 if result['ok'] else 1
+
+
+if __name__=='__main__':raise SystemExit(main())

tests/test_vesuvius.py

@@ -0,0 +1,234 @@
+import asyncio
+import json
+import math
+from pathlib import Path
+import subprocess
+import sys
+import time
+import zipfile
+
+import numpy as np
+import pytest
+
+from src.storage import Storage
+from src.loader import Loader,read_chunk,request_spec
+
+
+@pytest.fixture
+def storage(tmp_path):
+    s=Storage(tmp_path/'data',require_mount=False);s.initialize();return s
+
+
+def spec(origin=(0,0,0),shape=(8,8,8)):
+    return request_spec('s3://vesuvius-challenge-open-data/testing.zarr','0',list(origin),list(shape),7.91)
+
+
+def chunk(storage,origin=(0,0,0)):
+    import zarr
+    data=np.indices((24,24,24)).sum(0).astype('uint16')
+    array=zarr.array(data,chunks=(8,8,8))
+    return Loader(storage,opener=lambda s:array).load(spec(origin))['path']
+
+
+def test_missing_data_mount_fails_closed(tmp_path):
+    with pytest.raises(ValueError):Storage(tmp_path)
+    if not Path('/data').is_mount():
+        with pytest.raises(RuntimeError,match='non monté'):Storage().initialize()
+
+
+def test_storage_blocks_paths_and_symlink_escape(storage,tmp_path):
+    with pytest.raises(ValueError):storage.path('chunks','../private')
+    with pytest.raises(ValueError):storage.checked(tmp_path/'elsewhere','weights')
+    outside=tmp_path/'outside';outside.mkdir()
+    link=storage.folder('chunks')/'link';link.symlink_to(outside,target_is_directory=True)
+    with pytest.raises(ValueError):storage.checked(link/'x.npy','chunks')
+
+
+@pytest.mark.parametrize('uri',['https://evil.example/v.zarr','s3://private/v.zarr',
+    's3://vesuvius-challenge-open-data/a/../v.zarr','s3://vesuvius-challenge-open-data/v.zarr?secret=x'])
+def test_loader_rejects_nonpublic_or_ambiguous_destinations(uri):
+    with pytest.raises(ValueError):request_spec(uri,'0',[0,0,0],[8,8,8],7.91)
+
+
+def test_loader_cache_exact_roi_and_offline_fallback(storage):
+    import zarr
+    array=zarr.array(np.arange(16**3).reshape(16,16,16).astype('uint16'),chunks=(8,8,8))
+    loader=Loader(storage,opener=lambda s:array)
+    first=loader.load(spec());data,meta=read_chunk(storage,first['path'])
+    assert data.shape==(8,8,8) and not meta['cache_fallback']
+    def offline(s):raise OSError('offline')
+    fallback=Loader(storage,opener=offline).load(spec())
+    assert fallback['metadata']['cache_fallback']
+    with pytest.raises(RuntimeError,match='aucun cache exact'):
+        Loader(storage,opener=offline).load(spec(origin=(8,0,0)))
+
+
+def test_roi_and_huge_remote_chunks_are_bounded(storage):
+    with pytest.raises(ValueError):spec(shape=(65,8,8))
+    class Huge:
+        shape=(100,100,100);chunks=(1024,1024,1024);dtype=np.dtype('uint16')
+        def __getitem__(self,x):pytest.fail('huge chunk was materialized')
+    with pytest.raises(ValueError,match='volumineux'):Loader(storage,opener=lambda s:Huge()).load(spec())
+
+
+def test_async_loading_is_supported(storage):
+    import zarr
+    array=zarr.array(np.ones((8,8,8),dtype='uint8'),chunks=(4,4,4))
+    result=asyncio.run(Loader(storage,opener=lambda s:array).load_async(spec()))
+    assert result['shape']==[8,8,8]
+
+
+def test_fft_top_one_percent_and_constant_data():
+    from src.scanner import scan
+    assert scan(np.ones((4,16,16)),8)['selected']==[]
+    y,x=np.indices((32,32))
+    volume=np.stack([np.sin(x*2*np.pi/4)]*4)
+    result=scan(volume,8)
+    assert len(result['selected'])==math.ceil(result['candidates']*.01)
+    assert not result['ink_detected'] and result['selected'][0]['score']>0.8
+
+
+def test_flatten_plane_preserves_metric_and_has_size_guard():
+    from src.unwrapper import flatten
+    y,x=np.indices((5,6));xyz=np.stack([x,y,np.ones_like(x)],axis=-1)
+    uv,report=flatten(xyz)
+    assert uv.shape==(5,6,2) and report['max_relative_stretch']<1e-5
+    assert not report['folds'] and not report['isometry_guaranteed']
+    with pytest.raises(ValueError):flatten(np.zeros((65,5,3)))
+
+
+def test_cpu_hybrid_training_disjoint_prediction_and_overlap_guard(storage):
+    from src.trainer import train,predict
+    first=chunk(storage)
+    second=chunk(storage,origin=(8,0,0))
+    trained=train(storage,first,steps=1,device='cpu')
+    assert trained['report']['precision']=='float32' and trained['report']['initialization']=='random'
+    assert len(trained['report']['loss'])==1 and math.isfinite(trained['report']['loss'][0])
+    with pytest.raises(ValueError,match='recouvrement'):predict(storage,first,trained['path'])
+    predicted=predict(storage,second,trained['path'])
+    assert Path(predicted['path']).is_file() and not predicted['held_out_evaluated']
+
+
+def test_supervised_mode_needs_real_labels(storage):
+    from src.trainer import train
+    first=chunk(storage)
+    with pytest.raises(ValueError,match='annoté'):train(storage,first,steps=1,mode='ink_supervised')
+
+
+def test_research_export_has_matching_xyz_and_provenance(storage):
+    from src.unwrapper import unwrap
+    from src.exporter import export
+    import tifffile
+    first=chunk(storage)
+    xyz_path=storage.path('meshes','plane.npy')
+    y,x=np.indices((8,8),dtype='float32');np.save(xyz_path,np.stack([x,y,np.ones_like(x)*3],axis=-1))
+    mesh=unwrap(storage,first,str(xyz_path))
+    result=export(storage,mesh['path'],pixels=64)
+    assert not result['metadata']['submission_ready']
+    assert result['metadata']['render_kind']=='CT_density_not_ink'
+    with zipfile.ZipFile(result['path']) as z:
+        names=z.namelist()
+        assert 'metadata.json' in names and any(n.endswith('/x.tif') for n in names)
+        assert any(n.endswith('.png') for n in names)
+    folder=Path(result['path']).with_suffix('')
+    tiff=next(folder.rglob('x.tif'))
+    assert tifffile.imread(tiff).shape==(64,64)
+    meta=json.loads((tiff.parent/'meta.json').read_text())
+    assert meta['type']=='seg' and meta['scale'][0]>1 and len(meta['bbox'])==2
+    assert (tiff.parent/'mask.tif').is_file()
+
+
+def test_importing_controller_does_not_load_torch_or_touch_storage(tmp_path):
+    code='import sys; from src.controller import Controller; c=Controller(); assert "torch" not in sys.modules; assert c.status()["status"]=="idle"'
+    result=subprocess.run([sys.executable,'-c',code],capture_output=True,text=True)
+    assert result.returncode==0,result.stderr
+
+
+def test_controller_reserves_no_gpu_when_unique_is_busy(storage):
+    from src.controller import Controller
+    c=Controller(storage,busy=lambda:'mission active')
+    with pytest.raises(RuntimeError,match='prioritaire'):
+        c.start('train',{'device':'cuda'})
+    assert not c.gpu_active
+
+
+def test_gradio_tab_constructs_with_no_data_mount():
+    import gradio as gr
+    from src.controller import Controller
+    from src.ui import build_tab
+    with gr.Blocks(analytics_enabled=False) as app:build_tab(Controller(),lambda k:False)
+    config=app.get_config_file()
+    assert any(c.get('props',{}).get('label')=='Laboratoire Vesuvius 3D' for c in config['components'])
+
+
+def test_gpu_job_is_preempted_and_resource_context_released(storage,monkeypatch):
+    import contextlib
+    from src.controller import Controller
+    import src.controller as module
+    released=[];processes=[]
+    class Process:
+        def __init__(self,*a,**kw):self.done=False;self.terminated=False;processes.append(self)
+        def poll(self):return 0 if self.done else None
+        def terminate(self):self.terminated=True;self.done=True
+        def wait(self,timeout=None):return 0
+        def kill(self):self.done=True
+    @contextlib.contextmanager
+    def resource():
+        try:yield
+        finally:released.append(True)
+    monkeypatch.setattr(module.subprocess,'Popen',Process)
+    c=Controller(storage,busy=lambda:None,preempt=lambda:True,gpu_context=resource,concurrent_uses=lambda:1)
+    c.start('train',{'device':'cuda'})
+    until=time.monotonic()+3
+    while c.status()['status']=='running' and time.monotonic()<until:time.sleep(.01)
+    assert c.status()['status']=='error' and not c.gpu_active
+    assert processes[0].terminated and released
+
+
+def test_gradio_isolated_asgi_config_and_authentication():
+    import gradio as gr
+    from fastapi import FastAPI
+    from fastapi.testclient import TestClient
+    from src.controller import Controller
+    from src.ui import build_tab
+    with gr.Blocks(analytics_enabled=False) as tab:build_tab(Controller(),lambda key:key=='admin')
+    app=gr.mount_gradio_app(FastAPI(),tab,path='/lab')
+    with TestClient(app) as client:
+        response=client.get('/lab/config')
+        assert response.status_code==200
+        assert any(c.get('type')=='plot' for c in response.json()['components'])
+    action=next(f.fn for f in tab.fns.values() if f.fn and f.fn.__name__=='load')
+    assert action('invalid','s3://irrelevant','0','0,0,0',8,7.91)['error']=='clé d’administration requise'
+
+
+def test_lab_gpu_wait_guard_and_original_ui_are_preserved():
+    import ast
+    app=Path('app.py').read_text()
+    tree=ast.parse(app)
+    wait=next(n for n in tree.body if isinstance(n,ast.FunctionDef) and n.name=='mission_gpu_reason')
+    assert 'gpu_active' in ast.unparse(wait)
+    for label in ('Pilotage','Données','Vérifier du code','Agents'):
+        assert f'with gr.Tab("{label}"):' in app
+    assert 'candidate_observer = REMOTE_EXECUTOR.check' in app
+
+
+def test_nonmatching_prediction_cannot_be_exported(storage):
+    from src.unwrapper import unwrap
+    from src.exporter import export
+    first=chunk(storage)
+    xyz_path=storage.path('meshes','plane.npy')
+    y,x=np.indices((8,8),dtype='float32');np.save(xyz_path,np.stack([x,y,np.ones_like(x)*3],axis=-1))
+    mesh=unwrap(storage,first,str(xyz_path))
+    prediction=storage.path('chunks','invalid.prediction.npz')
+    np.savez_compressed(prediction,prediction=np.zeros((8,8)),metadata=json.dumps({'request':spec(origin=(8,0,0))}))
+    with pytest.raises(ValueError,match='correspondent'):export(storage,mesh['path'],str(prediction),pixels=64)
+
+
+def test_worker_scan_runs_in_an_isolated_process(storage):
+    first=chunk(storage)
+    code=('import json;from src.storage import Storage;from src.worker import execute;'
+          f's=Storage({str(storage.root)!r},require_mount=False);'
+          f'print(json.dumps(execute(s,"scan",{{"chunk":{first!r},"tile":4}})))')
+    result=subprocess.run([sys.executable,'-c',code],capture_output=True,text=True,timeout=15)
+    assert result.returncode==0,result.stderr
+    assert json.loads(result.stdout)['method']=='FFT_anisotropy'

unique_ext/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 import os
 
 API_VERSION = 1          # contrat entre le job d'entraînement et ce paquet : le job refuse une autre valeur
-__version__ = "4.12.3"
+__version__ = "4.14.0"
 
 
 def enabled(name: str) -> bool: