monai-weekly 1.7.dev2638__tar.gz → 1.7.dev2639__tar.gz

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2639}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2638
+Version: 1.7.dev2639
 Summary: AI Toolkit for Healthcare Imaging
 Author-email: MONAI Consortium <monai.contact@gmail.com>
 License: Apache License 2.0

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2639}/monai/__init__.py

@@ -136,4 +136,4 @@ except Exception:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "f2ec87ae9b536baaeca1d6bcc2b6349369e2af8f"
+__commit_id__ = "25847e7570361fc93261509943b21c1639ab9f04"

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2639}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-09-20T02:14:58+0000",
+ "date": "2026-09-27T02:18:34+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "43b604323beaeca5718d23b2ba4c130da08d84b8",
- "version": "1.7.dev2638"
+ "full-revisionid": "5cfc144e2f41cc448085b59758dd2ab1d335f3d1",
+ "version": "1.7.dev2639"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2639}/monai/inferers/inferer.py

@@ -11,6 +11,7 @@
 
 from __future__ import annotations
 
+import inspect
 import math
 import warnings
 from abc import ABC, abstractmethod
@@ -862,6 +863,96 @@ class DiffusionInferer(Inferer):
 
         self.scheduler = scheduler
 
+    @staticmethod
+    def _scheduler_step_supports_kwarg(scheduler: Scheduler, kwarg: str) -> bool:
+        try:
+            return kwarg in inspect.signature(scheduler.step).parameters
+        except (TypeError, ValueError):
+            return False
+
+    @staticmethod
+    def _get_previous_sample_from_step_output(step_output: Any) -> torch.Tensor:
+        if isinstance(step_output, tuple):
+            return step_output[0]
+        if isinstance(step_output, Mapping):
+            return step_output["prev_sample"]
+        if hasattr(step_output, "prev_sample"):
+            return step_output.prev_sample
+        raise TypeError("Unsupported scheduler.step output. Expected a tuple or an object with `prev_sample`.")
+
+    @staticmethod
+    def _get_scheduler_name(scheduler: Scheduler) -> str:
+        if hasattr(scheduler, "_get_name"):
+            return scheduler._get_name()
+        return scheduler.__class__.__name__
+
+    @staticmethod
+    def _get_scheduler_config_value(scheduler: Scheduler, name: str, default: Any = None) -> Any:
+        config = getattr(scheduler, "config", None)
+        if isinstance(config, Mapping):
+            if name in config:
+                return config[name]
+        elif config is not None and hasattr(config, name):
+            return getattr(config, name)
+
+        if hasattr(scheduler, name):
+            return getattr(scheduler, name)
+        return default
+
+    @staticmethod
+    def _get_posterior_mean(
+        scheduler: Scheduler, timestep: int | torch.Tensor, x_0: torch.Tensor, x_t: torch.Tensor
+    ) -> torch.Tensor:
+        alpha_t = scheduler.alphas[timestep]
+        alpha_prod_t = scheduler.alphas_cumprod[timestep]
+        alpha_prod_t_prev = scheduler.alphas_cumprod[timestep - 1] if timestep > 0 else scheduler.one
+
+        x_0_coefficient = alpha_prod_t_prev.sqrt() * scheduler.betas[timestep] / (1 - alpha_prod_t)
+        x_t_coefficient = alpha_t.sqrt() * (1 - alpha_prod_t_prev) / (1 - alpha_prod_t)
+
+        return x_0_coefficient * x_0 + x_t_coefficient * x_t
+
+    def _get_posterior_variance(
+        self, scheduler: Scheduler, timestep: int | torch.Tensor, predicted_variance: torch.Tensor | None = None
+    ) -> torch.Tensor:
+        alpha_prod_t = scheduler.alphas_cumprod[timestep]
+        alpha_prod_t_prev = scheduler.alphas_cumprod[timestep - 1] if timestep > 0 else scheduler.one
+        variance = (1 - alpha_prod_t_prev) / (1 - alpha_prod_t) * scheduler.betas[timestep]
+        variance_type = self._get_scheduler_config_value(scheduler, "variance_type")
+
+        if variance_type == "fixed_small":
+            variance = torch.clamp(variance, min=1e-20)
+        elif variance_type == "fixed_large":
+            variance = scheduler.betas[timestep]
+        elif variance_type == "learned" and predicted_variance is not None:
+            return predicted_variance
+        elif variance_type == "learned_range" and predicted_variance is not None:
+            min_log = variance
+            max_log = scheduler.betas[timestep]
+            frac = (predicted_variance + 1) / 2
+            variance = frac * max_log + (1 - frac) * min_log
+
+        return variance
+
+    def _scheduler_step(
+        self,
+        scheduler: Scheduler,
+        model_output: torch.Tensor,
+        timestep: int | torch.Tensor,
+        sample: torch.Tensor,
+        next_timestep: int | torch.Tensor | None = None,
+    ) -> torch.Tensor:
+        step_kwargs = {}
+        if self._scheduler_step_supports_kwarg(scheduler, "return_dict"):
+            step_kwargs["return_dict"] = False
+
+        if isinstance(scheduler, RFlowScheduler):
+            step_output = scheduler.step(model_output, timestep, sample, next_timestep, **step_kwargs)  # type: ignore
+        else:
+            step_output = scheduler.step(model_output, timestep, sample, **step_kwargs)  # type: ignore
+
+        return self._get_previous_sample_from_step_output(step_output)
+
     def __call__(  # type: ignore[override]
         self,
         inputs: torch.Tensor,
@@ -941,7 +1032,12 @@ class DiffusionInferer(Inferer):
             scheduler = self.scheduler
         image = input_noise
 
-        all_next_timesteps = torch.cat((scheduler.timesteps[1:], torch.tensor([0], dtype=scheduler.timesteps.dtype)))
+        all_next_timesteps = torch.cat(
+            (
+                scheduler.timesteps[1:],
+                torch.tensor([0], dtype=scheduler.timesteps.dtype, device=scheduler.timesteps.device),
+            )
+        )
         if verbose and has_tqdm:
             progress_bar = tqdm(
                 zip(scheduler.timesteps, all_next_timesteps),
@@ -985,10 +1081,9 @@ class DiffusionInferer(Inferer):
                 model_output = model_output_uncond + cfg * (model_output_cond - model_output_uncond)
 
             # 2. compute previous image: x_t -> x_t-1
-            if not isinstance(scheduler, RFlowScheduler):
-                image, _ = scheduler.step(model_output, t, image)  # type: ignore
-            else:
-                image, _ = scheduler.step(model_output, t, image, next_t)  # type: ignore
+            image = self._scheduler_step(
+                scheduler=scheduler, model_output=model_output, timestep=t, sample=image, next_timestep=next_t
+            )
             if save_intermediates and t % intermediate_steps == 0:
                 intermediates.append(image)
 
@@ -1029,10 +1124,10 @@ class DiffusionInferer(Inferer):
 
         if not scheduler:
             scheduler = self.scheduler
-        if scheduler._get_name() != "DDPMScheduler":
+        scheduler_name = self._get_scheduler_name(scheduler)
+        if scheduler_name != "DDPMScheduler":
             raise NotImplementedError(
-                f"Likelihood computation is only compatible with DDPMScheduler,"
-                f" you are using {scheduler._get_name()}"
+                f"Likelihood computation is only compatible with DDPMScheduler, you are using {scheduler_name},"
             )
         if mode not in ["crossattn", "concat"]:
             raise NotImplementedError(f"{mode} condition is not supported")
@@ -1047,7 +1142,7 @@ class DiffusionInferer(Inferer):
         total_kl = torch.zeros(inputs.shape[0]).to(inputs.device)
         for t in progress_bar:
             timesteps = torch.full(inputs.shape[:1], t, device=inputs.device).long()
-            noisy_image = self.scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
+            noisy_image = scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
             diffusion_model = (
                 partial(diffusion_model, seg=seg)
                 if isinstance(diffusion_model, SPADEDiffusionModelUNet)
@@ -1060,7 +1155,8 @@ class DiffusionInferer(Inferer):
                 model_output = diffusion_model(x=noisy_image, timesteps=timesteps, context=conditioning)
 
             # get the model's predicted mean,  and variance if it is predicted
-            if model_output.shape[1] == inputs.shape[1] * 2 and scheduler.variance_type in ["learned", "learned_range"]:
+            variance_type = self._get_scheduler_config_value(scheduler, "variance_type")
+            if model_output.shape[1] == inputs.shape[1] * 2 and variance_type in ["learned", "learned_range"]:
                 model_output, predicted_variance = torch.split(model_output, inputs.shape[1], dim=1)
             else:
                 predicted_variance = None
@@ -1073,15 +1169,17 @@ class DiffusionInferer(Inferer):
 
             # 2. compute predicted original sample from predicted noise also called
             # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf
-            if scheduler.prediction_type == "epsilon":
+            prediction_type = self._get_scheduler_config_value(scheduler, "prediction_type")
+            if prediction_type == "epsilon":
                 pred_original_sample = (noisy_image - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
-            elif scheduler.prediction_type == "sample":
+            elif prediction_type == "sample":
                 pred_original_sample = model_output
-            elif scheduler.prediction_type == "v_prediction":
+            elif prediction_type == "v_prediction":
                 pred_original_sample = (alpha_prod_t**0.5) * noisy_image - (beta_prod_t**0.5) * model_output
             # 3. Clip "predicted x_0"
-            if scheduler.clip_sample:
-                pred_original_sample = torch.clamp(pred_original_sample, -1, 1)
+            if self._get_scheduler_config_value(scheduler, "clip_sample"):
+                clip_sample_range = self._get_scheduler_config_value(scheduler, "clip_sample_range", 1.0)
+                pred_original_sample = torch.clamp(pred_original_sample, -clip_sample_range, clip_sample_range)
 
             # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t
             # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
@@ -1093,11 +1191,15 @@ class DiffusionInferer(Inferer):
             predicted_mean = pred_original_sample_coeff * pred_original_sample + current_sample_coeff * noisy_image
 
             # get the posterior mean and variance
-            posterior_mean = scheduler._get_mean(timestep=t, x_0=inputs, x_t=noisy_image)  # type: ignore[operator]
-            posterior_variance = scheduler._get_variance(timestep=t, predicted_variance=predicted_variance)  # type: ignore[operator]
+            posterior_mean = self._get_posterior_mean(scheduler=scheduler, timestep=t, x_0=inputs, x_t=noisy_image)
+            posterior_variance = self._get_posterior_variance(
+                scheduler=scheduler, timestep=t, predicted_variance=predicted_variance
+            )
 
             log_posterior_variance = torch.log(posterior_variance)
-            log_predicted_variance = torch.log(predicted_variance) if predicted_variance else log_posterior_variance
+            log_predicted_variance = (
+                torch.log(predicted_variance) if predicted_variance is not None else log_posterior_variance
+            )
 
             if t == 0:
                 # compute -log p(x_0|x_1)
@@ -1510,7 +1612,12 @@ class ControlNetDiffusionInferer(DiffusionInferer):
             scheduler = self.scheduler
         image = input_noise
 
-        all_next_timesteps = torch.cat((scheduler.timesteps[1:], torch.tensor([0], dtype=scheduler.timesteps.dtype)))
+        all_next_timesteps = torch.cat(
+            (
+                scheduler.timesteps[1:],
+                torch.tensor([0], dtype=scheduler.timesteps.dtype, device=scheduler.timesteps.device),
+            )
+        )
         if verbose and has_tqdm:
             progress_bar = tqdm(
                 zip(scheduler.timesteps, all_next_timesteps),
@@ -1584,10 +1691,9 @@ class ControlNetDiffusionInferer(DiffusionInferer):
                 model_output = model_output_uncond + cfg * (model_output_cond - model_output_uncond)
 
             # 3. compute previous image: x_t -> x_t-1
-            if not isinstance(scheduler, RFlowScheduler):
-                image, _ = scheduler.step(model_output, t, image)  # type: ignore
-            else:
-                image, _ = scheduler.step(model_output, t, image, next_t)  # type: ignore
+            image = self._scheduler_step(
+                scheduler=scheduler, model_output=model_output, timestep=t, sample=image, next_timestep=next_t
+            )
 
             if save_intermediates and t % intermediate_steps == 0:
                 intermediates.append(image)
@@ -1632,10 +1738,10 @@ class ControlNetDiffusionInferer(DiffusionInferer):
 
         if not scheduler:
             scheduler = self.scheduler
-        if scheduler._get_name() != "DDPMScheduler":
+        scheduler_name = self._get_scheduler_name(scheduler)
+        if scheduler_name != "DDPMScheduler":
             raise NotImplementedError(
-                f"Likelihood computation is only compatible with DDPMScheduler,"
-                f" you are using {scheduler._get_name()}"
+                f"Likelihood computation is only compatible with DDPMScheduler, you are using {scheduler_name}."
             )
         if mode not in ["crossattn", "concat"]:
             raise NotImplementedError(f"{mode} condition is not supported")
@@ -1648,7 +1754,7 @@ class ControlNetDiffusionInferer(DiffusionInferer):
         total_kl = torch.zeros(inputs.shape[0]).to(inputs.device)
         for t in progress_bar:
             timesteps = torch.full(inputs.shape[:1], t, device=inputs.device).long()
-            noisy_image = self.scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
+            noisy_image = scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps)
 
             diffuse = diffusion_model
             if isinstance(diffusion_model, SPADEDiffusionModelUNet):
@@ -1681,7 +1787,8 @@ class ControlNetDiffusionInferer(DiffusionInferer):
                     mid_block_additional_residual=mid_block_res_sample,
                 )
             # get the model's predicted mean,  and variance if it is predicted
-            if model_output.shape[1] == inputs.shape[1] * 2 and scheduler.variance_type in ["learned", "learned_range"]:
+            variance_type = self._get_scheduler_config_value(scheduler, "variance_type")
+            if model_output.shape[1] == inputs.shape[1] * 2 and variance_type in ["learned", "learned_range"]:
                 model_output, predicted_variance = torch.split(model_output, inputs.shape[1], dim=1)
             else:
                 predicted_variance = None
@@ -1694,15 +1801,17 @@ class ControlNetDiffusionInferer(DiffusionInferer):
 
             # 2. compute predicted original sample from predicted noise also called
             # "predicted x_0" of formula (15) from https://arxiv.org/pdf/2006.11239.pdf
-            if scheduler.prediction_type == "epsilon":
+            prediction_type = self._get_scheduler_config_value(scheduler, "prediction_type")
+            if prediction_type == "epsilon":
                 pred_original_sample = (noisy_image - beta_prod_t ** (0.5) * model_output) / alpha_prod_t ** (0.5)
-            elif scheduler.prediction_type == "sample":
+            elif prediction_type == "sample":
                 pred_original_sample = model_output
-            elif scheduler.prediction_type == "v_prediction":
+            elif prediction_type == "v_prediction":
                 pred_original_sample = (alpha_prod_t**0.5) * noisy_image - (beta_prod_t**0.5) * model_output
             # 3. Clip "predicted x_0"
-            if scheduler.clip_sample:
-                pred_original_sample = torch.clamp(pred_original_sample, -1, 1)
+            if self._get_scheduler_config_value(scheduler, "clip_sample"):
+                clip_sample_range = self._get_scheduler_config_value(scheduler, "clip_sample_range", 1.0)
+                pred_original_sample = torch.clamp(pred_original_sample, -clip_sample_range, clip_sample_range)
 
             # 4. Compute coefficients for pred_original_sample x_0 and current sample x_t
             # See formula (7) from https://arxiv.org/pdf/2006.11239.pdf
@@ -1714,11 +1823,15 @@ class ControlNetDiffusionInferer(DiffusionInferer):
             predicted_mean = pred_original_sample_coeff * pred_original_sample + current_sample_coeff * noisy_image
 
             # get the posterior mean and variance
-            posterior_mean = scheduler._get_mean(timestep=t, x_0=inputs, x_t=noisy_image)  # type: ignore[operator]
-            posterior_variance = scheduler._get_variance(timestep=t, predicted_variance=predicted_variance)  # type: ignore[operator]
+            posterior_mean = self._get_posterior_mean(scheduler=scheduler, timestep=t, x_0=inputs, x_t=noisy_image)
+            posterior_variance = self._get_posterior_variance(
+                scheduler=scheduler, timestep=t, predicted_variance=predicted_variance
+            )
 
             log_posterior_variance = torch.log(posterior_variance)
-            log_predicted_variance = torch.log(predicted_variance) if predicted_variance else log_posterior_variance
+            log_predicted_variance = (
+                torch.log(predicted_variance) if predicted_variance is not None else log_posterior_variance
+            )
 
             if t == 0:
                 # compute -log p(x_0|x_1)

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2639}/monai/transforms/utils.py

@@ -2281,7 +2281,8 @@ def squarepulse(sig, duty: float = 0.5):
     w = convert_to_tensor(w)
     t = convert_to_tensor(t)
 
-    y = torch.zeros(t.shape)
+    out_dtype = t.dtype if t.is_floating_point() else torch.get_default_dtype()
+    y = torch.zeros_like(t, dtype=out_dtype)
 
     mask1 = (w > 1) | (w < 0)
 

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2639}/monai/utils/__init__.py

@@ -11,6 +11,7 @@
 
 from __future__ import annotations
 
+from .compare_sources import SKIP_EXTS, files_considered_equal, sources_equal
 from .component_store import ComponentStore
 from .decorators import MethodReplacer, RestartGenerator
 from .deprecate_utils import DeprecatedError, deprecated, deprecated_arg, deprecated_arg_default

monai_weekly-1.7.dev2639/monai/utils/compare_sources.py

@@ -0,0 +1,107 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This module is used in Github Actions to determine if a Python source file has been modified in a PR.
+"""
+
+from __future__ import annotations
+
+import ast
+import os
+import sys
+from os.path import splitext
+
+PathLike = str | os.PathLike  # needs to be duplicated here to avoid importing anything from MONAI inside actions
+
+SKIP_EXTS = (".md", ".rst", ".cff")
+
+
+class RemoveDocstrings(ast.NodeTransformer):
+    """
+    Strips docstrings from source files so that they aren't used for comparing ASTs.
+    """
+
+    def visit(self, node: ast.AST) -> ast.AST:
+        try:
+            # remove docstrings from the files
+            if ast.get_docstring(node) is not None:
+                del node.body[0]
+        except TypeError:
+            pass
+        return super().visit(node)
+
+
+def sources_equal(src1: str, src2: str) -> bool:
+    """
+    Compare Python source texts at the AST level without docstrings or comments. If two texts are equal except for
+    changes to docstrings or comments, they will be considered equal by this function. Any other changes will appear
+    as differences in the AST representations, which are compared inefficiently by comparing tree string dumps.
+
+    Args:
+        src1: first Python source text.
+        src2: second Python source text.
+
+    Returns:
+        True if the texts `src1` and `src2` are equal with docstrings and comments removed, False otherwise.
+    """
+    remdoc = RemoveDocstrings()
+
+    m1 = ast.parse(src1)
+    m2 = ast.parse(src2)
+    remdoc.visit(m1)
+    remdoc.visit(m2)
+
+    list1 = list(ast.walk(m1))
+    list2 = list(ast.walk(m2))
+
+    if len(list1) != len(list2) or any(type(n1) is not type(n2) for n1, n2 in zip(list1, list2)):
+        return False
+
+    return ast.dump(m1) == ast.dump(m2)
+
+
+def files_considered_equal(file1: PathLike, file2: PathLike) -> bool:
+    """
+    Returns True if the files are considered equal, that is they are doc files or differ only in docstrings or comments.
+
+    Args:
+        file1: first file path to compare.
+        file2: second file path to compare.
+
+    Returns:
+        True if the files have the same extension, and either this extension is in `SKIP_EXTS`, or is ".py" with the
+        files having the same content according to `sources_equal`. If the extensions differ, or are both ".py" but the
+        file contents differ, returns False.
+    """
+    _, ext1 = splitext(str(file1))
+    _, ext2 = splitext(str(file2))
+
+    # if extensions aren't equal then definitely different (which shouldn't happen anyway)
+    if ext1 != ext2:
+        return False
+
+    # if extensions are an ignored type, ie. docs, don't compare at all
+    if ext1 in SKIP_EXTS:
+        return True
+
+    # if not Python source files, they aren't doc files at this point so assume different
+    if ext1 != ".py":
+        return False
+
+    # compare the actual parsed contents of the source files
+    with open(file1) as o1, open(file2) as o2:
+        return sources_equal(o1.read(), o2.read())
+
+
+if __name__ == "__main__":
+    _, file1, file2 = sys.argv
+    sys.exit(0 if files_considered_equal(file1, file2) else 1)

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2639}/monai/utils/safeeval.py

@@ -71,6 +71,13 @@ def safe_eval(
     expressions with constants and names can be evaluated, so excludes attribute access, indexing, and calls. Code
     injection is infeasible through such expressions, so this is a safe and secure way of evaluating simple expressions.
 
+    Names are resolved only against `globals_vars` and `locals_vars`, so an expression naming anything the caller did
+    not supply raises a `NameError` rather than silently resolving to a builtin or to a module imported here. Two
+    names resolve without being supplied: `__builtins__`, which is bound to an empty mapping so that nothing can be
+    reached through it, and `np`, which `rewrite_np` adds because the rewritten constants need it. This matters when
+    `allowed_types` is widened beyond `SAFE_TYPES`, since node types such as `ast.Attribute` and `ast.Call` would
+    otherwise make the builtins and this module's imports reachable.
+
     If `rewrite_np` is True, int and float constants in the given expression will be wrapped with Numpy types as given
     by `int_type_str` and `float_type_str`. These are expected to be constructor names prefixed with `np.` as Numpy
     will be present in the expression global variables under that name. The values can be changed to other types if
@@ -79,7 +86,8 @@ def safe_eval(
 
     Args:
         expr: expression to evaluate, this will be stripped before parsing to avoid indentation complaints
-        globals_vars: global variable mapping, this will be treated as read-only for this function, unlike `eval`
+        globals_vars: global variable mapping, this will be treated as read-only for this function, unlike `eval`.
+            An empty `__builtins__` is added to the copy unless the mapping provides its own value for that key
         locals_vars: local variable mapping
         allowed_types: sequence of allowed AST types which can be found in `expr` when parsed
         rewrite_np: if True, wrap int or float literals in Numpy types
@@ -88,6 +96,8 @@ def safe_eval(
 
     Raises:
         ValueError: raised when any node in the AST parsed from `expr` has a type not in `allowed_types`
+        NameError: raised when `expr` names a variable not present in `globals_vars` or `locals_vars`, other than
+            `__builtins__` and, when `rewrite_np` is True, `np`
 
     Returns:
         The evaluated expression value, using `eval` with `globals_vars` and `locals_vars`
@@ -105,4 +115,9 @@ def safe_eval(
         ast.fix_missing_locations(parsed)
         locals_vars = {**(locals_vars or {}), "np": np}
 
-    return eval(compile(parsed, "<safe_eval>", "eval"), dict(globals_vars) if globals_vars else None, locals_vars)
+    # an explicit globals mapping stops `eval` from falling back to this module's globals, and an empty
+    # `__builtins__` keeps the builtins out of scope, so only names the caller supplied can be resolved
+    eval_globals: dict[str, Any] = dict(globals_vars) if globals_vars else {}
+    eval_globals.setdefault("__builtins__", {})
+
+    return eval(compile(parsed, "<safe_eval>", "eval"), eval_globals, locals_vars)

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2639}/monai_weekly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2638
+Version: 1.7.dev2639
 Summary: AI Toolkit for Healthcare Imaging
 Author-email: MONAI Consortium <monai.contact@gmail.com>
 License: Apache License 2.0

{monai_weekly-1.7.dev2638 → monai_weekly-1.7.dev2639}/monai_weekly.egg-info/SOURCES.txt

@@ -426,6 +426,7 @@ monai/transforms/utility/__init__.py
 monai/transforms/utility/array.py
 monai/transforms/utility/dictionary.py
 monai/utils/__init__.py
+monai/utils/compare_sources.py
 monai/utils/component_store.py
 monai/utils/decorators.py
 monai/utils/deprecate_utils.py