#!/usr/bin/env python3 """Unit tests for per-(dataset, plan-kind) annotation version resolution. Every config loads the newest annotation published at or before the requested version. The invariant under test: For every config x every pin, resolution either returns a version that is declared for that (dataset, plan-kind), or raises the "not published at this version" error. There is no third outcome -- in particular, never a path that does not exist. Run: python scripts/test_annotation_resolution.py python scripts/test_annotation_resolution.py --datasets-root /path/to/Datasets Sections 1-4, 6 and 7 are pure and need no data on disk. Section 5 reconciles _ANNOTATION_INDEX against a real Datasets/ tree and is skipped when none is given. The repo has no test framework; this is a standalone script that exits non-zero on any failure, matching scripts/test_tl_ack_gate.py. """ import argparse import ast import importlib.util import inspect import os import re import shutil import sys import tempfile sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) import _medvision_test_support as _support # noqa: E402 _MEDVISION_PY = _support.MEDVISION_PY _INFO_CSV = _support.INFO_CSV mv = _support.load_loader("medvision_res_test_") PINS = ["1.0.0", "1.1.0", "1.1.1", "1.2.0", "1.2.1", "1.3.0", "latest"] RELEASE = "1.3.0" _results = [] def check(ok, desc, detail=""): _results.append(ok) print(f"[{'PASS' if ok else 'FAIL'}] {desc}" + (f" {detail}" if detail else "")) def section(title): print(f"\n--- {title} ---") # ---------------------------------------------------------------- 1. helpers section("1. Version helpers") check(mv._version_tuple("1.1.0") == (1, 1, 0), "parses 1.1.0") check(mv._version_tuple("1.2") == (1, 2, 0), "pads 1.2 -> (1,2,0)", "unpadded, (1,2) would sort BELOW (1,2,0)") check(mv._version_tuple(True) == (1, 0, 0), "legacy boolean True -> v1.0.0 baseline") check(mv._version_tuple(None) == (1, 0, 0), "None -> v1.0.0 baseline") check( mv._version_tuple("1.0.0") < mv._version_tuple("1.1.0") < mv._version_tuple("1.1.1") < mv._version_tuple("1.2.0"), "release ordering is strictly increasing", ) for good in ("1.0.0", "1.2.0", "10.20.30"): check(mv._is_version(good), f"_is_version accepts {good!r}") for bad in ("vdraft", "", "1.2", "v1.1.1", "1.2.0-rc1", "latest"): check(not mv._is_version(bad), f"_is_version rejects {bad!r}") # ------------------------------------------------------- 2. pin normalization section("2. Pin normalization") def _norm(raw): try: return mv._normalize_requested(raw, RELEASE) except EnvironmentError: return "RAISE" check(_norm(None) == "RAISE", "unset -> EnvironmentError") check(_norm("latest") == RELEASE, "latest -> release version") check(_norm("LATEST") == RELEASE, "LATEST is case-insensitive") check(_norm(" latest ") == RELEASE, "whitespace is stripped") check(_norm("1.1.1") == "1.1.1", "explicit version passes through") for bad in ("v1.1.1", "1.2", "", " ", "1.2.0-rc1"): check(_norm(bad) == "RAISE", f"malformed pin {bad!r} -> EnvironmentError", "previously collapsed to v1.0.0 and could load silently") # The accepted SET is derived from _ANNOTATION_INDEX, so a well-formed version # that was never published is refused rather than silently resolved down. check(mv._published_versions() == tuple(sorted({v for ks in mv._ANNOTATION_INDEX.values() for vs in ks.values() for v in vs}, key=mv._version_tuple)), "_published_versions is derived from _ANNOTATION_INDEX") for v in mv._published_versions(): check(_norm(v) == v, f"published version {v!r} is accepted") # RE-BASED twice: 1.3.0 used to sit in this list until MSWAL published it. for unknown in ("1.1.5", "1.0.1", "0.0.0", "1.2.2", "2.0.0", "999.999.999"): check(_norm(unknown) == "RAISE", f"unpublished version {unknown!r} -> EnvironmentError", "would otherwise resolve silently to an older annotation, or to nothing") # The release version must stay acceptable even when nothing is published at it, # or a version bump made before any regeneration would break `latest` outright. check(mv._normalize_requested("latest", "1.3.0") == "1.3.0", "latest still works when the release is ahead of every published annotation") check("1.3.0" in mv._acceptable_versions("1.3.0"), "the release version is always acceptable") check(set(mv._acceptable_versions(RELEASE)) == set(mv._published_versions()) | {RELEASE}, "acceptable = published versions + the release") # ------------------------------------------- 3. index / BUILDER_CONFIGS parity section("3. Index covers every config (and nothing extra)") configs = mv.MedVision.BUILDER_CONFIGS needed = set() for c in configs: kind = mv._PLAN_KIND_BY_TASKTYPE.get(c.taskType) if kind is None: check(False, f"taskType {c.taskType!r} missing from _PLAN_KIND_BY_TASKTYPE") else: needed.add((c.dataset_name, kind)) declared = {(ds, k) for ds, kinds in mv._ANNOTATION_INDEX.items() for k in kinds} # The released config list is the oracle, not a hardcoded 922 -- that count also # passes if a config is silently renamed. _released = {ln.split(",")[0].strip() for ln in open(_INFO_CSV, encoding="utf-8") if ln.strip()} _built = {c.name for c in configs} check(_built == _released, f"BUILDER_CONFIGS matches {os.path.basename(_INFO_CSV)} exactly", f"only in code: {sorted(_built - _released)[:3]} | " f"only in csv: {sorted(_released - _built)[:3]}") check(len(configs) == len(_released), f"{len(_released)} BUILDER_CONFIGS", f"got {len(configs)}") check(len(needed) == 75, "75 (dataset, plan-kind) pairs", f"got {len(needed)}") check(len({d for d, _ in needed}) == 31, "31 datasets", f"got {len({d for d, _ in needed})}") check(not (needed - declared), "every config's pair is declared", f"missing: {sorted(needed - declared)}") check(not (declared - needed), "no unreachable index entries", f"extra: {sorted(declared - needed)}") for ds, kinds in mv._ANNOTATION_INDEX.items(): for kind, versions in kinds.items(): check(bool(versions) and all(mv._is_version(v) for v in versions), f"{ds}/{kind} declares well-formed versions", str(versions)) check(list(versions) == sorted(versions, key=mv._version_tuple), f"{ds}/{kind} versions are ascending", str(versions)) # ------------------------------------------------- 4. biometry family hygiene section("4. Biometry families are disjoint") tl = {c.dataset_name for c in configs if c.taskType == "Tumor-Lesion-Size"} lm = {c.dataset_name for c in configs if c.taskType.startswith("Biometrics-From-Landmarks")} check(not (tl & lm), "no dataset carries both biometry families", f"overlap: {sorted(tl & lm)}") check(tl | lm == set(mv._BIOMETRY_FAMILY), "_BIOMETRY_FAMILY covers exactly the biometry datasets", f"symmetric difference: {sorted((tl | lm) ^ set(mv._BIOMETRY_FAMILY))}") for ds in tl: check(mv._BIOMETRY_FAMILY.get(ds) == "fromSeg", f"{ds} registered as fromSeg") for ds in lm: check(mv._BIOMETRY_FAMILY.get(ds) == "landmark", f"{ds} registered as landmark") # the guard itself try: mv._check_biometry_family("KiTS23", "Biometrics-From-Landmarks") check(False, "family mismatch raises") except RuntimeError: check(True, "family mismatch raises", "KiTS23 is fromSeg, asked as landmark") try: mv._check_biometry_family("KiTS23", "Tumor-Lesion-Size") check(True, "matching family passes") except RuntimeError as e: check(False, "matching family passes", str(e)) # ------------------------------------------------------- 5. index vs the disk section("5. Index reconciles with a real Datasets/ tree") ap = argparse.ArgumentParser() ap.add_argument("--datasets-root", default=None) args, _ = ap.parse_known_args() if not args.datasets_root: print("[SKIP] no --datasets-root given") else: root = args.datasets_root seen = 0 for ds, kinds in sorted(mv._ANNOTATION_INDEX.items()): ddir = os.path.join(root, ds) if not os.path.isdir(ddir): continue for kind, want in kinds.items(): got = mv._discover_versions(ddir, kind) if not got: print(f"[SKIP] {ds}/{kind}: not generated yet") continue seen += 1 check(list(got) == list(want), f"{ds}/{kind} disk matches index", f"disk={got} index={list(want)}") print(f" reconciled {seen} pair(s)") # ------------------------------------------------------------ 6. full sweep section("6. Full sweep: 992 configs x every pin") # 1.2.0 still resolves for every config: v1.2.0 stays DECLARED in the index # (MAMA-MIA/PI-CAI are withheld by _PAUSED_ANNOTATIONS, not by de-listing), # so resolution is unchanged and only the pause gate refuses those loads. # 1.2.0 no longer covers the whole catalogue: MAMA-MIA and PI-CAI withdrew their # v1.2.0 annotations, so their 36 configs have nothing at or below that pin. EXPECTED = {"1.0.0": (820, 172), "1.1.0": (820, 172), "1.1.1": (820, 172), "1.2.0": (914, 78), "1.2.1": (950, 42), "1.3.0": (992, 0), "latest": (992, 0)} for pin in PINS: requested = mv._normalize_requested(pin, RELEASE) resolved = unavailable = bad = 0 for c in configs: kind = mv._PLAN_KIND_BY_TASKTYPE[c.taskType] decl = mv._declared_versions(c.dataset_name, kind) got = mv._resolve(decl, requested) if got is None: unavailable += 1 elif got in decl and mv._version_tuple(got) <= mv._version_tuple(requested): resolved += 1 else: bad += 1 want_r, want_u = EXPECTED[pin] check(bad == 0, f"pin {pin}: no third outcome", f"invalid={bad}") check((resolved, unavailable) == (want_r, want_u), f"pin {pin}: {want_r} resolve / {want_u} unavailable", f"got {resolved}/{unavailable}") # the headline regression: TL at latest used to hand a non-existent path to # _generate_examples and crash at gzip.open() for ds in ["BraTS24", "HNTSMRG24", "KiPA22", "KiTS23", "MSD", "autoPET-III"]: got = mv._resolve(mv._declared_versions(ds, "biometry"), RELEASE) check(got == "1.1.1", f"{ds} biometry at latest -> 1.1.1", f"got {got}") # new datasets are unreachable below the version that introduced them, and that # must be an explicit refusal rather than a silent slide to something older. _INTRODUCED_120 = ["AFIDs", "DEEP-PSMA", "LIDC-IDRI", "LNQ2023", "PDDCA", "VerSe"] # MAMA-MIA and PI-CAI shipped at 1.2.0 but that annotation was WITHDRAWN (it was # recorded in the source orientation), so their earliest reachable version is # 1.2.1 and a 1.2.0 pin now finds nothing for them at all. _WITHDREW_120 = ["MAMA-MIA", "PI-CAI"] for ds in _INTRODUCED_120 + _WITHDREW_120: earliest = "1.2.1" if ds in _WITHDREW_120 else "1.2.0" for kind in mv._ANNOTATION_INDEX[ds]: declared = mv._declared_versions(ds, kind) check(mv._resolve(declared, "1.1.1") is None, f"{ds}/{kind} unavailable at 1.1.1") want = None if ds in _WITHDREW_120 else "1.2.0" got = mv._resolve(declared, "1.2.0") check(got == want, f"{ds}/{kind} at pin 1.2.0 -> {want}", f"got {got}") check(mv._resolve(declared, earliest) == earliest, f"{ds}/{kind} resolves at {earliest}") _INTRODUCED_130 = ["MSWAL"] for ds in _INTRODUCED_130: for kind in mv._ANNOTATION_INDEX[ds]: declared = mv._declared_versions(ds, kind) check(mv._resolve(declared, "1.2.1") is None, f"{ds}/{kind} unavailable at 1.2.1") check(mv._resolve(declared, "1.3.0") == "1.3.0", f"{ds}/{kind} resolves at 1.3.0") # ------------------------------------------------------- 7. download decision section("7. Download decision") def needs_download(declared, local_versions, requested, force=False, tracker="1.0.0"): """Drive the REAL predicate, mv._download_needed, not a copy of it. Only the two resolutions are done here, exactly as _split_generators does them. `tracker` is the `dataset_` entry of .downloaded_datasets.json, written only after the images land; None means "no completed install". This used to re-implement the predicate, which meant every row below could stay green while the shipped decision was broken. """ target = mv._resolve(declared, requested) local = mv._resolve(local_versions, requested) return mv._download_needed(force, tracker, local, target) KITS_BIO = ("1.0.0", "1.1.0", "1.1.1") ACDC_SEG = ("1.0.0",) # (declared, on-disk, pin, force, tracker, expect_download, description) DL_CASES = [ (ACDC_SEG, (), "1.2.0", False, None, True, "first-time download"), (ACDC_SEG, ("1.0.0",), "1.2.0", False, "1.0.0", False, "unchanged dataset at latest -> SKIP (was a ~28 GiB re-download)"), (KITS_BIO, ("1.0.0",), "1.1.1", False, "1.0.0", True, "v1.0.0-era copy, pin 1.1.1 -> DOWNLOAD (glob-only would skip: regression guard)"), (KITS_BIO, KITS_BIO, "1.0.0", False, "1.1.1", False, "downgrade with cumulative zip on disk -> SKIP"), (KITS_BIO, KITS_BIO, "1.1.1", False, "1.1.1", False, "already current -> SKIP"), (KITS_BIO, ("1.0.0",), "1.0.0", False, "1.0.0", False, "pin matches what is on disk -> SKIP"), (ACDC_SEG, ("1.0.0",), "1.2.0", True, "1.0.0", True, "force_download_data overrides"), (KITS_BIO, (), "1.1.1", False, "1.1.1", True, "plans deleted -> DOWNLOAD"), # a tracker entry recording a version the dataset does not possess must not # suppress a download the disk says is needed (KITS_BIO, ("1.0.0",), "1.1.1", False, "1.2.0", True, "poisoned tracker entry cannot suppress a needed download (self-heal)"), (KITS_BIO + ("1.3.0",), KITS_BIO, "1.3.0", False, "1.1.1", True, "future regeneration -> DOWNLOAD"), # REGRESSION GUARD (audit finding 1, high): the annotation plans are extracted # at step 3.1, BEFORE the images (3.2) and the RAS+ reorientation (3.3). A run # that dies in between leaves plans with no images and no tracker entry. Judged # on the plans alone that state looks complete, the images are never fetched, # and the loader yields rows whose image paths do not exist. (KITS_BIO, KITS_BIO, "1.1.1", False, None, True, "plans present but install never completed -> DOWNLOAD (interrupted-download guard)"), (ACDC_SEG, ("1.0.0",), "1.0.0", False, None, True, "same, for a single-version dataset"), # legacy boolean entries mean a completed install under the old scheme (ACDC_SEG, ("1.0.0",), "1.2.0", False, True, False, "legacy boolean tracker entry counts as complete -> SKIP"), ] for declared, local, pin, force, tracker, want, desc in DL_CASES: got = needs_download(declared, local, pin, force, tracker) check(got == want, desc, f"download={got}, expected={want}") # ------------------------------------------- 8. glob robustness in the data dir section("8. _discover_versions survives glob metacharacters in the path") _probe = tempfile.mkdtemp(prefix="medvision_glob_probe_") for tag in ["plain", "med[v2]", "st*ar", "que?ry", "a*b[c]?d"]: ddir = os.path.join(_probe, tag, "KiTS23") os.makedirs(ddir, exist_ok=True) for v in ("1.0.0", "1.1.0", "1.1.1"): open(os.path.join(ddir, f"benchmark_plan_biometry_v{v}.json.gz"), "w").close() open(os.path.join(ddir, "benchmark_plan_biometry_vdraft.json.gz"), "w").close() got = mv._discover_versions(ddir, "biometry") check(got == ["1.0.0", "1.1.0", "1.1.1"], f"data dir containing {tag!r} discovers all versions", f"got {got}") shutil.rmtree(_probe, ignore_errors=True) # ------------------------------------ 9. fingerprint token vs. what is loaded section("9. create_config_id token matches the version actually loaded") _by_name = {c.name: c for c in configs} def _token(config_name, pin): """The fingerprint token MedVisionConfig hands to its parent. Intercepts BuilderConfig.create_config_id rather than reading the return value, so this works whether the real `datasets` is installed (the parent returns a hashed string) or the stub above is in use. Reading the return value only worked under the stub. """ if pin is None: os.environ.pop("MedVision_PLANNER_VERSION", None) else: os.environ["MedVision_PLANNER_VERSION"] = pin cfg = _by_name[config_name] parent = type(cfg).__mro__[1] # BuilderConfig orig = parent.create_config_id parent.create_config_id = ( lambda self, config_kwargs, custom_features=None: dict(config_kwargs or {}) ) try: return cfg.create_config_id({})["planner_version"] finally: parent.create_config_id = orig _KITS = "KiTS23_TumorLesionSize_Task01_Axial_Test" _ACDC = "ACDC_MaskSize_Task01_Axial_Test" # The token is "-<8 hex of the canonical data root>". # The version prefix must stay readable in the cache path; the root suffix is what # stops two data roots from sharing one cache (see the guards further down). def _ver(config_name, pin): return _token(config_name, pin).rsplit("-", 1)[0] check(_ver(_ACDC, "1.0.0") == "1.0.0", "pin 1.0.0 -> resolved version in the token") check(_ver(_ACDC, "latest") == "1.0.0", "latest on an unchanged dataset -> resolved version") check(_ver(_KITS, "latest") == "1.1.1", "latest on a TL dataset -> resolved version") check(_ver(_ACDC, None) == "unset", "unset is preserved as the version part") check(_token(_ACDC, "1.1.1") == _token(_ACDC, "latest") == _token(_ACDC, "1.0.0"), "pins selecting the same plan share one cache key") check(re.fullmatch(r"1\.0\.0-[0-9a-f]{8}", _token(_ACDC, "latest")) is not None, "token shape is -<8 hex>", _token(_ACDC, "latest")) # REGRESSION GUARD (audit finding 2): _normalize_requested strips whitespace, so a # padded pin loads normally. If create_config_id does not strip identically, the # token reverts to the raw request string -- the request-keyed fingerprint this # change exists to remove -- and identical data lands in a second cache directory. for pin, base in [("latest", _KITS), ("1.1.1", _KITS), ("1.2.0", _ACDC), ("1.0.0", _ACDC)]: plain = _token(base, pin) for padded in (f" {pin}", f"{pin} ", f"\t{pin}", f"{pin}\n"): got = _token(base, padded) check(got == plain, f"padded pin {padded!r} yields the same token as {pin!r}", f"got {got!r}, expected {plain!r}") # and the loader must agree it is the same request check(mv._normalize_requested(padded, RELEASE) == mv._normalize_requested(pin, RELEASE), f"_normalize_requested agrees for {padded!r}") os.environ.pop("MedVision_PLANNER_VERSION", None) # ------------------------------------ 10. step 3.2 cannot fake a completed install section("10. Step 3.2 never swallows a failure into a completion marker") # The tracker entry written at step 3.4 is the "install completed" marker that the # download predicate tests for presence. It is only trustworthy if a failed image # download (3.2) can never reach 3.4. These assertions are structural on purpose: # they hold regardless of which exception a download script happens to raise. _src = open(_MEDVISION_PY, encoding="utf-8").read() _tree = ast.parse(_src) def _dl_calls(node): return [ n for n in ast.walk(node) if isinstance(n, ast.Call) and isinstance(n.func, ast.Attribute) and n.func.attr == "download_and_extract" ] _tries = [t for t in ast.walk(_tree) if isinstance(t, ast.Try) and _dl_calls(t)] check(bool(_tries), "found the step-3.2 try block") _step32 = max(_tries, key=lambda t: t.end_lineno - t.lineno) # A bare `except:` used to re-call download_and_extract, re-running a multi-GB # transfer on ANY failure -- including a Ctrl-C, which it swallowed. check(len(_dl_calls(_step32)) == 1, "download_and_extract is invoked exactly once (no blind retry)", f"found {len(_dl_calls(_step32))} call site(s)") _broad = [ ast.unparse(h.type) if h.type else "bare except" for t in ast.walk(_step32) if isinstance(t, ast.Try) for h in t.handlers if h.type is None or (isinstance(h.type, ast.Name) and h.type.id in ("BaseException", "Exception")) ] check(not _broad, "nothing around step 3.2 catches BaseException (Ctrl-C aborts)", f"found {_broad}") # Any except clause here would let a failed download fall through to 3.3/3.4 and # stamp the completion marker onto a dataset with no images. check(_step32.handlers == [], "step 3.2 has no except clause, so a failed download cannot reach the 3.4 marker", f"handlers: {[ast.unparse(h.type) if h.type else 'bare' for h in _step32.handlers]}") # The signature pre-check must select kwargs correctly for both conventions, and # must not wrap the transfer itself. def _pick(fn): kw = {"max_workers": 4} try: inspect.signature(fn).bind("d", "n", **kw) except TypeError: kw = {} return kw check(_pick(lambda dataset_dir, dataset_name, **kw: None) == {"max_workers": 4}, "script accepting **kwargs is called WITH max_workers") check(_pick(lambda dataset_dir, dataset_name, max_workers=1: None) == {"max_workers": 4}, "script declaring max_workers explicitly is called WITH it") check(_pick(lambda dataset_dir, dataset_name: None) == {}, "legacy script without max_workers is called WITHOUT it") def _raiser(dataset_dir, dataset_name, **kw): raise ConnectionError("simulated network drop mid-transfer") try: _f = _raiser _kw = _pick(_f) _f("d", "n", **_kw) check(False, "a failing download propagates rather than being swallowed") except ConnectionError: check(True, "a failing download propagates rather than being swallowed", "so 3.3/3.4 never run and no completion marker is written") # --------------------------------- 11. the data root is part of the cache identity section("11. Two data roots never share one Arrow cache") # Every row's image_file/mask_file/landmark_file is os.path.join(dataset_dir, ...), # rooted at MedVision_DATA_DIR, so the root changes what the rows SAY. Before it was # folded into the token, two runs differing only in data root produced a byte-identical # config_id -> cache hit -> _split_generators never ran -> nothing downloaded into the # new root and the rows pointed into the old one. _saved_root = os.environ.get("MedVision_DATA_DIR") def _token_at(config_name, root, pin="latest"): os.environ["MedVision_DATA_DIR"] = root return _token(config_name, pin) try: _tA = _token_at(_ACDC, "/tmp/mv-rootA") check(_tA != _token_at(_ACDC, "/tmp/mv-rootB"), "different data roots -> different cache ids", f"both {_tA}") check(_tA == _token_at(_ACDC, "/tmp/mv-rootA/") == _token_at(_ACDC, "/tmp/./mv-rootA"), "non-canonical spellings of one root share one cache id") check(_token_at(_KITS, "/tmp/mv-rootA", "1.1.1") == _token_at(_KITS, "/tmp/mv-rootA", "latest"), "for a fixed root, pins selecting the same plan still share one key") check(_tA.startswith("1.0.0-"), "resolved annotation version stays readable in the id", _tA) finally: if _saved_root is None: os.environ.pop("MedVision_DATA_DIR", None) else: os.environ["MedVision_DATA_DIR"] = _saved_root os.environ.pop("MedVision_PLANNER_VERSION", None) # ------------------------------- 12. a relative data root survives the download scripts section("12. The data root is canonicalised before the download scripts see it") # MedVision.py chdirs into dataset_dir, then hands that same path to the dataset's # download script, which begins with its own os.chdir(dataset_dir). A relative root # makes the second chdir resolve against the first one's result and fail -- for all # 30 datasets, so nothing could be downloaded at all. _saved_root, _cwd0 = os.environ.get("MedVision_DATA_DIR"), os.getcwd() _probe = tempfile.mkdtemp(prefix="medvision_relroot_") try: os.chdir(_probe) os.environ["MedVision_DATA_DIR"] = "relroot" check(os.path.isabs(mv._data_root()), "_data_root() is absolute for a relative env value", mv._data_root()) _d = os.path.join(mv._data_root(), "Datasets", "PDDCA") os.makedirs(_d, exist_ok=True) os.chdir(_d) # what _split_generators does try: os.chdir(_d) # what the download script then does check(True, "dataset_dir survives the download script's own chdir(dataset_dir)") except FileNotFoundError as e: check(False, "dataset_dir survives the download script's own chdir(dataset_dir)", str(e)) os.chdir(_probe) for blank in ("", " "): os.environ["MedVision_DATA_DIR"] = blank try: mv._data_root() check(False, f"blank data root {blank!r} is rejected, not resolved to cwd") except ValueError: check(True, f"blank data root {blank!r} is rejected, not resolved to cwd") check(mv._data_root(strict=False) == "", f"strict=False returns empty for {blank!r} instead of raising") # structural: _split_generators must not read the env var raw again _sg = next(n for n in ast.walk(_tree) if isinstance(n, ast.FunctionDef) and n.name == "_split_generators") _asg = [ast.unparse(a) for a in ast.walk(_sg) if isinstance(a, ast.Assign) and any(isinstance(t, ast.Name) and t.id == "MedVision_data_dir" for t in a.targets)] check(_asg == ["MedVision_data_dir = _data_root()"], "_split_generators takes the data root from _data_root()", f"got {_asg}") finally: os.chdir(_cwd0) if _saved_root is None: os.environ.pop("MedVision_DATA_DIR", None) else: os.environ["MedVision_DATA_DIR"] = _saved_root shutil.rmtree(_probe, ignore_errors=True) # ------------------------- 13. the annotation zip has an owner across processes section("13. Step 3.1 owns the shared annotation zip under a per-dataset lock") # Datasets/.zip is one shared path per dataset. HF's builder lock is per CONFIG # (Train and Test of one task are two configs), so two concurrent preparations of the # same dataset both downloaded, both extractall'd into one tree, and the second # os.remove died with a bare FileNotFoundError. _dl_block = next( n for n in ast.walk(_tree) if isinstance(n, ast.If) and isinstance(n.test, ast.Name) and n.test.id == "_needs_download" ) _removes = [n for n in ast.walk(_dl_block) if isinstance(n, ast.Call) and isinstance(n.func, ast.Attribute) and n.func.attr == "remove"] check(len(_removes) == 1, "exactly one os.remove of the zip", f"found {len(_removes)}") _withs = [w for w in ast.walk(_dl_block) if isinstance(w, ast.With)] _locked = [ w for w in _withs if any(isinstance(i.context_expr, ast.Call) and isinstance(i.context_expr.func, ast.Name) and i.context_expr.func.id == "FileLock" for i in w.items) ] check(bool(_locked), "the download block acquires a FileLock") # the remove, the extract and the snapshot_download must all sit INSIDE that lock _lock = _locked[0] for attr, what in (("remove", "os.remove"), ("extractall", "extractall")): inside = [n for n in ast.walk(_lock) if isinstance(n, ast.Call) and isinstance(n.func, ast.Attribute) and n.func.attr == attr] check(bool(inside), f"{what} is inside the per-dataset lock") _snap = [n for n in ast.walk(_lock) if isinstance(n, ast.Call) and isinstance(n.func, ast.Name) and n.func.id == "snapshot_download"] check(bool(_snap), "snapshot_download is inside the per-dataset lock") # and the lock must be re-checking, so the waiter skips instead of repeating the work _resolves_in_lock = [n for n in ast.walk(_lock) if isinstance(n, ast.Call) and isinstance(n.func, ast.Name) and n.func.id == "_resolve"] check(bool(_resolves_in_lock), "the lock re-checks resolution so a waiter skips the redundant download") # REGRESSION GUARD: the in-lock re-check must not swallow force_download_data. # A plan rewritten in place at the same version is already >= _target, so without # this the documented remediation (MedVision_FORCE_DOWNLOAD_DATA=True to refresh a # stale annotation) re-fetches the images and keeps the stale plan. _lock_guard = next((n for n in ast.walk(_lock) if isinstance(n, ast.If)), None) check(_lock_guard is not None, "the lock has a skip guard") _guard_src = ast.unparse(_lock_guard.test) if _lock_guard is not None else "" check("force_download_data" in _guard_src, "the in-lock skip guard honours force_download_data", _guard_src) # --------------------------------------------- 14. paused annotations are refused section("14. Paused annotations cannot be loaded") class _StubBuilder: """Just enough of the builder for _info() — it only reads self.config.""" def __init__(self, cfg): self.config = cfg # Invariants on whatever is REALLY paused right now. The table is empty most of the # time - a pause is an incident response, not a steady state - so this loop is # usually a no-op and the mechanism itself is exercised synthetically below. for ds, versions in mv._PAUSED_ANNOTATIONS.items(): _decl = {v for vs in mv._ANNOTATION_INDEX.get(ds, {}).values() for v in vs} check(ds in mv._ANNOTATION_INDEX, f"{ds} is still declared in the index", "a PAUSED version is still published, so it must stay listed; a version " "deleted from the hub is WITHDRAWN and belongs in neither table") check(set(versions) <= _decl, f"{ds} pauses only versions the index declares", f"paused={sorted(versions)} declared={sorted(_decl)}") _clean_cfgs = [c for c in configs if c.dataset_name not in mv._PAUSED_ANNOTATIONS] _broke = [] for c in _clean_cfgs: try: mv.MedVision._info(_StubBuilder(c)) except Exception as e: # noqa: BLE001 _broke.append((c.name, type(e).__name__)) check(not _broke, f"all {len(_clean_cfgs)} unpaused configs load through _info()", f"broke: {_broke[:3]}") # ---- the mechanism itself, exercised on a SYNTHETIC pause ---- # # Driven by a fabricated entry rather than by whatever happens to be paused today, so # the gate stays under test when the table is empty. Pausing only ever happens in # response to an incident, so a test that needs a live incident to run is a test that # is silently absent exactly when it is about to be needed. # # ACDC is the subject: it publishes a single version, so pausing that version makes # every one of its (dataset, kind) pairs FULLY paused, which is the state _info() gates # on. try/finally because both globals are module-level - leaving a fabricated entry # behind would poison every later section instead of failing here. _SUBJECT = "ACDC" _saved_index = dict(mv._ANNOTATION_INDEX[_SUBJECT]) _saved_paused = dict(mv._PAUSED_ANNOTATIONS) _subject_cfgs = [c for c in configs if c.dataset_name == _SUBJECT] _other_cfgs = [c for c in configs if c.dataset_name != _SUBJECT] check(bool(_subject_cfgs), f"{len(_subject_cfgs)} {_SUBJECT} configs available to test the gate") try: mv._PAUSED_ANNOTATIONS[_SUBJECT] = ("1.0.0",) check(mv._fully_paused(_SUBJECT, "segmentation"), "pausing a dataset's only version makes the pair fully paused") # _info() is the gate a warm Arrow cache still has to pass: datasets calls it from # DatasetBuilder.__init__, before the cache directory is consulted. _leaked = [] for c in _subject_cfgs: _kind = mv._PLAN_KIND_BY_TASKTYPE.get(c.taskType) if _kind is None or not mv._fully_paused(c.dataset_name, _kind): continue try: mv.MedVision._info(_StubBuilder(c)) _leaked.append(c.name) except RuntimeError: pass check(not _leaked, "every config of a fully paused (dataset, kind) is refused by _info()", f"loadable: {_leaked[:3]}") _collateral = [] for c in _other_cfgs[:200]: try: mv.MedVision._info(_StubBuilder(c)) except Exception as e: # noqa: BLE001 _collateral.append((c.name, type(e).__name__)) check(not _collateral, "pausing one dataset does not affect the others", f"broke: {_collateral[:3]}") check(mv._resolve(mv._declared_versions(_SUBJECT, "detection"), "1.0.0") == "1.0.0", "a pin to the paused version still RESOLVES to it", "which is why _split_generators re-checks _target against the pause table") # Publishing a correction lifts the pause with no edit to the gate. mv._ANNOTATION_INDEX[_SUBJECT] = {k: v + ("1.3.0",) for k, v in _saved_index.items()} check(not mv._fully_paused(_SUBJECT, "segmentation"), "a corrected version lifts the pause automatically") try: mv.MedVision._info(_StubBuilder(_subject_cfgs[0])) check(True, "and _info() lets the dataset through again") except RuntimeError as e: check(False, "and _info() lets the dataset through again", str(e)[:60]) finally: mv._ANNOTATION_INDEX[_SUBJECT] = _saved_index mv._PAUSED_ANNOTATIONS.clear() mv._PAUSED_ANNOTATIONS.update(_saved_paused) check(mv._PAUSED_ANNOTATIONS == _saved_paused, "the pause table is restored after the test") _sg_node = next(n for n in ast.walk(_tree) if isinstance(n, ast.FunctionDef) and n.name == "_split_generators") check(any(isinstance(n, ast.Call) and isinstance(n.func, ast.Name) and n.func.id == "_annotation_paused_error" for n in ast.walk(_sg_node)), "_split_generators also refuses a withheld resolved version") # ------------------------------------------- 15. withdrawn versions are named as such section("15. A withdrawn version is reported as withdrawn, not as never-published") # Invariant: a withdrawn version must NOT still be declared. The two states are # mutually exclusive - if it is still in the index, it is published (or paused), and # claiming it was deleted from the hub would be a lie the loader tells with a # straight face. for _ds, _entries in mv._WITHDRAWN_ANNOTATIONS.items(): _decl = {v for vs in mv._ANNOTATION_INDEX.get(_ds, {}).values() for v in vs} check(not (set(_entries) & _decl), f"{_ds}: withdrawn versions are absent from the index", f"still declared: {sorted(set(_entries) & _decl)}") check(all(isinstance(r, str) and r for r in _entries.values()), f"{_ds}: every withdrawn version records why") _task = next(c for c in configs if c.dataset_name == "MAMA-MIA").taskType # Pinned AT the withdrawn version -> the withdrawal branch. _msg = str(mv._annotation_unavailable_error( "MAMA-MIA", _task, "detection", "1.2.0", mv._declared_versions("MAMA-MIA", "detection"))) check("WITHDRAWN" in _msg, "a pin at the withdrawn version says WITHDRAWN") check("did not exist yet" not in _msg, "and does NOT claim the annotations never existed", "that would send someone holding a v1.2.0 cache after the wrong problem") check("1.2.0" in _msg and "RAS+" in _msg, "and names the withdrawn version and the reason") # Pinned BELOW it -> the version was never reachable from that pin, so the # never-published wording is the correct one and must be preserved. _msg = str(mv._annotation_unavailable_error( "MAMA-MIA", _task, "detection", "1.1.1", mv._declared_versions("MAMA-MIA", "detection"))) check("did not exist yet" in _msg, "a pin BELOW the withdrawn version keeps the never-published wording", "1.2.0 sits above that pin, so it explains nothing") # A dataset with no withdrawals is untouched by any of this. _msg = str(mv._annotation_unavailable_error( "PDDCA", _task, "detection", "1.1.1", mv._declared_versions("PDDCA", "detection"))) check("WITHDRAWN" not in _msg and "did not exist yet" in _msg, "datasets with no withdrawn version keep the original banner") # Withdrawing must never empty a dataset. If it did, every config of that dataset # would be permanently unloadable while still advertised in BUILDER_CONFIGS - at # which point the dataset itself should be de-listed, not just one of its versions. for _ds in mv._WITHDRAWN_ANNOTATIONS: _kinds = mv._ANNOTATION_INDEX.get(_ds, {}) check(bool(_kinds) and all(_kinds.values()), f"{_ds} still publishes something after the withdrawal", f"index entry: {_kinds}") check(mv._resolve(mv._declared_versions(_ds, "detection"), RELEASE) is not None, f"{_ds} still resolves at the current release") # ------------------------------------------------------------------ summary print() failures = _results.count(False) if failures: print(f"{failures} of {len(_results)} check(s) FAILED.") sys.exit(1) print(f"All {len(_results)} checks passed.")