segresnet-mlx 0.2.3__tar.gz → 0.3.0__tar.gz

segresnet_mlx-0.3.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.5
+Name: segresnet-mlx
+Version: 0.3.0
+Summary: Native MLX SegResNet with NumPy sliding-window logit inference
+Project-URL: Homepage, https://huggingface.co/MedMLX/segresnet-renal-cect-mlx
+Author: Joseph Sandoval, Alfredo Sandoval Jr.
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES.md
+Classifier: Operating System :: MacOS :: MacOS X
+Requires-Python: <3.15,>=3.13
+Requires-Dist: medmlx-core==0.2.5
+Requires-Dist: nibabel<6,>=5.3
+Requires-Dist: numpy<3,>=2.0
+Provides-Extra: dev
+Requires-Dist: hypothesis<7,>=6; extra == 'dev'
+Requires-Dist: monai==1.6.1; extra == 'dev'
+Requires-Dist: pyright==1.1.414; extra == 'dev'
+Requires-Dist: pytest<10,>=8.4; extra == 'dev'
+Requires-Dist: pytorch-ignite<0.6,>=0.4.11; extra == 'dev'
+Requires-Dist: ruff<1,>=0.13; extra == 'dev'
+Requires-Dist: torch<3,>=2.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# segresnet-mlx
+
+Segment brain tumors, renal structures and whole-body CT anatomy with MONAI SegResNet models in native MLX.
+
+[BraTS weights](https://huggingface.co/MedMLX/segresnet-brats-mlx) · [Renal weights](https://huggingface.co/MedMLX/segresnet-renal-cect-mlx)
+
+| Input | Output |
+| :--- | :--- |
+| MRI sequences or CT volumes | Segmentation on the input grid |
+
+**Apple Silicon · Metal · Python 3.13 / 3.14** · [uv](https://docs.astral.sh/uv/)
+
+## Quick start
+
+```bash
+uv venv --python 3.13
+source .venv/bin/activate
+uv pip install "segresnet-mlx>=0.3.0"
+```
+
+```python
+from segresnet_mlx.medmlx import brats
+
+result = brats(
+    t1c_path="t1c.nii.gz", t1_path="t1.nii.gz", t2_path="t2.nii.gz",
+    flair_path="flair.nii.gz", output_dir="out",
+)
+print(result["outputs"]["mask"])
+```
+
+The registered models are `segresnet-brats` and `segresnet-renal-cect`. Their `brats`
+and `renal_cect` runners select the matching bundle internally and download
+`MedMLX/segresnet-brats-mlx` or `MedMLX/segresnet-renal-cect-mlx` when `weights_path`
+is omitted. An explicit folder contains `segresnet-brats.safetensors` for BraTS or
+`segresnet-renal-cect.safetensors` for renal CECT. The renal runner takes
+`arterial_path`, `venous_path` and `excretory_path`. Keep each model's input volumes
+on one voxel grid.
+
+The standalone `run(bundle=..., weights_path=...)` interface remains available for
+explicit local checkpoints, including the whole-body CT variants. Published native
+weights are also available for [renal CECT](https://huggingface.co/MedMLX/segresnet-renal-cect-mlx)
+and [whole-body CT](https://huggingface.co/MedMLX/segresnet-wholebody-mlx).
+
+Downloaded commits are returned in `details.weights_revision`; explicit local
+weights report `null` unless the folder carries a MedMLX download revision.
+
+## License
+
+Apache-2.0; license and third-party notices are included in the distribution. Model weights retain their publisher terms.
+
+For research and education. Outputs require human review.

segresnet_mlx-0.3.0/README.md

@@ -0,0 +1,51 @@
+# segresnet-mlx
+
+Segment brain tumors, renal structures and whole-body CT anatomy with MONAI SegResNet models in native MLX.
+
+[BraTS weights](https://huggingface.co/MedMLX/segresnet-brats-mlx) · [Renal weights](https://huggingface.co/MedMLX/segresnet-renal-cect-mlx)
+
+| Input | Output |
+| :--- | :--- |
+| MRI sequences or CT volumes | Segmentation on the input grid |
+
+**Apple Silicon · Metal · Python 3.13 / 3.14** · [uv](https://docs.astral.sh/uv/)
+
+## Quick start
+
+```bash
+uv venv --python 3.13
+source .venv/bin/activate
+uv pip install "segresnet-mlx>=0.3.0"
+```
+
+```python
+from segresnet_mlx.medmlx import brats
+
+result = brats(
+    t1c_path="t1c.nii.gz", t1_path="t1.nii.gz", t2_path="t2.nii.gz",
+    flair_path="flair.nii.gz", output_dir="out",
+)
+print(result["outputs"]["mask"])
+```
+
+The registered models are `segresnet-brats` and `segresnet-renal-cect`. Their `brats`
+and `renal_cect` runners select the matching bundle internally and download
+`MedMLX/segresnet-brats-mlx` or `MedMLX/segresnet-renal-cect-mlx` when `weights_path`
+is omitted. An explicit folder contains `segresnet-brats.safetensors` for BraTS or
+`segresnet-renal-cect.safetensors` for renal CECT. The renal runner takes
+`arterial_path`, `venous_path` and `excretory_path`. Keep each model's input volumes
+on one voxel grid.
+
+The standalone `run(bundle=..., weights_path=...)` interface remains available for
+explicit local checkpoints, including the whole-body CT variants. Published native
+weights are also available for [renal CECT](https://huggingface.co/MedMLX/segresnet-renal-cect-mlx)
+and [whole-body CT](https://huggingface.co/MedMLX/segresnet-wholebody-mlx).
+
+Downloaded commits are returned in `details.weights_revision`; explicit local
+weights report `null` unless the folder carries a MedMLX download revision.
+
+## License
+
+Apache-2.0; license and third-party notices are included in the distribution. Model weights retain their publisher terms.
+
+For research and education. Outputs require human review.

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "segresnet-mlx"
-version = "0.2.3"
+version = "0.3.0"
 description = "Native MLX SegResNet with NumPy sliding-window logit inference"
 readme = "README.md"
 requires-python = ">=3.13,<3.15"
@@ -13,22 +13,19 @@ license = "Apache-2.0"
 license-files = ["LICENSE", "THIRD_PARTY_NOTICES.md"]
 authors = [{ name = "Joseph Sandoval" }, { name = "Alfredo Sandoval Jr." }]
 dependencies = [
-  "medmlx-core==0.2.4",
+  "medmlx-core==0.2.5",
   "nibabel>=5.3,<6",
   "numpy>=2.0,<3",
 ]
 
 [project.entry-points."medmlx.models"]
-segresnet = "segresnet_mlx.medmlx:MODEL"
+segresnet-brats = "segresnet_mlx.medmlx:BRATS_MODEL"
+segresnet-renal-cect = "segresnet_mlx.medmlx:RENAL_CECT_MODEL"
 
 [project.urls]
-Homepage = "https://github.com/MedMLX/segresnet-mlx"
-Documentation = "https://github.com/MedMLX/segresnet-mlx/blob/main/docs/technical.md"
-Repository = "https://github.com/MedMLX/segresnet-mlx"
-Issues = "https://github.com/MedMLX/segresnet-mlx/issues"
+Homepage = "https://huggingface.co/MedMLX/segresnet-renal-cect-mlx"
 
 [project.optional-dependencies]
-conversion = ["torch>=2.6,<3"]
 dev = [
   "pyright==1.1.414",
   "pytorch-ignite>=0.4.11,<0.6",
@@ -64,7 +61,7 @@ select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
 
 [tool.pyright]
 include = ["scripts","src","tests"]
-extraPaths = ["src"]
+extraPaths = ["src", "scripts", "tests"]
 pythonVersion = "3.13"
 typeCheckingMode = "strict"
 enableTypeIgnoreComments = false
@@ -77,9 +74,6 @@ ban-relative-imports = "all"
 "typing.Any" = {msg = "Use a precise type and parse untyped values at the boundary."}
 "typing_extensions.Any" = {msg = "Use a precise type and parse untyped values at the boundary."}
 
-[tool.uv.sources]
-medmlx-core = { git = "https://github.com/MedMLX/medmlx.git", rev = "f98e0924f50228e2b9509474947b9672054b3217", subdirectory = "packages/core" }
-
 [tool.hatch.build.targets.sdist]
 only-include = [
   "src/segresnet_mlx",

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/__init__.py

@@ -16,12 +16,10 @@ if TYPE_CHECKING:
     from segresnet_mlx.predictor import predict_logits as predict_logits
     from segresnet_mlx.telemetry import WindowTelemetry as WindowTelemetry
     from segresnet_mlx.topology import SegResNetSpec as SegResNetSpec
-    from segresnet_mlx.weights import convert_checkpoint as convert_checkpoint
-    from segresnet_mlx.weights import convert_state_dict as convert_state_dict
     from segresnet_mlx.weights import load_model as load_model
     from segresnet_mlx.weights import required_shapes as required_shapes
 
-__version__ = "0.2.3"
+__version__ = "0.3.0"
 
 _EXPORTS = {
     "BUNDLE_CONFIGS": "segresnet_mlx.predictor",
@@ -30,8 +28,6 @@ _EXPORTS = {
     "SegResNetSpec": "segresnet_mlx.topology",
     "SlidingWindowConfig": "segresnet_mlx.predictor",
     "WindowTelemetry": "segresnet_mlx.telemetry",
-    "convert_checkpoint": "segresnet_mlx.weights",
-    "convert_state_dict": "segresnet_mlx.weights",
     "forward_patch": "segresnet_mlx.inference",
     "load_model": "segresnet_mlx.weights",
     "predict_logits": "segresnet_mlx.predictor",
@@ -45,8 +41,6 @@ __all__ = [
     "SegResNetSpec",
     "SlidingWindowConfig",
     "WindowTelemetry",
-    "convert_checkpoint",
-    "convert_state_dict",
     "forward_patch",
     "load_model",
     "predict_logits",
@@ -55,6 +49,7 @@ __all__ = [
 
 
 def __getattr__(name: str) -> object:
+    """Load a public export on first access and cache it in the package."""
     module = _EXPORTS.get(name)
     if module is None:
         raise AttributeError(f"module 'segresnet_mlx' has no attribute {name!r}")
@@ -64,4 +59,5 @@ def __getattr__(name: str) -> object:
 
 
 def __dir__() -> list[str]:
+    """Include lazy exports in interactive package discovery."""
     return sorted({*globals(), *_EXPORTS})

segresnet_mlx-0.3.0/src/segresnet_mlx/_nifti.py

@@ -0,0 +1,109 @@
+"""Typed protocols for the NiBabel NIfTI, header and orientation calls used here."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from os import PathLike
+from typing import Protocol, cast
+
+import nibabel
+import numpy as np
+from nibabel.filebasedimages import ImageFileError as ImageFileError
+
+from segresnet_mlx._arrays import Float64Array, HostArray
+
+type PathArg = str | PathLike[str]
+
+
+class ArrayBuffer(Protocol):
+    def __array__(
+        self, dtype: np.dtype[np.generic] | None = None, copy: bool | None = None
+    ) -> HostArray:
+        """Expose image data through NumPy's array conversion protocol."""
+        ...
+
+
+class NiftiHeader(Protocol):
+    def get_zooms(self) -> tuple[float, ...]:
+        """Return the voxel spacing stored in the header."""
+        ...
+
+    def set_zooms(self, zooms: Sequence[float] | Float64Array) -> None:
+        """Set voxel spacing in the header."""
+        ...
+
+    def __getitem__(self, key: str) -> HostArray:
+        """Return a named NIfTI header field."""
+        ...
+
+
+class NiftiImage(Protocol):
+    shape: tuple[int, ...]
+    affine: Float64Array
+    dataobj: ArrayBuffer | HostArray
+    header: NiftiHeader
+
+    def __init__(self, dataobj: HostArray, affine: HostArray) -> None:
+        """Create an image from voxel data and its affine."""
+        ...
+
+    def get_data_dtype(self) -> np.dtype[np.generic]:
+        """Return the stored voxel-data dtype."""
+        ...
+
+    def get_sform(self) -> Float64Array:
+        """Return the header's sform affine."""
+        ...
+
+    def get_qform(self) -> Float64Array:
+        """Return the header's qform affine."""
+        ...
+
+    def set_sform(self, affine: Float64Array, code: int | None = None) -> None:
+        """Set the header's sform affine and optional code."""
+        ...
+
+    def set_qform(self, affine: Float64Array, code: int | None = None) -> None:
+        """Set the header's qform affine and optional code."""
+        ...
+
+
+class Orientations(Protocol):
+    def axcodes2ornt(self, axcodes: str, labels: tuple[tuple[str, str], ...]) -> Float64Array:
+        """Convert axis codes to an orientation array."""
+        ...
+
+    def ornt_transform(self, start_ornt: Float64Array, end_ornt: Float64Array) -> Float64Array:
+        """Return the transform between two orientation arrays."""
+        ...
+
+    def inv_ornt_aff(self, ornt: Float64Array, shape: Sequence[int]) -> Float64Array:
+        """Return the inverse voxel-coordinate affine for an orientation change."""
+        ...
+
+    def aff2axcodes(
+        self, aff: Float64Array, labels: tuple[tuple[str, str], ...]
+    ) -> tuple[str | None, ...]:
+        """Return axis codes implied by an affine."""
+        ...
+
+
+class Nibabel(Protocol):
+    Nifti1Image: type[NiftiImage]
+    orientations: Orientations
+
+    def load(self, filename: PathArg) -> NiftiImage:
+        """Load an image from a NIfTI path."""
+        ...
+
+    def save(self, img: NiftiImage, filename: PathArg) -> None:
+        """Write an image to a NIfTI path."""
+        ...
+
+    def io_orientation(self, affine: Float64Array) -> Float64Array:
+        """Return the input-to-output orientation implied by an affine."""
+        ...
+
+
+# Bound to the real module; this runner admits only NIfTI images.
+nib = cast(Nibabel, nibabel)

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/_records.py

@@ -57,6 +57,7 @@ class Details(TypedDict):
     ``requires_human_review`` is always true: outputs are research results.
     """
 
+    weights_revision: NotRequired[str | None]
     bundle: str
     arithmetic_profile: ArithmeticProfile
     labels: dict[str, str]

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/_types.py

@@ -19,7 +19,9 @@ if TYPE_CHECKING:
     class ArrayConstructor(Protocol):
         def __call__(
             self, value: HostArray | Array | ArrayValue, dtype: mx.Dtype | None = None
-        ) -> Array: ...
+        ) -> Array:
+            """Construct an MLX array with an optional dtype."""
+            ...
 
     class MLX(MlxRuntime, Protocol):
         all = staticmethod(mx.all)
@@ -32,7 +34,6 @@ if TYPE_CHECKING:
         load = staticmethod(mx.load)
 
         def eval(self, *args: Array | Mapping[str, Array] | Sequence[Array]) -> None: ...
-
         def save_safetensors(self, file: str, arrays: dict[str, Array]) -> None: ...
 
     class SlidingWindowInference(Protocol):
@@ -50,10 +51,14 @@ if TYPE_CHECKING:
             with_coord: bool = False,
             predictor_input: Literal["numpy"],
             preserve_window_strides: bool = False,
-        ) -> Float32Array: ...
+        ) -> Float32Array:
+            """Blend predictor outputs from overlapping windows into host logits."""
+            ...
 
     class CoreSlidingWindow(Protocol):
         sliding_window_inference: SlidingWindowInference
 
     class Metal(Protocol):
-        def is_available(self) -> bool: ...
+        def is_available(self) -> bool:
+            """Report whether the Metal backend is available."""
+            ...

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/medmlx.py

@@ -22,6 +22,7 @@ from medmlx_core.errors import (
     InvalidInputError,
     ModelExecutionError,
 )
+from medmlx_core.weights import weights_dir, weights_revision
 
 from segresnet_mlx import transforms
 from segresnet_mlx.topology import ArithmeticProfile, SegResNetSpec
@@ -39,6 +40,21 @@ MODEL = {
     ),
 }
 
+BRATS_MODEL = {
+    "id": "segresnet-brats",
+    "label": "SegResNet BraTS MRI",
+    "task": "segmentation",
+    "run": "segresnet_mlx.medmlx:brats",
+    "summary": "BraTS brain tumor segmentation from co-registered MRI sequences.",
+}
+RENAL_CECT_MODEL = {
+    "id": "segresnet-renal-cect",
+    "label": "SegResNet renal CECT",
+    "task": "segmentation",
+    "run": "segresnet_mlx.medmlx:renal_cect",
+    "summary": "Renal structures from arterial, venous and excretory phase CT.",
+}
+
 # Label values of the 104 TotalSegmentator structures plus background, as listed in the
 # whole-body bundle's metadata.json ``channel_def``.
 _WHOLE_BODY_LABELS: Mapping[int, str] = {
@@ -295,10 +311,8 @@ def run(
     at 1.5 mm or 3 mm respectively). ``weights_path`` is a native ``.safetensors``
     file: ``segresnet-brats.safetensors`` from ``MedMLX/segresnet-brats-mlx`` for
     BraTS, or ``segresnet-renal-cect.safetensors`` from
-    ``MedMLX/segresnet-renal-cect-mlx`` for renal CECT. These published files need
-    no conversion. For other checkpoints, convert the original ``models/model.pt``
-    (``models/model_lowres.pt`` for lowres whole-body) with
-    :func:`segresnet_mlx.convert_checkpoint` and pass the resulting file.
+    ``MedMLX/segresnet-renal-cect-mlx`` for renal CECT, or the corresponding
+    high- or low-resolution file from ``MedMLX/segresnet-wholebody-mlx``.
 
     Inputs must be finite 3D NIfTI volumes; multi-input bundles need identical shape
     and affine (atol 1e-5). Writes ``<bundle>_mask.nii.gz`` in ``output_dir`` on the
@@ -423,6 +437,7 @@ def run(
     return {
         "outputs": {"mask": mask_path.as_posix()},
         "details": {
+            "weights_revision": weights_revision(weights.parent),
             "bundle": bundle,
             "arithmetic_profile": arithmetic_profile,
             "labels": {str(value): name for value, name in config.labels.items()},
@@ -450,6 +465,66 @@ def run(
     }
 
 
+def brats(
+    *,
+    t1c_path: str,
+    t1_path: str,
+    t2_path: str,
+    flair_path: str,
+    output_dir: str,
+    weights_path: str | None = None,
+    overwrite: bool = False,
+    arithmetic_profile: ArithmeticProfile = "torch-order-fp32",
+) -> RunResult:
+    """Segment BraTS MRI; omit weights_path to download its cached model folder.
+
+    The four input volumes must share a voxel grid. An explicit folder contains
+    ``segresnet-brats.safetensors``; an explicit safetensors file is also accepted.
+    Automatic downloads use ``MedMLX/segresnet-brats-mlx``. All arithmetic and
+    preprocessing are delegated unchanged to ``run``.
+    """
+    folder = (
+        weights_dir("segresnet-brats-mlx")
+        if weights_path is None else Path(weights_path).expanduser()
+    )
+    checkpoint = folder / "segresnet-brats.safetensors" if folder.is_dir() else folder
+    return run(
+        bundle="brats_mri_segmentation", weights_path=str(checkpoint), output_dir=output_dir,
+        t1c_path=t1c_path, t1_path=t1_path, t2_path=t2_path, flair_path=flair_path,
+        overwrite=overwrite, arithmetic_profile=arithmetic_profile,
+    )
+
+
+def renal_cect(
+    *,
+    arterial_path: str,
+    venous_path: str,
+    excretory_path: str,
+    output_dir: str,
+    weights_path: str | None = None,
+    overwrite: bool = False,
+    arithmetic_profile: ArithmeticProfile = "torch-order-fp32",
+) -> RunResult:
+    """Segment renal CECT; omit weights_path to download its cached model folder.
+
+    The arterial, venous and excretory CT volumes must share a voxel grid. An
+    explicit folder contains ``segresnet-renal-cect.safetensors`` as published for
+    this bundle; an explicit safetensors file is also accepted. Automatic downloads
+    use ``MedMLX/segresnet-renal-cect-mlx``. Arithmetic and preprocessing are
+    delegated unchanged to ``run``.
+    """
+    folder = (
+        weights_dir("segresnet-renal-cect-mlx")
+        if weights_path is None else Path(weights_path).expanduser()
+    )
+    checkpoint = folder / "segresnet-renal-cect.safetensors" if folder.is_dir() else folder
+    return run(
+        bundle="renalStructures_CECT_segmentation", weights_path=str(checkpoint),
+        output_dir=output_dir, arterial_path=arterial_path, venous_path=venous_path,
+        excretory_path=excretory_path, overwrite=overwrite, arithmetic_profile=arithmetic_profile,
+    )
+
+
 def preprocess_renal(volumes: list[Volume]) -> tuple[Float32Array, SpatialInverse]:
     """The renal bundle's ``preprocessing`` from ``EnsureChannelFirstd`` onward.
 
@@ -562,14 +637,11 @@ def postprocess_wholebody(logits: Float32Array, inverse: SpatialInverse) -> Floa
 
 
 def _weights_file(weights_path: str) -> Path:
+    """Validate a safetensors file path while retaining any Hub-cache symlink."""
     # MLX identifies the file format from the supplied name. Hub cache paths are
     # named .safetensors symlinks whose underlying content-addressed blobs have no suffix.
     path = Path(weights_path).expanduser().absolute()
-    hint = (
-        "Convert the bundle's models/model.pt once with "
-        "segresnet_mlx.convert_checkpoint(model_pt, destination, spec=...) "
-        "(requires the conversion extra)."
-    )
+    hint = "Download the matching safetensors file from the MedMLX weight repositories."
     if not path.is_file():
         raise AssetNotReadyError(
             f"SegResNet weights not found: {path}", reason=f"missing {path}", hint=hint
@@ -646,7 +718,7 @@ def _load_network(
         raise AssetNotReadyError(
             f"SegResNet weights {weights} do not match {spec}: {error}",
             reason=f"mismatched {weights.name}",
-            hint="Convert the matching bundle's models/model.pt with convert_checkpoint.",
+            hint="Download the matching safetensors file from the MedMLX weight repositories.",
         ) from error
 
 
@@ -702,4 +774,4 @@ def write_atomic(path: Path, mask: MaskArray, affine: Float64Array, dtype: str)
         Path(name).unlink(missing_ok=True)
 
 
-__all__ = ["BUNDLES", "MODEL", "run"]
+__all__ = ["BRATS_MODEL", "BUNDLES", "MODEL", "RENAL_CECT_MODEL", "brats", "renal_cect", "run"]

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/network.py

@@ -22,9 +22,8 @@ def group_mean(values: Array, mx: MLX) -> Array:
 
     Tiling bounds the float32 accumulation depth of a group that spans a whole
     volume. The last dimension must be nonempty. Returns ``(N, G, 1)``. ``SegResNet``
-    does not call this (its GroupNorm
-    comes from the ``medmlx_core`` operators); it is exercised by
-    ``tests/test_equivalence.py``.
+    does not call this (its GroupNorm comes from the ``medmlx_core`` operators); it is
+    exercised by ``tests/test_equivalence.py``.
     """
     size = int(values.shape[-1])
     padded = mx.pad(values, [(0, 0), (0, 0), (0, (-size) % 256)])
@@ -59,6 +58,7 @@ class SegResNet:
         mx: MLX,
         arithmetic_profile: ArithmeticProfile = "torch-order-fp32",
     ) -> None:
+        """Bind the topology and weights and select their arithmetic operators."""
         self.spec = spec
         self._weights = weights
         self._mx = mx
@@ -105,6 +105,7 @@ class SegResNet:
         return self._forward(operators.pack(values))
 
     def _forward(self, values: Array) -> Array:
+        """Run the encoder and decoder, retaining skip connections between stages."""
         require_ncdhw(values, name="SegResNet input")
         if int(values.shape[1]) != self.spec.in_channels:
             raise ValueError(
@@ -163,6 +164,8 @@ class SegResNet:
         return self._add(hidden, values)
 
     def _relu(self, values: Array) -> Array:
+        """Apply ReLU using paired arithmetic when the fp48 profile is active."""
+        # fp48 activations are paired float32 words, so ReLU must act on the pair.
         return (
             cast("CompensatedFloat48Operators", self._operators).relu(values)
             if self.arithmetic_profile == "compensated-fp48"
@@ -170,6 +173,8 @@ class SegResNet:
         )
 
     def _add(self, values: Array, other: Array) -> Array:
+        """Add residual or skip values using the selected arithmetic profile."""
+        # Residual/skip add; for fp48 it is a paired-precision add, not a plain float32 sum.
         return (
             cast("CompensatedFloat48Operators", self._operators).add(values, other)
             if self.arithmetic_profile == "compensated-fp48"
@@ -177,6 +182,7 @@ class SegResNet:
         )
 
     def _norm(self, values: Array, prefix: str) -> Array:
+        """Apply group normalization using the weights at the given prefix."""
         return self._operators.norm(
             values, self._weights[f"{prefix}.weight"], self._weights[f"{prefix}.bias"]
         )

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/predictor.py

@@ -92,6 +92,7 @@ class BundlePredictor:
         telemetry: WindowTelemetry | None = None,
         mx: MLX | None = None,
     ) -> None:
+        """Initialize the network runtime and optional per-window telemetry."""
         self.network = network
         self.telemetry = telemetry
         try:
@@ -124,6 +125,7 @@ class BundlePredictor:
             self.telemetry.attach(engine, events=events)
 
     def __call__(self, values: HostArray | Array) -> Array:
+        """Run one patch through the same validated path as ``forward``."""
         return self.forward(values)
 
     def forward(self, values: HostArray | Array) -> Array:
@@ -140,6 +142,7 @@ class BundlePredictor:
             raise
 
     def _forward_window(self, values: HostArray | Array) -> Float32Array:
+        """Run and synchronize one window, returning finite host logits."""
         host = self._host_input(values)
         self.mx.synchronize()
         started = time.perf_counter()
@@ -159,6 +162,7 @@ class BundlePredictor:
         return output
 
     def _host_input(self, values: HostArray | Array) -> Float32Array:
+        """Admit finite float32 input as a NumPy array or raise an input error."""
         host = np.asarray(values)
         if host.dtype != np.float32 or not np.isfinite(host).all():
             raise InvalidInputError(f"{self.network_label} input must be finite float32")
@@ -242,6 +246,7 @@ def predict_wide_logits(
     def window(
         patch: np.ndarray[tuple[int, ...], np.dtype[np.float64]],
     ) -> np.ndarray[tuple[int, ...], np.dtype[np.float64]]:
+        """Combine paired Metal output words into float64 host logits."""
         result = network.paired_forward(cast(ArrayFactory, mx.array)(patch.astype(np.float32)))
         mx.eval(result)
         mx.synchronize()

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/telemetry.py

@@ -20,7 +20,9 @@ import numpy as np
 
 
 class EventEngine(Protocol):
-    def add_event_handler(self, event_name: Events, handler: Callable[..., None]) -> object: ...
+    def add_event_handler(self, event_name: Events, handler: Callable[..., None]) -> object:
+        """Register a handler for an Ignite lifecycle event."""
+        ...
 
 
 SCHEMA_VERSION = "medmlx.segresnet.mlx.v1"
@@ -37,6 +39,7 @@ class WindowTelemetry:
     """
 
     def __init__(self, path: Path, record: dict[str, Json]) -> None:
+        """Create the output directory and initialize the caller-owned progress record."""
         self.path = path
         self.record = record
         self._metadata = {"schema_version": SCHEMA_VERSION, **record}
@@ -141,20 +144,25 @@ class WindowTelemetry:
             attached.add_event_handler(event, self._interrupted)
 
     def _started(self, engine: object) -> None:
+        """Start a fresh record when the attached engine starts."""
         self.begin()
 
     def _completed(self, engine: object) -> None:
+        """Finalize a completed engine run."""
         self.finish()
 
     def _failed(self, engine: object, error: BaseException) -> None:
+        """Record and re-raise an engine failure."""
         self.fail(error)
         # Registering EXCEPTION_RAISED otherwise makes Ignite swallow the error.
         raise error
 
     def _interrupted(self, engine: object, **kwargs: object) -> None:
+        """Finalize an interrupted engine run."""
         self.finish("interrupted")
 
     def _write(self) -> None:
+        """Replace the progress file atomically with the current JSON record."""
         # Atomic visibility for progress readers, not a crash-durability promise.
         descriptor, name = tempfile.mkstemp(prefix=f".{self.path.name}.", dir=self.path.parent)
         try:

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/topology.py

@@ -33,6 +33,7 @@ class SegResNetSpec:
     upsample_mode: str = "nontrainable"
 
     def __post_init__(self) -> None:
+        """Reject unsupported channel, stage, normalization, and upsampling settings."""
         if min(self.in_channels, self.out_channels, self.init_filters) < 1:
             raise ValueError("SegResNet channel counts must be positive")
         if len(self.blocks_down) != len(self.blocks_up) + 1:

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/transforms.py

@@ -18,12 +18,35 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 from dataclasses import dataclass
-from fractions import Fraction
 from pathlib import Path
 from typing import cast
 
 import numpy as np
 import numpy.typing as npt
+from medmlx_core.geometry import (
+    _bmm as _bmm,
+)
+from medmlx_core.geometry import (
+    _fma as _fma,
+)
+from medmlx_core.geometry import (
+    _linspace_from_neg_one as _linspace_from_neg_one,
+)
+from medmlx_core.geometry import (
+    _mm as _mm,
+)
+from medmlx_core.geometry import (
+    affine_to_spacing as affine_to_spacing,
+)
+from medmlx_core.geometry import (
+    compute_shape_offset as compute_shape_offset,
+)
+from medmlx_core.geometry import (
+    to_affine_nd as to_affine_nd,
+)
+from medmlx_core.geometry import (
+    zoom_affine as zoom_affine,
+)
 
 from segresnet_mlx._arrays import HostArray, Int64Array
 from segresnet_mlx._nifti import NiftiImage, nib
@@ -83,76 +106,12 @@ def correct_nifti_header(image: NiftiImage) -> None:
     image.header.set_zooms(affine_to_spacing(image.affine, 3))
 
 
-def to_affine_nd(rank: int, affine: npt.ArrayLike) -> Float64Array:
-    """``monai.data.utils.to_affine_nd`` for an integer rank."""
-    source = np.array(affine, dtype=np.float64, copy=True)
-    result = np.eye(rank + 1, dtype=np.float64)
-    size = max(min(len(result) - 1, len(source) - 1), 1)
-    result[:size, :size] = source[:size, :size]
-    if size > 1:
-        result[:size, -1] = source[:size, -1]
-    return result
 
 
-def affine_to_spacing(affine: Float64Array, rank: int) -> Float64Array:
-    """``monai.data.utils.affine_to_spacing`` with zeros suppressed to one."""
-    part = np.asarray(affine[:rank, :rank], dtype=np.float64)
-    spacing = np.sqrt(np.sum(part * part, axis=0))
-    spacing[spacing == 0] = 1.0
-    return spacing
-
-
-def zoom_affine(affine: Float64Array, scale: Float64Array) -> Float64Array:
-    """``monai.data.utils.zoom_affine`` with ``diagonal=False``."""
-    affine = np.array(affine, dtype=float, copy=True)
-    scale_np = np.array(scale, dtype=float, copy=True)
-    size = len(affine) - 1
-    norm = affine_to_spacing(affine, size)
-    if len(scale_np) < size:
-        scale_np = np.append(scale_np, norm[len(scale_np) :])
-    scale_np = scale_np[:size]
-    scale_np = np.where(scale_np > 0, scale_np, norm)
-    scale_np[scale_np == 0] = 1.0
-    rzs = affine[:-1, :-1]
-    zs = np.linalg.cholesky(rzs.T @ rzs).T
-    rotation = rzs @ np.linalg.inv(zs)
-    signed = np.sign(np.diag(zs)) * np.abs(scale_np)
-    result = np.eye(len(affine))
-    result[:-1, :-1] = rotation @ np.diag(signed)
-    return result
 
 
-def compute_shape_offset(
-    spatial_shape: Sequence[int],
-    in_affine: Float64Array,
-    out_affine: Float64Array,
-) -> tuple[npt.NDArray[np.int_], Float64Array]:
-    """``monai.data.utils.compute_shape_offset`` with ``scale_extent=False``."""
-    shape = np.array(tuple(spatial_shape), copy=True, dtype=float)
-    rank = len(shape)
-    in_affine_ = to_affine_nd(rank, in_affine)
-    out_affine_ = to_affine_nd(rank, out_affine)
-    in_coords = [(0.0, dim - 1.0) for dim in shape]
-    corners: Float64Array = np.asarray(np.meshgrid(*in_coords, indexing="ij")).reshape((rank, -1))
-    corners = np.concatenate((corners, np.ones_like(corners[:1])))
-    corners_out = np.linalg.solve(out_affine_, in_affine_) @ corners
-    corners = in_affine_ @ corners
-    all_dist = corners_out[:-1].copy()
-    corners_out = corners_out[:-1] / corners_out[-1]
-    out_shape = np.round(cast(Float64Array, np.ptp(corners_out, axis=1)) + 1.0)
-    offset = None
-    for index in range(corners.shape[1]):
-        min_corner = np.min(all_dist - all_dist[:, index : index + 1], 1)
-        if np.allclose(min_corner, 0.0, rtol=AFFINE_TOL):
-            offset = corners[:-1, index]
-            break
-    if offset is None:
-        offset = (
-            in_affine_[:-1, :-1] @ (shape / 2.0)
-            + in_affine_[:-1, -1]
-            - out_affine_[:-1, :-1] @ (out_shape / 2.0)
-        )
-    return out_shape.astype(int, copy=False), offset
+
+
 
 
 def orient(
@@ -387,35 +346,8 @@ def write_nifti(path: Path, data: HostArray, affine: Float64Array, dtype: npt.DT
     nib.save(image, str(path))
 
 
-def _mm(left: Float64Array, right: Float64Array) -> Float64Array:
-    """A MetaTensor affine update, ``torch.mm`` of two 4x4 float64 matrices.
-
-    The reference Torch build's MKL computes each entry as
-    ``fma(a2, b2, a0 * b0) + fma(a3, b3, a1 * b1)``.
-    """
-    if left.shape != (4, 4) or right.shape != (4, 4):
-        return left @ right
-    result = np.empty((4, 4), dtype=np.float64)
-    for row in range(4):
-        a = [float(value) for value in left[row]]
-        for column in range(4):
-            b = [float(value) for value in right[:, column]]
-            result[row, column] = _fma(a[2], b[2], a[0] * b[0]) + _fma(a[3], b[3], a[1] * b[1])
-    return result
 
 
-def _bmm(left: Float64Array, right: Float64Array) -> Float64Array:
-    """Torch's small-matrix ``bmm`` kernel: unfused sequential float64 accumulation."""
-    rows, inner = left.shape
-    columns = right.shape[1]
-    result = np.empty((rows, columns), dtype=np.float64)
-    for row in range(rows):
-        for column in range(columns):
-            total = 0.0
-            for index in range(inner):
-                total += float(left[row, index]) * float(right[index, column])
-            result[row, column] = total
-    return result
 
 
 def _normalize_transform(shape: Sequence[int]) -> Float64Array:
@@ -429,29 +361,8 @@ def _normalize_transform(shape: Sequence[int]) -> Float64Array:
     return result
 
 
-def _fma(left: float, right: float, addend: float) -> float:
-    """Correctly rounded ``left * right + addend``."""
-    return float(Fraction(left) * Fraction(right) + Fraction(addend))
-
 
-def _linspace_from_neg_one(steps: int) -> Float64Array:
-    """ATen ``linspace(-1, 1, steps) * (steps - 1) / steps`` in float64.
 
-    ATen evaluates ``start + step * i`` below the midpoint and
-    ``end - step * (steps - i - 1)`` above it, each as one fused multiply-add.
-    """
-    if steps <= 1:
-        return np.zeros(1, dtype=np.float64)
-    step = (1.0 - (-1.0)) / (steps - 1)
-    halfway = steps // 2
-    values = np.array(
-        [
-            _fma(step, index, -1.0) if index < halfway else _fma(-step, steps - index - 1, 1.0)
-            for index in range(steps)
-        ],
-        dtype=np.float64,
-    )
-    return values * (steps - 1) / steps
 
 
 def _theta(
@@ -461,7 +372,8 @@ def _theta(
 ) -> Float64Array:
     """``AffineTransform`` normalization and reverse indexing of a voxel transform."""
     theta = _bmm(
-        _bmm(_normalize_transform(in_size), xform), np.linalg.inv(_normalize_transform(out_size))
+        _bmm(_normalize_transform(in_size), xform),
+        np.linalg.inv(_normalize_transform(out_size)),
     )
     rank = len(in_size)
     reverse = list(range(rank - 1, -1, -1))
@@ -545,6 +457,7 @@ def _product_error(
     """Dekker's exact remainder ``left * right - product``."""
 
     def split[T: (Float64Array, np.float64)](value: T) -> tuple[T, T]:
+        """Split a float64 value into high and low words for Dekker multiplication."""
         scaled = 134217729.0 * value
         high = scaled - (scaled - value)
         return cast(T, high), cast(T, value - high)

{segresnet_mlx-0.2.3 → segresnet_mlx-0.3.0}/src/segresnet_mlx/weights.py

@@ -1,16 +1,11 @@
-"""Strict Torch checkpoint conversion for MONAI SegResNet MLX inference."""
+"""Strict safetensors loading for MONAI SegResNet MLX inference."""
 
 from __future__ import annotations
 
-from collections.abc import Mapping
 from pathlib import Path
 from typing import TYPE_CHECKING, cast
 
-import numpy as np
-import numpy.typing as npt
-from medmlx_core.checkpoints import load_torch_checkpoint, tensor_mapping_from_payload
 from medmlx_core.errors import InvalidInputError
-from medmlx_core.typing import ArrayFactory
 
 from segresnet_mlx._runtime import import_mlx
 
@@ -20,8 +15,6 @@ if TYPE_CHECKING:
 from segresnet_mlx.network import SegResNet
 from segresnet_mlx.topology import ArithmeticProfile, SegResNetSpec
 
-type HostArray = npt.NDArray[np.float32]
-
 
 def required_shapes(spec: SegResNetSpec) -> dict[str, tuple[int, ...]]:
     """Return the exact ``{parameter name: shape}`` set a checkpoint must provide.
@@ -71,84 +64,6 @@ def required_shapes(spec: SegResNetSpec) -> dict[str, tuple[int, ...]]:
     return shapes
 
 
-def convert_state_dict(
-    state: Mapping[str, object] | Mapping[object, object], spec: SegResNetSpec
-) -> dict[str, HostArray]:
-    """Check a Torch state dict against ``spec`` and return float32 NumPy parameters.
-
-    ``state`` is either a raw state dict or a checkpoint holding it under the
-    ``"model"`` key. Arrays keep their Torch layout and are returned C-contiguous.
-    Validation checks the parameter inventory and values, not the checkpoint's
-    identity or origin; other checkpoints with the same topology are admissible.
-
-    Raises:
-        InvalidInputError: If a required parameter is missing, an unsupported one is
-            present, a shape differs from ``required_shapes(spec)``, or a value is
-            not finite.
-    """
-    # The bundle's CheckpointLoader selects model and ignores other saved objects.
-    if "model" in state:
-        state = cast("Mapping[str, object] | Mapping[object, object]", state["model"])
-    source = tensor_mapping_from_payload(state, what="SegResNet")
-    required = required_shapes(spec)
-    missing = [key for key in required if key not in source]
-    extra = [key for key in source if key not in required]
-    if missing:
-        raise InvalidInputError(
-            "SegResNet checkpoint is missing parameter(s): " + ", ".join(missing)
-        )
-    if extra:
-        raise InvalidInputError(
-            "SegResNet checkpoint has unsupported parameter(s): " + ", ".join(extra)
-        )
-    converted: dict[str, HostArray] = {}
-    for key, expected_shape in required.items():
-        array = np.asarray(source[key], dtype=np.float32)
-        if array.shape != expected_shape:
-            raise InvalidInputError(
-                f"SegResNet parameter {key!r} has shape {array.shape}; expected {expected_shape}"
-            )
-        if not np.isfinite(array).all():
-            raise InvalidInputError(f"SegResNet parameter {key!r} contains non-finite values")
-        converted[key] = np.ascontiguousarray(array)
-    return converted
-
-
-def convert_checkpoint(checkpoint_path: Path, destination: Path, *, spec: SegResNetSpec) -> Path:
-    """Convert a Torch checkpoint to float32 safetensors and return ``destination``.
-
-    The checkpoint is read with the shared loader (``torch.load`` with its default
-    ``weights_only=True``, so Torch from the ``conversion`` extra is required) and
-    checked by ``convert_state_dict``. ``destination`` must end in
-    ``.safetensors``. Parent directories of ``destination`` are
-    created. An existing destination is replaced, except when it aliases the
-    source checkpoint. Alias checks occur before conversion and do not lock out
-    subsequent filesystem changes. MLX is also needed to write the file, so this
-    runs only on a supported Apple Silicon host.
-
-    Raises:
-        InvalidInputError: The destination has a different suffix or aliases the
-            source checkpoint, or checkpoint contents fail ``convert_state_dict``.
-    """
-
-    if destination.suffix != ".safetensors":
-        raise InvalidInputError("Converted weights destination must end in .safetensors")
-    if checkpoint_path.resolve() == destination.resolve() or (
-        checkpoint_path.is_file()
-        and destination.is_file()
-        and checkpoint_path.samefile(destination)
-    ):
-        raise InvalidInputError("Converted weights must not overwrite their source checkpoint")
-    mx = import_mlx()
-    converted = convert_state_dict(load_torch_checkpoint(checkpoint_path), spec)
-    destination.parent.mkdir(parents=True, exist_ok=True)
-    mx.save_safetensors(
-        str(destination),
-        {key: cast(ArrayFactory, mx.array)(value) for key, value in converted.items()},
-    )
-    return destination
-
-
 def load_model(
     weights_path: Path,
     *,
@@ -162,6 +77,8 @@ def load_model(
             from ``required_shapes(spec)``, or a parameter is not finite float32.
         RuntimeError: If MLX cannot open or decode the weights file.
     """
+    if Path(weights_path).suffix != ".safetensors":
+        raise InvalidInputError("SegResNet weights must be a safetensors file")
     mx = import_mlx()
     raw: object = mx.load(str(weights_path))
     if not isinstance(raw, dict):
@@ -191,6 +108,7 @@ def load_model(
 
 
 def _residual_shapes(prefix: str, channels: int) -> dict[str, tuple[int, ...]]:
+    """Expected parameter shapes of one residual block (Torch layouts, no conv bias)."""
     return {
         f"{prefix}.norm1.weight": (channels,),
         f"{prefix}.norm1.bias": (channels,),

segresnet_mlx-0.2.3/PKG-INFO

@@ -1,87 +0,0 @@
-Metadata-Version: 2.5
-Name: segresnet-mlx
-Version: 0.2.3
-Summary: Native MLX SegResNet with NumPy sliding-window logit inference
-Project-URL: Homepage, https://github.com/MedMLX/segresnet-mlx
-Project-URL: Documentation, https://github.com/MedMLX/segresnet-mlx/blob/main/docs/technical.md
-Project-URL: Repository, https://github.com/MedMLX/segresnet-mlx
-Project-URL: Issues, https://github.com/MedMLX/segresnet-mlx/issues
-Author: Joseph Sandoval, Alfredo Sandoval Jr.
-License-Expression: Apache-2.0
-License-File: LICENSE
-License-File: THIRD_PARTY_NOTICES.md
-Classifier: Operating System :: MacOS :: MacOS X
-Requires-Python: <3.15,>=3.13
-Requires-Dist: medmlx-core==0.2.4
-Requires-Dist: nibabel<6,>=5.3
-Requires-Dist: numpy<3,>=2.0
-Provides-Extra: conversion
-Requires-Dist: torch<3,>=2.6; extra == 'conversion'
-Provides-Extra: dev
-Requires-Dist: hypothesis<7,>=6; extra == 'dev'
-Requires-Dist: monai==1.6.1; extra == 'dev'
-Requires-Dist: pyright==1.1.414; extra == 'dev'
-Requires-Dist: pytest<10,>=8.4; extra == 'dev'
-Requires-Dist: pytorch-ignite<0.6,>=0.4.11; extra == 'dev'
-Requires-Dist: ruff<1,>=0.13; extra == 'dev'
-Requires-Dist: torch<3,>=2.6; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# segresnet-mlx
-
-Segment brain tumors, renal structures and whole-body CT anatomy with MONAI SegResNet models in native MLX.
-
-[Docs](https://github.com/MedMLX/segresnet-mlx/blob/main/docs/technical.md) · [MedMLX](https://github.com/MedMLX)
-
-![SegResNet brain tumor segmentation in axial, coronal and sagittal views](https://raw.githubusercontent.com/MedMLX/segresnet-mlx/main/docs/example.png)
-
-*BraTS bundle output on a Medical Segmentation Decathlon brain MRI: tumor core
-(red), edema (green) and enhancing tumor (yellow).*
-
-| Input | Output |
-| :--- | :--- |
-| MRI sequences or CT volumes | Segmentation on the input grid |
-
-**Apple Silicon · Metal · Python 3.13 / 3.14** · [uv](https://docs.astral.sh/uv/)
-
-## Quick start
-
-```bash
-uv venv --python 3.13
-source .venv/bin/activate
-uv pip install segresnet-mlx huggingface-hub
-```
-
-Download the converted [BraTS](https://huggingface.co/MedMLX/segresnet-brats-mlx) weights, then run:
-
-```python
-from huggingface_hub import hf_hub_download
-from segresnet_mlx.medmlx import run
-
-bundle = "brats_mri_segmentation"
-weights = hf_hub_download(
-    "MedMLX/segresnet-brats-mlx", "segresnet-brats.safetensors",
-    revision="14f9cda3649965729663c7365c49fd839c81a01b",
-)
-
-result = run(
-    bundle=bundle,
-    t1c_path="t1c.nii.gz",
-    t1_path="t1.nii.gz",
-    t2_path="t2.nii.gz",
-    flair_path="flair.nii.gz",
-    weights_path=weights,
-    output_dir="out",
-)
-print(result["outputs"]["mask"])
-```
-
-Keep input volumes on the same voxel grid. Converted weights are also available for
-[renal CECT](https://huggingface.co/MedMLX/segresnet-renal-cect-mlx). Docs cover
-checkpoint conversion and whole-body CT.
-
-## License
-
-[Apache-2.0](https://github.com/MedMLX/segresnet-mlx/blob/main/LICENSE). See [third-party notices](https://github.com/MedMLX/segresnet-mlx/blob/main/THIRD_PARTY_NOTICES.md). Model weights retain their publisher terms.
-
-For research and education. Outputs require human review.

segresnet_mlx-0.2.3/README.md

@@ -1,58 +0,0 @@
-# segresnet-mlx
-
-Segment brain tumors, renal structures and whole-body CT anatomy with MONAI SegResNet models in native MLX.
-
-[Docs](https://github.com/MedMLX/segresnet-mlx/blob/main/docs/technical.md) · [MedMLX](https://github.com/MedMLX)
-
-![SegResNet brain tumor segmentation in axial, coronal and sagittal views](https://raw.githubusercontent.com/MedMLX/segresnet-mlx/main/docs/example.png)
-
-*BraTS bundle output on a Medical Segmentation Decathlon brain MRI: tumor core
-(red), edema (green) and enhancing tumor (yellow).*
-
-| Input | Output |
-| :--- | :--- |
-| MRI sequences or CT volumes | Segmentation on the input grid |
-
-**Apple Silicon · Metal · Python 3.13 / 3.14** · [uv](https://docs.astral.sh/uv/)
-
-## Quick start
-
-```bash
-uv venv --python 3.13
-source .venv/bin/activate
-uv pip install segresnet-mlx huggingface-hub
-```
-
-Download the converted [BraTS](https://huggingface.co/MedMLX/segresnet-brats-mlx) weights, then run:
-
-```python
-from huggingface_hub import hf_hub_download
-from segresnet_mlx.medmlx import run
-
-bundle = "brats_mri_segmentation"
-weights = hf_hub_download(
-    "MedMLX/segresnet-brats-mlx", "segresnet-brats.safetensors",
-    revision="14f9cda3649965729663c7365c49fd839c81a01b",
-)
-
-result = run(
-    bundle=bundle,
-    t1c_path="t1c.nii.gz",
-    t1_path="t1.nii.gz",
-    t2_path="t2.nii.gz",
-    flair_path="flair.nii.gz",
-    weights_path=weights,
-    output_dir="out",
-)
-print(result["outputs"]["mask"])
-```
-
-Keep input volumes on the same voxel grid. Converted weights are also available for
-[renal CECT](https://huggingface.co/MedMLX/segresnet-renal-cect-mlx). Docs cover
-checkpoint conversion and whole-body CT.
-
-## License
-
-[Apache-2.0](https://github.com/MedMLX/segresnet-mlx/blob/main/LICENSE). See [third-party notices](https://github.com/MedMLX/segresnet-mlx/blob/main/THIRD_PARTY_NOTICES.md). Model weights retain their publisher terms.
-
-For research and education. Outputs require human review.

segresnet_mlx-0.2.3/src/segresnet_mlx/_nifti.py

@@ -1,63 +0,0 @@
-"""Typed protocols for the NiBabel NIfTI, header and orientation calls used here."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from os import PathLike
-from typing import Protocol, cast
-
-import nibabel
-import numpy as np
-from nibabel.filebasedimages import ImageFileError as ImageFileError
-
-from segresnet_mlx._arrays import Float64Array, HostArray
-
-type PathArg = str | PathLike[str]
-
-
-class ArrayBuffer(Protocol):
-    def __array__(
-        self, dtype: np.dtype[np.generic] | None = None, copy: bool | None = None
-    ) -> HostArray: ...
-
-
-class NiftiHeader(Protocol):
-    def get_zooms(self) -> tuple[float, ...]: ...
-    def set_zooms(self, zooms: Sequence[float] | Float64Array) -> None: ...
-    def __getitem__(self, key: str) -> HostArray: ...
-
-
-class NiftiImage(Protocol):
-    shape: tuple[int, ...]
-    affine: Float64Array
-    dataobj: ArrayBuffer | HostArray
-    header: NiftiHeader
-
-    def __init__(self, dataobj: HostArray, affine: HostArray) -> None: ...
-    def get_data_dtype(self) -> np.dtype[np.generic]: ...
-    def get_sform(self) -> Float64Array: ...
-    def get_qform(self) -> Float64Array: ...
-    def set_sform(self, affine: Float64Array, code: int | None = None) -> None: ...
-    def set_qform(self, affine: Float64Array, code: int | None = None) -> None: ...
-
-
-class Orientations(Protocol):
-    def axcodes2ornt(self, axcodes: str, labels: tuple[tuple[str, str], ...]) -> Float64Array: ...
-    def ornt_transform(self, start_ornt: Float64Array, end_ornt: Float64Array) -> Float64Array: ...
-    def inv_ornt_aff(self, ornt: Float64Array, shape: Sequence[int]) -> Float64Array: ...
-    def aff2axcodes(
-        self, aff: Float64Array, labels: tuple[tuple[str, str], ...]
-    ) -> tuple[str | None, ...]: ...
-
-
-class Nibabel(Protocol):
-    Nifti1Image: type[NiftiImage]
-    orientations: Orientations
-
-    def load(self, filename: PathArg) -> NiftiImage: ...
-    def save(self, img: NiftiImage, filename: PathArg) -> None: ...
-    def io_orientation(self, affine: Float64Array) -> Float64Array: ...
-
-
-# Bound to the real module; this runner admits only NIfTI images.
-nib = cast(Nibabel, nibabel)