update docstring and eval with overrides

monai/data/dataset.py

@@ -316,7 +316,7 @@ def _pre_transform(self, item_transformed):
 
         """
         if not isinstance(self.transform, Compose):
-            raise ValueError("transform must be an instance of monai.transforms.Compose.")
+            raise ValueError(f"transform must be an instance of monai.transforms.Compose, got {type(self.transform)}.")
 
         first_random = self.transform.get_index_of_first(
             lambda t: isinstance(t, RandomizableTrait) or not isinstance(t, Transform)
@@ -345,8 +345,7 @@ def _post_transform(self, item_transformed):
         first_random = self.transform.get_index_of_first(
             lambda t: isinstance(t, RandomizableTrait) or not isinstance(t, Transform)
         )
-        if first_random is not None:
-            item_transformed = self.transform(item_transformed, start=first_random)
+        item_transformed = self.transform(item_transformed, start=first_random)
         return item_transformed
 
     def _cachecheck(self, item_transformed):
@@ -489,7 +488,7 @@ def _pre_transform(self, item_transformed):
             the transformed element up to the N transform object
         """
         if not isinstance(self.transform, Compose):
-            raise ValueError("transform must be an instance of monai.transforms.Compose.")
+            raise ValueError(f"transform must be an instance of monai.transforms.Compose, got {type(self.transform)}.")
 
         item_transformed = self.transform(item_transformed, end=self.cache_n_trans, threading=True)
 
@@ -906,14 +905,14 @@ def _transform(self, index: int):
 
         # load data from cache and execute from the first random transform
         if not isinstance(self.transform, Compose):
-            raise ValueError("transform must be an instance of monai.transforms.Compose.")
+            raise ValueError(f"transform must be an instance of monai.transforms.Compose, got {type(self.transform)}.")
 
         first_random = self.transform.get_index_of_first(
             lambda t: isinstance(t, RandomizableTrait) or not isinstance(t, Transform)
         )
         if first_random is not None:
             data = deepcopy(data) if self.copy_cache is True else data
-            data = self.transform(data, start=first_random)
+        data = self.transform(data, start=first_random)
 
         return data
 

monai/transforms/compose.py

@@ -262,8 +262,8 @@ def randomize(self, data: Any | None = None) -> None:
                 )
 
     def get_index_of_first(self, predicate):
-        for i in range(len(self.transforms)):
-            if predicate(self.transforms[i]):
+        for i, xform in enumerate(self.transforms):
+            if predicate(xform):
                 return i
         return None
 
@@ -294,11 +294,11 @@ def execute(
         transforms: Sequence[Any],
         map_items: bool = True,
         unpack_items: bool = False,
-        start: int = 0,
+        start: int | None = 0,
         end: int | None = None,
         lazy_evaluation: bool = False,
-        overrides: dict = None,
-        override_keys: tuple = None,
+        overrides: dict | None = None,
+        override_keys: Sequence[str] | None = None,
         threading: bool = False,
         log_stats: bool = False,
         verbose: bool = False,
@@ -309,27 +309,48 @@ def execute(
         Compose and by code that doesn't have a Compose instance but needs to execute a
         sequence of transforms is if it were executed by Compose. It should only be used directly
         when it is not possible to use ``Compose.__call__`` to achieve the same goal.
+
         Args:
-            `input_`: a tensor-like object to be transformed
+            input_: a tensor-like object to be transformed
             transforms: a sequence of transforms to be carried out
             map_items: whether to apply the transform to each item in ``data``.
-            Defaults to True if not set.
+                Defaults to True if not set.
             unpack_items: whether to unpack parameters using '*'. Defaults to False if not set
-            log_stats: whether to log detailed information about the application of ``transforms``
-            to ``input_``. For NumPy ndarrays and PyTorch tensors, log only the data shape and
-            value range. Defaults to False if not set.
             start: the index of the first transform to be executed. If not set, this defaults to 0
-            end: the index after the last transform to be exectued. If set, the transform at index-1
-            is the last transform that is executed. If this is not set, it defaults to len(transforms)
-            threading: whether executing is happening in a threaded environment. If set, copies are made
-            of transforms that have the ``RandomizedTrait`` interface.
-
-        Returns:
-
+            end: the index after the last transform to be exectued. If set, the transform at ``end-1``
+                is the last transform that is executed. If this is not set, it defaults to len(transforms)
+            lazy_evaluation: whether to enable lazy evaluation for lazy transforms. If False, transforms will be
+                carried out on a transform by transform basis. If True, all lazy transforms will
+                be executed by accumulating changes and resampling as few times as possible.
+                A `monai.transforms.Identity[D]` transform in the pipeline will trigger the evaluation of
+                the pending operations and make the primary data up-to-date.
+            overrides: this optional parameter allows you to specify a dictionary of parameters that should be overridden
+                when executing a pipeline. These each parameter that is compatible with a given transform is then applied
+                to that transform before it is executed. Note that overrides are currently only applied when lazy_evaluation
+                is True. If lazy_evaluation is False they are ignored.
+                currently supported args are:
+                {``"mode"``, ``"padding_mode"``, ``"dtype"``, ``"align_corners"``, ``"resample_mode"``, ``device``},
+                please see also :py:func:`monai.transforms.lazy.apply_transforms` for more details.
+            override_keys: this optional parameter specifies the keys to which ``overrides`` are to be applied. If
+                ``overrides`` is set, ``override_keys`` must also be set.
+            threading: whether executing is happening in a threaded environment. If set, deepcopies are made
+                of transforms that have the ``RandomizedTrait`` interface.
+            log_stats: whether to log detailed information about the application of ``transforms``
+                to ``input_``. For NumPy ndarrays and PyTorch tensors, log only the data shape and
+                value range. Defaults to False if not set.
+            verbose: whether to print debugging info when lazy_evaluation=True.
         """
         end_ = len(transforms) if end is None else end
         if start is None:
-            raise ValueError(f"'start' ({start}) cannot be None")
+            input_ = evaluate_with_overrides(
+                input_,
+                None,
+                lazy_evaluation=lazy_evaluation,
+                overrides=overrides,
+                override_keys=override_keys,
+                verbose=verbose,
+            )
+            return input_
         if start > end_:
             raise ValueError(f"'start' ({start}) must be less than 'end' ({end_})")
         if end_ > len(transforms):
@@ -350,7 +371,7 @@ def execute(
                 override_keys=override_keys,
                 verbose=verbose,
             )
-            input_ = apply_transform(_transform, input_, map_items, unpack_items, log_stats)
+            input_ = apply_transform(_transform, input_, map_items, unpack_items, log_stats)  # type: ignore
         input_ = evaluate_with_overrides(
             input_,
             None,
@@ -370,21 +391,32 @@ def evaluate_with_overrides(self, input_, upcoming_xform):
         return evaluate_with_overrides(
             input_,
             upcoming_xform,
-            lazy_evaluation=self.lazy_evaluation,
+            lazy_evaluation=bool(self.lazy_evaluation),
             overrides=self.overrides,
             override_keys=self.override_keys,
             verbose=self.verbose,
         )
 
-    def __call__(self, input_, start=0, end=None, threading=False):
+    def __call__(self, input_, start: int | None = 0, end: int | None = None, threading: bool = False):
+        """
+        apply the ``self.transforms`` to ``input_``.
+
+        Args:
+            input_: input data to be transformed.
+            start: the index of the first transform to be executed. If not set, this defaults to 0.
+            end: the index after the last transform to be exectued. If set, the transform at ``end-1``
+                is the last transform that is executed. If this is not set, it defaults to len(transforms).
+            threading: whether executing is happening in a threaded environment. If set, deepcopies are made
+                of transforms that have the ``RandomizedTrait`` interface.
+        """
         return Compose.execute(
             input_,
             self.transforms,
             start=start,
             end=end,
             map_items=self.map_items,
             unpack_items=self.unpack_items,
-            lazy_evaluation=self.lazy_evaluation,
+            lazy_evaluation=bool(self.lazy_evaluation),
             overrides=self.overrides,
             override_keys=self.override_keys,
             threading=threading,