seqseg 2.1.2__tar.gz → 2.1.3__tar.gz

{seqseg-2.1.2 → seqseg-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqseg
-Version: 2.1.2
+Version: 2.1.3
 Summary: A deep learning-based medical image blood vessel tracking and segmentation tool.
 Author-email: Numi Sveinsson Cepero <numi@berkeley.com>
 License: Apache-2.0

{seqseg-2.1.2 → seqseg-2.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seqseg"
-version = "2.1.2"
+version = "2.1.3"
 description = "A deep learning-based medical image blood vessel tracking and segmentation tool."
 readme = "README.md"
 requires-python = ">=3.9"

{seqseg-2.1.2 → seqseg-2.1.3}/seqseg/cli.py

@@ -671,6 +671,7 @@ def _cmd_train_prepare(ns: argparse.Namespace) -> None:
             also_test=ns.also_test,
             yes=ns.yes,
             verbose=ns.verbose,
+            img_ext=ns.img_ext,
         )
     except TrainDependencyError as e:
         print(str(e), file=sys.stderr)
@@ -1038,6 +1039,14 @@ def _build_parser() -> argparse.ArgumentParser:
         help="Write DatasetXXX_* here "
         "(default: seqseg paths nnunet_raw / $nnUNet_raw; else --outdir)",
     )
+    p_prep.add_argument(
+        "--img-ext",
+        "-img_ext",
+        default=None,
+        type=str,
+        help="Image/label suffix (.nii.gz, .mha, .nrrd, …). "
+        "Default: detect from data_dir/images/; else sampler YAML IMG_EXT",
+    )
     p_prep.add_argument("--perc-dataset", default=1.0, type=float)
     p_prep.add_argument("--num-cores", default=1, type=int)
     p_prep.add_argument("--start-from", default=0, type=int)
@@ -1075,7 +1084,7 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     p_prep.add_argument("--yes", action="store_true", help="Non-interactive confirms")
     p_prep.add_argument("--verbose", action="store_true")
-    p_prep.set_defaults(_handler=_cmd_train_prepare)
+    p_prep.set_defaults(_handler=_cmd_train_prepare, img_ext=None)
 
     p_nn = train_sub.add_parser(
         "nnunet",

{seqseg-2.1.2 → seqseg-2.1.3}/seqseg/pipeline/train.py

@@ -5,12 +5,15 @@ from __future__ import annotations
 import os
 import shutil
 import subprocess
+from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Optional, Sequence, Union
+from typing import Iterator, List, Optional, Sequence, Union
 
 from seqseg.user_paths import apply_nnunet_env, ensure_nnunet_dirs, resolve_path
 
+_VOLUME_EXTS = (".nii.gz", ".nrrd", ".nii", ".mha", ".mhd")
+
 
 class TrainDependencyError(RuntimeError):
     """Raised when optional training dependencies are missing."""
@@ -48,6 +51,250 @@ def _dir_for_sampler(path: str) -> str:
     return os.path.join(os.path.abspath(os.path.expanduser(path)), "")
 
 
+def _is_missing_stats_csv(exc: BaseException) -> bool:
+    return isinstance(exc, FileNotFoundError) and "Sample_stats.csv" in str(exc)
+
+
+def _normalize_img_ext(ext: str) -> str:
+    ext = str(ext).strip()
+    if not ext.startswith("."):
+        ext = "." + ext
+    return ext
+
+
+def _volume_ext_of(name: str) -> Optional[str]:
+    lower = name.lower()
+    for ext in _VOLUME_EXTS:
+        if lower.endswith(ext):
+            return ext
+    return None
+
+
+def _detect_img_ext(images_dir: Path) -> Optional[str]:
+    """Pick the most common volume suffix under ``images/`` (``.nii.gz`` first)."""
+    if not images_dir.is_dir():
+        return None
+    counts: dict[str, int] = {}
+    for name in os.listdir(images_dir):
+        if name.startswith("."):
+            continue
+        ext = _volume_ext_of(name)
+        if ext:
+            counts[ext] = counts.get(ext, 0) + 1
+    if not counts:
+        return None
+    best = max(counts.values())
+    for ext in _VOLUME_EXTS:
+        if counts.get(ext) == best:
+            return ext
+    return None
+
+
+def _load_sampler_config(config: Union[str, dict]) -> dict:
+    if isinstance(config, dict):
+        return dict(config)
+    try:
+        from vascular_segment_sampler.sampling.extract import _load_config
+
+        return dict(_load_config(config))
+    except Exception:  # noqa: BLE001 — tests and missing sampler YAML
+        return {"IMG_EXT": ".nrrd"}
+
+
+def _resolve_img_ext(
+    data_dir: str,
+    config: dict,
+    img_ext: Optional[str] = None,
+) -> str:
+    if img_ext:
+        return _normalize_img_ext(img_ext)
+    detected = _detect_img_ext(Path(data_dir) / "images")
+    if detected:
+        return detected
+    return _normalize_img_ext(str(config.get("IMG_EXT") or ".nrrd"))
+
+
+def _stems_with_suffix(directory: Path, suffix: str) -> List[str]:
+    if not directory.is_dir():
+        return []
+    stems: List[str] = []
+    for name in os.listdir(directory):
+        if name.startswith("."):
+            continue
+        if name.endswith(suffix):
+            stems.append(name[: -len(suffix)])
+    return sorted(stems)
+
+
+def _count_volume_files(directory: str) -> int:
+    if not os.path.isdir(directory):
+        return 0
+    n = 0
+    for name in os.listdir(directory):
+        if name.startswith("."):
+            continue
+        if name.endswith(".nii.gz") or name.endswith(_VOLUME_EXTS[1:]):
+            n += 1
+    return n
+
+
+def _preflight_training_data(
+    data_dir: str,
+    *,
+    img_ext: str,
+    truth_from_surface: bool,
+) -> None:
+    """Fail fast when the sampler would iterate zero usable cases."""
+    root = Path(data_dir)
+    images = root / "images"
+    centerlines = root / "centerlines"
+    missing = [
+        str(p)
+        for p, label in ((images, "images"), (centerlines, "centerlines"))
+        if not p.is_dir()
+    ]
+    if missing:
+        raise FileNotFoundError(
+            "Training data_dir must contain images/ and centerlines/.\n"
+            f"  data_dir: {root}\n"
+            "  missing: " + ", ".join(missing)
+        )
+
+    img_stems = _stems_with_suffix(images, img_ext)
+    if not img_stems:
+        present = sorted(
+            {
+                name
+                for name in os.listdir(images)
+                if not name.startswith(".")
+            }
+        )
+        preview = ", ".join(present[:8]) if present else "(empty)"
+        raise FileNotFoundError(
+            f"No images with IMG_EXT={img_ext!r} in {images}.\n"
+            f"  files found: {preview}\n"
+            "Pass --img-ext (e.g. .nii.gz or .mha) or convert images."
+        )
+
+    cent_stems = _stems_with_suffix(centerlines, ".vtp")
+    if not cent_stems:
+        raise FileNotFoundError(
+            f"No .vtp centerlines in {centerlines}."
+        )
+
+    overlap = sorted(set(img_stems) & set(cent_stems))
+    if not overlap:
+        raise FileNotFoundError(
+            "No case has both an image and a matching centerline stem.\n"
+            f"  image stems ({img_ext}): {img_stems[:8]}\n"
+            f"  centerline stems (.vtp): {cent_stems[:8]}"
+        )
+
+    if truth_from_surface:
+        surfaces = root / "surfaces"
+        if not surfaces.is_dir():
+            raise FileNotFoundError(
+                "--truth-from-surface requires a surfaces/ folder under "
+                f"{root}."
+            )
+        surf_stems = _stems_with_suffix(surfaces, ".vtp") + _stems_with_suffix(
+            surfaces, ".stl"
+        )
+        if not surf_stems:
+            raise FileNotFoundError(
+                f"No .vtp/.stl surfaces in {surfaces}."
+            )
+        surf_overlap = sorted(set(overlap) & set(surf_stems))
+        if not surf_overlap:
+            raise FileNotFoundError(
+                "No case has an image, centerline, and surface with the same stem.\n"
+                f"  usable image+centerline stems: {overlap[:8]}\n"
+                f"  surface stems: {sorted(set(surf_stems))[:8]}"
+            )
+
+
+def _missing_patches_error(outdir: str, modalities: Sequence[str]) -> RuntimeError:
+    lines = [
+        "Patch extraction finished without writing any samples.",
+        f"  outdir: {os.path.abspath(outdir)}",
+    ]
+    for mod in modalities:
+        img_dir = os.path.join(outdir, f"{mod.lower()}_train")
+        mask_dir = os.path.join(outdir, f"{mod.lower()}_train_masks")
+        lines.append(
+            f"  {mod}: {_count_volume_files(img_dir)} images in {img_dir}, "
+            f"{_count_volume_files(mask_dir)} masks in {mask_dir}"
+        )
+    lines.extend(
+        [
+            "",
+            "vascular-segment-sampler always opens "
+            "{modality}_train_Sample_stats.csv at the end, even when no case "
+            "completed (so that FileNotFoundError is a symptom, not the cause).",
+            "Typical causes:",
+            "  - Worker crashes with --num-cores > 1 (exceptions are not re-raised).",
+            "    Re-run with --num-cores 1 to see the real error.",
+            "  - Image extension mismatch (pass --img-ext, e.g. .nii.gz).",
+            "  - Missing truths/ (or surfaces/ when using --truth-from-surface).",
+            "  - All cases listed in outdir/done.txt, so they were skipped.",
+        ]
+    )
+    return RuntimeError("\n".join(lines))
+
+
+def _assert_patches_extracted(outdir: str, modalities: Sequence[str]) -> None:
+    for mod in modalities:
+        img_dir = os.path.join(outdir, f"{mod.lower()}_train")
+        mask_dir = os.path.join(outdir, f"{mod.lower()}_train_masks")
+        if _count_volume_files(img_dir) == 0 or _count_volume_files(mask_dir) == 0:
+            raise _missing_patches_error(outdir, modalities)
+
+
+@contextmanager
+def _tolerate_missing_sampler_stats() -> Iterator[None]:
+    """Skip the sampler's end-of-run CSV summary when no case wrote it."""
+    try:
+        import vascular_segment_sampler.sampling.extract as extract_mod
+    except ImportError:
+        yield
+        return
+
+    orig = getattr(extract_mod, "print_csv_stats", None)
+    if orig is None:
+        yield
+        return
+
+    def _safe(out_dir, global_config, modality):
+        suffix = global_config.get("OUTPUT_SUFFIX", "") or ""
+        if global_config.get("TESTING"):
+            csv_file = f"{modality}_test{suffix}_Sample_stats.csv"
+        else:
+            csv_file = f"{modality}_train{suffix}_Sample_stats.csv"
+        path = out_dir + csv_file
+        if not os.path.isfile(path):
+            print(
+                f"Warning: no sampler stats file at {path}; continuing."
+            )
+            return
+        orig(out_dir, global_config, modality)
+
+    extract_mod.print_csv_stats = _safe
+    try:
+        yield
+    finally:
+        extract_mod.print_csv_stats = orig
+
+
+def _run_extract_patches(extract_patches, **kwargs) -> None:
+    try:
+        with _tolerate_missing_sampler_stats():
+            extract_patches(**kwargs)
+    except FileNotFoundError as e:
+        if not _is_missing_stats_csv(e):
+            raise
+        print(f"Warning: {e}")
+
+
 def expected_nnunet_dataset_name(name: str, dataset_number: int, modality: str) -> str:
     """Match vascular-segment-sampler naming for DatasetXXX_* folders."""
     if dataset_number < 10:
@@ -91,6 +338,7 @@ def prepare_training_dataset(
     also_test: bool = False,
     yes: bool = False,
     verbose: bool = False,
+    img_ext: Optional[str] = None,
 ) -> PrepareResult:
     """
     Extract SeqSeg-style patches and convert them to nnU-Net raw datasets.
@@ -118,14 +366,27 @@ def prepare_training_dataset(
     modalities = _parse_modalities(modality)
     modality_arg = ",".join(modalities)
 
+    sampler_config = _load_sampler_config(config)
+    resolved_img_ext = _resolve_img_ext(data_dir, sampler_config, img_ext)
+    sampler_config["IMG_EXT"] = resolved_img_ext
+
     if not skip_sample:
+        _preflight_training_data(
+            data_dir,
+            img_ext=resolved_img_ext,
+            truth_from_surface=truth_from_surface,
+        )
         print("=" * 72)
         print("Extracting vascular segment patches")
+        print(f"  data_dir: {data_dir}")
+        print(f"  outdir:   {outdir}")
+        print(f"  IMG_EXT:  {resolved_img_ext}")
         print("=" * 72)
-        extract_patches(
+        _run_extract_patches(
+            extract_patches,
             data_dir=data_dir,
             outdir=outdir,
-            config=config,
+            config=sampler_config,
             perc_dataset=perc_dataset,
             num_cores=num_cores,
             start_from=start_from,
@@ -142,6 +403,7 @@ def prepare_training_dataset(
             yes=yes,
             verbose=verbose,
         )
+        _assert_patches_extracted(outdir, modalities)
     else:
         print("Skipping patch extraction (--skip-sample)")
 

{seqseg-2.1.2 → seqseg-2.1.3}/seqseg/tests/test_cli_helpers.py

@@ -288,6 +288,7 @@ def test_parser_train_prepare():
     assert ns.data_dir == "/tmp/data"
     assert ns.name == "MYDATA"
     assert ns.dataset_number == 999
+    assert ns.img_ext is None
 
 
 def test_parser_paths_init():
@@ -349,6 +350,7 @@ def test_cmd_train_prepare_missing_dep(tmp_path, capsys):
         also_test=False,
         yes=False,
         verbose=False,
+        img_ext=None,
     )
     with patch(
         "seqseg.cli.prepare_training_dataset",

seqseg-2.1.3/seqseg/tests/test_train_pipeline.py

@@ -0,0 +1,288 @@
+"""Unit tests for seqseg.pipeline.train helpers (no GPU / sampler required)."""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+import os
+
+from pathlib import Path
+
+from seqseg.pipeline.train import (
+    TrainDependencyError,
+    _detect_img_ext,
+    _dir_for_sampler,
+    _normalize_img_ext,
+    _resolve_img_ext,
+    dataset_id_from_name,
+    expected_nnunet_dataset_name,
+    prepare_training_dataset,
+    run_nnunet_training,
+)
+
+
+def _make_training_data(tmp_path, *, surfaces=False, img_ext=".nrrd"):
+    data = tmp_path / "data"
+    (data / "images").mkdir(parents=True)
+    (data / "centerlines").mkdir()
+    (data / "images" / f"case1{img_ext}").write_bytes(b"x")
+    (data / "centerlines" / "case1.vtp").write_bytes(b"x")
+    if surfaces:
+        (data / "surfaces").mkdir()
+        (data / "surfaces" / "case1.vtp").write_bytes(b"x")
+    return str(data)
+
+
+def _make_patch_dirs(extracted, modality="ct"):
+    img_dir = extracted / f"{modality}_train"
+    mask_dir = extracted / f"{modality}_train_masks"
+    img_dir.mkdir(parents=True)
+    mask_dir.mkdir()
+    (img_dir / "a.nrrd").write_bytes(b"x")
+    (mask_dir / "a.nrrd").write_bytes(b"x")
+    return img_dir, mask_dir
+
+
+def test_dir_for_sampler_adds_trailing_sep(tmp_path):
+    raw = str(tmp_path / "seqseg_train")
+    out = _dir_for_sampler(raw)
+    assert out.endswith(os.sep)
+    assert out.rstrip("/\\") == os.path.abspath(raw)
+    # Sampler concatenates outdir + "ct_train_Sample_stats.csv"
+    stats = out + "ct_train_Sample_stats.csv"
+    assert os.path.dirname(stats) == os.path.abspath(raw)
+
+
+def test_expected_nnunet_dataset_name_padding():
+    assert expected_nnunet_dataset_name("AORTAS", 1, "ct") == "Dataset001_AORTASCT"
+    assert expected_nnunet_dataset_name("AORTAS", 10, "mr") == "Dataset010_AORTASMR"
+    assert expected_nnunet_dataset_name("MYDATA", 999, "CT") == "Dataset0999_MYDATACT"
+
+
+def test_dataset_id_from_name_errors():
+    with pytest.raises(ValueError):
+        dataset_id_from_name("not_a_dataset")
+    with pytest.raises(ValueError):
+        dataset_id_from_name("Dataset_FOO")
+
+
+def test_prepare_requires_sampler():
+    with patch(
+        "seqseg.pipeline.train._require_sampler",
+        side_effect=TrainDependencyError("nope"),
+    ):
+        with pytest.raises(TrainDependencyError):
+            prepare_training_dataset(
+                "/tmp/data",
+                "/tmp/out",
+                name="X",
+                dataset_number=1,
+            )
+
+
+def test_prepare_calls_sampler_apis(tmp_path):
+    extract = MagicMock()
+    write = MagicMock(return_value=str(tmp_path / "Dataset0999_MYDATACT"))
+    data = _make_training_data(tmp_path)
+    extracted = tmp_path / "extracted"
+    _make_patch_dirs(extracted)
+
+    with patch(
+        "seqseg.pipeline.train._require_sampler",
+        return_value=(extract, write),
+    ):
+        result = prepare_training_dataset(
+            data,
+            str(extracted),
+            name="MYDATA",
+            dataset_number=999,
+            modality="CT",
+            yes=True,
+        )
+
+    extract.assert_called_once()
+    write.assert_called_once()
+    outdir_arg = extract.call_args.kwargs["outdir"]
+    assert outdir_arg.endswith(os.sep)
+    assert os.path.basename(os.path.normpath(outdir_arg)) == "extracted"
+    assert extract.call_args.kwargs["config"]["IMG_EXT"] == ".nrrd"
+    assert result.dataset_names == ["Dataset0999_MYDATACT"]
+    assert result.modalities == ["CT"]
+
+
+def test_detect_img_ext_prefers_nii_gz(tmp_path):
+    images = tmp_path / "images"
+    images.mkdir()
+    (images / "716.nii.gz").write_bytes(b"x")
+    (images / "notes.txt").write_text("nope")
+    assert _detect_img_ext(images) == ".nii.gz"
+    assert _normalize_img_ext("nii.gz") == ".nii.gz"
+    assert _resolve_img_ext(str(tmp_path), {"IMG_EXT": ".nrrd"}) == ".nii.gz"
+
+
+def test_prepare_detects_nii_gz_and_sets_sampler_config(tmp_path):
+    extract = MagicMock()
+    write = MagicMock(return_value=str(tmp_path / "Dataset0999_MYDATACT"))
+    data = _make_training_data(tmp_path, img_ext=".nii.gz")
+    extracted = tmp_path / "extracted"
+    _make_patch_dirs(extracted)
+
+    with patch(
+        "seqseg.pipeline.train._require_sampler",
+        return_value=(extract, write),
+    ):
+        prepare_training_dataset(
+            data,
+            str(extracted),
+            name="MYDATA",
+            dataset_number=999,
+            yes=True,
+        )
+
+    assert extract.call_args.kwargs["config"]["IMG_EXT"] == ".nii.gz"
+
+
+def test_prepare_explicit_img_ext_overrides_detection(tmp_path):
+    extract = MagicMock()
+    write = MagicMock(return_value=str(tmp_path / "Dataset0999_MYDATACT"))
+    data = Path(_make_training_data(tmp_path, img_ext=".nii.gz"))
+    (data / "images" / "case1.mha").write_bytes(b"x")
+    extracted = tmp_path / "extracted"
+    _make_patch_dirs(extracted)
+
+    with patch(
+        "seqseg.pipeline.train._require_sampler",
+        return_value=(extract, write),
+    ):
+        prepare_training_dataset(
+            str(data),
+            str(extracted),
+            name="MYDATA",
+            dataset_number=999,
+            img_ext="mha",
+            yes=True,
+        )
+
+    assert extract.call_args.kwargs["config"]["IMG_EXT"] == ".mha"
+
+
+def test_prepare_multi_modality_increments_ids(tmp_path):
+    extract = MagicMock()
+    write = MagicMock(
+        side_effect=[
+            str(tmp_path / "Dataset0999_MYDATACT"),
+            str(tmp_path / "Dataset1000_MYDATAMR"),
+        ]
+    )
+
+    with patch(
+        "seqseg.pipeline.train._require_sampler",
+        return_value=(extract, write),
+    ):
+        result = prepare_training_dataset(
+            str(tmp_path / "data"),
+            str(tmp_path / "extracted"),
+            name="MYDATA",
+            dataset_number=999,
+            modality="CT,MR",
+            skip_sample=True,
+        )
+
+    assert write.call_count == 2
+    assert result.dataset_names == [
+        "Dataset0999_MYDATACT",
+        "Dataset01000_MYDATAMR",
+    ]
+
+
+def test_prepare_preflight_rejects_missing_images(tmp_path):
+    extract = MagicMock()
+    write = MagicMock()
+    empty = tmp_path / "data"
+    empty.mkdir()
+    with patch(
+        "seqseg.pipeline.train._require_sampler",
+        return_value=(extract, write),
+    ):
+        with pytest.raises(FileNotFoundError, match="images/ and centerlines"):
+            prepare_training_dataset(
+                str(empty),
+                str(tmp_path / "extracted"),
+                name="MYDATA",
+                dataset_number=999,
+                yes=True,
+            )
+    extract.assert_not_called()
+
+
+def test_prepare_continues_if_stats_csv_missing_but_patches_exist(tmp_path):
+    extracted = tmp_path / "extracted"
+    _make_patch_dirs(extracted)
+    extract = MagicMock(
+        side_effect=FileNotFoundError(
+            f"[Errno 2] No such file or directory: "
+            f"'{extracted}/ct_train_Sample_stats.csv'"
+        )
+    )
+    write = MagicMock(return_value=str(tmp_path / "Dataset0999_MYDATACT"))
+
+    with patch(
+        "seqseg.pipeline.train._require_sampler",
+        return_value=(extract, write),
+    ):
+        result = prepare_training_dataset(
+            _make_training_data(tmp_path),
+            str(extracted),
+            name="MYDATA",
+            dataset_number=999,
+            yes=True,
+        )
+
+    write.assert_called_once()
+    assert result.dataset_names == ["Dataset0999_MYDATACT"]
+
+
+def test_prepare_missing_stats_csv_without_patches_is_actionable(tmp_path):
+    extract = MagicMock(
+        side_effect=FileNotFoundError(
+            "[Errno 2] No such file or directory: "
+            "'/scratch/11178/numi/seqseg_train/ct_train_Sample_stats.csv'"
+        )
+    )
+    write = MagicMock()
+
+    with patch(
+        "seqseg.pipeline.train._require_sampler",
+        return_value=(extract, write),
+    ):
+        with pytest.raises(RuntimeError, match="--num-cores 1"):
+            prepare_training_dataset(
+                _make_training_data(tmp_path),
+                str(tmp_path / "extracted"),
+                name="MYDATA",
+                dataset_number=999,
+                yes=True,
+            )
+    write.assert_not_called()
+
+
+def test_run_nnunet_training_requires_env(tmp_path, monkeypatch):
+    monkeypatch.setenv("SEQSEG_PATHS_FILE", str(tmp_path / "no_paths.yaml"))
+    for key in ("nnUNet_raw", "nnUNet_preprocessed", "nnUNet_results"):
+        monkeypatch.delenv(key, raising=False)
+    with pytest.raises(RuntimeError, match="nnU-Net paths"):
+        run_nnunet_training(999, plan_only=True)
+
+
+def test_run_nnunet_training_plan_only(monkeypatch):
+    monkeypatch.setenv("nnUNet_raw", "/raw")
+    monkeypatch.setenv("nnUNet_preprocessed", "/pre")
+    monkeypatch.setenv("nnUNet_results", "/res")
+
+    with patch("seqseg.pipeline.train.subprocess.run") as run:
+        run_nnunet_training(999, plan_only=True, configuration="3d_fullres")
+    assert run.call_count == 1
+    cmd = run.call_args[0][0]
+    assert "nnUNetv2_plan_and_preprocess" in cmd[0]
+    assert cmd[cmd.index("-d") + 1] == "999"
+    assert cmd[cmd.index("-c") + 1] == "3d_fullres"

{seqseg-2.1.2 → seqseg-2.1.3}/seqseg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seqseg
-Version: 2.1.2
+Version: 2.1.3
 Summary: A deep learning-based medical image blood vessel tracking and segmentation tool.
 Author-email: Numi Sveinsson Cepero <numi@berkeley.com>
 License: Apache-2.0

seqseg-2.1.2/seqseg/tests/test_train_pipeline.py

@@ -1,130 +0,0 @@
-"""Unit tests for seqseg.pipeline.train helpers (no GPU / sampler required)."""
-
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-import os
-
-from seqseg.pipeline.train import (
-    TrainDependencyError,
-    _dir_for_sampler,
-    dataset_id_from_name,
-    expected_nnunet_dataset_name,
-    prepare_training_dataset,
-    run_nnunet_training,
-)
-
-
-def test_dir_for_sampler_adds_trailing_sep(tmp_path):
-    raw = str(tmp_path / "seqseg_train")
-    out = _dir_for_sampler(raw)
-    assert out.endswith(os.sep)
-    assert out.rstrip("/\\") == os.path.abspath(raw)
-    # Sampler concatenates outdir + "ct_train_Sample_stats.csv"
-    stats = out + "ct_train_Sample_stats.csv"
-    assert os.path.dirname(stats) == os.path.abspath(raw)
-
-
-def test_expected_nnunet_dataset_name_padding():
-    assert expected_nnunet_dataset_name("AORTAS", 1, "ct") == "Dataset001_AORTASCT"
-    assert expected_nnunet_dataset_name("AORTAS", 10, "mr") == "Dataset010_AORTASMR"
-    assert expected_nnunet_dataset_name("MYDATA", 999, "CT") == "Dataset0999_MYDATACT"
-
-
-def test_dataset_id_from_name_errors():
-    with pytest.raises(ValueError):
-        dataset_id_from_name("not_a_dataset")
-    with pytest.raises(ValueError):
-        dataset_id_from_name("Dataset_FOO")
-
-
-def test_prepare_requires_sampler():
-    with patch(
-        "seqseg.pipeline.train._require_sampler",
-        side_effect=TrainDependencyError("nope"),
-    ):
-        with pytest.raises(TrainDependencyError):
-            prepare_training_dataset(
-                "/tmp/data",
-                "/tmp/out",
-                name="X",
-                dataset_number=1,
-            )
-
-
-def test_prepare_calls_sampler_apis(tmp_path):
-    extract = MagicMock()
-    write = MagicMock(return_value=str(tmp_path / "Dataset0999_MYDATACT"))
-
-    with patch(
-        "seqseg.pipeline.train._require_sampler",
-        return_value=(extract, write),
-    ):
-        result = prepare_training_dataset(
-            str(tmp_path / "data"),
-            str(tmp_path / "extracted"),
-            name="MYDATA",
-            dataset_number=999,
-            modality="CT",
-            yes=True,
-        )
-
-    extract.assert_called_once()
-    write.assert_called_once()
-    outdir_arg = extract.call_args.kwargs["outdir"]
-    assert outdir_arg.endswith(os.sep)
-    assert os.path.basename(os.path.normpath(outdir_arg)) == "extracted"
-    assert result.dataset_names == ["Dataset0999_MYDATACT"]
-    assert result.modalities == ["CT"]
-
-
-def test_prepare_multi_modality_increments_ids(tmp_path):
-    extract = MagicMock()
-    write = MagicMock(
-        side_effect=[
-            str(tmp_path / "Dataset0999_MYDATACT"),
-            str(tmp_path / "Dataset1000_MYDATAMR"),
-        ]
-    )
-
-    with patch(
-        "seqseg.pipeline.train._require_sampler",
-        return_value=(extract, write),
-    ):
-        result = prepare_training_dataset(
-            str(tmp_path / "data"),
-            str(tmp_path / "extracted"),
-            name="MYDATA",
-            dataset_number=999,
-            modality="CT,MR",
-            skip_sample=True,
-        )
-
-    assert write.call_count == 2
-    assert result.dataset_names == [
-        "Dataset0999_MYDATACT",
-        "Dataset01000_MYDATAMR",
-    ]
-
-
-def test_run_nnunet_training_requires_env(tmp_path, monkeypatch):
-    monkeypatch.setenv("SEQSEG_PATHS_FILE", str(tmp_path / "no_paths.yaml"))
-    for key in ("nnUNet_raw", "nnUNet_preprocessed", "nnUNet_results"):
-        monkeypatch.delenv(key, raising=False)
-    with pytest.raises(RuntimeError, match="nnU-Net paths"):
-        run_nnunet_training(999, plan_only=True)
-
-
-def test_run_nnunet_training_plan_only(monkeypatch):
-    monkeypatch.setenv("nnUNet_raw", "/raw")
-    monkeypatch.setenv("nnUNet_preprocessed", "/pre")
-    monkeypatch.setenv("nnUNet_results", "/res")
-
-    with patch("seqseg.pipeline.train.subprocess.run") as run:
-        run_nnunet_training(999, plan_only=True, configuration="3d_fullres")
-    assert run.call_count == 1
-    cmd = run.call_args[0][0]
-    assert "nnUNetv2_plan_and_preprocess" in cmd[0]
-    assert cmd[cmd.index("-d") + 1] == "999"
-    assert cmd[cmd.index("-c") + 1] == "3d_fullres"