[src] fix: fetch QC figures on every load and track them per annotation version

The fetch used to sit in _split_generators, which made it unreachable after a
config's first build: datasets consults the Arrow cache after _info() and skips
_split_generators on a hit, so a machine whose figures had gone stale could not
obtain the current ones by any means short of deleting that cache.

QC figures:
- move the fetch into _ensure_qc_figures and call it from BOTH _info() and
_split_generators. _info() is the only hook a warm-cache load reaches, since
DatasetBuilder.__init__ runs it before the cache directory is consulted --
the same reasoning that put the paused-annotation gate there
- defer in _info() while the dataset's files are absent, so a first install is
served by the _split_generators call site instead. That one runs after step
3.3, whose reorientation pass globs "<dataset_dir>/**/*.nii.gz" recursively and
would otherwise walk hundreds of thousands of freshly extracted PNGs per
dataset for nothing. The two conditions are complementary: a warm cache skips
_split_generators, but having been built at all implies the files are on disk
- memoise per (data root, dataset, requested version): _info() runs once per
config, a sweep constructs hundreds of them over a handful of datasets, and an
annotation-version bump fires both call sites, since planner_version changes
and the config_id is therefore cold
- not covered, and deliberately so: a data directory deleted while its HF cache
is kept. That state already yields rows whose image_file paths do not exist,
and MedVision_FORCE_DOWNLOAD_DATA=True rebuilds out of it
- record "qc_figures_<dataset>" in .downloaded_datasets.json as the biometry
annotation version the figures belong to rather than a bare true, so a release
that regenerates a dataset re-fetches its figures while one that leaves the
dataset alone re-pulls nothing; keying on the release version instead would
invalidate all 295 GB on every release
- resolve the wanted version from the dataset's declared biometry versions --
figures are generated with the biometry plans and their directories carry that
version (Landmarks-Label2-fig-v1.4.0) -- whatever task type the config loads
- fall back to reading those directories when the tracker names no usable
version, which is every install predating v1.4.0: the figures shipped inside
Datasets/<name>.zip then, so such a machine already holds the set but never ran
a figure download to record it
- treat a legacy `true` as "version unknown" so it neither forces a blanket
re-pull nor blocks a genuine refresh; MedVision_FORCE_DOWNLOAD_DATA still
overrides the skip
- keep _figure_versions bounded: os.scandir over only the two directory levels
the archives use, emptiness tested by first entry, so a directory holding
hundreds of thousands of PNGs is never enumerated; an empty one does not count,
since that is the shape a crashed extract leaves behind
- five datasets predate the -fig-v{X} naming (AFIDs, Ceph-Biometrics-400,
FeTA24, PDDCA, VerSe); for them presence is the only on-disk signal, and the
tracker entry is what still lets a later release invalidate them
- keep the directory regex identical to FIG_COMPONENT in
scripts/split_qc_figures.py, which decided what went into those archives
- wrap both call sites in _try_ensure_qc_figures so a Hub failure warns instead
of raising. _info() runs inside DatasetBuilder.__init__, so an exception there
blocked even a fully cached local dataset from loading. Swallowing is safe here
in a way it is not at step 3.2: the tracker entry is written last and only on a
clean pass, so a failure leaves it unwritten and the next load retries, rather
than stamping a marker later runs would trust
- create the data root explicitly rather than relying on filelock to make the
parent of the lock files it opens, which is not a documented guarantee

Configs:
- add the 8 DEEP-PSMA and 4 LNQ2023 tumour/lesion sagittal+coronal configs; every
other T/L dataset already published all three planes

MedVision.py

@@ -452,6 +452,107 @@ def _discover_versions(dataset_dir, kind):
     return sorted(found, key=_version_tuple)
 
 
+# A path COMPONENT that is a QC-figure directory: "Landmarks-Label1-fig-v1.4.0",
+# "Landmarks-fig", "Landmarks-fig-w-projection". Kept identical to FIG_COMPONENT
+# in scripts/split_qc_figures.py, which is what decided the CONTENTS of the _fig
+# archives: a probe that disagreed with the splitter would either call a dataset
+# "already has figures" on directories the archives never carried, or miss the
+# ones they did. The leading hyphen is what keeps this off innocent names --
+# "config" contains "fig" but not "-fig".
+_FIG_COMPONENT = re.compile(r"-fig(?:-|$)")
+
+# The annotation version a figure directory belongs to. Figures are generated
+# alongside the biometry plans and carry the same version, so
+# "Landmarks-Label2-fig-v1.4.0" holds the figures for biometry v1.4.0. Five
+# datasets (AFIDs, Ceph-Biometrics-400, FeTA24, PDDCA, VerSe) predate the
+# convention and have only unversioned directories; they are handled separately
+# rather than being forced into it.
+_FIG_VERSION = re.compile(r"-fig-v(\d+\.\d+\.\d+)$")
+
+
+def _figure_versions(dataset_dir):
+    """QC-figure state on disk: (annotation versions present, any unversioned dir).
+
+    Answers a different question from the tracker's qc_figures_<name> key. The
+    tracker records which version was fetched HERE; this records what is actually
+    on disk, however it arrived. Only the second one covers an install made before
+    v1.4.0, when the figures shipped INSIDE Datasets/<name>.zip: such a machine
+    holds figures already, yet no figure download ever ran on it, so the key
+    cannot exist and the tracker alone would re-pull the entire set.
+
+    Bounded on purpose. Only the two directory levels the archives use are
+    scanned - <dataset>/<figdir> and <dataset>/<subset>/<figdir>, the latter for
+    the subset-bearing datasets (BraTS24/BraTS24-GLI/...). os.scandir, not glob:
+    glob would stat every sibling of every Images/ tree on the way past, and the
+    emptiness test stops at the first entry so a directory holding hundreds of
+    thousands of PNGs is never enumerated.
+
+    A figure directory that exists but is EMPTY does not count. That is the shape
+    a crashed extract leaves behind, and treating it as present would suppress
+    the retry forever. A half-filled one still counts - the same limitation the
+    tracker has always had, since it is written only after a clean pass and a
+    partial extract is indistinguishable from a complete one without a manifest.
+    """
+
+    def _subdirs(path):
+        try:
+            with os.scandir(path) as it:
+                return [e for e in it if e.is_dir()]
+        except OSError:
+            return []
+
+    def _nonempty(path):
+        try:
+            with os.scandir(path) as it:
+                return any(True for _ in it)
+        except OSError:
+            return False
+
+    versions, unversioned = set(), False
+
+    def _record(name, path):
+        nonlocal unversioned
+        if not _nonempty(path):
+            return
+        match = _FIG_VERSION.search(name)
+        if match:
+            versions.add(match.group(1))
+        else:
+            unversioned = True
+
+    for _lvl1 in _subdirs(dataset_dir):
+        if _FIG_COMPONENT.search(_lvl1.name):
+            _record(_lvl1.name, _lvl1.path)
+        else:
+            for _lvl2 in _subdirs(_lvl1.path):
+                if _FIG_COMPONENT.search(_lvl2.name):
+                    _record(_lvl2.name, _lvl2.path)
+    return versions, unversioned
+
+
+def _figures_current(dataset_dir, target):
+    """Whether the figures on disk cover the annotation version being loaded.
+
+    `target` is the biometry version this request resolves to - figures track the
+    biometry plans, so that is the only version that can be asked about. A
+    dataset that publishes no biometry has no figures either, which is `target is
+    None` and is decided by the caller.
+
+    Exact membership, not ">=": the figure archive carries every version's
+    directories at once, so holding v1.4.0 but not the v1.2.0 a pin asked for
+    means the extract is incomplete, and re-fetching is the right answer.
+
+    The unversioned fallback exists for the five datasets whose figures predate
+    the "-fig-v{X}" convention. For them presence is the only signal available;
+    the tracker entry written alongside is what lets a later release still
+    invalidate them.
+    """
+    versions, unversioned = _figure_versions(dataset_dir)
+    if versions:
+        return target in versions
+    return unversioned
+
+
 def _check_biometry_family(dataset_name, task_type):
     """Fail loudly if a dataset's biometry plan could be the wrong family."""
     if _PLAN_KIND_BY_TASKTYPE.get(task_type) != "biometry":
@@ -786,6 +887,189 @@ def _enforce_release_ack(planner_version, latest_version, ack_value=None,
     )
 
 
+# QC figures already handled in THIS process, keyed by (data root, dataset,
+# requested version). _info() runs once per config and a sweep constructs
+# hundreds of them, all resolving to a handful of datasets; without this the
+# directory scan and tracker read repeat for every one of them.
+_QC_FIGURES_DONE = set()
+
+
+def _tracker_read(data_dir, key):
+    """One key out of .downloaded_datasets.json, or None."""
+    path = os.path.join(data_dir, ".downloaded_datasets.json")
+    with FileLock(path + ".lock"):
+        if os.path.exists(path):
+            try:
+                with open(path, "r") as f:
+                    return json.load(f).get(key)
+            except Exception:
+                return None
+    return None
+
+
+def _tracker_write(data_dir, key, value):
+    """Set one key in .downloaded_datasets.json, preserving the rest."""
+    path = os.path.join(data_dir, ".downloaded_datasets.json")
+    with FileLock(path + ".lock"):
+        current = {}
+        if os.path.exists(path):
+            try:
+                with open(path, "r") as f:
+                    current = json.load(f)
+            except Exception:
+                current = {}
+        current[key] = value
+        with open(path, "w") as f:
+            json.dump(current, f)
+
+
+def _try_ensure_qc_figures(dataset_name, requested, data_dir, num_proc):
+    """_ensure_qc_figures, but a failure warns instead of aborting the load.
+
+    The figures are review material -- nothing in this loader reads them and no
+    task needs them -- so a transient Hub error or a half-written archive must not
+    take down a dataset that is otherwise fine. It would otherwise do exactly
+    that: _info() runs inside DatasetBuilder.__init__, so raising here blocks even
+    a fully cached local dataset from loading at all.
+
+    Swallowing is safe here in a way it is NOT at step 3.2, which deliberately
+    lets failures out. That one guards the completion marker: a swallowed error
+    there would stamp "installed" onto a dataset with no images, and every later
+    run would trust it. Here the tracker entry is written last and only on a clean
+    pass, so a failure simply leaves it unwritten and the next load retries.
+    """
+    try:
+        _ensure_qc_figures(dataset_name, requested, data_dir, num_proc)
+    except Exception as exc:
+        logger.warning(
+            "QC figures for %s could not be fetched (%s: %s). The dataset itself "
+            "is unaffected; the next load retries. Set "
+            "MedVision_DOWNLOAD_QC_FIGURES=False to stop trying.",
+            dataset_name, type(exc).__name__, exc,
+        )
+
+
+def _ensure_qc_figures(dataset_name, requested, data_dir, num_proc):
+    """Fetch the per-slice QC figures for one dataset, if they are not current.
+
+    Called from _info(), not from _split_generators: datasets consults the Arrow
+    cache after _info() and short-circuits _split_generators when it hits, so a
+    fetch placed there runs on a config's first build and never again. _info()
+    runs on every load, warm cache or cold.
+
+    Until v1.4.0 the figures shipped inside Datasets/<name>.zip. They are ~99% of
+    that payload -- 298 GB of PNG against 3 GB of annotation -- nothing in this
+    loader reads them, and they pushed BraTS24.zip to 72.6 GB and MSD.zip to
+    51.4 GB, past HuggingFace's 50 GB per-file limit, which is a hard publish
+    failure (HTTP 422). They now ship as Datasets/<name>_fig.zip, or
+    <name>_fig.partNN.zip where a single archive would again clear 50 GB.
+
+    The archives carry the SAME arcnames the figures had inside the dataset
+    archive, so restoring them is the same extractall into the same root: every
+    figure lands back at the path it used to occupy. Shards are independent zips,
+    not `zip -s` volumes, so they extract in any order and a missing one costs
+    only its own figures.
+    """
+    _memo = (data_dir, dataset_name, requested)
+    if _memo in _QC_FIGURES_DONE:
+        return
+    force = (
+        os.environ.get("MedVision_FORCE_DOWNLOAD_DATA", "False").lower() == "true"
+    )
+    dataset_dir = os.path.join(data_dir, "Datasets", dataset_name)
+    # _split_generators creates the data root, but this can run before it -- and
+    # from _info(), which runs before _split_generators exists to be reached at
+    # all. The locks below are created INSIDE data_dir, and filelock only happens
+    # to make their parents; that is not a documented guarantee, so do not depend
+    # on the version installed.
+    os.makedirs(data_dir, exist_ok=True)
+
+    # Datasets/<name>_fig.zip is ONE shared path per dataset and HF's builder lock
+    # is per CONFIG, so two configs of one dataset would otherwise download the
+    # same gigabytes twice into the same staging path and race at os.remove.
+    # Lock order is always zip-lock -> tracker-lock, matching step 3.1.
+    with FileLock(os.path.join(data_dir, f".{dataset_name}_fig.zip.lock")):
+        _tracked = _tracker_read(data_dir, f"qc_figures_{dataset_name}")
+
+        # Which figures this request wants. Figures are generated with the
+        # biometry plans and carry their version, so the biometry resolution is
+        # what decides whether what is on disk is current -- whatever task type
+        # the config loads. Resolved per DATASET, exactly as annotations are: a
+        # release that did not regenerate this dataset leaves the version
+        # unchanged and must not invalidate its figures. Keying on the release
+        # version instead would re-pull all 295 GB on every release.
+        target = _resolve(_declared_versions(dataset_name, "biometry"), requested)
+
+        if target is None:
+            # No biometry annotations, so no QC figures are published for this
+            # dataset. Any truthy entry means the Hub was already asked; keep
+            # taking that answer rather than re-querying on every load.
+            current = bool(_tracked)
+        else:
+            # The tracker settles it only when it names a version at least as new
+            # as the one wanted. A legacy `true` names none, so it falls through
+            # to the disk -- which is version-aware, and so can still skip the
+            # download when the figures really are there. That keeps the
+            # pre-v1.4.0 installs (figures shipped inside Datasets/<name>.zip, no
+            # key ever written) from re-pulling a set they already hold.
+            current = (
+                _is_version(_tracked)
+                and _version_tuple(_tracked) >= _version_tuple(target)
+            ) or _figures_current(dataset_dir, target)
+
+        stamp = target if target is not None else True
+
+        if current and not force:
+            logger.info(
+                " - QC figures for %s already cover annotation v%s; skipping",
+                dataset_name, target,
+            )
+            if _tracked != stamp:
+                _tracker_write(data_dir, f"qc_figures_{dataset_name}", stamp)
+            _QC_FIGURES_DONE.add(_memo)
+            return
+
+        logger.info("Downloading QC figures for %s...", dataset_name)
+        _datasets_root = os.path.join(data_dir, "Datasets")
+        snapshot_download(
+            repo_id="YongchengYAO/MedVision",
+            repo_type="dataset",
+            allow_patterns=[
+                f"Datasets/{dataset_name}_fig.zip",
+                f"Datasets/{dataset_name}_fig.part*.zip",
+            ],
+            local_dir=data_dir,
+            max_workers=num_proc,
+        )
+        _fig_zips = sorted(
+            glob.glob(os.path.join(_datasets_root, f"{dataset_name}_fig.zip"))
+            + glob.glob(os.path.join(_datasets_root, f"{dataset_name}_fig.part*.zip"))
+        )
+        # Roughly half the datasets have no figures at all. Record the attempt
+        # anyway so a figure-less dataset does not re-query the Hub on every
+        # single load; MedVision_FORCE_DOWNLOAD_DATA is the way back if figures
+        # are published for it later.
+        if not _fig_zips:
+            logger.info(" - No QC figures are published for %s", dataset_name)
+        else:
+            for _fig_zip in _fig_zips:
+                with zipfile.ZipFile(_fig_zip, "r") as zip_ref:
+                    zip_ref.extractall(_datasets_root)
+                os.remove(_fig_zip)
+            logger.info(
+                " - QC figures restored to %s from %d archive(s)",
+                dataset_dir, len(_fig_zips),
+            )
+        # Written last, and only on a clean pass: a crash mid-extract leaves the
+        # entry untouched, so the next load redoes the whole download and
+        # extractall overwrites whatever landed. The value is the annotation
+        # version these figures belong to, so a later release that regenerates
+        # this dataset supersedes it; True only where the dataset publishes no
+        # biometry at all and there is no version to name.
+        _tracker_write(data_dir, f"qc_figures_{dataset_name}", stamp)
+        _QC_FIGURES_DONE.add(_memo)
+
+
 class MedVisionConfig(BuilderConfig):
     """BuilderConfig for MedVision."""
 
@@ -9660,6 +9944,46 @@ class MedVision(GeneratorBasedBuilder):
             split="test",
         ),
         # DEEP-PSMA:Tumor-Lesion-Size:Task01
+        MedVisionConfig(
+            name="DEEP-PSMA_TumorLesionSize_Task01_Sagittal_Train",
+            dataset_name="DEEP-PSMA",
+            taskType="Tumor-Lesion-Size",
+            taskID="01",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="sagittal",
+            split="train",
+        ),
+        MedVisionConfig(
+            name="DEEP-PSMA_TumorLesionSize_Task01_Sagittal_Test",
+            dataset_name="DEEP-PSMA",
+            taskType="Tumor-Lesion-Size",
+            taskID="01",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="sagittal",
+            split="test",
+        ),
+        MedVisionConfig(
+            name="DEEP-PSMA_TumorLesionSize_Task01_Coronal_Train",
+            dataset_name="DEEP-PSMA",
+            taskType="Tumor-Lesion-Size",
+            taskID="01",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="coronal",
+            split="train",
+        ),
+        MedVisionConfig(
+            name="DEEP-PSMA_TumorLesionSize_Task01_Coronal_Test",
+            dataset_name="DEEP-PSMA",
+            taskType="Tumor-Lesion-Size",
+            taskID="01",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="coronal",
+            split="test",
+        ),
         MedVisionConfig(
             name="DEEP-PSMA_TumorLesionSize_Task01_Axial_Train",
             dataset_name="DEEP-PSMA",
@@ -9681,6 +10005,46 @@ class MedVision(GeneratorBasedBuilder):
             split="test",
         ),
         # DEEP-PSMA:Tumor-Lesion-Size:Task02
+        MedVisionConfig(
+            name="DEEP-PSMA_TumorLesionSize_Task02_Sagittal_Train",
+            dataset_name="DEEP-PSMA",
+            taskType="Tumor-Lesion-Size",
+            taskID="02",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="sagittal",
+            split="train",
+        ),
+        MedVisionConfig(
+            name="DEEP-PSMA_TumorLesionSize_Task02_Sagittal_Test",
+            dataset_name="DEEP-PSMA",
+            taskType="Tumor-Lesion-Size",
+            taskID="02",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="sagittal",
+            split="test",
+        ),
+        MedVisionConfig(
+            name="DEEP-PSMA_TumorLesionSize_Task02_Coronal_Train",
+            dataset_name="DEEP-PSMA",
+            taskType="Tumor-Lesion-Size",
+            taskID="02",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="coronal",
+            split="train",
+        ),
+        MedVisionConfig(
+            name="DEEP-PSMA_TumorLesionSize_Task02_Coronal_Test",
+            dataset_name="DEEP-PSMA",
+            taskType="Tumor-Lesion-Size",
+            taskID="02",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="coronal",
+            split="test",
+        ),
         MedVisionConfig(
             name="DEEP-PSMA_TumorLesionSize_Task02_Axial_Train",
             dataset_name="DEEP-PSMA",
@@ -10007,6 +10371,46 @@ class MedVision(GeneratorBasedBuilder):
             split="test",
         ),
         # LNQ2023:Tumor-Lesion-Size:Task01
+        MedVisionConfig(
+            name="LNQ2023_TumorLesionSize_Task01_Sagittal_Train",
+            dataset_name="LNQ2023",
+            taskType="Tumor-Lesion-Size",
+            taskID="01",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="sagittal",
+            split="train",
+        ),
+        MedVisionConfig(
+            name="LNQ2023_TumorLesionSize_Task01_Sagittal_Test",
+            dataset_name="LNQ2023",
+            taskType="Tumor-Lesion-Size",
+            taskID="01",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="sagittal",
+            split="test",
+        ),
+        MedVisionConfig(
+            name="LNQ2023_TumorLesionSize_Task01_Coronal_Train",
+            dataset_name="LNQ2023",
+            taskType="Tumor-Lesion-Size",
+            taskID="01",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="coronal",
+            split="train",
+        ),
+        MedVisionConfig(
+            name="LNQ2023_TumorLesionSize_Task01_Coronal_Test",
+            dataset_name="LNQ2023",
+            taskType="Tumor-Lesion-Size",
+            taskID="01",
+            imageType="2D",
+            features_dict=features_dict_TumorLesionSize,
+            imageSliceType="coronal",
+            split="test",
+        ),
         MedVisionConfig(
             name="LNQ2023_TumorLesionSize_Task01_Axial_Train",
             dataset_name="LNQ2023",
@@ -11184,6 +11588,56 @@ class MedVision(GeneratorBasedBuilder):
                 _paused_versions(self.config.dataset_name, _kind),
             )
 
+        # QC figures, opt-in and off by default. This sits in _info() rather than
+        # in _split_generators for the same reason the pause gate above does: this
+        # is the only point EVERY load passes through. datasets calls _info() from
+        # DatasetBuilder.__init__, before the cache directory is consulted, while a
+        # config that already has an Arrow cache never reaches _split_generators at
+        # all. Fetching figures there meant they were obtained on a config's first
+        # build and never again, so a machine holding stale figures could not get
+        # the current ones by any means short of deleting its cache.
+        #
+        # Ordering against the data download is not a concern: the figure archives
+        # extract into Datasets/<name>/ on their own, and the version they are
+        # checked against comes from _ANNOTATION_INDEX, which touches neither disk
+        # nor network. Everything here is behind the opt-in flag, so the default
+        # path is unchanged -- including MedVision_PLANNER_VERSION, which is only
+        # required (via _normalize_requested) once the flag is on, and is required
+        # for the load itself regardless.
+        # Deferred when the dataset's own files are not on disk yet, because that
+        # is a first install: no Arrow cache can exist for a config that has never
+        # been built, so _split_generators is guaranteed to run and its call site
+        # fetches the figures AFTER step 3.3. That ordering matters -- the
+        # reorientation pass globs "<dataset_dir>/**/*.nii.gz" recursively, and
+        # figures extracted before it turn that into a walk over hundreds of
+        # thousands of PNGs per dataset. Nothing is modified (only .nii.gz
+        # matches), it is purely wasted stat traffic.
+        #
+        # Conversely, a warm cache implies the dataset was built successfully,
+        # which implies its files ARE on disk -- so the branch that skips
+        # _split_generators is exactly the branch this one covers. A version bump
+        # satisfies both: it changes planner_version in the config fingerprint, so
+        # the cache is cold and both call sites fire, with _QC_FIGURES_DONE making
+        # the second a no-op.
+        #
+        # Not covered: a data directory deleted while its HF cache is kept. That
+        # state already yields rows whose image_file paths do not exist, and
+        # MedVision_FORCE_DOWNLOAD_DATA=True rebuilds out of it.
+        if (
+            os.environ.get("MedVision_DOWNLOAD_QC_FIGURES", "False").lower()
+            == "true"
+        ) and os.path.isdir(
+            os.path.join(_data_root(), "Datasets", self.config.dataset_name)
+        ):
+            _try_ensure_qc_figures(
+                self.config.dataset_name,
+                _normalize_requested(
+                    os.environ.get("MedVision_PLANNER_VERSION"), self.config.version
+                ),
+                _data_root(),
+                self.config.num_proc,
+            )
+
         # Define dataset information including feature schema
         dataset_description = f"You are using the configuration <{self.config.name}> of the <{self.config.dataset_name}> dataset."
         return DatasetInfo(
@@ -11592,96 +12046,18 @@ class MedVision(GeneratorBasedBuilder):
                 _discover_versions(dataset_dir, _kind),
             )
 
-        # 3.5 QC figures — opt-in, off by default.
-        #
-        # Until v1.4.0 the per-slice QC figures shipped inside Datasets/<name>.zip.
-        # They are ~99% of that payload — 298 GB of PNG against 3 GB of annotation —
-        # nothing in this loader reads them, and they pushed BraTS24.zip to 72.6 GB
-        # and MSD.zip to 51.4 GB, past HuggingFace's 50 GB per-file limit. That is a
-        # hard publish failure (HTTP 422), not merely a slow download. The figures
-        # now ship as Datasets/<name>_fig.zip, or <name>_fig.partNN.zip where a
-        # single archive would again clear 50 GB.
-        #
-        # The archives carry the SAME arcnames the figures had inside the dataset
-        # archive, so restoring them is the same extractall into the same root: every
-        # figure lands back at the path it used to occupy. Nothing is relocated
-        # afterwards, so there is no path mapping here that can drift out of step
-        # with whatever wrote the archives. Shards are independent zips, not `zip -s`
-        # volumes, so they extract in any order and a missing one costs only its own
-        # figures.
-        #
-        # This sits OUTSIDE the `_needs_download` block deliberately. A user who sets
-        # the flag on a machine whose annotations are already present takes the
-        # "using existing dataset" branch above, and would otherwise never get the
-        # figures at all.
+        # 3.5 QC figures -- one of TWO call sites, and the one that serves a first
+        # install. It runs here, after step 3.3, so the reorientation glob above
+        # does not walk the figure tree. _info() holds the other call site and
+        # covers the case this method cannot: a config with a warm Arrow cache
+        # never reaches _split_generators at all, so a fetch placed only here ran
+        # on a config's first build and never again -- which is what made stale
+        # figures impossible to refresh. _QC_FIGURES_DONE keeps whichever call
+        # comes second from repeating the work.
         if download_qc_figures:
-            _fig_lock_file = os.path.join(
-                MedVision_data_dir, f".{dataset_name}_fig.zip.lock"
+            _try_ensure_qc_figures(
+                dataset_name, _requested, MedVision_data_dir, self.config.num_proc
             )
-            with FileLock(_fig_lock_file):
-                # Re-read the tracker inside the lock instead of trusting the copy
-                # loaded at entry: a sibling config of the same dataset may have
-                # fetched the figures while this process waited. Lock order stays
-                # zip-lock -> tracker-lock, matching step 3.1, so it cannot invert.
-                _figs_present = False
-                with FileLock(dataset_cache_lock_file):
-                    if os.path.exists(dataset_cache_file):
-                        try:
-                            with open(dataset_cache_file, "r") as f:
-                                _figs_present = bool(
-                                    json.load(f).get(f"qc_figures_{dataset_name}")
-                                )
-                        except Exception:
-                            _figs_present = False
-
-                if _figs_present and not force_download_data:
-                    logger.info(
-                        f" - QC figures for {dataset_name} already on disk; skipping"
-                    )
-                else:
-                    logger.info(f"Downloading QC figures for {dataset_name}...")
-                    _datasets_root = os.path.join(MedVision_data_dir, "Datasets")
-                    snapshot_download(
-                        repo_id="YongchengYAO/MedVision",
-                        repo_type="dataset",
-                        allow_patterns=[
-                            f"Datasets/{dataset_name}_fig.zip",
-                            f"Datasets/{dataset_name}_fig.part*.zip",
-                        ],
-                        local_dir=MedVision_data_dir,
-                        max_workers=self.config.num_proc,
-                    )
-                    _fig_zips = sorted(
-                        glob.glob(
-                            os.path.join(_datasets_root, f"{dataset_name}_fig.zip")
-                        )
-                        + glob.glob(
-                            os.path.join(
-                                _datasets_root, f"{dataset_name}_fig.part*.zip"
-                            )
-                        )
-                    )
-                    # Roughly half the datasets have no figures at all. Record the
-                    # attempt anyway so a figure-less dataset does not re-query the
-                    # Hub on every single load; MedVision_FORCE_DOWNLOAD_DATA is the
-                    # way back if figures are published for it later.
-                    if not _fig_zips:
-                        logger.info(
-                            f" - No QC figures are published for {dataset_name}"
-                        )
-                    else:
-                        for _fig_zip in _fig_zips:
-                            with zipfile.ZipFile(_fig_zip, "r") as zip_ref:
-                                zip_ref.extractall(_datasets_root)
-                            os.remove(_fig_zip)
-                        logger.info(
-                            f" - QC figures restored to {dataset_dir} from "
-                            f"{len(_fig_zips)} archive(s)"
-                        )
-                    # Written last, and only on a clean pass: a crash mid-extract
-                    # leaves the flag unset, so the next load redoes the whole
-                    # download and extractall overwrites whatever landed.
-                    _update_download_status(f"qc_figures_{dataset_name}", True)
 
         # 4. Get the benchmark planner file - this is config specific but should use existing files if possible
         # NOTE: MUST NOT move the import to the front, as the "medvision_ds" package may not be installed yet at the beginning