MedVision.py

import os
import re
import sys
import glob
import hashlib
import inspect
import subprocess
import gzip
import json
import zipfile
import importlib
import datasets
from datasets import (
    BuilderConfig,
    GeneratorBasedBuilder,
    SplitGenerator,
    Split,
    DatasetInfo,
    Features,
    Value,
    Sequence,
)
from huggingface_hub import snapshot_download
from filelock import FileLock


if os.environ.get("MedVision_DATA_DIR") is None:
    raise ValueError(
        "Environment variable MedVision_DATA_DIR must be set to specify download directory"
    )

logger = datasets.logging.get_logger("MedVision")

# Set parameters
RAMDOM_SEED = 1024
SPLIT_TRAIN_RATIO = 0.7

_CITATION = """\
@misc{yao2026medvisionbenchmarkingquantitativemedical,
      title={MedVision: Benchmarking Quantitative Medical Image Analysis}, 
      author={Yongcheng Yao and Yongshuo Zong and Raman Dutt and Yongxin Yang and Sotirios A Tsaftaris and Timothy Hospedales},
      year={2026},
      eprint={2511.18676},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2511.18676}, 
}
"""

_DESCRIPTION = """\
This is the official release of the MedVision dataset.
Project: https://medvision-vlm.github.io
"""

_HOME_PAGE = "https://huggingface.co/datasets/YongchengYAO/MedVision"

_LICENSE = "CC-BY 4.0"

# ---------------------------------------------------------------------------
# Annotation version control
#
# Two different things must never be conflated:
#   * the RELEASE version  - MedVisionConfig.version, a property of this repo,
#     which advances on every release;
#   * the ANNOTATION version - the "_v{X}" in benchmark_plan_{kind}_v{X}.json.gz,
#     a property of a (dataset, plan-kind) pair, which advances only when that
#     pair's plan is actually regenerated.
#
# Resolution rule: for each (dataset, plan-kind), load the newest published
# annotation version <= the requested version. That is what a reproducibility
# pin means - "the annotations as they stood at release R" - and it is uniform
# across task types.
# ---------------------------------------------------------------------------

_VERSION_RE = re.compile(r"^\d+\.\d+\.\d+$")


def _version_tuple(v):
    """Parse "1.1.0" -> (1, 1, 0), zero-padded/truncated to three components.

    Any non-version value collapses to the v1.0.0 baseline. That branch is the
    published contract for the legacy boolean ``true`` entries written by
    pre-v1.1.0 download caches - see "Backward compatibility with legacy boolean
    entries" in doc/release-v1.1.0.md. It is reached only by cache values;
    requested versions and filename captures are validated by _is_version first.
    """
    try:
        parts = tuple(map(int, str(v).split(".")))
    except Exception:
        return (1, 0, 0)
    return (parts + (0, 0, 0))[:3]


def _is_version(v):
    """True for a strict three-component version string such as "1.2.0"."""
    return bool(_VERSION_RE.match(str(v)))


# Task type -> the plan-kind whose file carries its annotations. A pure lookup,
# so plan-kind is known before medvision_ds is installed; the planner-class
# dispatch in _split_generators keeps using the package's own get_bm_plan_file.
_PLAN_KIND_BY_TASKTYPE = {
    "Mask-Size": "segmentation",
    "Box-Size": "detection",
    "Tumor-Lesion-Size": "biometry",
    "Biometrics-From-Landmarks": "biometry",
    "Biometrics-From-Landmarks-Distance": "biometry",
    "Biometrics-From-Landmarks-Angle": "biometry",
}

# Annotation versions published per (dataset, plan-kind), ascending.
#
# This is authoritative for every decision taken BEFORE the data is on disk -
# the cache fingerprint, the acknowledgement gate, and whether a newer plan is
# available for download. Globbing cannot serve those: it sees only local files,
# so it cannot distinguish "v1.0.0 is the newest that exists for this pair" from
# "v1.0.0 is merely the newest I happen to have", and would silently skip a
# needed upgrade. The on-disk glob remains authoritative for the file actually
# opened, and _split_generators reconciles the two.
#
# MedVision.py is re-fetched from the hub on every load_dataset, so this table is
# always as current as the data it describes.
_ANNOTATION_INDEX = {
    "AbdomenAtlas1.0Mini": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "AbdomenCT-1K": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "ACDC": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "AFIDs": {"biometry": ("1.2.0",)},
    "AMOS22": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "autoPET-III": {"segmentation": ("1.0.0",), "detection": ("1.0.0",), "biometry": ("1.0.0", "1.1.0", "1.1.1", "1.4.0")},
    "BCV15": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "BraTS24": {"segmentation": ("1.0.0",), "detection": ("1.0.0",), "biometry": ("1.0.0", "1.1.0", "1.1.1", "1.4.0")},
    "CAMUS": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "Ceph-Biometrics-400": {"biometry": ("1.0.0",)},
    "CrossMoDA": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "DEEP-PSMA": {"segmentation": ("1.2.0",), "detection": ("1.2.0",), "biometry": ("1.2.0", "1.4.0")},
    "FeTA24": {"segmentation": ("1.0.0",), "detection": ("1.0.0",), "biometry": ("1.0.0",)},
    "FLARE22": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "HNTSMRG24": {"segmentation": ("1.0.0",), "detection": ("1.0.0",), "biometry": ("1.0.0", "1.1.0", "1.1.1", "1.4.0")},
    "ISLES24": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "KiPA22": {"segmentation": ("1.0.0",), "detection": ("1.0.0",), "biometry": ("1.0.0", "1.1.0", "1.1.1", "1.4.0")},
    "KiTS23": {"segmentation": ("1.0.0",), "detection": ("1.0.0",), "biometry": ("1.0.0", "1.1.0", "1.1.1", "1.4.0")},
    "LIDC-IDRI": {"segmentation": ("1.2.0",), "detection": ("1.2.0",), "biometry": ("1.2.0", "1.4.0")},
    "LNQ2023": {"segmentation": ("1.2.0",), "detection": ("1.2.0",), "biometry": ("1.2.0", "1.4.0")},
    "MAMA-MIA": {"segmentation": ("1.2.1",), "detection": ("1.2.1",), "biometry": ("1.2.1", "1.4.0")},
    "MSD": {"segmentation": ("1.0.0",), "detection": ("1.0.0",), "biometry": ("1.0.0", "1.1.0", "1.1.1", "1.4.0")},
    "MSWAL": {"segmentation": ("1.3.0",), "detection": ("1.3.0",), "biometry": ("1.3.0", "1.4.0")},
    "OAIZIB-CM": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "PDDCA": {"segmentation": ("1.2.0",), "detection": ("1.2.0",), "biometry": ("1.2.0",)},
    "PI-CAI": {"segmentation": ("1.2.1",), "detection": ("1.2.1",), "biometry": ("1.2.1", "1.4.0")},
    "SKM-TEA": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "ToothFairy2": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "TopCoW24": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "TotalSegmentator": {"segmentation": ("1.0.0",), "detection": ("1.0.0",)},
    "VerSe": {"segmentation": ("1.2.0",), "detection": ("1.2.0",), "biometry": ("1.2.0",)},
}

# Annotation versions that are STILL PUBLISHED but MUST NOT be loaded, keyed by
# dataset then by plan-kind - the same shape as _ANNOTATION_INDEX above.
#
# The plan-kind level is load-bearing, not decoration. A defect is usually found
# in one planner, and the datasets it touches almost always publish other kinds at
# the SAME version number: pausing "VerSe 1.2.0" outright would withhold VerSe's
# segmentation and detection too, neither of which the defect touches.
#
# Pausing and withdrawing are different states, and the difference is which table
# an entry belongs in:
#
#   PAUSED     - the file is still on the hub, but is known or suspected to be
#                wrong. It stays listed in _ANNOTATION_INDEX (that table states
#                what the hub holds) and is named here. Loading it raises
#                _annotation_paused_error; resolution is otherwise untouched, so
#                a pin to it still resolves and is refused downstream rather than
#                silently sliding to an older version. Use this while an
#                investigation is open, when removing the file is premature.
#
#   WITHDRAWN  - the file has been deleted from the hub. It is removed from
#                _ANNOTATION_INDEX and does NOT belong here: there is nothing
#                left to withhold, and listing it would make the on-disk
#                reconciliation in scripts/test_annotation_resolution.py expect
#                a file that no longer exists. A pin at or below the withdrawn
#                version then resolves to whatever older version remains, or
#                raises the "introduced after your pin" error if none does.
#
# Worked example of the paused -> withdrawn transition: MAMA-MIA and PI-CAI
# shipped v1.2.0 with annotations recorded in the source orientation rather than
# RAS+, so both were paused here while v1.2.1 was prepared. Once v1.2.1 was
# published the v1.2.0 files were deleted from the hub, which moved them from
# paused to withdrawn - so they left this table and their index entries above.
#
# Entries are scoped by version, not by dataset, so a pause expires on its own:
# the correction ships as a NEW version (a published plan is never rewritten in
# place), and once that version is in the index the dataset loads again without
# this gate being edited.
#
# Current entries - the angle/distance (A/D) biometry plans of AFIDs, PDDCA and
# VerSe, paused 2026-08-16. An audit found that the planner records each
# measurement against a slice index taken from its FIRST landmark only, with no
# co-planarity check, while the value itself is a full 3-D length or angle. 1652
# of 2064 released items (80.0%) therefore name a slice that does not contain the
# measurement, which makes them unanswerable from the image the model is shown.
# Only the biometry kind is affected: the same defect cannot reach segmentation
# or detection, which is why those stay loadable at the same version number.
_PAUSED_ANNOTATIONS = {
    "AFIDs": {"biometry": ("1.2.0",)},
    "PDDCA": {"biometry": ("1.2.0",)},
    "VerSe": {"biometry": ("1.2.0",)},
}


# Annotation versions that WERE published and have since been deleted from the hub,
# with the reason. Keyed by dataset, then by the withdrawn version.
#
# This table is documentation, not policy: withdrawal is expressed by absence from
# _ANNOTATION_INDEX, and nothing in version resolution reads this. It exists only so
# the error banner can tell the truth. Without it, absence from the index is
# indistinguishable from "this dataset did not exist yet", and someone holding a
# v1.2.0 cache would be told the annotations never existed - false, and it sends them
# looking for the wrong problem.
#
# Entries stay forever. A version number is never reused, so the record of what
# happened to it stays valid, and a user resurrecting an old pin years later still
# gets an accurate answer.
_WITHDRAWN_ANNOTATIONS = {
    "MAMA-MIA": {
        "1.2.0": "annotations were recorded in the source image orientation, not RAS+",
    },
    "PI-CAI": {
        "1.2.0": "annotations were recorded in the source image orientation, not RAS+",
    },
}

# MedVision_BenchmarkPlannerBiometry (landmark) and
# MedVision_BenchmarkPlannerBiometry_fromSeg (tumour/lesion) emit the SAME
# filename, benchmark_plan_biometry_v{X}.json.gz. That is safe only while no
# dataset carries both families. This table makes the assumption executable
# instead of tacit, so a future dataset that acquires both fails loudly here
# rather than silently loading the wrong family's plan.
_BIOMETRY_FAMILY = {
    "AFIDs": "landmark",
    "autoPET-III": "fromSeg",
    "BraTS24": "fromSeg",
    "Ceph-Biometrics-400": "landmark",
    "DEEP-PSMA": "fromSeg",
    "FeTA24": "landmark",
    "HNTSMRG24": "fromSeg",
    "KiPA22": "fromSeg",
    "KiTS23": "fromSeg",
    "LIDC-IDRI": "fromSeg",
    "LNQ2023": "fromSeg",
    "MAMA-MIA": "fromSeg",
    "MSD": "fromSeg",
    "MSWAL": "fromSeg",
    "PDDCA": "landmark",
    "PI-CAI": "fromSeg",
    "VerSe": "landmark",
}


def _data_root(strict=True):
    """Canonical absolute MedVision_DATA_DIR.

    Absolute because dataset_dir derived from it is handed to the per-dataset
    download scripts, which each begin with their own os.chdir(dataset_dir) -
    after _split_generators has already chdir'd there. A relative root makes the
    second chdir resolve against the first one's result and fail, for every
    dataset. Normalised so that two spellings of one root ("/d", "/d/", "/./d")
    do not get two Arrow caches.

    strict=False never raises: create_config_id runs at builder construction and
    must not fail there. The blank guard is load-bearing - the import-time check
    tests only `is None`, and a bare abspath("") would silently promote the
    caller's cwd to the data root.
    """
    raw = (os.environ.get("MedVision_DATA_DIR") or "").strip()
    if not raw:
        if strict:
            raise ValueError(
                "MedVision_DATA_DIR must be set to a non-empty download directory"
            )
        return ""
    try:
        return os.path.normpath(os.path.abspath(os.path.expanduser(raw)))
    except OSError:  # e.g. cwd deleted -> abspath raises; never break construction
        if strict:
            raise
        return raw


def _published_versions():
    """Every annotation version any dataset publishes, ascending.

    Derived from _ANNOTATION_INDEX rather than hand-listed, so it cannot fall out
    of step with the index it summarises.
    """
    return tuple(sorted(
        {v for kinds in _ANNOTATION_INDEX.values() for vs in kinds.values() for v in vs},
        key=_version_tuple,
    ))


def _acceptable_versions(release_version):
    """Values MedVision_PLANNER_VERSION may take, besides 'latest'.

    The published annotation versions, plus the release version itself. The
    release must be included even when nothing is published at it: 'latest'
    resolves to the release, so a version bump made before any dataset is
    regenerated would otherwise make 'latest' unusable.
    """
    return tuple(sorted(
        set(_published_versions()) | {str(release_version)}, key=_version_tuple
    ))


# What changed in each annotation version, for the error banners. The SET of
# accepted values is derived from _ANNOTATION_INDEX, never from this dict, so a
# version added to the index without a note here is still listed (just bare)
# rather than silently missing.
_VERSION_NOTES = {
    "1.4.0": "regenerates all 12 TL datasets: mm size floor replaces pixel count (50x landmarks)",
    "1.3.0": "adds MSWAL (484 abdominal CT cases, 7-class lesion masks)",
    "1.2.1": "corrects MAMA-MIA and PI-CAI to RAS+ (their v1.2.0 is withdrawn)",
    "1.2.0": "adds 8 datasets (MAMA-MIA and PI-CAI have no 1.2.0 annotation - use 1.2.1)",
    "1.1.1": "fixes transposed in-plane voxel spacing in the TL ellipse fit",
    "1.1.0": "corrected TL filtering, cluster threshold 20px",
    "1.0.0": "original TL filtering, cluster threshold 200px",
}


def _accepted_values_block(acceptable, release_version):
    """The 'Accepted values' listing shared by the unset and unknown-pin errors."""
    release_version = str(release_version)
    published = set(_published_versions())
    rows = [("latest", f"resolves to {release_version}")]
    for v in reversed(acceptable):
        note = _VERSION_NOTES.get(v, "")
        if v == release_version:
            tag = "current release" if v in published else "current release, nothing published at it yet"
            note = f"{note} [{tag}]" if note else f"[{tag}]"
        rows.append((v, note))
    width = max(len(label) for label, _ in rows)
    return "".join(
        (f"   {label:<{width}}  — {note}\n" if note else f"   {label}\n")
        for label, note in rows
    )


def _plan_path(dataset_dir, kind, version):
    """Mirror the plan filename convention of medvision_ds.utils.benchmark_planner.

    _split_generators asserts this agrees with the package's own
    get_bm_plan_file, so the duplicated convention cannot drift silently.
    """
    return os.path.join(dataset_dir, f"benchmark_plan_{kind}_v{version}.json.gz")


def _resolve(versions, requested):
    """Newest version in `versions` that is <= `requested`, else None."""
    # `requested` is parsed once rather than once per candidate; max() keeps the
    # key= form so ties (two spellings of one version, e.g. "1.2.0"/"01.2.0")
    # still resolve to the first, as before.
    ceiling = _version_tuple(requested)
    eligible = [v for v in versions if _version_tuple(v) <= ceiling]
    return max(eligible, key=_version_tuple) if eligible else None


def _download_needed(force, tracker_entry, local, target):
    """Whether the raw data must be (re)fetched.

    Module-level and pure so the decision can be exercised directly rather than
    through a copy in the test suite. The four inputs are, in order: the user's
    force flag; this dataset's `.downloaded_datasets.json` entry (None when no
    install ever completed - the marker is written only after the images land,
    so its absence catches a run that died mid-download); the newest annotation
    version present on disk for this request; and the newest the published index
    can offer for it.
    """
    return bool(
        force
        or tracker_entry is None
        or local is None
        or _version_tuple(local) < _version_tuple(target)
    )


def _declared_versions(dataset_name, kind):
    """Versions the index says are published for this (dataset, plan-kind)."""
    return tuple(_ANNOTATION_INDEX.get(dataset_name, {}).get(kind, ()))


def _newest_declared(dataset_name, kind):
    declared = _declared_versions(dataset_name, kind)
    return max(declared, key=_version_tuple) if declared else None


def _paused_versions(dataset_name, kind):
    """Versions of this (dataset, plan-kind) published but withheld from loading.

    Scoped by kind for the same reason resolution is: a defect lives in one
    planner, so withholding must not reach the other kinds this dataset
    publishes at the same version number.
    """
    return tuple(_PAUSED_ANNOTATIONS.get(dataset_name, {}).get(kind, ()))


def _withdrawn_at_or_below(dataset_name, requested):
    """Withdrawn versions this pin would have resolved to, newest first.

    Only versions at or below the pin matter: a version withdrawn ABOVE the pin was
    never reachable from it, so mentioning it would explain nothing.
    """
    entries = _WITHDRAWN_ANNOTATIONS.get(dataset_name, {})
    hits = [v for v in entries if _version_tuple(v) <= _version_tuple(requested)]
    return sorted(hits, key=_version_tuple, reverse=True)


def _fully_paused(dataset_name, kind):
    """True when nothing this (dataset, plan-kind) publishes may be loaded.

    Answered without the requested version, so it holds however the pin is set -
    including unset, which is what makes it usable from _info().
    """
    declared = _declared_versions(dataset_name, kind)
    paused = _paused_versions(dataset_name, kind)
    return bool(declared) and all(v in paused for v in declared)


def _discover_versions(dataset_dir, kind):
    """Versions physically present in `dataset_dir` for this plan-kind.

    `dataset_dir` is user-controlled (it derives from MedVision_DATA_DIR), so it
    is escaped before matching and the prefix/suffix are cut on an unglobbable
    sentinel rather than on the "*" itself. Without the escape a "[" in the path
    is read as a character class and matches nothing; without the sentinel a "*"
    in the path makes the split land inside the directory component, so every
    capture is sliced at the wrong offset. Either way a dataset whose plans are
    physically present looks empty, which forces a re-download on every load and
    then fails with "annotation file missing" while the file plainly exists.
    """
    prefix, suffix = _plan_path(dataset_dir, kind, "\x00").split("\x00", 1)
    found = set()
    for path in glob.glob(_plan_path(glob.escape(dataset_dir), kind, "*")):
        captured = path[len(prefix): len(path) - len(suffix)]
        if _is_version(captured):
            found.add(captured)
        else:
            # e.g. a hand-made "..._vdraft.json.gz". Without this guard the
            # lenient _version_tuple would score it (1, 0, 0) and it could be
            # selected as the v1.0.0 plan.
            logger.warning(
                "Ignoring annotation file with an unparseable version: %s", path
            )
    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":
        return
    expected = "fromSeg" if task_type == "Tumor-Lesion-Size" else "landmark"
    declared = _BIOMETRY_FAMILY.get(dataset_name)
    if declared is None:
        raise RuntimeError(
            f"\n\nMedVision: dataset '{dataset_name}' has a biometry task "
            f"('{task_type}') but no entry in _BIOMETRY_FAMILY. Add one so the "
            "landmark/tumour-lesion plan families cannot be confused.\n"
        )
    if declared != expected:
        raise RuntimeError(
            f"\n\nMedVision: dataset '{dataset_name}' is registered as biometry "
            f"family '{declared}' but task '{task_type}' implies '{expected}'. "
            "Both families write benchmark_plan_biometry_v*.json.gz, so a dataset "
            "carrying both would overwrite one with the other. Give the two "
            "families distinct filenames before shipping this dataset.\n"
        )


def _require_planner_version_error(release_version):
    return EnvironmentError(
        "\n\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
        " MedVision: annotation version selection required\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
        " WARNING: any slice with anisotropic in-plane pixel size (e.g. sagittal\n"
        "    or coronal reslices) should use the v1.1.1+ annotation.\n"
        "\n"
        " The value is a CEILING, not a selection. Annotation versions resolve\n"
        " PER DATASET: each dataset/task loads the newest annotation published at\n"
        " or before the version you set, so setting a version never silently\n"
        " changes a dataset that did not change in that release.\n"
        "\n"
        " Either kind of version is accepted — a published annotation version,\n"
        " or the medvision_ds release version. Anything else is refused rather\n"
        " than silently resolved to some older annotation.\n"
        "\n"
        " Set the environment variable before loading the dataset:\n"
        "\n"
        "   export MedVision_PLANNER_VERSION=<version>\n"
        "\n"
        " Accepted values\n"
       + _accepted_values_block(_acceptable_versions(release_version), release_version)
       + "\n"
        " To always use the latest annotations:\n"
        "   export MedVision_PLANNER_VERSION=latest\n"
        "\n"
        " Backward compatibility:\n"
        "   The codebase `medvision_ds` will always be updated to the latest version.\n"
        "   Setting MedVision_PLANNER_VERSION='1.0.0' ensures the original annotations\n"
        "   are used. Datasets introduced after the version you select cannot be\n"
        "   loaded at that version; see info/ for the config list of each release.\n"
        "\n"
        " See release notes: \n"
        "   release-v1.1.0\n"
        "   release-v1.1.1\n"
        "   release-v1.2.0\n"
        "   release-v1.2.1\n"
        "   @ https://medvision-vlm.github.io/explorer.html\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
    )


def _normalize_requested(raw, release_version):
    """Validate MedVision_PLANNER_VERSION and resolve the literal 'latest'.

    Malformed values are rejected outright. Previously they fell through the
    lenient _version_tuple to (1, 0, 0), which - with MedVision_ACK_RELEASE set -
    silently loaded v1.0.0 annotations for a user who had typed e.g. "v1.1.1".
    """
    if raw is None:
        raise _require_planner_version_error(release_version)
    requested = str(raw).strip()
    if requested.lower() == "latest":
        return str(release_version)
    if not _is_version(requested):
        raise EnvironmentError(
            "\n\n"
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
            " MedVision: invalid MedVision_PLANNER_VERSION\n"
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
           f" Got: {raw!r}\n"
            "\n"
            " Expected 'latest' or a three-component version such as '1.2.0'.\n"
            " Values like 'v1.1.1' or '1.2' are rejected rather than guessed,\n"
            " because guessing them has previously loaded the wrong annotations.\n"
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
        )
    acceptable = _acceptable_versions(release_version)
    if requested not in acceptable:
        raise EnvironmentError(
            "\n\n"
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
            " MedVision: unknown MedVision_PLANNER_VERSION\n"
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
           f" Got: {requested}\n"
            "\n"
            " No annotation was ever published at that version, and it is not the\n"
            " current release. Accepting it would silently resolve every dataset\n"
            " to some older annotation — or, below the oldest one, leave every\n"
            " config unloadable.\n"
            "\n"
            " Accepted values\n"
           + _accepted_values_block(acceptable, release_version)
           + "\n"
            " Pick the newest annotations you are willing to load; each dataset\n"
            " then loads the newest it published at or before that.\n"
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
        )
    if _version_tuple(requested) > _version_tuple(release_version):
        # Reachable only if _ANNOTATION_INDEX declares a version above the
        # hardcoded release — i.e. annotations were published without bumping
        # MedVisionConfig.version. That is a release-process error, not a user one.
        logger.warning(
            "MedVision_PLANNER_VERSION=%s is above the current release %s; "
            "_ANNOTATION_INDEX declares an annotation newer than the release.",
            requested, release_version,
        )
    return requested


def _annotation_unavailable_error(dataset_name, task_type, kind, requested, declared):
    """Nothing resolves at this pin - either the pin predates the dataset, or the
    version it would have reached has since been withdrawn.

    Those two look identical in _ANNOTATION_INDEX (both are simply absent) but mean
    opposite things to the reader, so _WITHDRAWN_ANNOTATIONS is consulted to tell
    them apart. Saying "the annotations did not exist yet" to someone holding a cache
    built from a version that DID exist sends them after the wrong problem.

    `declared` is never empty here: the only caller raises separately when the
    index has no entry for the pair at all.
    """
    first = min(declared, key=_version_tuple)
    tail = (
        "\n"
        " Choose one:\n"
        "\n"
        "   - Use annotations that include this dataset:\n"
        "       export MedVision_PLANNER_VERSION=latest\n"
        "\n"
        "   - Keep your pinned version and skip this dataset. The config list\n"
        "     valid for each release is under info/, so a sweep can filter\n"
        "     before loading rather than failing here.\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
    )

    gone = _withdrawn_at_or_below(dataset_name, requested)
    if gone:
        reasons = "".join(
            f"   v{v} - {_WITHDRAWN_ANNOTATIONS[dataset_name][v]}\n" for v in gone
        )
        return EnvironmentError(
            "\n\n"
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
            " MedVision: annotation WITHDRAWN at the selected version\n"
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
           f" Dataset   : {dataset_name}\n"
           f" Task      : {task_type}  (plan kind: {kind})\n"
           f" Selected  : MedVision_PLANNER_VERSION={requested}\n"
           f" Available : {', '.join(declared)}\n"
            "\n"
            " Your pin would have loaded an annotation that was published and has\n"
            " since been removed because it was defective:\n"
            "\n"
           f"{reasons}"
            "\n"
            " It is not available at any pin and will not be reissued under that\n"
            " number - a correction always ships as a NEW version, so that a version\n"
            " string always identifies one set of data. Acknowledging the release\n"
            " does not bring it back.\n"
            "\n"
            " If you hold results or a builder cache built from a withdrawn version,\n"
            " discard them: the rows came from the defective annotation.\n"
            + tail
        )

    return EnvironmentError(
        "\n\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
        " MedVision: annotation not published at the selected version\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
       f" Dataset   : {dataset_name}\n"
       f" Task      : {task_type}  (plan kind: {kind})\n"
       f" Selected  : MedVision_PLANNER_VERSION={requested}\n"
       f" Published : {', '.join(declared)}\n"
        "\n"
       f" This dataset/task first ships at v{first}, after the version you\n"
        " selected. Acknowledging the release will not help - the annotations\n"
        " did not exist yet.\n"
        + tail
    )


def _annotation_paused_error(dataset_name, task_type, kind, paused):
    """The annotation exists but is known to be wrong - refuse to serve it.

    The affected datasets are read from _PAUSED_ANNOTATIONS rather than named in
    the text, so the banner cannot outlive the table it describes.
    """
    return RuntimeError(
        "\n\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
        " MedVision: annotation paused pending investigation\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
       f" Dataset   : {dataset_name}\n"
       f" Task      : {task_type}  (plan kind: {kind})\n"
       f" Withheld  : {', '.join('v' + v for v in paused)}\n"
        "\n"
        " We are investigating a defect that corrupts the annotations of:\n"
       f"   {', '.join(sorted(_PAUSED_ANNOTATIONS))}\n"
        "\n"
        " Loading them is paused until the cause is confirmed, so that no one\n"
        " trains or evaluates against annotations we already know to be wrong.\n"
        " Every other dataset in the release is unaffected.\n"
        "\n"
        " If you have already loaded these configs, discard those results and the\n"
        " builder cache built for them — the rows came from the defective plan.\n"
        "\n"
        " The correction will be published under a NEW annotation version; the\n"
        " withheld versions above will not be reused. Status and release notes:\n"
        "   https://medvision-vlm.github.io/explorer.html\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
    )


def _annotation_integrity_error(dataset_name, kind, requested, target, on_disk):
    """The index and the data on disk disagree - a broken install or a bad index."""
    return FileNotFoundError(
        "\n\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
        " MedVision: annotation file missing after download\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
       f" Dataset   : {dataset_name}  (plan kind: {kind})\n"
       f" Selected  : {requested}\n"
       f" Expected  : v{target} (per the published annotation index)\n"
       f" On disk   : {', '.join(on_disk) if on_disk else '(none)'}\n"
        "\n"
        " The dataset directory does not contain the annotation the index says\n"
        " is published. This usually means the download was interrupted, or the\n"
        " dataset is still being generated.\n"
        "\n"
        " Try a forced refresh:\n"
        "   export MedVision_FORCE_DOWNLOAD_DATA=True\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
    )


def _enforce_release_ack(planner_version, latest_version, ack_value=None,
                         dataset_name=None, plan_kind=None):
    """Block silent use of outdated annotations.

    `latest_version` is the newest annotation published for the (dataset,
    plan-kind) actually being loaded, so a release that did not touch this
    dataset does not block it. `ack_value` is the repo's release version. It
    defaults to `latest_version` for direct unit testing.

    MedVision_ACK_RELEASE may equal EITHER, because the two acknowledge
    different things and both are legitimate:

      * `latest_version` (this pair's newest annotation) - "I know this dataset
        moved past my pin". It is the number the error actually shows, and it
        expires precisely: regenerate this pair and the value changes, so the
        user is re-prompted, while users of untouched datasets are not.
      * `ack_value` (the release) - "I have read release <X>". A blanket
        acknowledgement, and the only one that composes across a catalogue
        sweep: a single env var cannot hold the several distinct per-pair values
        a sweep would demand once different datasets sit at different newest
        versions.
    """
    latest_version = str(latest_version)
    if ack_value is None:
        ack_value = latest_version
    ack_value = str(ack_value)

    if _version_tuple(planner_version) >= _version_tuple(latest_version):
        return
    if os.environ.get("MedVision_ACK_RELEASE") in (ack_value, latest_version):
        return

    scope = ""
    if dataset_name is not None:
        kind_note = f"  (plan kind: {plan_kind})" if plan_kind else ""
        scope = f" Dataset   : {dataset_name}{kind_note}\n\n"

    # Both values are accepted, so offer both - unless they coincide (a dataset
    # regenerated in the current release), where there is only one number to give.
    if ack_value == latest_version:
        ack_block = (
           f"   - To deliberately keep version {planner_version}, acknowledge it:\n"
           f"       export MedVision_ACK_RELEASE={ack_value}\n"
        )
    else:
        _pad = max(len(latest_version), len(ack_value))
        ack_block = (
           f"   - To deliberately keep version {planner_version}, acknowledge with\n"
            "     EITHER value:\n"
           f"       export MedVision_ACK_RELEASE={latest_version:<{_pad}}   "
            "# this dataset's newest annotation\n"
           f"       export MedVision_ACK_RELEASE={ack_value:<{_pad}}   "
           f"# the whole {ack_value} release\n"
            "\n"
            "     The first expires when this dataset is next regenerated, so it\n"
            "     re-prompts only if this dataset changes. The second is a blanket\n"
            "     acknowledgement and is the one to use for a catalogue sweep.\n"
        )

    raise EnvironmentError(
        "\n\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
        " MedVision: outdated annotation version — acknowledgement required\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
       + scope
       + f" You selected MedVision_PLANNER_VERSION={planner_version}, but the newest\n"
       f" annotation published for it is {latest_version}. Older versions may carry\n"
        " known annotation errors that the newer release corrects; the changes\n"
        " are documented in the release note.\n"
        "\n"
        " Choose one:\n"
        "\n"
        "   - Recommended — use the latest annotations:\n"
        "       export MedVision_PLANNER_VERSION=latest\n"
        "\n"
       + ack_block
       + "\n"
        " Release note:\n"
       f"   release-v{ack_value} @ https://medvision-vlm.github.io/explorer.html\n"
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
    )


# 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."""

    def __init__(
        self,
        features_dict,
        dataset_name,
        taskType,
        taskID,
        imageType,
        imageSliceType=None,
        split=None,
        num_proc=1,
        **kwargs,
    ):

        # Validate taskType
        valid_task_types = [
            "Mask-Size",
            "Box-Size",
            "Tumor-Lesion-Size",
            "Biometrics-From-Landmarks",
            "Biometrics-From-Landmarks-Distance",
            "Biometrics-From-Landmarks-Angle",
        ]
        if taskType.lower() not in [t.lower() for t in valid_task_types]:
            raise ValueError(
                f"\nError: taskType must be one of {valid_task_types}, got {taskType}\n"
            )

        # TaskID starts from 01
        if not taskID.isdigit() or len(taskID) != 2 or int(taskID) < 1:
            raise ValueError(
                f"\nError: taskID must be a 2-digit string starting from '01', got {taskID}\n"
            )

        # Validate imageType
        valid_image_types = ["2D", "3D"]
        if imageType.lower() not in [t.lower() for t in valid_image_types]:
            raise ValueError(
                f"\nError: imageType must be one of {valid_image_types}, got {imageType}\n"
            )

        # Validate imageSliceType
        if imageType.lower() == "2d":
            valid_slice_types = ["sagittal", "coronal", "axial"]
            if not imageSliceType or imageSliceType.lower() not in valid_slice_types:
                raise ValueError(
                    f"\nError: For 2D images, imageSliceType must be one of {valid_slice_types}, got {imageSliceType}\n"
                )
        if imageType.lower() == "3d" and imageSliceType is not None:
            raise ValueError(
                f"\nError: For 3D images, imageSliceType must be None or removed, got {imageSliceType}\n"
            )

        # Validate split
        if split is not None:
            valid_splits = ["train", "test"]
            if split.lower() not in valid_splits:
                raise ValueError(
                    f"\nError: split must be one of {valid_splits}, got {split}\n"
                )

        # Check: 3D images not supported for Mask-Size task
        if taskType.lower() == "Mask-Size" and imageType.lower() == "3D":
            raise ValueError(
                f"\nError: 3D images are not supported for Mask-Size task, got {imageType}\n"
            )

        # Set number of workers for multiprocessing
        self.num_proc = num_proc

        super().__init__(
            version="1.4.0", **kwargs
        )  # dataset version; keep this hardcoded — MedVision.py is downloaded from
           # the remote repo, so self.config.version must reflect the remote version,
           # not whatever medvision_ds version is currently installed locally.
        self.features_dict = features_dict
        self.dataset_name = dataset_name
        self.taskType = taskType
        self.taskID = taskID
        self.imageType = imageType
        self.imageSliceType = imageSliceType
        self.split = split

    def create_config_id(self, config_kwargs, custom_features=None):
        # Make the annotation version part of the builder cache fingerprint.
        # Without this, switching annotation versions reuses the same cache
        # folder and triggers NonMatchingSplitsSizesError in verify_splits.
        #
        # The token is the version this config actually RESOLVES to, not the one
        # requested. A requested version does not identify the data: several
        # pins can map to one annotation file, and one pin can map to different
        # data over time. Keying on the request meant that when a pin's
        # resolution changed, the cache key did not, and load_dataset silently
        # returned stale rows. Keying on the resolved version also lets two pins
        # that select the same file share one cache, so a release that changed
        # nothing for a dataset does not force it to regenerate.
        #
        # This runs at builder construction, before any download, so it must
        # never raise and never touch disk. An unresolvable pin keeps its raw
        # value here; _split_generators raises before anything is written.
        #
        # Strip exactly as _normalize_requested does. Otherwise a padded pin
        # (" latest", "1.2.0 ") is accepted and loaded there but falls out of the
        # _is_version guard here, so the token silently reverts to the requested
        # string — reinstating the request-keyed fingerprint this change removed,
        # and building identical data into a second cache directory labelled with
        # a version it does not contain.
        raw = (os.environ.get("MedVision_PLANNER_VERSION") or "unset").strip() or "unset"
        planner_version = self.version if raw.lower() == "latest" else raw
        kind = _PLAN_KIND_BY_TASKTYPE.get(self.taskType)
        if kind is not None and _is_version(planner_version):
            resolved = _resolve(
                _declared_versions(self.dataset_name, kind), planner_version
            )
            if resolved is not None:
                planner_version = resolved
        # MedVision_DATA_DIR belongs here by the same rule that put planner_version
        # here: it changes what the rows say. Every row's image_file/mask_file/
        # landmark_file is os.path.join(dataset_dir, ...) with dataset_dir rooted at
        # this variable, so two roots yield different rows. Without it, two runs
        # differing only in data root produced a byte-identical config_id, hence a
        # cache hit: _split_generators never ran, nothing was downloaded into the new
        # root, and the returned rows pointed into the old one.
        #
        # Folded INTO the planner_version token rather than added as a second key, so
        # the id suffix stays inside datasets' 32-char readability limit — past that,
        # upstream hashes the whole suffix and the resolved annotation version stops
        # being visible in the cache path. abspath, not realpath: realpath stats the
        # filesystem, and two symlinks to one root only cost a duplicate cache.
        _root_token = hashlib.sha1(_data_root(strict=False).encode()).hexdigest()[:8]
        kwargs_with_planner = {
            **(config_kwargs or {}),
            "planner_version": f"{planner_version}-{_root_token}",
        }
        # MedVision_DISABLE_SAMPLE_FILTERING changes which rows _generate_examples yields, so it
        # must also be part of the fingerprint — otherwise flipping it reuses the cache built
        # under the other setting and silently returns the wrong annotation set. Added ONLY when
        # enabled, so the default (filtered) config id — and every cache already built with it —
        # stays byte-identical.
        if os.environ.get("MedVision_DISABLE_SAMPLE_FILTERING", "False").lower() == "true":
            kwargs_with_planner["disable_sample_filtering"] = True
        return super().create_config_id(kwargs_with_planner, custom_features=custom_features)


class MedVision(GeneratorBasedBuilder):
    """
    MedVision dataset.

    NOTE: To update the features returned by the load_dataset() method, the followings should be updated:
            - the feature dict in this class 
            - the dict yielded by the _generate_examples() method 
    """

    # The feature dict for the task:
    # - Mask-Size
    features_dict_MaskSize = {
        "dataset_name": Value("string"),
        "taskID": Value("string"),
        "taskType": Value("string"),
        "image_file": Value("string"),
        "mask_file": Value("string"),
        "slice_dim": Value("uint8"),
        "slice_idx": Value("uint16"),
        "label": Value("uint16"),
        "image_size_2d": Sequence(Value("uint16"), length=2),
        "pixel_size": Sequence(Value("float16"), length=2),
        "image_size_3d": Sequence(Value("uint16"), length=3),
        "voxel_size": Sequence(Value("float16"), length=3),
        "pixel_count": Value("uint32"),
        "ROI_area": Value("float16"),
    }

    # The feature dict for the task:
    # - Box-Size
    features_dict_BoxSize = {
        "dataset_name": Value("string"),
        "taskID": Value("string"),
        "taskType": Value("string"),
        "image_file": Value("string"),
        "mask_file": Value("string"),
        "slice_dim": Value("uint8"),
        "slice_idx": Value("uint16"),
        "label": Value("uint16"),
        "image_size_2d": Sequence(Value("uint16"), length=2),
        "pixel_size": Sequence(Value("float16"), length=2),
        "image_size_3d": Sequence(Value("uint16"), length=3),
        "voxel_size": Sequence(Value("float16"), length=3),
        "bounding_boxes": Sequence(
            {
                "min_coords": Sequence(Value("uint16"), length=2),
                "max_coords": Sequence(Value("uint16"), length=2),
                "center_coords": Sequence(Value("uint16"), length=2),
                "dimensions": Sequence(Value("uint16"), length=2),
                "sizes": Sequence(Value("float16"), length=2),
            },
        ),
    }

    features_dict_BiometricsFromLandmarks = {
        "dataset_name": Value("string"),
        "taskID": Value("string"),
        "taskType": Value("string"),
        "image_file": Value("string"),
        "landmark_file": Value("string"),
        "slice_dim": Value("uint8"),
        "slice_idx": Value("uint16"),
        "image_size_2d": Sequence(Value("uint16"), length=2),
        "pixel_size": Sequence(Value("float16"), length=2),
        "image_size_3d": Sequence(Value("uint16"), length=3),
        "voxel_size": Sequence(Value("float16"), length=3),
        "biometric_profile": {
            "metric_type": Value("string"),
            "metric_map_name": Value("string"),
            "metric_key": Value("string"),
            "metric_value": Value("float16"),
            "metric_unit": Value("string"),
            "slice_dim": Value("uint8"),
        },
    }

    features_dict_TumorLesionSize = {
        "dataset_name": Value("string"),
        "taskID": Value("string"),
        "taskType": Value("string"),
        "image_file": Value("string"),
        "landmark_file": Value("string"),
        "mask_file": Value("string"),
        "slice_dim": Value("uint8"),
        "slice_idx": Value("uint16"),
        "label": Value("uint16"),
        "image_size_2d": Sequence(Value("uint16"), length=2),
        "pixel_size": Sequence(Value("float16"), length=2),
        "image_size_3d": Sequence(Value("uint16"), length=3),
        "voxel_size": Sequence(Value("float16"), length=3),
        "biometric_profile": Sequence(
            {
                "metric_type": Value("string"),
                "metric_map_name": Value("string"),
                "metric_key_major_axis": Value("string"),
                "metric_value_major_axis": Value("float16"),
                "metric_key_minor_axis": Value("string"),
                "metric_value_minor_axis": Value("float16"),
                "metric_unit": Value("string"),
            },
        ),
    }

    BUILDER_CONFIGS = [
        # AbdomenAtlas1.0Mini:Mask-Size:Task01
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_MaskSize_Task01_Sagittal_Train",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_MaskSize_Task01_Sagittal_Test",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_MaskSize_Task01_Coronal_Train",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_MaskSize_Task01_Coronal_Test",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_MaskSize_Task01_Axial_Train",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_MaskSize_Task01_Axial_Test",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # AbdomenAtlas1.0Mini:Box-Size:Task01
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_BoxSize_Task01_Sagittal_Train",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_BoxSize_Task01_Sagittal_Test",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_BoxSize_Task01_Coronal_Train",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_BoxSize_Task01_Coronal_Test",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_BoxSize_Task01_Axial_Train",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenAtlas1.0Mini_BoxSize_Task01_Axial_Test",
            dataset_name="AbdomenAtlas1.0Mini",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # AbdomenCT-1K:Mask-Size:Task01
        MedVisionConfig(
            name="AbdomenCT-1K_MaskSize_Task01_Sagittal_Train",
            dataset_name="AbdomenCT-1K",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_MaskSize_Task01_Sagittal_Test",
            dataset_name="AbdomenCT-1K",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_MaskSize_Task01_Coronal_Train",
            dataset_name="AbdomenCT-1K",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_MaskSize_Task01_Coronal_Test",
            dataset_name="AbdomenCT-1K",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_MaskSize_Task01_Axial_Train",
            dataset_name="AbdomenCT-1K",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_MaskSize_Task01_Axial_Test",
            dataset_name="AbdomenCT-1K",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # AbdomenCT-1K:Box-Size:Task01
        MedVisionConfig(
            name="AbdomenCT-1K_BoxSize_Task01_Sagittal_Train",
            dataset_name="AbdomenCT-1K",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_BoxSize_Task01_Sagittal_Test",
            dataset_name="AbdomenCT-1K",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_BoxSize_Task01_Coronal_Train",
            dataset_name="AbdomenCT-1K",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_BoxSize_Task01_Coronal_Test",
            dataset_name="AbdomenCT-1K",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_BoxSize_Task01_Axial_Train",
            dataset_name="AbdomenCT-1K",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="AbdomenCT-1K_BoxSize_Task01_Axial_Test",
            dataset_name="AbdomenCT-1K",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # ACDC:Mask-Size:Task01
        MedVisionConfig(
            name="ACDC_MaskSize_Task01_Sagittal_Train",
            dataset_name="ACDC",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="ACDC_MaskSize_Task01_Sagittal_Test",
            dataset_name="ACDC",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="ACDC_MaskSize_Task01_Coronal_Train",
            dataset_name="ACDC",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="ACDC_MaskSize_Task01_Coronal_Test",
            dataset_name="ACDC",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="ACDC_MaskSize_Task01_Axial_Train",
            dataset_name="ACDC",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="ACDC_MaskSize_Task01_Axial_Test",
            dataset_name="ACDC",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # ACDC:Box-Size:Task01
        MedVisionConfig(
            name="ACDC_BoxSize_Task01_Sagittal_Train",
            dataset_name="ACDC",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="ACDC_BoxSize_Task01_Sagittal_Test",
            dataset_name="ACDC",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="ACDC_BoxSize_Task01_Coronal_Train",
            dataset_name="ACDC",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="ACDC_BoxSize_Task01_Coronal_Test",
            dataset_name="ACDC",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="ACDC_BoxSize_Task01_Axial_Train",
            dataset_name="ACDC",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="ACDC_BoxSize_Task01_Axial_Test",
            dataset_name="ACDC",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # AMOS22:Mask-Size:Task01
        MedVisionConfig(
            name="AMOS22_MaskSize_Task01_Sagittal_Train",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task01_Sagittal_Test",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task01_Coronal_Train",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task01_Coronal_Test",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task01_Axial_Train",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task01_Axial_Test",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # AMOS22:Mask-Size:Task02
        MedVisionConfig(
            name="AMOS22_MaskSize_Task02_Sagittal_Train",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task02_Sagittal_Test",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task02_Coronal_Train",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task02_Coronal_Test",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task02_Axial_Train",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_MaskSize_Task02_Axial_Test",
            dataset_name="AMOS22",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # AMOS22:Box-Size:Task01
        MedVisionConfig(
            name="AMOS22_BoxSize_Task01_Sagittal_Train",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task01_Sagittal_Test",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task01_Coronal_Train",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task01_Coronal_Test",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task01_Axial_Train",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task01_Axial_Test",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # AMOS22:Box-Size:Task02
        MedVisionConfig(
            name="AMOS22_BoxSize_Task02_Sagittal_Train",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task02_Sagittal_Test",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task02_Coronal_Train",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task02_Coronal_Test",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task02_Axial_Train",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="AMOS22_BoxSize_Task02_Axial_Test",
            dataset_name="AMOS22",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # autoPET-III:Mask-Size:Task01
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task01_Sagittal_Train",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task01_Sagittal_Test",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task01_Coronal_Train",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task01_Coronal_Test",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task01_Axial_Train",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task01_Axial_Test",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # autoPET-III:Mask-Size:Task02
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task02_Sagittal_Train",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task02_Sagittal_Test",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task02_Coronal_Train",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task02_Coronal_Test",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task02_Axial_Train",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_MaskSize_Task02_Axial_Test",
            dataset_name="autoPET-III",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # autoPET-III:Box-Size:Task01
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task01_Sagittal_Train",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task01_Sagittal_Test",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task01_Coronal_Train",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task01_Coronal_Test",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task01_Axial_Train",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task01_Axial_Test",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # autoPET-III:Box-Size:Task02
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task02_Sagittal_Train",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task02_Sagittal_Test",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task02_Coronal_Train",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task02_Coronal_Test",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task02_Axial_Train",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_BoxSize_Task02_Axial_Test",
            dataset_name="autoPET-III",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # autoPET-III:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="autoPET-III_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="autoPET-III",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="autoPET-III",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="autoPET-III",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="autoPET-III",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="autoPET-III_TumorLesionSize_Task01_Axial_Train",
            dataset_name="autoPET-III",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="autoPET-III_TumorLesionSize_Task01_Axial_Test",
            dataset_name="autoPET-III",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BCV15:Mask-Size:Task01
        MedVisionConfig(
            name="BCV15_MaskSize_Task01_Sagittal_Train",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task01_Sagittal_Test",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task01_Coronal_Train",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task01_Coronal_Test",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task01_Axial_Train",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task01_Axial_Test",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BCV15:Mask-Size:Task02
        MedVisionConfig(
            name="BCV15_MaskSize_Task02_Sagittal_Train",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task02_Sagittal_Test",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task02_Coronal_Train",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task02_Coronal_Test",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task02_Axial_Train",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_MaskSize_Task02_Axial_Test",
            dataset_name="BCV15",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BCV15:Box-Size:Task01
        MedVisionConfig(
            name="BCV15_BoxSize_Task01_Sagittal_Train",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task01_Sagittal_Test",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task01_Coronal_Train",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task01_Coronal_Test",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task01_Axial_Train",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task01_Axial_Test",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BCV15:Box-Size:Task02
        MedVisionConfig(
            name="BCV15_BoxSize_Task02_Sagittal_Train",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task02_Sagittal_Test",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task02_Coronal_Train",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task02_Coronal_Test",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task02_Axial_Train",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BCV15_BoxSize_Task02_Axial_Test",
            dataset_name="BCV15",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task01
        MedVisionConfig(
            name="BraTS24_MaskSize_Task01_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task01_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task01_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task01_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task01_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task01_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task02
        MedVisionConfig(
            name="BraTS24_MaskSize_Task02_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task02_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task02_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task02_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task02_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task02_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task03
        MedVisionConfig(
            name="BraTS24_MaskSize_Task03_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task03_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task03_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task03_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task03_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task03_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task04
        MedVisionConfig(
            name="BraTS24_MaskSize_Task04_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task04_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task04_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task04_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task04_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task04_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task05
        MedVisionConfig(
            name="BraTS24_MaskSize_Task05_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task05_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task05_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task05_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task05_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task05_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task06
        MedVisionConfig(
            name="BraTS24_MaskSize_Task06_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task06_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task06_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task06_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task06_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task06_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task07
        MedVisionConfig(
            name="BraTS24_MaskSize_Task07_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task07_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task07_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task07_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task07_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task07_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task08
        MedVisionConfig(
            name="BraTS24_MaskSize_Task08_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task08_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task08_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task08_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task08_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task08_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task09
        MedVisionConfig(
            name="BraTS24_MaskSize_Task09_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task09_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task09_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task09_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task09_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task09_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task10
        MedVisionConfig(
            name="BraTS24_MaskSize_Task10_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task10_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task10_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task10_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task10_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task10_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task11
        MedVisionConfig(
            name="BraTS24_MaskSize_Task11_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task11_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task11_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task11_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task11_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task11_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task12
        MedVisionConfig(
            name="BraTS24_MaskSize_Task12_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task12_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task12_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task12_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task12_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task12_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Mask-Size:Task13
        MedVisionConfig(
            name="BraTS24_MaskSize_Task13_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task13_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task13_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task13_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task13_Axial_Train",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_MaskSize_Task13_Axial_Test",
            dataset_name="BraTS24",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task01
        MedVisionConfig(
            name="BraTS24_BoxSize_Task01_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task01_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task01_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task01_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task01_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task01_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task02
        MedVisionConfig(
            name="BraTS24_BoxSize_Task02_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task02_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task02_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task02_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task02_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task02_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task03
        MedVisionConfig(
            name="BraTS24_BoxSize_Task03_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task03_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task03_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task03_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task03_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task03_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task04
        MedVisionConfig(
            name="BraTS24_BoxSize_Task04_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task04_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task04_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task04_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task04_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task04_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task05
        MedVisionConfig(
            name="BraTS24_BoxSize_Task05_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task05_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task05_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task05_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task05_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task05_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task06
        MedVisionConfig(
            name="BraTS24_BoxSize_Task06_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task06_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task06_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task06_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task06_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task06_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task07
        MedVisionConfig(
            name="BraTS24_BoxSize_Task07_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task07_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task07_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task07_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task07_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task07_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task08
        MedVisionConfig(
            name="BraTS24_BoxSize_Task08_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task08_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task08_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task08_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task08_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task08_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task09
        MedVisionConfig(
            name="BraTS24_BoxSize_Task09_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task09_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task09_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task09_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task09_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task09_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task10
        MedVisionConfig(
            name="BraTS24_BoxSize_Task10_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task10_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task10_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task10_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task10_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task10_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task11
        MedVisionConfig(
            name="BraTS24_BoxSize_Task11_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task11_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task11_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task11_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task11_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task11_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task12
        MedVisionConfig(
            name="BraTS24_BoxSize_Task12_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task12_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task12_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task12_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task12_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task12_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Box-Size:Task13
        MedVisionConfig(
            name="BraTS24_BoxSize_Task13_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task13_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task13_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task13_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task13_Axial_Train",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_BoxSize_Task13_Axial_Test",
            dataset_name="BraTS24",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task01_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task01_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task02
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task02_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task02_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task02_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task02_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task02_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task02_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task03
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task03_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task03_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task03_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task03_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task03_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task03_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task04
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task04_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task04_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task04_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task04_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task04_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task04_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task05
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task05_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task05_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task05_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task05_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task05_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task05_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task06
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task06_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task06_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task06_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task06_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task06_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task06_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task07
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task07_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task07_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task07_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task07_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task07_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task07_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task08
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task08_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task08_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task08_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task08_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task08_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task08_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task09
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task09_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task09_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task09_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task09_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task09_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task09_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task10
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task10_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task10_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task10_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task10_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task10_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task10_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task11
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task11_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task11_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task11_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task11_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task11_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task11_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # BraTS24:Tumor-Lesion-Size:Task12
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task12_Sagittal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task12_Sagittal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task12_Coronal_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task12_Coronal_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task12_Axial_Train",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="BraTS24_TumorLesionSize_Task12_Axial_Test",
            dataset_name="BraTS24",
            taskType="Tumor-Lesion-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # CAMUS:Mask-Size:Task01
        MedVisionConfig(
            name="CAMUS_MaskSize_Task01_Sagittal_Train",
            dataset_name="CAMUS",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="CAMUS_MaskSize_Task01_Sagittal_Test",
            dataset_name="CAMUS",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="CAMUS_MaskSize_Task01_Coronal_Train",
            dataset_name="CAMUS",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="CAMUS_MaskSize_Task01_Coronal_Test",
            dataset_name="CAMUS",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="CAMUS_MaskSize_Task01_Axial_Train",
            dataset_name="CAMUS",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="CAMUS_MaskSize_Task01_Axial_Test",
            dataset_name="CAMUS",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # CAMUS:Box-Size:Task01
        MedVisionConfig(
            name="CAMUS_BoxSize_Task01_Sagittal_Train",
            dataset_name="CAMUS",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="CAMUS_BoxSize_Task01_Sagittal_Test",
            dataset_name="CAMUS",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="CAMUS_BoxSize_Task01_Coronal_Train",
            dataset_name="CAMUS",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="CAMUS_BoxSize_Task01_Coronal_Test",
            dataset_name="CAMUS",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="CAMUS_BoxSize_Task01_Axial_Train",
            dataset_name="CAMUS",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="CAMUS_BoxSize_Task01_Axial_Test",
            dataset_name="CAMUS",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # Ceph-Biometrics-400:Biometrics-From-Landmarks:Task01
        # NOTE: We split angle and distance estimate tasks into different subsets
        MedVisionConfig(
            name="Ceph-Biometrics-400_BiometricsFromLandmarks_Distance_Task01_Sagittal_Train",
            dataset_name="Ceph-Biometrics-400",
            taskType="Biometrics-From-Landmarks-Distance",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="Ceph-Biometrics-400_BiometricsFromLandmarks_Distance_Task01_Sagittal_Test",
            dataset_name="Ceph-Biometrics-400",
            taskType="Biometrics-From-Landmarks-Distance",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="Ceph-Biometrics-400_BiometricsFromLandmarks_Angle_Task01_Sagittal_Train",
            dataset_name="Ceph-Biometrics-400",
            taskType="Biometrics-From-Landmarks-Angle",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="Ceph-Biometrics-400_BiometricsFromLandmarks_Angle_Task01_Sagittal_Test",
            dataset_name="Ceph-Biometrics-400",
            taskType="Biometrics-From-Landmarks-Angle",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="test",
        ),
        # CrossMoDA:Mask-Size:Task01
        MedVisionConfig(
            name="CrossMoDA_MaskSize_Task01_Sagittal_Train",
            dataset_name="CrossMoDA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="CrossMoDA_MaskSize_Task01_Sagittal_Test",
            dataset_name="CrossMoDA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="CrossMoDA_MaskSize_Task01_Coronal_Train",
            dataset_name="CrossMoDA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="CrossMoDA_MaskSize_Task01_Coronal_Test",
            dataset_name="CrossMoDA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="CrossMoDA_MaskSize_Task01_Axial_Train",
            dataset_name="CrossMoDA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="CrossMoDA_MaskSize_Task01_Axial_Test",
            dataset_name="CrossMoDA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # CrossMoDA:Box-Size:Task01
        MedVisionConfig(
            name="CrossMoDA_BoxSize_Task01_Sagittal_Train",
            dataset_name="CrossMoDA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="CrossMoDA_BoxSize_Task01_Sagittal_Test",
            dataset_name="CrossMoDA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="CrossMoDA_BoxSize_Task01_Coronal_Train",
            dataset_name="CrossMoDA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="CrossMoDA_BoxSize_Task01_Coronal_Test",
            dataset_name="CrossMoDA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="CrossMoDA_BoxSize_Task01_Axial_Train",
            dataset_name="CrossMoDA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="CrossMoDA_BoxSize_Task01_Axial_Test",
            dataset_name="CrossMoDA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # FeTA24:Mask-Size:Task01
        MedVisionConfig(
            name="FeTA24_MaskSize_Task01_Sagittal_Train",
            dataset_name="FeTA24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="FeTA24_MaskSize_Task01_Sagittal_Test",
            dataset_name="FeTA24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="FeTA24_MaskSize_Task01_Coronal_Train",
            dataset_name="FeTA24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="FeTA24_MaskSize_Task01_Coronal_Test",
            dataset_name="FeTA24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="FeTA24_MaskSize_Task01_Axial_Train",
            dataset_name="FeTA24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="FeTA24_MaskSize_Task01_Axial_Test",
            dataset_name="FeTA24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # FeTA24:Box-Size:Task01
        MedVisionConfig(
            name="FeTA24_BoxSize_Task01_Sagittal_Train",
            dataset_name="FeTA24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="FeTA24_BoxSize_Task01_Sagittal_Test",
            dataset_name="FeTA24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="FeTA24_BoxSize_Task01_Coronal_Train",
            dataset_name="FeTA24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="FeTA24_BoxSize_Task01_Coronal_Test",
            dataset_name="FeTA24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="FeTA24_BoxSize_Task01_Axial_Train",
            dataset_name="FeTA24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="FeTA24_BoxSize_Task01_Axial_Test",
            dataset_name="FeTA24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # FeTA24:Biometrics-From-Landmarks:Task01
        MedVisionConfig(
            name="FeTA24_BiometricsFromLandmarks_Task01_Sagittal_Train",
            dataset_name="FeTA24",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="FeTA24_BiometricsFromLandmarks_Task01_Sagittal_Test",
            dataset_name="FeTA24",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="FeTA24_BiometricsFromLandmarks_Task01_Coronal_Train",
            dataset_name="FeTA24",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="FeTA24_BiometricsFromLandmarks_Task01_Coronal_Test",
            dataset_name="FeTA24",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="FeTA24_BiometricsFromLandmarks_Task01_Axial_Train",
            dataset_name="FeTA24",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="FeTA24_BiometricsFromLandmarks_Task01_Axial_Test",
            dataset_name="FeTA24",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="axial",
            split="test",
        ),
        # FLARE22:Mask-Size:Task01
        MedVisionConfig(
            name="FLARE22_MaskSize_Task01_Sagittal_Train",
            dataset_name="FLARE22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="FLARE22_MaskSize_Task01_Sagittal_Test",
            dataset_name="FLARE22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="FLARE22_MaskSize_Task01_Coronal_Train",
            dataset_name="FLARE22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="FLARE22_MaskSize_Task01_Coronal_Test",
            dataset_name="FLARE22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="FLARE22_MaskSize_Task01_Axial_Train",
            dataset_name="FLARE22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="FLARE22_MaskSize_Task01_Axial_Test",
            dataset_name="FLARE22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # FLARE22:Box-Size:Task01
        MedVisionConfig(
            name="FLARE22_BoxSize_Task01_Sagittal_Train",
            dataset_name="FLARE22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="FLARE22_BoxSize_Task01_Sagittal_Test",
            dataset_name="FLARE22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="FLARE22_BoxSize_Task01_Coronal_Train",
            dataset_name="FLARE22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="FLARE22_BoxSize_Task01_Coronal_Test",
            dataset_name="FLARE22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="FLARE22_BoxSize_Task01_Axial_Train",
            dataset_name="FLARE22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="FLARE22_BoxSize_Task01_Axial_Test",
            dataset_name="FLARE22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # HNTSMRG24:Mask-Size:Task01
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task01_Sagittal_Train",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task01_Sagittal_Test",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task01_Coronal_Train",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task01_Coronal_Test",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task01_Axial_Train",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task01_Axial_Test",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # HNTSMRG24:Mask-Size:Task02
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task02_Sagittal_Train",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task02_Sagittal_Test",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task02_Coronal_Train",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task02_Coronal_Test",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task02_Axial_Train",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_MaskSize_Task02_Axial_Test",
            dataset_name="HNTSMRG24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # HNTSMRG24:Box-Size:Task01
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task01_Sagittal_Train",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task01_Sagittal_Test",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task01_Coronal_Train",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task01_Coronal_Test",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task01_Axial_Train",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task01_Axial_Test",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # HNTSMRG24:Box-Size:Task02
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task02_Sagittal_Train",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task02_Sagittal_Test",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task02_Coronal_Train",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task02_Coronal_Test",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task02_Axial_Train",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_BoxSize_Task02_Axial_Test",
            dataset_name="HNTSMRG24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # HNTSMRG24:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task01_Axial_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task01_Axial_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # HNTSMRG24:Tumor-Lesion-Size:Task02
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task02_Sagittal_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task02_Sagittal_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task02_Coronal_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task02_Coronal_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task02_Axial_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task02_Axial_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # HNTSMRG24:Tumor-Lesion-Size:Task03
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task03_Sagittal_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task03_Sagittal_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task03_Coronal_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task03_Coronal_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task03_Axial_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task03_Axial_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # HNTSMRG24:Tumor-Lesion-Size:Task04
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task04_Sagittal_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task04_Sagittal_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task04_Coronal_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task04_Coronal_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task04_Axial_Train",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="HNTSMRG24_TumorLesionSize_Task04_Axial_Test",
            dataset_name="HNTSMRG24",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # ISLES24:Mask-Size:Task01
        MedVisionConfig(
            name="ISLES24_MaskSize_Task01_Sagittal_Train",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task01_Sagittal_Test",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task01_Coronal_Train",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task01_Coronal_Test",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task01_Axial_Train",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task01_Axial_Test",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # ISLES24:Mask-Size:Task02
        MedVisionConfig(
            name="ISLES24_MaskSize_Task02_Sagittal_Train",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task02_Sagittal_Test",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task02_Coronal_Train",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task02_Coronal_Test",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task02_Axial_Train",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_MaskSize_Task02_Axial_Test",
            dataset_name="ISLES24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # ISLES24:Box-Size:Task01
        MedVisionConfig(
            name="ISLES24_BoxSize_Task01_Sagittal_Train",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task01_Sagittal_Test",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task01_Coronal_Train",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task01_Coronal_Test",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task01_Axial_Train",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task01_Axial_Test",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # ISLES24:Box-Size:Task02
        MedVisionConfig(
            name="ISLES24_BoxSize_Task02_Sagittal_Train",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task02_Sagittal_Test",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task02_Coronal_Train",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task02_Coronal_Test",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task02_Axial_Train",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="ISLES24_BoxSize_Task02_Axial_Test",
            dataset_name="ISLES24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # KiPA22:Mask-Size:Task01
        MedVisionConfig(
            name="KiPA22_MaskSize_Task01_Sagittal_Train",
            dataset_name="KiPA22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="KiPA22_MaskSize_Task01_Sagittal_Test",
            dataset_name="KiPA22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="KiPA22_MaskSize_Task01_Coronal_Train",
            dataset_name="KiPA22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="KiPA22_MaskSize_Task01_Coronal_Test",
            dataset_name="KiPA22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="KiPA22_MaskSize_Task01_Axial_Train",
            dataset_name="KiPA22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="KiPA22_MaskSize_Task01_Axial_Test",
            dataset_name="KiPA22",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # KiPA22:Box-Size:Task01
        MedVisionConfig(
            name="KiPA22_BoxSize_Task01_Sagittal_Train",
            dataset_name="KiPA22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="KiPA22_BoxSize_Task01_Sagittal_Test",
            dataset_name="KiPA22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="KiPA22_BoxSize_Task01_Coronal_Train",
            dataset_name="KiPA22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="KiPA22_BoxSize_Task01_Coronal_Test",
            dataset_name="KiPA22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="KiPA22_BoxSize_Task01_Axial_Train",
            dataset_name="KiPA22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="KiPA22_BoxSize_Task01_Axial_Test",
            dataset_name="KiPA22",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # KiPA22:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="KiPA22_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="KiPA22",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="KiPA22_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="KiPA22",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="KiPA22_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="KiPA22",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="KiPA22_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="KiPA22",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="KiPA22_TumorLesionSize_Task01_Axial_Train",
            dataset_name="KiPA22",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="KiPA22_TumorLesionSize_Task01_Axial_Test",
            dataset_name="KiPA22",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # KiTS23:Mask-Size:Task01
        MedVisionConfig(
            name="KiTS23_MaskSize_Task01_Sagittal_Train",
            dataset_name="KiTS23",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="KiTS23_MaskSize_Task01_Sagittal_Test",
            dataset_name="KiTS23",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="KiTS23_MaskSize_Task01_Coronal_Train",
            dataset_name="KiTS23",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="KiTS23_MaskSize_Task01_Coronal_Test",
            dataset_name="KiTS23",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="KiTS23_MaskSize_Task01_Axial_Train",
            dataset_name="KiTS23",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="KiTS23_MaskSize_Task01_Axial_Test",
            dataset_name="KiTS23",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # KiTS23:Box-Size:Task01
        MedVisionConfig(
            name="KiTS23_BoxSize_Task01_Sagittal_Train",
            dataset_name="KiTS23",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="KiTS23_BoxSize_Task01_Sagittal_Test",
            dataset_name="KiTS23",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="KiTS23_BoxSize_Task01_Coronal_Train",
            dataset_name="KiTS23",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="KiTS23_BoxSize_Task01_Coronal_Test",
            dataset_name="KiTS23",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="KiTS23_BoxSize_Task01_Axial_Train",
            dataset_name="KiTS23",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="KiTS23_BoxSize_Task01_Axial_Test",
            dataset_name="KiTS23",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # KiTS23:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="KiTS23_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="KiTS23",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="KiTS23_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="KiTS23",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="KiTS23_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="KiTS23",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="KiTS23_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="KiTS23",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="KiTS23_TumorLesionSize_Task01_Axial_Train",
            dataset_name="KiTS23",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="KiTS23_TumorLesionSize_Task01_Axial_Test",
            dataset_name="KiTS23",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task01
        MedVisionConfig(
            name="MSD_MaskSize_Task01_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task01_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task01_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task01_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task01_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task01_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task02
        MedVisionConfig(
            name="MSD_MaskSize_Task02_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task02_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task02_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task02_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task02_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task02_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task03
        MedVisionConfig(
            name="MSD_MaskSize_Task03_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task03_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task03_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task03_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task03_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task03_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task04
        MedVisionConfig(
            name="MSD_MaskSize_Task04_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task04_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task04_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task04_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task04_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task04_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task05
        MedVisionConfig(
            name="MSD_MaskSize_Task05_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task05_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task05_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task05_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task05_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task05_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task06
        MedVisionConfig(
            name="MSD_MaskSize_Task06_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task06_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task06_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task06_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task06_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task06_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task07
        MedVisionConfig(
            name="MSD_MaskSize_Task07_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task07_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task07_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task07_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task07_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task07_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task08
        MedVisionConfig(
            name="MSD_MaskSize_Task08_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task08_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task08_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task08_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task08_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task08_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task09
        MedVisionConfig(
            name="MSD_MaskSize_Task09_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task09_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task09_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task09_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task09_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task09_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task10
        MedVisionConfig(
            name="MSD_MaskSize_Task10_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task10_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task10_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task10_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task10_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task10_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task11
        MedVisionConfig(
            name="MSD_MaskSize_Task11_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task11_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task11_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task11_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task11_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task11_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task12
        MedVisionConfig(
            name="MSD_MaskSize_Task12_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task12_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task12_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task12_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task12_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task12_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task13
        MedVisionConfig(
            name="MSD_MaskSize_Task13_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task13_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task13_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task13_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task13_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task13_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Mask-Size:Task14
        MedVisionConfig(
            name="MSD_MaskSize_Task14_Sagittal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task14_Sagittal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task14_Coronal_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task14_Coronal_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task14_Axial_Train",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_MaskSize_Task14_Axial_Test",
            dataset_name="MSD",
            taskType="Mask-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task01
        MedVisionConfig(
            name="MSD_BoxSize_Task01_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task01_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task01_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task01_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task01_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task01_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task02
        MedVisionConfig(
            name="MSD_BoxSize_Task02_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task02_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task02_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task02_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task02_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task02_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task03
        MedVisionConfig(
            name="MSD_BoxSize_Task03_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task03_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task03_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task03_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task03_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task03_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task04
        MedVisionConfig(
            name="MSD_BoxSize_Task04_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task04_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task04_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task04_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task04_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task04_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task05
        MedVisionConfig(
            name="MSD_BoxSize_Task05_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task05_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task05_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task05_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task05_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task05_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task06
        MedVisionConfig(
            name="MSD_BoxSize_Task06_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task06_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task06_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task06_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task06_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task06_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task07
        MedVisionConfig(
            name="MSD_BoxSize_Task07_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task07_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task07_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task07_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task07_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task07_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task08
        MedVisionConfig(
            name="MSD_BoxSize_Task08_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task08_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task08_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task08_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task08_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task08_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task09
        MedVisionConfig(
            name="MSD_BoxSize_Task09_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task09_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task09_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task09_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task09_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task09_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="09",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task10
        MedVisionConfig(
            name="MSD_BoxSize_Task10_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task10_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task10_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task10_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task10_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task10_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="10",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task11
        MedVisionConfig(
            name="MSD_BoxSize_Task11_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task11_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task11_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task11_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task11_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task11_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="11",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task12
        MedVisionConfig(
            name="MSD_BoxSize_Task12_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task12_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task12_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task12_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task12_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task12_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="12",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task13
        MedVisionConfig(
            name="MSD_BoxSize_Task13_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task13_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task13_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task13_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task13_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task13_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="13",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Box-Size:Task14
        MedVisionConfig(
            name="MSD_BoxSize_Task14_Sagittal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task14_Sagittal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task14_Coronal_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task14_Coronal_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task14_Axial_Train",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_BoxSize_Task14_Axial_Test",
            dataset_name="MSD",
            taskType="Box-Size",
            taskID="14",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task01_Axial_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task01_Axial_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Tumor-Lesion-Size:Task02
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task02_Sagittal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task02_Sagittal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task02_Coronal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task02_Coronal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task02_Axial_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task02_Axial_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Tumor-Lesion-Size:Task03
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task03_Sagittal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task03_Sagittal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task03_Coronal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task03_Coronal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task03_Axial_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task03_Axial_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Tumor-Lesion-Size:Task04
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task04_Sagittal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task04_Sagittal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task04_Coronal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task04_Coronal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task04_Axial_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task04_Axial_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Tumor-Lesion-Size:Task05
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task05_Sagittal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task05_Sagittal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task05_Coronal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task05_Coronal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task05_Axial_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task05_Axial_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Tumor-Lesion-Size:Task06
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task06_Sagittal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task06_Sagittal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task06_Coronal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task06_Coronal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task06_Axial_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task06_Axial_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="06",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Tumor-Lesion-Size:Task07
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task07_Sagittal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task07_Sagittal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task07_Coronal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task07_Coronal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task07_Axial_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task07_Axial_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="07",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSD:Tumor-Lesion-Size:Task08
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task08_Sagittal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task08_Sagittal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task08_Coronal_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task08_Coronal_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task08_Axial_Train",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSD_TumorLesionSize_Task08_Axial_Test",
            dataset_name="MSD",
            taskType="Tumor-Lesion-Size",
            taskID="08",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # OAIZIB-CM:Mask-Size:Task01
        MedVisionConfig(
            name="OAIZIB-CM_MaskSize_Task01_Sagittal_Train",
            dataset_name="OAIZIB-CM",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_MaskSize_Task01_Sagittal_Test",
            dataset_name="OAIZIB-CM",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_MaskSize_Task01_Coronal_Train",
            dataset_name="OAIZIB-CM",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_MaskSize_Task01_Coronal_Test",
            dataset_name="OAIZIB-CM",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_MaskSize_Task01_Axial_Train",
            dataset_name="OAIZIB-CM",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_MaskSize_Task01_Axial_Test",
            dataset_name="OAIZIB-CM",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # OAIZIB-CM:Box-Size:Task01
        MedVisionConfig(
            name="OAIZIB-CM_BoxSize_Task01_Sagittal_Train",
            dataset_name="OAIZIB-CM",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_BoxSize_Task01_Sagittal_Test",
            dataset_name="OAIZIB-CM",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_BoxSize_Task01_Coronal_Train",
            dataset_name="OAIZIB-CM",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_BoxSize_Task01_Coronal_Test",
            dataset_name="OAIZIB-CM",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_BoxSize_Task01_Axial_Train",
            dataset_name="OAIZIB-CM",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="OAIZIB-CM_BoxSize_Task01_Axial_Test",
            dataset_name="OAIZIB-CM",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # SKM-TEA:Mask-Size:Task01
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task01_Sagittal_Train",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task01_Sagittal_Test",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task01_Coronal_Train",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task01_Coronal_Test",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task01_Axial_Train",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task01_Axial_Test",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # SKM-TEA:Mask-Size:Task02
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task02_Sagittal_Train",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task02_Sagittal_Test",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task02_Coronal_Train",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task02_Coronal_Test",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task02_Axial_Train",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_MaskSize_Task02_Axial_Test",
            dataset_name="SKM-TEA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # SKM-TEA:Box-Size:Task01
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task01_Sagittal_Train",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task01_Sagittal_Test",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task01_Coronal_Train",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task01_Coronal_Test",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task01_Axial_Train",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task01_Axial_Test",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # SKM-TEA:Box-Size:Task02
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task02_Sagittal_Train",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task02_Sagittal_Test",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task02_Coronal_Train",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task02_Coronal_Test",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task02_Axial_Train",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="SKM-TEA_BoxSize_Task02_Axial_Test",
            dataset_name="SKM-TEA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # ToothFairy2:Mask-Size:Task01
        MedVisionConfig(
            name="ToothFairy2_MaskSize_Task01_Sagittal_Train",
            dataset_name="ToothFairy2",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="ToothFairy2_MaskSize_Task01_Sagittal_Test",
            dataset_name="ToothFairy2",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="ToothFairy2_MaskSize_Task01_Coronal_Train",
            dataset_name="ToothFairy2",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="ToothFairy2_MaskSize_Task01_Coronal_Test",
            dataset_name="ToothFairy2",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="ToothFairy2_MaskSize_Task01_Axial_Train",
            dataset_name="ToothFairy2",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="ToothFairy2_MaskSize_Task01_Axial_Test",
            dataset_name="ToothFairy2",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # ToothFairy2:Box-Size:Task01
        MedVisionConfig(
            name="ToothFairy2_BoxSize_Task01_Sagittal_Train",
            dataset_name="ToothFairy2",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="ToothFairy2_BoxSize_Task01_Sagittal_Test",
            dataset_name="ToothFairy2",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="ToothFairy2_BoxSize_Task01_Coronal_Train",
            dataset_name="ToothFairy2",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="ToothFairy2_BoxSize_Task01_Coronal_Test",
            dataset_name="ToothFairy2",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="ToothFairy2_BoxSize_Task01_Axial_Train",
            dataset_name="ToothFairy2",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="ToothFairy2_BoxSize_Task01_Axial_Test",
            dataset_name="ToothFairy2",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # TopCoW24:Mask-Size:Task01
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task01_Sagittal_Train",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task01_Sagittal_Test",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task01_Coronal_Train",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task01_Coronal_Test",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task01_Axial_Train",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task01_Axial_Test",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # TopCoW24:Mask-Size:Task02
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task02_Sagittal_Train",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task02_Sagittal_Test",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task02_Coronal_Train",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task02_Coronal_Test",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task02_Axial_Train",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_MaskSize_Task02_Axial_Test",
            dataset_name="TopCoW24",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # TopCoW24:Box-Size:Task01
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task01_Sagittal_Train",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task01_Sagittal_Test",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task01_Coronal_Train",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task01_Coronal_Test",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task01_Axial_Train",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task01_Axial_Test",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # TopCoW24:Box-Size:Task02
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task02_Sagittal_Train",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task02_Sagittal_Test",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task02_Coronal_Train",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task02_Coronal_Test",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task02_Axial_Train",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="TopCoW24_BoxSize_Task02_Axial_Test",
            dataset_name="TopCoW24",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # TotalSegmentator:Mask-Size:Task01
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task01_Sagittal_Train",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task01_Sagittal_Test",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task01_Coronal_Train",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task01_Coronal_Test",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task01_Axial_Train",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task01_Axial_Test",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # TotalSegmentator:Mask-Size:Task02
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task02_Sagittal_Train",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task02_Sagittal_Test",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task02_Coronal_Train",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task02_Coronal_Test",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task02_Axial_Train",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_MaskSize_Task02_Axial_Test",
            dataset_name="TotalSegmentator",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # TotalSegmentator:Box-Size:Task01
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task01_Sagittal_Train",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task01_Sagittal_Test",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task01_Coronal_Train",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task01_Coronal_Test",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task01_Axial_Train",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task01_Axial_Test",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # TotalSegmentator:Box-Size:Task02
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task02_Sagittal_Train",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task02_Sagittal_Test",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task02_Coronal_Train",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task02_Coronal_Test",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task02_Axial_Train",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="TotalSegmentator_BoxSize_Task02_Axial_Test",
            dataset_name="TotalSegmentator",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # AFIDs:Biometrics-From-Landmarks:Task01
        MedVisionConfig(
            name="AFIDs_BiometricsFromLandmarks_Task01_Sagittal_Train",
            dataset_name="AFIDs",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="AFIDs_BiometricsFromLandmarks_Task01_Sagittal_Test",
            dataset_name="AFIDs",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="AFIDs_BiometricsFromLandmarks_Task01_Axial_Train",
            dataset_name="AFIDs",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="AFIDs_BiometricsFromLandmarks_Task01_Axial_Test",
            dataset_name="AFIDs",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="axial",
            split="test",
        ),
        # DEEP-PSMA:Mask-Size:Task01
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task01_Sagittal_Train",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task01_Sagittal_Test",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task01_Coronal_Train",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task01_Coronal_Test",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task01_Axial_Train",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task01_Axial_Test",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # DEEP-PSMA:Mask-Size:Task02
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task02_Sagittal_Train",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task02_Sagittal_Test",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task02_Coronal_Train",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task02_Coronal_Test",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task02_Axial_Train",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_MaskSize_Task02_Axial_Test",
            dataset_name="DEEP-PSMA",
            taskType="Mask-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # DEEP-PSMA:Box-Size:Task01
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task01_Sagittal_Train",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task01_Sagittal_Test",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task01_Coronal_Train",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task01_Coronal_Test",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task01_Axial_Train",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task01_Axial_Test",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # DEEP-PSMA:Box-Size:Task02
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task02_Sagittal_Train",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task02_Sagittal_Test",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task02_Coronal_Train",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task02_Coronal_Test",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task02_Axial_Train",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_BoxSize_Task02_Axial_Test",
            dataset_name="DEEP-PSMA",
            taskType="Box-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            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",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_TumorLesionSize_Task01_Axial_Test",
            dataset_name="DEEP-PSMA",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            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",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="DEEP-PSMA_TumorLesionSize_Task02_Axial_Test",
            dataset_name="DEEP-PSMA",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # LIDC-IDRI:Box-Size:Task01
        MedVisionConfig(
            name="LIDC-IDRI_BoxSize_Task01_Sagittal_Train",
            dataset_name="LIDC-IDRI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_BoxSize_Task01_Sagittal_Test",
            dataset_name="LIDC-IDRI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_BoxSize_Task01_Coronal_Train",
            dataset_name="LIDC-IDRI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_BoxSize_Task01_Coronal_Test",
            dataset_name="LIDC-IDRI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_BoxSize_Task01_Axial_Train",
            dataset_name="LIDC-IDRI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_BoxSize_Task01_Axial_Test",
            dataset_name="LIDC-IDRI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # LIDC-IDRI:Mask-Size:Task01
        MedVisionConfig(
            name="LIDC-IDRI_MaskSize_Task01_Sagittal_Train",
            dataset_name="LIDC-IDRI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_MaskSize_Task01_Sagittal_Test",
            dataset_name="LIDC-IDRI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_MaskSize_Task01_Coronal_Train",
            dataset_name="LIDC-IDRI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_MaskSize_Task01_Coronal_Test",
            dataset_name="LIDC-IDRI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_MaskSize_Task01_Axial_Train",
            dataset_name="LIDC-IDRI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_MaskSize_Task01_Axial_Test",
            dataset_name="LIDC-IDRI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # LIDC-IDRI:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="LIDC-IDRI_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="LIDC-IDRI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="LIDC-IDRI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="LIDC-IDRI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="LIDC-IDRI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_TumorLesionSize_Task01_Axial_Train",
            dataset_name="LIDC-IDRI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="LIDC-IDRI_TumorLesionSize_Task01_Axial_Test",
            dataset_name="LIDC-IDRI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # LNQ2023:Box-Size:Task01
        MedVisionConfig(
            name="LNQ2023_BoxSize_Task01_Sagittal_Train",
            dataset_name="LNQ2023",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="LNQ2023_BoxSize_Task01_Sagittal_Test",
            dataset_name="LNQ2023",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="LNQ2023_BoxSize_Task01_Coronal_Train",
            dataset_name="LNQ2023",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="LNQ2023_BoxSize_Task01_Coronal_Test",
            dataset_name="LNQ2023",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="LNQ2023_BoxSize_Task01_Axial_Train",
            dataset_name="LNQ2023",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="LNQ2023_BoxSize_Task01_Axial_Test",
            dataset_name="LNQ2023",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # LNQ2023:Mask-Size:Task01
        MedVisionConfig(
            name="LNQ2023_MaskSize_Task01_Sagittal_Train",
            dataset_name="LNQ2023",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="LNQ2023_MaskSize_Task01_Sagittal_Test",
            dataset_name="LNQ2023",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="LNQ2023_MaskSize_Task01_Coronal_Train",
            dataset_name="LNQ2023",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="LNQ2023_MaskSize_Task01_Coronal_Test",
            dataset_name="LNQ2023",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="LNQ2023_MaskSize_Task01_Axial_Train",
            dataset_name="LNQ2023",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="LNQ2023_MaskSize_Task01_Axial_Test",
            dataset_name="LNQ2023",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            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",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="LNQ2023_TumorLesionSize_Task01_Axial_Test",
            dataset_name="LNQ2023",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MAMA-MIA:Box-Size:Task01
        MedVisionConfig(
            name="MAMA-MIA_BoxSize_Task01_Sagittal_Train",
            dataset_name="MAMA-MIA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MAMA-MIA_BoxSize_Task01_Sagittal_Test",
            dataset_name="MAMA-MIA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MAMA-MIA_BoxSize_Task01_Coronal_Train",
            dataset_name="MAMA-MIA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MAMA-MIA_BoxSize_Task01_Coronal_Test",
            dataset_name="MAMA-MIA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MAMA-MIA_BoxSize_Task01_Axial_Train",
            dataset_name="MAMA-MIA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MAMA-MIA_BoxSize_Task01_Axial_Test",
            dataset_name="MAMA-MIA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MAMA-MIA:Mask-Size:Task01
        MedVisionConfig(
            name="MAMA-MIA_MaskSize_Task01_Sagittal_Train",
            dataset_name="MAMA-MIA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MAMA-MIA_MaskSize_Task01_Sagittal_Test",
            dataset_name="MAMA-MIA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MAMA-MIA_MaskSize_Task01_Coronal_Train",
            dataset_name="MAMA-MIA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MAMA-MIA_MaskSize_Task01_Coronal_Test",
            dataset_name="MAMA-MIA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MAMA-MIA_MaskSize_Task01_Axial_Train",
            dataset_name="MAMA-MIA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MAMA-MIA_MaskSize_Task01_Axial_Test",
            dataset_name="MAMA-MIA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MAMA-MIA:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="MAMA-MIA_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="MAMA-MIA",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MAMA-MIA_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="MAMA-MIA",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MAMA-MIA_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="MAMA-MIA",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MAMA-MIA_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="MAMA-MIA",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MAMA-MIA_TumorLesionSize_Task01_Axial_Train",
            dataset_name="MAMA-MIA",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MAMA-MIA_TumorLesionSize_Task01_Axial_Test",
            dataset_name="MAMA-MIA",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # PDDCA:Mask-Size:Task01
        MedVisionConfig(
            name="PDDCA_MaskSize_Task01_Sagittal_Train",
            dataset_name="PDDCA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="PDDCA_MaskSize_Task01_Sagittal_Test",
            dataset_name="PDDCA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="PDDCA_MaskSize_Task01_Coronal_Train",
            dataset_name="PDDCA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="PDDCA_MaskSize_Task01_Coronal_Test",
            dataset_name="PDDCA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="PDDCA_MaskSize_Task01_Axial_Train",
            dataset_name="PDDCA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="PDDCA_MaskSize_Task01_Axial_Test",
            dataset_name="PDDCA",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # PDDCA:Box-Size:Task01
        MedVisionConfig(
            name="PDDCA_BoxSize_Task01_Sagittal_Train",
            dataset_name="PDDCA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="PDDCA_BoxSize_Task01_Sagittal_Test",
            dataset_name="PDDCA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="PDDCA_BoxSize_Task01_Coronal_Train",
            dataset_name="PDDCA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="PDDCA_BoxSize_Task01_Coronal_Test",
            dataset_name="PDDCA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="PDDCA_BoxSize_Task01_Axial_Train",
            dataset_name="PDDCA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="PDDCA_BoxSize_Task01_Axial_Test",
            dataset_name="PDDCA",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # PDDCA:Biometrics-From-Landmarks:Task01
        MedVisionConfig(
            name="PDDCA_BiometricsFromLandmarks_Task01_Sagittal_Train",
            dataset_name="PDDCA",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="PDDCA_BiometricsFromLandmarks_Task01_Sagittal_Test",
            dataset_name="PDDCA",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="PDDCA_BiometricsFromLandmarks_Task01_Axial_Train",
            dataset_name="PDDCA",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="PDDCA_BiometricsFromLandmarks_Task01_Axial_Test",
            dataset_name="PDDCA",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="axial",
            split="test",
        ),
        # PI-CAI:Box-Size:Task01
        MedVisionConfig(
            name="PI-CAI_BoxSize_Task01_Sagittal_Train",
            dataset_name="PI-CAI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="PI-CAI_BoxSize_Task01_Sagittal_Test",
            dataset_name="PI-CAI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="PI-CAI_BoxSize_Task01_Coronal_Train",
            dataset_name="PI-CAI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="PI-CAI_BoxSize_Task01_Coronal_Test",
            dataset_name="PI-CAI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="PI-CAI_BoxSize_Task01_Axial_Train",
            dataset_name="PI-CAI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="PI-CAI_BoxSize_Task01_Axial_Test",
            dataset_name="PI-CAI",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # PI-CAI:Mask-Size:Task01
        MedVisionConfig(
            name="PI-CAI_MaskSize_Task01_Sagittal_Train",
            dataset_name="PI-CAI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="PI-CAI_MaskSize_Task01_Sagittal_Test",
            dataset_name="PI-CAI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="PI-CAI_MaskSize_Task01_Coronal_Train",
            dataset_name="PI-CAI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="PI-CAI_MaskSize_Task01_Coronal_Test",
            dataset_name="PI-CAI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="PI-CAI_MaskSize_Task01_Axial_Train",
            dataset_name="PI-CAI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="PI-CAI_MaskSize_Task01_Axial_Test",
            dataset_name="PI-CAI",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # PI-CAI:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="PI-CAI_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="PI-CAI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="PI-CAI_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="PI-CAI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="PI-CAI_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="PI-CAI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="PI-CAI_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="PI-CAI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="PI-CAI_TumorLesionSize_Task01_Axial_Train",
            dataset_name="PI-CAI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="PI-CAI_TumorLesionSize_Task01_Axial_Test",
            dataset_name="PI-CAI",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # VerSe:Mask-Size:Task01
        MedVisionConfig(
            name="VerSe_MaskSize_Task01_Sagittal_Train",
            dataset_name="VerSe",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="VerSe_MaskSize_Task01_Sagittal_Test",
            dataset_name="VerSe",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="VerSe_MaskSize_Task01_Coronal_Train",
            dataset_name="VerSe",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="VerSe_MaskSize_Task01_Coronal_Test",
            dataset_name="VerSe",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="VerSe_MaskSize_Task01_Axial_Train",
            dataset_name="VerSe",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="VerSe_MaskSize_Task01_Axial_Test",
            dataset_name="VerSe",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # VerSe:Box-Size:Task01
        MedVisionConfig(
            name="VerSe_BoxSize_Task01_Sagittal_Train",
            dataset_name="VerSe",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="VerSe_BoxSize_Task01_Sagittal_Test",
            dataset_name="VerSe",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="VerSe_BoxSize_Task01_Coronal_Train",
            dataset_name="VerSe",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="VerSe_BoxSize_Task01_Coronal_Test",
            dataset_name="VerSe",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="VerSe_BoxSize_Task01_Axial_Train",
            dataset_name="VerSe",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="VerSe_BoxSize_Task01_Axial_Test",
            dataset_name="VerSe",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # VerSe:Biometrics-From-Landmarks:Task01
        MedVisionConfig(
            name="VerSe_BiometricsFromLandmarks_Task01_Sagittal_Train",
            dataset_name="VerSe",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="VerSe_BiometricsFromLandmarks_Task01_Sagittal_Test",
            dataset_name="VerSe",
            taskType="Biometrics-From-Landmarks",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BiometricsFromLandmarks,
            imageSliceType="sagittal",
            split="test",
        ),
        # MSWAL:Mask-Size:Task01
        MedVisionConfig(
            name="MSWAL_MaskSize_Task01_Sagittal_Train",
            dataset_name="MSWAL",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_MaskSize_Task01_Sagittal_Test",
            dataset_name="MSWAL",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_MaskSize_Task01_Coronal_Train",
            dataset_name="MSWAL",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_MaskSize_Task01_Coronal_Test",
            dataset_name="MSWAL",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_MaskSize_Task01_Axial_Train",
            dataset_name="MSWAL",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_MaskSize_Task01_Axial_Test",
            dataset_name="MSWAL",
            taskType="Mask-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_MaskSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSWAL:Box-Size:Task01
        MedVisionConfig(
            name="MSWAL_BoxSize_Task01_Sagittal_Train",
            dataset_name="MSWAL",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_BoxSize_Task01_Sagittal_Test",
            dataset_name="MSWAL",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_BoxSize_Task01_Coronal_Train",
            dataset_name="MSWAL",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_BoxSize_Task01_Coronal_Test",
            dataset_name="MSWAL",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_BoxSize_Task01_Axial_Train",
            dataset_name="MSWAL",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_BoxSize_Task01_Axial_Test",
            dataset_name="MSWAL",
            taskType="Box-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_BoxSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSWAL:Tumor-Lesion-Size:Task01
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task01_Sagittal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task01_Sagittal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task01_Coronal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task01_Coronal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task01_Axial_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task01_Axial_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="01",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSWAL:Tumor-Lesion-Size:Task02
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task02_Sagittal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task02_Sagittal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task02_Coronal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task02_Coronal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task02_Axial_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task02_Axial_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="02",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSWAL:Tumor-Lesion-Size:Task03
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task03_Sagittal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task03_Sagittal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task03_Coronal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task03_Coronal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task03_Axial_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task03_Axial_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="03",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSWAL:Tumor-Lesion-Size:Task04
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task04_Sagittal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task04_Sagittal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task04_Coronal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task04_Coronal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task04_Axial_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task04_Axial_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="04",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
        # MSWAL:Tumor-Lesion-Size:Task05
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task05_Sagittal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task05_Sagittal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="sagittal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task05_Coronal_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task05_Coronal_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="coronal",
            split="test",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task05_Axial_Train",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="train",
        ),
        MedVisionConfig(
            name="MSWAL_TumorLesionSize_Task05_Axial_Test",
            dataset_name="MSWAL",
            taskType="Tumor-Lesion-Size",
            taskID="05",
            imageType="2D",
            features_dict=features_dict_TumorLesionSize,
            imageSliceType="axial",
            split="test",
        ),
    ]

    # Mapping from dataset name to package name
    # NOTE: It is important to use the same dataset name as in:
    #   - MedVisionConfig()
    #   - DATASETS_NAME2PACKAGE
    # NOTE: only use "_" in package names
    DATASETS_NAME2PACKAGE = {
        "ACDC": "ACDC",
        "AMOS22": "AMOS22",
        "AbdomenAtlas1.0Mini": "AbdomenAtlas__1_0__Mini",
        "AbdomenCT-1K": "AbdomenCT_1K",
        "BCV15": "BCV15",
        "BraTS24": "BraTS24",
        "CAMUS": "CAMUS",
        "Ceph-Biometrics-400": "Ceph_Biometrics_400",
        "CrossMoDA": "CrossMoDA",
        "FLARE22": "FLARE22",
        "FeTA24": "FeTA24",
        "HNTSMRG24": "HNTSMRG24",
        "ISLES24": "ISLES24",
        "KiPA22": "KiPA22",
        "KiTS23": "KiTS23",
        "MSD": "MSD",
        "OAIZIB-CM": "OAIZIB_CM",
        "SKM-TEA": "SKM_TEA",
        "ToothFairy2": "ToothFairy2",
        "TopCoW24": "TopCoW24",
        "TotalSegmentator": "TotalSegmentator",
        "autoPET-III": "autoPET_III",
        "AFIDs": "AFIDs",
        "DEEP-PSMA": "DEEP_PSMA",
        "LIDC-IDRI": "LIDC_IDRI",
        "LNQ2023": "LNQ2023",
        "MAMA-MIA": "MAMA_MIA",
        "PDDCA": "PDDCA",
        "PI-CAI": "PICAI",
        "VerSe": "VerSe",
        "MSWAL": "MSWAL",
    }

    def _info(self):
        # Paused annotations are refused HERE, not in _split_generators, because
        # this is the only point every load passes through: datasets calls _info()
        # from DatasetBuilder.__init__, before the cache directory is consulted.
        # A user who already built an Arrow cache from the defective plan would
        # otherwise keep reading it — silently, and indefinitely — since a warm
        # cache never reaches _split_generators. The check needs no requested
        # version, so it holds even when MedVision_PLANNER_VERSION is unset.
        _kind = _PLAN_KIND_BY_TASKTYPE.get(self.config.taskType)
        if _fully_paused(self.config.dataset_name, _kind):
            raise _annotation_paused_error(
                self.config.dataset_name,
                self.config.taskType,
                _kind,
                _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(
            description=_DESCRIPTION + "\n" + dataset_description,
            features=Features(self.config.features_dict),
            citation=_CITATION,
            homepage=_HOME_PAGE,
            license=_LICENSE,
        )

    def _split_generators(self, dl_manager):
        # Annotation version must be explicitly chosen — silent upgrades break
        # reproducibility. Resolution is then per (dataset, plan-kind): each
        # config loads the newest annotation published at or before the
        # requested version, so a release that did not touch this dataset
        # cannot change what that dataset loads.
        _requested = _normalize_requested(
            os.environ.get("MedVision_PLANNER_VERSION"), self.config.version
        )
        dataset_name = self.config.dataset_name
        _kind = _PLAN_KIND_BY_TASKTYPE.get(self.config.taskType)
        if _kind is None:
            raise ValueError(f"Task type {self.config.taskType} not supported.")
        _check_biometry_family(dataset_name, self.config.taskType)

        # What the hub is known to hold for this pair, clamped to the request.
        # Decided from the index alone — no disk, no network — so a request the
        # data cannot satisfy fails before a single byte is downloaded.
        _declared = _declared_versions(dataset_name, _kind)
        if not _declared:
            raise RuntimeError(
                f"\n\nMedVision: no annotation versions declared for "
                f"'{dataset_name}' / '{_kind}'. _ANNOTATION_INDEX is out of sync "
                "with BUILDER_CONFIGS.\n"
            )
        _target = _resolve(_declared, _requested)
        if _target is None:
            raise _annotation_unavailable_error(
                dataset_name, self.config.taskType, _kind, _requested, _declared
            )
        # The _info() gate refuses a dataset whose every published version is
        # withheld. This one refuses a single withheld version, which is what the
        # ceiling resolution can still land on once the correction ships: a pin of
        # the paused version resolves to it in preference to nothing, so without
        # this the pause would quietly lift for exactly the users who pinned.
        if _target in _paused_versions(dataset_name, _kind):
            raise _annotation_paused_error(
                dataset_name, self.config.taskType, _kind, (_target,)
            )

        # Set root directory for MedVision data. Canonicalised once, here, and
        # nowhere else: dataset_dir derived from it is handed to the per-dataset
        # download scripts, each of which starts with its own os.chdir(dataset_dir)
        # after step 3.2 has already chdir'd there — a relative root makes that second
        # chdir resolve against the first and fail for every dataset. It also reaches
        # _update_download_status while the cwd is src_dir. Must use the SAME
        # canonicalisation as create_config_id, or "./data" and "/abs/data" get two
        # Arrow caches for one root.
        MedVision_data_dir = _data_root()
        os.makedirs(MedVision_data_dir, exist_ok=True)

        # Add a cache tracking mechanism
        dataset_cache_file = os.path.join(MedVision_data_dir, ".downloaded_datasets.json")
        dataset_cache_lock_file = dataset_cache_file + ".lock"

        # Helper function to update download status with file lock
        def _update_download_status(key, value=True):
            with FileLock(dataset_cache_lock_file):
                # Reload to get latest state
                current_status = {}
                if os.path.exists(dataset_cache_file):
                    try:
                        with open(dataset_cache_file, "r") as f:
                            current_status = json.load(f)
                    except Exception:
                        current_status = {}
                
                current_status[key] = value
                
                with open(dataset_cache_file, "w") as f:
                    json.dump(current_status, f)
            
            # Update local variable
            downloaded_datasets[key] = value

        # Load existing download cache if it exists
        downloaded_datasets = {}
        with FileLock(dataset_cache_lock_file):
            if os.path.exists(dataset_cache_file):
                try:
                    logger.info(f"Checking dataset download status from: {dataset_cache_file}")
                    with open(dataset_cache_file, "r") as f:
                        downloaded_datasets = json.load(f)
                        # Print current download status
                        for ds_name, status in downloaded_datasets.items():
                            logger.info(f" - Dataset/Package <{ds_name}> download status: {status}")
                except Exception as e:
                    # If the dataset download status file exists but failed to read, raise an error
                    logger.error(
                        f"Fail to read dataset status tracker file: {dataset_cache_file}\nError: {e}"
                    )

        # Check if we should force downloads based on environment variables
        print("\n[Info] Checking environment variables for download options...")
        print("       - MedVision_FORCE_DOWNLOAD_DATA:", os.environ.get("MedVision_FORCE_DOWNLOAD_DATA", "False"))
        print("       - MedVision_FORCE_INSTALL_CODE:", os.environ.get("MedVision_FORCE_INSTALL_CODE", "True"))
        print("       - MedVision_DOWNLOAD_QC_FIGURES:", os.environ.get("MedVision_DOWNLOAD_QC_FIGURES", "False"))
        force_download_data = (
            os.environ.get("MedVision_FORCE_DOWNLOAD_DATA", "False").lower()
            == "true"
        )
        force_install_code = (
            os.environ.get("MedVision_FORCE_INSTALL_CODE", "True").lower()
            == "true"
        )
        # Opt-in: the QC figures ship in their own archives and are not needed to
        # load any config. Default off — see step 3.5.
        download_qc_figures = (
            os.environ.get("MedVision_DOWNLOAD_QC_FIGURES", "False").lower()
            == "true"
        )

        # Track if we've already downloaded this dataset in this run
        dataset_dir = os.path.join(MedVision_data_dir, "Datasets", dataset_name)

        # Gate: selecting an annotation older than the newest published FOR THIS
        # dataset/task requires explicit acknowledgement (MedVision_ACK_RELEASE).
        # Comparing per pair rather than against the release version means a
        # release that did not regenerate this dataset does not block it, while
        # the acknowledgement value stays the release version so a bump still
        # invalidates old acknowledgements. Fail fast, before any download.
        _enforce_release_ack(
            _requested,
            max(_declared, key=_version_tuple),
            ack_value=self.config.version,
            dataset_name=dataset_name,
            plan_kind=_kind,
        )

        # 1. Codebase download - should happen only once globally
        if force_install_code or downloaded_datasets.get("medvision_ds") != self.config.version:
            logger.info("Downloading the <medvision_ds> package from HuggingFace...")
            snapshot_download(
                repo_id="YongchengYAO/MedVision",
                repo_type="dataset",
                allow_patterns=["src/*"],
                local_dir=MedVision_data_dir,
                max_workers=self.config.num_proc,
            )
            # Mark codebase as downloaded with version
            _update_download_status("medvision_ds", self.config.version)
        else:
            logger.info("Using cached <medvision_ds> package")

        # Make sure we point to the src directory itself
        src_dir = os.path.join(MedVision_data_dir, "src")
        logger.info(f" - Code located at: {src_dir}")

        # 2. Package installation - should happen only once globally
        if force_install_code or downloaded_datasets.get("medvision_ds_installed") != self.config.version:
            logger.info("Installing the <medvision_ds> package...")
            current_dir = os.getcwd()
            os.chdir(src_dir)
            try:
                logger.info(f"Installing <medvision_ds>: pip install {src_dir}")
                subprocess.run(
                    [sys.executable, "-m", "pip", "install", "."],
                    check=True,
                    capture_output=True,
                    text=True,
                )
                logger.info(" - The <medvision_ds> package installed successfully")
                # A package installed after this interpreter started is invisible
                # to import_module until the finder caches are dropped.
                importlib.invalidate_caches()
                # Mark package as installed with version
                _update_download_status("medvision_ds_installed", self.config.version)
            except subprocess.CalledProcessError as e:
                # Failing loudly here is deliberate: swallowing this error lets
                # execution reach the medvision_ds import below, which then dies
                # with a ModuleNotFoundError that hides the real cause.
                raise RuntimeError(
                    f"Failed to install the <medvision_ds> package from {src_dir}.\n"
                    f"pip stderr (last 3000 chars):\n{(e.stderr or '')[-3000:]}"
                ) from e
            finally:
                os.chdir(current_dir)
        else:
            logger.info("Using installed <medvision_ds> package")

        # 3. Dataset download — download only when what is on DISK cannot serve
        # the version the index says is obtainable for this request.
        #
        # Both sides of the comparison are resolutions of the SAME request: the
        # index side (_target) is the best version the hub can offer for this
        # pin, the disk side (_local) is the best version already present for it.
        # Comparing resolutions rather than raw maxima is what makes a downgrade
        # a no-op: annotation zips are cumulative, so the older file a downgrade
        # wants is already on disk.
        #
        # This replaces a VERSION comparison against .downloaded_datasets.json,
        # which recorded the version REQUESTED rather than the one obtained and
        # could therefore claim a version the dataset does not possess. Reading
        # the directory instead makes the version decision self-healing: a
        # poisoned entry no longer suppresses a download that is genuinely needed.
        #
        # The tracker entry is still consulted, but only for PRESENCE. It is
        # written at step 3.4, after the images (3.2) and the RAS+ reorientation
        # (3.3); the annotation plans this globs are extracted at step 3.1,
        # before them. Without the presence check, a run that dies anywhere
        # between 3.1 and 3.4 — a dropped connection, OOM, Ctrl-C, eviction —
        # would leave plans on disk with no images, and every later run would
        # classify that as complete, skip the download forever, and happily
        # yield rows whose image_file/mask_file paths do not exist. Step 3.2
        # swallows nothing, so a failed download raises out of here and leaves
        # no marker; this presence check covers the deaths no handler can see.
        # Presence-only (not a version comparison) keeps the advisory value
        # written at 3.4 compatible, and complete installs made by earlier
        # versions already carry this key, so nothing re-downloads en masse.
        _local = _resolve(_discover_versions(dataset_dir, _kind), _requested)
        _needs_download = _download_needed(
            force_download_data,
            downloaded_datasets.get(f"dataset_{dataset_name}"),
            _local,
            _target,
        )
        if _needs_download:
            logger.info(f"Downloading annotations to: {dataset_dir}")

            # 3.1 Download and extract the annotations.
            #
            # The lock below spans 3.1-3.3, not just 3.1. Step 3.2 runs a download script
            # that stages through a FIXED <dataset_dir>/tmp path and finishes with
            # move_folder into the shared dataset tree, and step 3.3 rewrites every volume
            # in that tree in place. HF's builder lock is per CONFIG, so two configs of one
            # dataset reach both steps at once and would otherwise download the same
            # gigabytes twice into the same staging path and reorient the same files
            # concurrently. Serialising is worth a waiter that redoes the download.
            #
            # Not claimed: that this lock has anything to do with the stale Images/Images
            # trees still on disk under BraTS24, BCV15 and FeTA24. Those came from the
            # ORIGINAL move_folder (33736c9), whose per-item loop was an unconditional
            # shutil.move(s, d) — that nests on any plain re-run, one process, no
            # concurrency involved. 853dbfd added the isdir guard and stopped it; every
            # surviving nest is stamped 2025-10-24..2025-11-04, inside that window, and
            # none postdates it. They are inert duplicates awaiting a one-off cleanup, not
            # evidence of a race. The two hazards above are real and independent of them.
            #
            # Datasets/<name>.zip is ONE shared path per dataset, and the lock used
            # elsewhere in this method guards only .downloaded_datasets.json. HF's own
            # builder lock is per CONFIG — Train and Test of one task are two configs —
            # so without this, two concurrent preparations of the same dataset both saw
            # the tracker entry absent, both downloaded, both extractall'd into the same
            # tree, and whichever finished second died at os.remove with a bare
            # FileNotFoundError. Own the whole download -> extract -> delete lifetime
            # per dataset, and re-check inside the lock so the waiter skips instead of
            # repeating the work. Lock order is always zip-lock -> tracker-lock; step
            # 3.4 stays outside this block so it can never invert.
            _zip_lock_file = os.path.join(
                MedVision_data_dir, f".{dataset_name}.zip.lock"
            )
            with FileLock(_zip_lock_file):
                # Lock-local: another process may have extracted while we waited.
                # Deliberately not `_local` — that is re-derived after the
                # extraction below, so a carry-over here would be stale.
                #
                # force_download_data must bypass this. Without it the guard
                # swallows the one case the flag exists for: a plan file that was
                # rewritten in place at the same version is already >= _target, so
                # a user told to set MedVision_FORCE_DOWNLOAD_DATA to refresh a
                # stale annotation would get the images re-fetched and keep the
                # stale plan.
                _have = _resolve(_discover_versions(dataset_dir, _kind), _requested)
                if (
                    not force_download_data
                    and _have is not None
                    and _version_tuple(_have) >= _version_tuple(_target)
                ):
                    logger.info(
                        f" - Annotations for {dataset_name} were prepared by another "
                        "process while waiting; skipping the download"
                    )
                else:
                    snapshot_download(
                        repo_id="YongchengYAO/MedVision",
                        repo_type="dataset",
                        allow_patterns=[f"Datasets/{dataset_name}.zip"],
                        local_dir=MedVision_data_dir,
                        max_workers=self.config.num_proc,
                    )
                    zipfile_path = os.path.join(
                        MedVision_data_dir, "Datasets", f"{dataset_name}.zip"
                    )
                    with zipfile.ZipFile(zipfile_path, "r") as zip_ref:
                        zip_ref.extractall(os.path.join(MedVision_data_dir, "Datasets"))
                    os.remove(zipfile_path)
                    logger.info(f" - Annotations downloaded to: {dataset_dir}")

                # 3.2 Download and process the image and/or mask files
                logger.info("Downloading and processing image and/or mask files...")
                # Look for download scripts in package_dir
                dataset_package_name = self.DATASETS_NAME2PACKAGE[dataset_name]
                package_medvision_ds = importlib.import_module("medvision_ds")
                package_dir_medvision_datasets = os.path.join(
                    os.path.dirname(os.path.abspath(package_medvision_ds.__file__)),
                    "datasets",
                )
                package_dir_medvision_dataset = os.path.join(
                    package_dir_medvision_datasets, dataset_package_name
                )
                download_scripts = ["download_debug.py", "download.py", "download_fast.py", "download_raw.py"]
                download_script_chosen = None
                for script in download_scripts:
                    script_path = os.path.join(package_dir_medvision_dataset, script)
                    if os.path.exists(script_path):
                        download_script_chosen = script
                        break
                    else:
                        continue
                if download_script_chosen is None:
                    raise ValueError(
                        f"Missing download script. There should be at least one of {download_scripts} in {package_dir_medvision_dataset}"
                    )
                # Use importlib to dynamically import the download module
                current_dir = os.getcwd()
                os.chdir(dataset_dir)
                try:
                    logger.info(f" - Using download script: {download_script_chosen}")
                    script_path = os.path.join(
                        package_dir_medvision_dataset, download_script_chosen
                    )
                    spec = importlib.util.spec_from_file_location(
                        "download_module", script_path
                    )
                    download_module = importlib.util.module_from_spec(spec)
                    spec.loader.exec_module(download_module)
                    # Execute the download function if it exists
                    if hasattr(download_module, "download_and_extract"):
                        # Choose the calling convention BEFORE transferring anything,
                        # then call exactly once. The old form passed max_workers
                        # inside a bare `except:` that re-called without it. That
                        # handler caught BaseException, so a Ctrl-C hours into a
                        # multi-GB transfer was swallowed and the download restarted
                        # from the top, and every genuine failure (network, disk,
                        # OOM) was retried blind on a half-written tree. Its stated
                        # purpose was unreachable: every shipped download script
                        # accepts max_workers or **kwargs, so the TypeError it
                        # guarded against could never be raised. Binding the
                        # signature is a pure check that touches no disk, so it
                        # cannot mask a transfer failure.
                        _dl_kwargs = {"max_workers": self.config.num_proc}
                        try:
                            inspect.signature(download_module.download_and_extract).bind(
                                dataset_dir, dataset_name, **_dl_kwargs
                            )
                        except TypeError:
                            _dl_kwargs = {}
                        download_module.download_and_extract(
                            dataset_dir, dataset_name, **_dl_kwargs
                        )
                        logger.info(f" - Download completed for {dataset_name}")
                    else:
                        logger.warning(
                            f" - download_and_extract function not found in {download_script_chosen}"
                        )
                finally:
                    # A failed download must NOT reach steps 3.3/3.4: the tracker
                    # entry written there is the "install completed" marker, and
                    # swallowing the failure here would stamp it onto a dataset with
                    # no images — which the download predicate then trusts forever.
                    # Restore the cwd and let the exception out.
                    os.chdir(current_dir)

                # 3.3 Standardize the image and/or mask files: convert NIfTI files to RAS+ orientation
                # NOTE: MUST NOT move the import to the front, as the "medvision_ds" package may not be installed yet at the beginning
                from medvision_ds.utils.data_conversion import reorient_niigz_RASplus_batch_inplace

                reorient_niigz_RASplus_batch_inplace(dataset_dir, workers_limit=self.config.num_proc)

            # 3.4 Re-resolve against what actually landed, and record the highest
            # annotation version now present — not the version requested. The old
            # behaviour stored the request, so a pin of 1.2.0 stamped "1.2.0" onto
            # datasets whose newest annotation is 1.0.0. Only the entry's VALUE
            # is advisory — the version decision above is taken from the disk —
            # but its PRESENCE is load-bearing: it is the "3.1-3.3 all completed"
            # marker that the predicate tests, which is why this must stay last
            # and must not be reachable when step 3.2 fails. An older
            # MedVision.py reading the value still behaves correctly because
            # on-disk-max >= any pin it can satisfy.
            _present = _discover_versions(dataset_dir, _kind)
            _local = _resolve(_present, _requested)
            _update_download_status(
                f"dataset_{dataset_name}",
                max(_present, key=_version_tuple) if _present else _target,
            )
        else:
            logger.info(f" - Using existing dataset at: {dataset_dir}")

        # The download either produced an annotation good enough for this request
        # or the index disagrees with the published data. Either way, never carry
        # a non-existent path forward: that is what used to crash inside
        # _generate_examples at gzip.open() with no version context.
        if _local is None or _version_tuple(_local) < _version_tuple(_target):
            raise _annotation_integrity_error(
                dataset_name, _kind, _requested, _target,
                _discover_versions(dataset_dir, _kind),
            )

        # 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:
            _try_ensure_qc_figures(
                dataset_name, _requested, MedVision_data_dir, self.config.num_proc
            )

        # 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
        from medvision_ds.utils.benchmark_planner import (
            MedVision_BenchmarkPlannerSegmentation,
            MedVision_BenchmarkPlannerDetection,
            MedVision_BenchmarkPlannerBiometry,
            MedVision_BenchmarkPlannerBiometry_fromSeg,
        )

        if self.config.taskType in ["Biometrics-From-Landmarks", "Biometrics-From-Landmarks-Distance", "Biometrics-From-Landmarks-Angle"]:
            get_bm_plan_file = MedVision_BenchmarkPlannerBiometry.get_bm_plan_file
        elif self.config.taskType == "Mask-Size":
            get_bm_plan_file = (
                MedVision_BenchmarkPlannerSegmentation.get_bm_plan_file
            )
        elif self.config.taskType == "Box-Size":
            get_bm_plan_file = MedVision_BenchmarkPlannerDetection.get_bm_plan_file
        elif self.config.taskType == "Tumor-Lesion-Size":
            get_bm_plan_file = (
                MedVision_BenchmarkPlannerBiometry_fromSeg.get_bm_plan_file
            )
        else:
            raise ValueError(f"Task type {self.config.taskType} not supported.")

        # The plan-kind mapping above (_PLAN_KIND_BY_TASKTYPE) and the package's
        # own get_bm_plan_file encode the same filename convention in two places.
        # Assert they agree so the duplication cannot drift silently.
        bm_plan_file = get_bm_plan_file(dataset_dir, _local)
        _expected = _plan_path(dataset_dir, _kind, _local)
        if bm_plan_file != _expected:
            raise RuntimeError(
                "\n\nMedVision: plan filename convention drift.\n"
               f"  medvision_ds : {bm_plan_file}\n"
               f"  MedVision.py : {_expected}\n"
            )
        # `_local` came out of a glob of real files, so this can only trip on a
        # concurrent delete between that glob and here. Cheap insurance against
        # ever handing _generate_examples a path that does not exist — which is
        # what used to surface as a bare gzip.open() failure with no context.
        if not os.path.exists(bm_plan_file):
            raise _annotation_integrity_error(
                dataset_name, _kind, _requested, _target,
                _discover_versions(dataset_dir, _kind),
            )
        logger.info(
            "Annotation: %s / %s — requested %s, resolved v%s",
            dataset_name, _kind, _requested, _local,
        )

        # Only generate the requested split
        if self.config.split == "train":
            return [
                SplitGenerator(
                    name=Split.TRAIN,
                    gen_kwargs={
                        "dataset_name": self.config.dataset_name,
                        "dataset_dir": dataset_dir,
                        "bm_plan_file": bm_plan_file,
                        "split": "train",
                        "taskID": self.config.taskID,
                        "taskType": self.config.taskType,
                        "imageType": self.config.imageType,
                        "imageSliceType": self.config.imageSliceType,
                    },
                )
            ]
        elif self.config.split == "test":
            return [
                SplitGenerator(
                    name=Split.TEST,
                    gen_kwargs={
                        "dataset_name": self.config.dataset_name,
                        "dataset_dir": dataset_dir,
                        "bm_plan_file": bm_plan_file,
                        "split": "test",
                        "taskID": self.config.taskID,
                        "taskType": self.config.taskType,
                        "imageType": self.config.imageType,
                        "imageSliceType": self.config.imageSliceType,
                    },
                )
            ]
        # Generate both train and test splits (for lazy configuration where split is None)
        elif self.config.split is None:
            return [
                SplitGenerator(
                    name=Split.TRAIN,
                    gen_kwargs={
                        "dataset_name": self.config.dataset_name,
                        "dataset_dir": dataset_dir,
                        "bm_plan_file": bm_plan_file,
                        "split": "train",
                        "taskID": self.config.taskID,
                        "taskType": self.config.taskType,
                        "imageType": self.config.imageType,
                        "imageSliceType": self.config.imageSliceType,
                    },
                ),
                SplitGenerator(
                    name=Split.TEST,
                    gen_kwargs={
                        "dataset_name": self.config.dataset_name,
                        "dataset_dir": dataset_dir,
                        "bm_plan_file": bm_plan_file,
                        "split": "test",
                        "taskID": self.config.taskID,
                        "taskType": self.config.taskType,
                        "imageType": self.config.imageType,
                        "imageSliceType": self.config.imageSliceType,
                    },
                ),
            ]
        else:
            raise ValueError(f"Invalid split: {self.config.split}")

    def _generate_examples(
        self,
        dataset_name,
        dataset_dir,
        bm_plan_file,
        split,
        taskID,
        taskType,
        imageType,
        imageSliceType,
    ):
        # NOTE: MUST NOT move the import to the front, as the "medvision_ds" package may not be installed yet at the beginning
        from medvision_ds.utils.benchmark_planner import (
            MedVision_BenchmarkPlannerSegmentation,
            MedVision_BenchmarkPlannerDetection,
            MedVision_BenchmarkPlannerBiometry,
            MedVision_BenchmarkPlannerBiometry_fromSeg,
        )

        # Load benchmark plan file
        if bm_plan_file.endswith(".gz"):
            with gzip.open(bm_plan_file, "rt") as f:
                benchmark_plan = json.load(f)
        else:
            with open(bm_plan_file, "r") as f:
                benchmark_plan = json.load(f)

        # Get annotation data: a list of dictionaries
        if split == "train":
            biometricData = benchmark_plan["tasks"][int(taskID) - 1]["train_cases"]
        elif split == "test":
            biometricData = benchmark_plan["tasks"][int(taskID) - 1]["test_cases"]
        else:
            raise ValueError(f"Unknown split: {split}")

        # Env var to disable per-sample quality filtering. When true, the size/cluster
        # exclusion filters below are bypassed so every sample in the planner is returned.
        # The distance/angle metric_type split (task partitioning) is always preserved.
        disable_sample_filtering = (
            os.environ.get("MedVision_DISABLE_SAMPLE_FILTERING", "False").lower()
            == "true"
        )
        if disable_sample_filtering:
            logger.info(
                "MedVision_DISABLE_SAMPLE_FILTERING=true — quality/size sample filters bypassed"
            )

        # Task type: Mask-Size
        if taskType == "Mask-Size":
            flatten_slice_profiles = (
                MedVision_BenchmarkPlannerSegmentation.flatten_slice_profiles_2d
            )
            if imageSliceType.lower() == "sagittal":
                slice_dim = 0
            elif imageSliceType.lower() == "coronal":
                slice_dim = 1
            elif imageSliceType.lower() == "axial":
                slice_dim = 2
            slice_profile_flattened = flatten_slice_profiles(biometricData, slice_dim)
            for idx, case in enumerate(slice_profile_flattened):
                # Skip cases with a mask size smaller than 200 pixels
                if not disable_sample_filtering and case["pixel_count"] < 200:
                    continue
                else:
                    yield idx, {
                        "dataset_name": dataset_name,
                        "taskID": taskID,
                        "taskType": taskType,
                        "image_file": os.path.join(dataset_dir, case["image_file"]),
                        "mask_file": os.path.join(dataset_dir, case["mask_file"]),
                        "slice_dim": case["slice_dim"],
                        "slice_idx": case["slice_idx"],
                        "label": case["label"],
                        "image_size_2d": case["image_size_2d"],
                        "pixel_size": case["pixel_size"],
                        "image_size_3d": case["image_size_3d"],
                        "voxel_size": case["voxel_size"],
                        "pixel_count": case["pixel_count"],
                        "ROI_area": case["ROI_area"],
                    }

        # Task type: Box-Size
        if taskType == "Box-Size":
            if imageType.lower() == "2d":
                flatten_slice_profiles = (
                    MedVision_BenchmarkPlannerDetection.flatten_slice_profiles_2d
                )
                if imageSliceType.lower() == "sagittal":
                    slice_dim = 0
                elif imageSliceType.lower() == "coronal":
                    slice_dim = 1
                elif imageSliceType.lower() == "axial":
                    slice_dim = 2
                slice_profile_flattened = flatten_slice_profiles(
                    biometricData, slice_dim
                )
                for idx, case in enumerate(slice_profile_flattened):
                    # Skip cases with multiple bounding boxes in the same slice
                    if not disable_sample_filtering and len(case["bounding_boxes"]) > 1:
                        continue
                    # Skip cases with a bounding box size smaller than 10 pixels in any dimension
                    elif not disable_sample_filtering and (
                        case["bounding_boxes"][0]["dimensions"][0] < 10
                        or case["bounding_boxes"][0]["dimensions"][1] < 10
                    ):
                        continue
                    else:
                        yield idx, {
                            "dataset_name": dataset_name,
                            "taskID": taskID,
                            "taskType": taskType,
                            "image_file": os.path.join(dataset_dir, case["image_file"]),
                            "mask_file": os.path.join(dataset_dir, case["mask_file"]),
                            "slice_dim": case["slice_dim"],
                            "slice_idx": case["slice_idx"],
                            "label": case["label"],
                            "image_size_2d": case["image_size_2d"],
                            "pixel_size": case["pixel_size"],
                            "image_size_3d": case["image_size_3d"],
                            "voxel_size": case["voxel_size"],
                            "bounding_boxes": case["bounding_boxes"],
                        }

        # Task type: Biometrics-From-Landmarks
        if taskType == "Biometrics-From-Landmarks":
            if imageType.lower() == "2d":
                flatten_slice_profiles = (
                    MedVision_BenchmarkPlannerBiometry.flatten_slice_profiles_2d
                )
                if imageSliceType.lower() == "sagittal":
                    slice_dim = 0
                elif imageSliceType.lower() == "coronal":
                    slice_dim = 1
                elif imageSliceType.lower() == "axial":
                    slice_dim = 2
                slice_profile_flattened = flatten_slice_profiles(
                    biometricData, slice_dim
                )
                for idx, case in enumerate(slice_profile_flattened):
                    yield idx, {
                        "dataset_name": dataset_name,
                        "taskID": taskID,
                        "taskType": taskType,
                        "image_file": os.path.join(dataset_dir, case["image_file"]),
                        "landmark_file": os.path.join(
                            dataset_dir, case["landmark_file"]
                        ),
                        "slice_dim": case["slice_dim"],
                        "slice_idx": case["slice_idx"],
                        "image_size_2d": case["image_size_2d"],
                        "pixel_size": case["pixel_size"],
                        "image_size_3d": case["image_size_3d"],
                        "voxel_size": case["voxel_size"],
                        "biometric_profile": case["biometric_profile"],
                    }

        # Task type: Biometrics-From-Landmarks-Distance
        if taskType == "Biometrics-From-Landmarks-Distance":
            if imageType.lower() == "2d":
                flatten_slice_profiles = (
                    MedVision_BenchmarkPlannerBiometry.flatten_slice_profiles_2d
                )
                if imageSliceType.lower() == "sagittal":
                    slice_dim = 0
                elif imageSliceType.lower() == "coronal":
                    slice_dim = 1
                elif imageSliceType.lower() == "axial":
                    slice_dim = 2
                slice_profile_flattened = flatten_slice_profiles(
                    biometricData, slice_dim
                )
                for idx, case in enumerate(slice_profile_flattened):
                    if case["biometric_profile"]["metric_type"] == "distance":
                        yield idx, {
                            "dataset_name": dataset_name,
                            "taskID": taskID,
                            "taskType": taskType,
                            "image_file": os.path.join(dataset_dir, case["image_file"]),
                            "landmark_file": os.path.join(
                                dataset_dir, case["landmark_file"]
                            ),
                            "slice_dim": case["slice_dim"],
                            "slice_idx": case["slice_idx"],
                            "image_size_2d": case["image_size_2d"],
                            "pixel_size": case["pixel_size"],
                            "image_size_3d": case["image_size_3d"],
                            "voxel_size": case["voxel_size"],
                            "biometric_profile": case["biometric_profile"],
                        }

        # Task type: Biometrics-From-Landmarks-Angle
        if taskType == "Biometrics-From-Landmarks-Angle":
            if imageType.lower() == "2d":
                flatten_slice_profiles = (
                    MedVision_BenchmarkPlannerBiometry.flatten_slice_profiles_2d
                )
                if imageSliceType.lower() == "sagittal":
                    slice_dim = 0
                elif imageSliceType.lower() == "coronal":
                    slice_dim = 1
                elif imageSliceType.lower() == "axial":
                    slice_dim = 2
                slice_profile_flattened = flatten_slice_profiles(
                    biometricData, slice_dim
                )
                for idx, case in enumerate(slice_profile_flattened):
                    if case["biometric_profile"]["metric_type"] == "angle":
                        yield idx, {
                            "dataset_name": dataset_name,
                            "taskID": taskID,
                            "taskType": taskType,
                            "image_file": os.path.join(dataset_dir, case["image_file"]),
                            "landmark_file": os.path.join(
                                dataset_dir, case["landmark_file"]
                            ),
                            "slice_dim": case["slice_dim"],
                            "slice_idx": case["slice_idx"],
                            "image_size_2d": case["image_size_2d"],
                            "pixel_size": case["pixel_size"],
                            "image_size_3d": case["image_size_3d"],
                            "voxel_size": case["voxel_size"],
                            "biometric_profile": case["biometric_profile"],
                        }

        # Task type: Tumor-Lesion-Size
        if taskType == "Tumor-Lesion-Size":
            if imageType.lower() == "2d":
                # Get the target label for the task
                target_label = benchmark_plan["tasks"][int(taskID) - 1]["target_label"]

                flatten_slice_profiles = (
                    MedVision_BenchmarkPlannerBiometry_fromSeg.flatten_slice_profiles_2d
                )
                if imageSliceType.lower() == "sagittal":
                    slice_dim = 0
                elif imageSliceType.lower() == "coronal":
                    slice_dim = 1
                elif imageSliceType.lower() == "axial":
                    slice_dim = 2
                slice_profile_flattened = flatten_slice_profiles(
                    biometricData, slice_dim
                )
                for idx, case in enumerate(slice_profile_flattened):
                    if not disable_sample_filtering:
                        n_total_clusters = case["n_total_clusters"]
                        if n_total_clusters is not None:
                            # New JSON (v1.1.0+): filter on raw cluster count
                            if n_total_clusters > 1:
                                continue
                        else:
                            # Old JSON (v1.0.0): fall back to above-threshold cluster count
                            if len(case["biometric_profile"]) > 1:
                                continue
                    yield idx, {
                        "dataset_name": dataset_name,
                        "taskID": taskID,
                        "taskType": taskType,
                        "image_file": os.path.join(dataset_dir, case["image_file"]),
                        "mask_file": os.path.join(dataset_dir, case["mask_file"]),
                        "landmark_file": os.path.join(
                            dataset_dir, case["landmark_file"]
                        ),
                        "slice_dim": case["slice_dim"],
                        "slice_idx": case["slice_idx"],
                        "label": target_label,
                        "image_size_2d": case["image_size_2d"],
                        "pixel_size": case["pixel_size"],
                        "image_size_3d": case["image_size_3d"],
                        "voxel_size": case["voxel_size"],
                        "biometric_profile": case["biometric_profile"],
                    }