monai-weekly 1.7.dev2625__tar.gz → 1.7.dev2627__tar.gz

{monai_weekly-1.7.dev2625/monai_weekly.egg-info → monai_weekly-1.7.dev2627}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2625
+Version: 1.7.dev2627
 Summary: AI Toolkit for Healthcare Imaging
 Home-page: https://project-monai.github.io/
 Author: MONAI Consortium

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/__init__.py

@@ -136,4 +136,4 @@ except Exception:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "15f50736067093ec3716dfebdf37fe454ef79189"
+__commit_id__ = "eb74488c5be06e97d8ee5d6bdec2488ac3903a1c"

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-21T03:12:46+0000",
+ "date": "2026-07-05T03:07:50+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "128f497c42f5eb7a57de6cd679ff5fe293f2b2de",
- "version": "1.7.dev2625"
+ "full-revisionid": "9c37af81ef49b616038685d338f97726a0266440",
+ "version": "1.7.dev2627"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/apps/nnunet/nnunetv2_runner.py

@@ -598,7 +598,11 @@ class nnUNetV2Runner:  # noqa: N801
 
         for _key, _value in kwargs.items():
             prefix = "-" if _key in {"p", "pretrained_weights"} else "--"
-            cmd += [f"{prefix}{_key}", str(_value)]
+            if isinstance(_value, bool):
+                if _value:
+                    cmd.append(f"{prefix}{_key}")
+            else:
+                cmd += [f"{prefix}{_key}", str(_value)]
 
         cmd_str: list[str] = [str(c) for c in cmd]
 
@@ -758,7 +762,7 @@ class nnUNetV2Runner:  # noqa: N801
             kwargs: this optional parameter allows you to specify additional arguments defined in the
                 ``train_single_model`` method.
         """
-        self.train_single_model(config=config, fold=fold, only_run_validation=True, **kwargs)
+        self.train_single_model(config=config, fold=fold, val=True, **kwargs)
 
     def validate(
         self, configs: tuple = (M.N_3D_FULLRES, M.N_2D, M.N_3D_LOWRES, M.N_3D_CASCADE_FULLRES), **kwargs: Any

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/apps/nnunet/utils.py

@@ -149,7 +149,6 @@ def create_new_dataset_json(
     """
     new_json_data: dict = {}
 
-    # modality = self.input_info.pop("modality")
     modality = ensure_tuple(modality)  # type: ignore
 
     new_json_data["channel_names"] = {}
@@ -161,18 +160,11 @@ def create_new_dataset_json(
     for _j in range(num_foreground_classes):
         new_json_data["labels"][f"class{_j + 1}"] = _j + 1
 
-    # new_json_data["numTraining"] = len(datalist_json["training"])
     new_json_data["numTraining"] = num_training_data
     new_json_data["file_ending"] = ".nii.gz"
 
     ConfigParser.export_config_file(
-        config=new_json_data,
-        # filepath=os.path.join(raw_data_foldername, "dataset.json"),
-        filepath=output_filepath,
-        fmt="json",
-        sort_keys=True,
-        indent=4,
-        ensure_ascii=False,
+        config=new_json_data, filepath=output_filepath, fmt="json", sort_keys=True, indent=4, ensure_ascii=False
     )
 
     return

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/apps/vista3d/transforms.py

@@ -160,8 +160,6 @@ class VistaPostTransformd(MapTransform):
                     pred = pred.argmax(0).unsqueeze(0).float() + 1.0
                     pred[is_bk] = 0.0
                 else:
-                    # AsDiscrete will remove NaN
-                    # pred = monai.transforms.AsDiscrete(threshold=0.5)(pred)
                     pred[pred > 0] = 1.0
                 if "label_prompt" in data and data["label_prompt"] is not None:
                     pred += 0.5  # inplace mapping to avoid cloning pred

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/auto3dseg/utils.py

@@ -284,7 +284,7 @@ def verify_report_format(report: dict, report_format: dict) -> bool:
 
         if isinstance(v_fmt, list) and isinstance(v, list):
             if len(v_fmt) != 1:
-                raise UserWarning("list length in report_format is not 1")
+                warnings.warn("list length in report_format is not 1", stacklevel=2)
             if len(v_fmt) > 0 and len(v) > 0:
                 return verify_report_format(v[0], v_fmt[0])
             else:

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/data/__init__.py

@@ -71,7 +71,7 @@ from .itk_torch_bridge import (
     monai_to_itk_ddf,
 )
 from .meta_obj import MetaObj, get_track_meta, set_track_meta
-from .meta_tensor import MetaTensor
+from .meta_tensor import MetaTensor, get_spatial_ndim
 from .samplers import DistributedSampler, DistributedWeightedRandomSampler
 from .synthetic import create_test_image_2d, create_test_image_3d
 from .test_time_augmentation import TestTimeAugmentation

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/data/box_utils.py

@@ -1200,7 +1200,7 @@ def batched_nms(
     # from different classes do not overlap
     max_coordinate = boxes_t.max()
     offsets = labels_t.to(boxes_t) * (max_coordinate + 1)
-    boxes_for_nms = boxes + offsets[:, None]
+    boxes_for_nms = boxes_t + offsets[:, None]
     keep = non_max_suppression(boxes_for_nms, scores_t, nms_thresh, max_proposals, box_overlap_metric)
 
     # convert tensor back to numpy if needed

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/data/dataset.py

@@ -210,8 +210,12 @@ class PersistentDataset(Dataset):
 
         Cached data is expected to be tensors, primitives, or dictionaries keying to these values. Numpy arrays will
         be converted to tensors, however any other object type returned by transforms will not be loadable since
-        `torch.load` will be used with `weights_only=True` to prevent loading of potentially malicious objects.
-        Legacy cache files may not be loadable and may need to be recomputed.
+        `torch.load` will be used with `weights_only=True` by default to prevent loading of potentially malicious
+        objects. Legacy cache files may not be loadable and may need to be recomputed. MetaTensor objects can be saved
+        and loaded with their metadata preserved if `track_meta` is True, however the objects stored in the metadata
+        must be acceptable as serialisable by `torch.load` by default or if they have been white-listed with
+        `torch.serialization.add_safe_globals`. Any other object type may be stored but will fail to load and force
+        a cache recompute.
 
     Lazy Resampling:
         If you make use of the lazy resampling feature of `monai.transforms.Compose`, please refer to
@@ -245,8 +249,8 @@ class PersistentDataset(Dataset):
                 may share a common cache dir provided that the transforms pre-processing is consistent.
                 If `cache_dir` doesn't exist, will automatically create it.
                 If `cache_dir` is `None`, there is effectively no caching.
-            hash_func: a callable to compute hash from data items to be cached.
-                defaults to `monai.data.utils.pickle_hashing`.
+            hash_func: a callable to compute hash from data items to be cached, defaults to
+                `monai.data.utils.pickle_hashing` which uses sha256 (previously md5 so old caches will not work).
             pickle_module: string representing the module used for pickling metadata and objects,
                 default to `"pickle"`. due to the pickle limitation in multi-processing of Dataloader,
                 we can't use `pickle` as arg directly, so here we use a string name instead.
@@ -266,17 +270,12 @@ class PersistentDataset(Dataset):
                 When this is enabled, the traced transform instance IDs will be removed from the cached MetaTensors.
                 This is useful for skipping the transform instance checks when inverting applied operations
                 using the cached content and with re-created transform instances.
-            track_meta: whether to track the meta information, if `True`, will convert to `MetaTensor`.
-                default to `False`. Cannot be used with `weights_only=True`.
+            track_meta: whether to track the meta information, defaults to False. If `True`, converts to `MetaTensor`.
             weights_only: keyword argument passed to `torch.load` when reading cached files.
-                default to `True`. When set to `True`, `torch.load` restricts loading to tensors and
-                other safe objects. Setting this to `False` is required for loading `MetaTensor`
-                objects saved with `track_meta=True`, however this creates the possibility of remote
-                code execution through `torch.load` so be aware of the security implications of doing so.
-
-        Raises:
-            ValueError: When both `track_meta=True` and `weights_only=True`, since this combination
-                prevents cached MetaTensors from being reloaded and causes perpetual cache regeneration.
+                default to `True`. When `True`, `torch.load` restricts loading to tensors and other safe objects.
+                Setting to `False` should only be done if it's absolutely necessary to load unsafe pickled data,
+                eg. MetaTensor objects with unsafe objects in their metadata. Users must verify the safety of the data
+                they intend to load before doing so.
         """
         super().__init__(data=data, transform=transform)
         self.cache_dir = Path(cache_dir) if cache_dir is not None else None
@@ -292,11 +291,6 @@ class PersistentDataset(Dataset):
         if hash_transform is not None:
             self.set_transform_hash(hash_transform)
         self.reset_ops_id = reset_ops_id
-        if track_meta and weights_only:
-            raise ValueError(
-                "Invalid argument combination: `track_meta=True` cannot be used with `weights_only=True`. "
-                "To cache and reload MetaTensors, set `track_meta=True` and `weights_only=False`."
-            )
         self.track_meta = track_meta
         self.weights_only = weights_only
 
@@ -390,9 +384,9 @@ class PersistentDataset(Dataset):
         """
         hashfile = None
         if self.cache_dir is not None:
-            data_item_md5 = self.hash_func(item_transformed).decode("utf-8")
-            data_item_md5 += self.transform_hash
-            hashfile = self.cache_dir / f"{data_item_md5}.pt"
+            data_item_hash = self.hash_func(item_transformed).decode("utf-8")
+            data_item_hash += self.transform_hash
+            hashfile = self.cache_dir / f"{data_item_hash}.pt"
 
         if hashfile is not None and hashfile.is_file():  # cache hit
             try:
@@ -1624,9 +1618,9 @@ class GDSDataset(PersistentDataset):
         hashfile = None
         # compute a cache id
         if self.cache_dir is not None:
-            data_item_md5 = self.hash_func(item_transformed).decode("utf-8")
-            data_item_md5 += self.transform_hash
-            hashfile = self.cache_dir / f"{data_item_md5}.pt"
+            data_item_hash = self.hash_func(item_transformed).decode("utf-8")
+            data_item_hash += self.transform_hash
+            hashfile = self.cache_dir / f"{data_item_hash}.pt"
 
         if hashfile is not None and hashfile.is_file():  # cache hit
             with cp.cuda.Device(self.device):

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/data/image_reader.py

@@ -761,10 +761,10 @@ class PydicomReader(ImageReader):
         if "lastImagePositionPatient" in metadata:
             t1n, t2n, t3n = metadata["lastImagePositionPatient"]
             n = metadata[MetaKeys.SPATIAL_SHAPE][-1]
-            k1, k2, k3 = (t1n - sx) / (n - 1), (t2n - sy) / (n - 1), (t3n - sz) / (n - 1)
-            affine[0, 2] = k1
-            affine[1, 2] = k2
-            affine[2, 2] = k3
+            if n > 1:
+                affine[0, 2] = (t1n - sx) / (n - 1)
+                affine[1, 2] = (t2n - sy) / (n - 1)
+                affine[2, 2] = (t3n - sz) / (n - 1)
 
         if lps_to_ras:
             affine = orientation_ras_lps(affine)

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/data/meta_obj.py

@@ -24,6 +24,9 @@ from monai.utils import TraceKeys, first, is_immutable
 
 _TRACK_META = True
 
+# Default number of spatial dimensions for medical imaging (3D volumetric data)
+_DEFAULT_SPATIAL_NDIM = 3
+
 __all__ = ["get_track_meta", "set_track_meta", "MetaObj"]
 
 
@@ -84,6 +87,7 @@ class MetaObj:
         self._applied_operations: list = MetaObj.get_default_applied_operations()
         self._pending_operations: list = MetaObj.get_default_applied_operations()  # the same default as applied_ops
         self._is_batch: bool = False
+        self._spatial_ndim: int = 3  # default: 3 spatial dimensions
 
     @staticmethod
     def flatten_meta_objs(*args: Iterable):

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/data/meta_tensor.py

@@ -13,22 +13,60 @@ from __future__ import annotations
 
 import functools
 import warnings
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from copy import deepcopy
+from numbers import Integral
 from typing import Any
 
 import numpy as np
 import torch
 
 import monai
-from monai.config.type_definitions import NdarrayTensor
-from monai.data.meta_obj import MetaObj, get_track_meta
-from monai.data.utils import affine_to_spacing, decollate_batch, list_data_collate, remove_extra_metadata
+from monai.config.type_definitions import NdarrayOrTensor, NdarrayTensor
+from monai.data.meta_obj import _DEFAULT_SPATIAL_NDIM, MetaObj, get_track_meta
+from monai.data.utils import affine_to_spacing, decollate_batch, is_no_channel, list_data_collate, remove_extra_metadata
 from monai.utils import look_up_option
 from monai.utils.enums import LazyAttr, MetaKeys, PostFix, SpaceKeys
 from monai.utils.type_conversion import convert_data_type, convert_to_dst_type, convert_to_numpy, convert_to_tensor
 
-__all__ = ["MetaTensor"]
+__all__ = ["MetaTensor", "get_spatial_ndim"]
+
+
+def _normalize_spatial_ndim(spatial_ndim: int, tensor_ndim: int, no_channel: bool = False) -> int:
+    """Clamp spatial dims to a valid range for the current tensor shape."""
+    limit = max(int(tensor_ndim), 1) if no_channel else max(int(tensor_ndim) - 1, 1)
+    return max(1, min(int(spatial_ndim), limit))
+
+
+def _has_explicit_no_channel(meta: Mapping | None) -> bool:
+    return (
+        isinstance(meta, Mapping)
+        and MetaKeys.ORIGINAL_CHANNEL_DIM in meta
+        and is_no_channel(meta[MetaKeys.ORIGINAL_CHANNEL_DIM])
+    )
+
+
+def get_spatial_ndim(img: NdarrayOrTensor) -> int:
+    """Return the number of spatial dimensions assuming channel-first layout.
+
+    Uses ``MetaTensor.spatial_ndim`` when available, otherwise falls back to
+    ``img.ndim - 1``.  Always assumes channel-first (``no_channel=False``)
+    because callers run after ``EnsureChannelFirst`` has already added one.
+    """
+    if isinstance(img, MetaTensor):
+        return _normalize_spatial_ndim(img.spatial_ndim, img.ndim)
+    return img.ndim - 1
+
+
+def _is_batch_only_index(index: Any) -> bool:
+    """True when indexing pattern selects only the batch axis (e.g., ``x[0]`` or ``x[0, ...]``)."""
+    if isinstance(index, (int, np.integer)):
+        return True
+    if not isinstance(index, Sequence) or not index:
+        return False
+    if not isinstance(index[0], (int, np.integer)):
+        return False
+    return all(i in (slice(None, None, None), Ellipsis, None) for i in index[1:])
 
 
 @functools.lru_cache(None)
@@ -111,6 +149,7 @@ class MetaTensor(MetaObj, torch.Tensor):
         meta: dict | None = None,
         applied_operations: list | None = None,
         *args,
+        spatial_ndim: int | None = None,
         **kwargs,
     ) -> MetaTensor:
         _kwargs = {"device": kwargs.pop("device", None), "dtype": kwargs.pop("dtype", None)} if kwargs else {}
@@ -123,6 +162,7 @@ class MetaTensor(MetaObj, torch.Tensor):
         meta: dict | None = None,
         applied_operations: list | None = None,
         *_args,
+        spatial_ndim: int | None = None,
         **_kwargs,
     ) -> None:
         """
@@ -134,6 +174,8 @@ class MetaTensor(MetaObj, torch.Tensor):
                 the list is typically maintained by `monai.transforms.TraceableTransform`.
                 See also: :py:class:`monai.transforms.TraceableTransform`
             _args: additional args (currently not in use in this constructor).
+            spatial_ndim: optional number of spatial dimensions. If ``None``, derived
+                from the affine matrix clamped by the tensor shape.
             _kwargs: additional kwargs (currently not in use in this constructor).
 
         Note:
@@ -158,6 +200,14 @@ class MetaTensor(MetaObj, torch.Tensor):
             self.affine = self.meta[MetaKeys.AFFINE]
         else:
             self.affine = self.get_default_affine()
+        # Initialize spatial_ndim from affine matrix (source of truth), clamped by tensor shape.
+        # This cached value is kept in sync via the affine setter for hot-path performance.
+        no_channel = _has_explicit_no_channel(self.meta)
+        if spatial_ndim is not None:
+            self.spatial_ndim = _normalize_spatial_ndim(spatial_ndim, self.ndim, no_channel=no_channel)
+        elif self.affine.ndim == 2:
+            self.spatial_ndim = _normalize_spatial_ndim(self.affine.shape[-1] - 1, self.ndim, no_channel=no_channel)
+
         # applied_operations
         if applied_operations is not None:
             self.applied_operations = applied_operations
@@ -237,6 +287,7 @@ class MetaTensor(MetaObj, torch.Tensor):
         if func == torch.Tensor.__getitem__:
             if idx > 0 or len(args) < 2 or len(args[0]) < 1:
                 return ret
+            full_idx = args[1]
             batch_idx = args[1][0] if isinstance(args[1], Sequence) else args[1]
             # if using e.g., `batch[:, -1]` or `batch[..., -1]`, then the
             # first element will be `slice(None, None, None)` and `Ellipsis`,
@@ -258,6 +309,8 @@ class MetaTensor(MetaObj, torch.Tensor):
                 ret_meta.is_batch = False
             if hasattr(ret_meta, "__dict__"):
                 ret.__dict__ = ret_meta.__dict__.copy()
+                if _is_batch_only_index(full_idx):
+                    ret.spatial_ndim = _normalize_spatial_ndim(ret.spatial_ndim, ret.ndim)
         # `unbind` is used for `next(iter(batch))`. Also for `decollate_batch`.
         # But we only want to split the batch if the `unbind` is along the 0th dimension.
         elif func == torch.Tensor.unbind:
@@ -467,15 +520,42 @@ class MetaTensor(MetaObj, torch.Tensor):
 
     @affine.setter
     def affine(self, d: NdarrayTensor) -> None:
-        """Set the affine."""
-        self.meta[MetaKeys.AFFINE] = torch.as_tensor(d, device=torch.device("cpu"), dtype=torch.float64)
+        """Set the affine.
+
+        When setting a non-batched affine matrix, automatically synchronizes the cached
+        spatial_ndim attribute to maintain consistency between the affine matrix (source of truth)
+        and the cached spatial dimension count.
+        """
+        a = torch.as_tensor(d, device=torch.device("cpu"), dtype=torch.float64)
+        self.meta[MetaKeys.AFFINE] = a
+        if a.ndim == 2:  # non-batched: sync spatial_ndim from affine (source of truth)
+            no_channel = _has_explicit_no_channel(self.meta)
+            self.spatial_ndim = _normalize_spatial_ndim(a.shape[-1] - 1, self.ndim, no_channel=no_channel)
+
+    @property
+    def spatial_ndim(self) -> int:
+        """Get the number of spatial dimensions.
+
+        This value is cached for hot-path performance and is kept in sync with the affine matrix
+        via the affine setter. The affine matrix is the source of truth for spatial dimensions.
+        """
+        return getattr(self, "_spatial_ndim", _DEFAULT_SPATIAL_NDIM)
+
+    @spatial_ndim.setter
+    def spatial_ndim(self, val: int) -> None:
+        """Set the number of spatial dimensions."""
+        if not isinstance(val, Integral):
+            raise TypeError(f"'val' must be an numbers.Integral type; got {type(val)}.")
+        if val < 1:
+            raise ValueError(f"spatial_ndim must be >= 1, got {val}")
+        self._spatial_ndim = int(val)
 
     @property
     def pixdim(self):
         """Get the spacing"""
         if self.is_batch:
-            return [affine_to_spacing(a) for a in self.affine]
-        return affine_to_spacing(self.affine)
+            return [affine_to_spacing(a, r=self.spatial_ndim) for a in self.affine]
+        return affine_to_spacing(self.affine, r=self.spatial_ndim)
 
     def peek_pending_shape(self):
         """
@@ -490,7 +570,7 @@ class MetaTensor(MetaObj, torch.Tensor):
 
     def peek_pending_affine(self):
         res = self.affine
-        r = len(res) - 1
+        r = res.shape[-1] - 1 if res.ndim >= 2 else self.spatial_ndim
         if r not in (2, 3):
             warnings.warn(f"Only 2d and 3d affine are supported, got {r}d input.")
         for p in self.pending_operations:
@@ -503,8 +583,10 @@ class MetaTensor(MetaObj, torch.Tensor):
         return res
 
     def peek_pending_rank(self):
-        a = self.pending_operations[-1].get(LazyAttr.AFFINE, None) if self.pending_operations else self.affine
-        return 1 if a is None else int(max(1, len(a) - 1))
+        if self.pending_operations:
+            a = self.pending_operations[-1].get(LazyAttr.AFFINE, None)
+            return 1 if a is None else int(max(1, len(a) - 1))
+        return self.spatial_ndim
 
     def new_empty(self, size, dtype=None, device=None, requires_grad=False):  # type: ignore[override]
         """

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/data/utils.py

@@ -17,7 +17,6 @@ import logging
 import math
 import os
 import pickle
-import sys
 from collections import abc, defaultdict
 from collections.abc import Generator, Iterable, Mapping, Sequence, Sized
 from copy import deepcopy
@@ -31,7 +30,7 @@ import torch
 from torch.utils.data._utils.collate import default_collate
 
 from monai.config.type_definitions import NdarrayOrTensor, NdarrayTensor, PathLike
-from monai.data.meta_obj import MetaObj
+from monai.data.meta_obj import _DEFAULT_SPATIAL_NDIM, MetaObj
 from monai.utils import (
     MAX_SEED,
     BlendMode,
@@ -432,6 +431,9 @@ def collate_meta_tensor_fn(batch, *, collate_fn_map=None):
     collated.meta = default_collate(meta_dicts)
     collated.applied_operations = [i.applied_operations or TraceKeys.NONE for i in batch]
     collated.is_batch = True
+    collated.spatial_ndim = min(
+        min(getattr(t, "spatial_ndim", _DEFAULT_SPATIAL_NDIM) for t in batch), max(collated.ndim - 1, 1)
+    )
     return collated
 
 
@@ -1367,13 +1369,8 @@ def json_hashing(item) -> bytes:
 
     """
     # TODO: Find way to hash transforms content as part of the cache
-    cache_key = ""
-    if sys.version_info.minor < 9:
-        cache_key = hashlib.md5(json.dumps(item, sort_keys=True).encode("utf-8")).hexdigest()
-    else:
-        cache_key = hashlib.md5(
-            json.dumps(item, sort_keys=True).encode("utf-8"), usedforsecurity=False  # type: ignore
-        ).hexdigest()
+    dump = json.dumps(item, sort_keys=True).encode("utf-8")
+    cache_key = hashlib.sha256(dump, usedforsecurity=False).hexdigest()  # type: ignore
     return f"{cache_key}".encode()
 
 
@@ -1388,13 +1385,8 @@ def pickle_hashing(item, protocol=pickle.HIGHEST_PROTOCOL) -> bytes:
     Returns: the corresponding hash key
 
     """
-    cache_key = ""
-    if sys.version_info.minor < 9:
-        cache_key = hashlib.md5(pickle.dumps(sorted_dict(item), protocol=protocol)).hexdigest()
-    else:
-        cache_key = hashlib.md5(
-            pickle.dumps(sorted_dict(item), protocol=protocol), usedforsecurity=False  # type: ignore
-        ).hexdigest()
+    dump = pickle.dumps(sorted_dict(item), protocol=protocol)
+    cache_key = hashlib.sha256(dump, usedforsecurity=False).hexdigest()  # type: ignore
     return f"{cache_key}".encode()
 
 

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/inferers/merger.py

@@ -309,9 +309,6 @@ class ZarrAvgMerger(Merger):
 
         self.chunks = chunks
 
-        # Handle compressor/codecs based on zarr version
-        is_zarr_v3 = version_geq(get_package_version("zarr"), "3.0.0")
-
         # Initialize codecs/compressor attributes with proper types
         self.codecs: list | None = None
         self.value_codecs: list | None = None

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/losses/adversarial_loss.py

@@ -129,7 +129,8 @@ class PatchAdversarialLoss(_Loss):
             target_is_real = True  # With generator, we always want this to be true!
             warnings.warn(
                 "Variable target_is_real has been set to False, but for_discriminator is set"
-                "to False. To optimise a generator, target_is_real must be set to True."
+                "to False. To optimise a generator, target_is_real must be set to True.",
+                stacklevel=2,
             )
 
         if not isinstance(input, list):

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/losses/cldice.py

@@ -134,7 +134,8 @@ class SoftclDiceLoss(_Loss):
         Args:
             iter_: Number of iterations for skeletonization. Must be a non-negative integer. Defaults to 3.
             smooth_nr: a small constant added to the numerator to avoid zero. Defaults to 1.0.
-            smooth_dr: a small constant added to the denominator to avoid nan. Defaults to 1.0.
+            smooth_dr: a small constant added to the denominator of the individual precision /
+                sensitivity ratios and the internal Dice denominator to avoid nan. Defaults to 1.0.
             smooth: a small constant added to the denominator of the harmonic mean to avoid nan. Defaults to 1e-4.
             include_background: if False, channel index 0 (background category) is excluded from the calculation.
                 if the non-background segmentations are small compared to the total image size they can get overwhelmed

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2627}/monai/losses/deform.py

@@ -44,9 +44,58 @@ def spatial_gradient(x: torch.Tensor, dim: int) -> torch.Tensor:
     return (x[slicing_s] - x[slicing_e]) / 2.0
 
 
+def spatial_gradient_squared(x: torch.Tensor, dim_1: int, dim_2: int) -> torch.Tensor:
+    """
+    Calculate the second-order partial derivative of ``x`` with respect to spatial dims
+    ``dim_1`` and ``dim_2`` using compact central finite differences.
+
+    For ``dim_1 == dim_2`` the pure second derivative uses the ``[1, -2, 1]`` stencil:
+    ``d2x[i] = x[i+1] - 2 * x[i] + x[i-1]``.
+
+    For ``dim_1 != dim_2`` the mixed partial uses the compact 4-point stencil:
+    ``d2x[i, j] = (x[i+1, j+1] - x[i+1, j-1] - x[i-1, j+1] + x[i-1, j-1]) / 4``.
+
+    Every spatial dimension is sliced to ``[1:-1]`` so the output shape is independent of
+    ``(dim_1, dim_2)``; this lets terms be summed together. Requires ``x.shape[d] > 2``
+    for every spatial dim ``d``.
+
+    Args:
+        x: the shape should be BCH(WD).
+        dim_1: first spatial dimension index.
+        dim_2: second spatial dimension index.
+
+    Returns:
+        Tensor with batch and channel axes preserved and every spatial axis sliced to
+        ``[1:-1]``.
+    """
+    slice_inner = slice(1, -1)
+    slice_plus = slice(2, None)
+    slice_minus = slice(None, -2)
+    slice_all = slice(None)
+
+    def _idx(overrides: dict) -> list:
+        out: list = [slice_all, slice_all]
+        for d in range(2, x.ndim):
+            out.append(overrides.get(d, slice_inner))
+        return out
+
+    if dim_1 == dim_2:
+        return x[_idx({dim_1: slice_plus})] - 2 * x[_idx({})] + x[_idx({dim_1: slice_minus})]
+    return (
+        x[_idx({dim_1: slice_plus, dim_2: slice_plus})]
+        - x[_idx({dim_1: slice_plus, dim_2: slice_minus})]
+        - x[_idx({dim_1: slice_minus, dim_2: slice_plus})]
+        + x[_idx({dim_1: slice_minus, dim_2: slice_minus})]
+    ) / 4.0
+
+
 class BendingEnergyLoss(_Loss):
     """
-    Calculate the bending energy based on second-order differentiation of ``pred`` using central finite difference.
+    Calculate the bending energy based on second-order differentiation of ``pred``.
+
+    Pure second derivatives use the compact ``[1, -2, 1]`` stencil; mixed partials use a
+    compact 4-point central scheme. Both span three voxels per axis, so each spatial
+    dimension of ``pred`` only needs to be greater than 2.
 
     For more information,
     see https://github.com/Project-MONAI/tutorials/blob/main/modules/bending_energy_diffusion_loss_notes.ipynb.
@@ -79,41 +128,41 @@ class BendingEnergyLoss(_Loss):
         Raises:
             ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
             ValueError: When ``pred`` is not 3-d, 4-d or 5-d.
-            ValueError: When any spatial dimension of ``pred`` has size less than or equal to 4.
+            ValueError: When any spatial dimension of ``pred`` has size less than or equal to 2.
             ValueError: When the number of channels of ``pred`` does not match the number of spatial dimensions.
 
         """
         if pred.ndim not in [3, 4, 5]:
             raise ValueError(f"Expecting 3-d, 4-d or 5-d pred, instead got pred of shape {pred.shape}")
         for i in range(pred.ndim - 2):
-            if pred.shape[-i - 1] <= 4:
-                raise ValueError(f"All spatial dimensions must be > 4, got spatial dimensions {pred.shape[2:]}")
+            if pred.shape[-i - 1] <= 2:
+                raise ValueError(f"All spatial dimensions must be > 2, got spatial dimensions {pred.shape[2:]}")
         if pred.shape[1] != pred.ndim - 2:
             raise ValueError(
                 f"Number of vector components, i.e. number of channels of the input DDF, {pred.shape[1]}, "
                 f"does not match number of spatial dimensions, {pred.ndim - 2}"
             )
 
-        # first order gradient
-        first_order_gradient = [spatial_gradient(pred, dim) for dim in range(2, pred.ndim)]
-
         # spatial dimensions in a shape suited for broadcasting below
         if self.normalize:
             spatial_dims = torch.tensor(pred.shape, device=pred.device)[2:].reshape((1, -1) + (pred.ndim - 2) * (1,))
 
-        energy = torch.tensor(0)
-        for dim_1, g in enumerate(first_order_gradient):
-            dim_1 += 2
+        # Initialize on pred.device so a GPU `pred` does not get added to a CPU
+        # accumulator, and as a float so an integer-dtype `pred` still produces a
+        # floating-point energy (the compact pure-derivative stencil has no
+        # division, so a Long input would otherwise propagate as Long and fail
+        # `torch.mean` at the reduction step).
+        energy = torch.tensor(0.0, device=pred.device)
+        for dim_1 in range(2, pred.ndim):
+            d2 = spatial_gradient_squared(pred, dim_1, dim_1)
             if self.normalize:
-                g *= pred.shape[dim_1] / spatial_dims
-                energy = energy + (spatial_gradient(g, dim_1) * pred.shape[dim_1]) ** 2
-            else:
-                energy = energy + spatial_gradient(g, dim_1) ** 2
+                d2 = d2 * (pred.shape[dim_1] ** 2 / spatial_dims)
+            energy = energy + d2**2
             for dim_2 in range(dim_1 + 1, pred.ndim):
+                d2_mixed = spatial_gradient_squared(pred, dim_1, dim_2)
                 if self.normalize:
-                    energy = energy + 2 * (spatial_gradient(g, dim_2) * pred.shape[dim_2]) ** 2
-                else:
-                    energy = energy + 2 * spatial_gradient(g, dim_2) ** 2
+                    d2_mixed = d2_mixed * (pred.shape[dim_1] * pred.shape[dim_2] / spatial_dims)
+                energy = energy + 2 * d2_mixed**2
 
         if self.reduction == LossReduction.MEAN.value:
             energy = torch.mean(energy)  # the batch and channel average