Type fixes for new mypy version

ericspod · ericspod · commit f2f76ff04a9c · 2025-08-08T02:47:48.000+01:00
Signed-off-by: Eric Kerfoot &lt;17726042+ericspod@users.noreply.github.com&gt;
diff --git a/monai/apps/detection/metrics/coco.py b/monai/apps/detection/metrics/coco.py
@@ -457,7 +457,7 @@ def _compute_statistics(self, results_list: list[dict[int, dict[str, np.ndarray]
                 dt_ignores = np.concatenate([r["dtIgnore"][:, 0:max_det] for r in results], axis=1)[:, inds]
                 self.check_number_of_iou(dt_matches, dt_ignores)
                 gt_ignore = np.concatenate([r["gtIgnore"] for r in results])
-                num_gt = np.count_nonzero(gt_ignore == 0)  # number of ground truth boxes (non ignored)
+                num_gt = int(np.count_nonzero(gt_ignore == 0))  # number of ground truth boxes (non ignored)
                 if num_gt == 0:
                     logger.warning(f"WARNING, no gt found for coco metric for class {cls_i}")
                     continue
@@ -523,13 +523,12 @@ def _compute_stats_single_threshold(
         recall = 0
 
     # array where precision values nearest to given recall th are saved
-    precision = np.zeros((num_recall_th,))
+    precision = [0.0] * num_recall_th
     # save scores for corresponding recall value in here
     th_scores = np.zeros((num_recall_th,))
     # numpy is slow without cython optimization for accessing elements
     # use python array gets significant speed improvement
     pr = pr.tolist()
-    precision = precision.tolist()
 
     # smooth precision curve (create box shape)
     for i in range(len(tp) - 1, 0, -1):
diff --git a/monai/apps/detection/utils/box_coder.py b/monai/apps/detection/utils/box_coder.py
@@ -210,7 +210,10 @@ def decode_single(self, rel_codes: Tensor, reference_boxes: Tensor) -> Tensor:
         offset = reference_boxes.shape[-1]
 
         pred_boxes = []
-        boxes_cccwhd = convert_box_mode(reference_boxes, src_mode=StandardMode, dst_mode=CenterSizeMode)
+        boxes_cccwhd: torch.Tensor = convert_box_mode(
+            reference_boxes, src_mode=StandardMode, dst_mode=CenterSizeMode
+        )  # type: ignore[assignment]
+
         for axis in range(self.spatial_dims):
             whd_axis = boxes_cccwhd[:, axis + self.spatial_dims]
             ctr_xyz_axis = boxes_cccwhd[:, axis]
diff --git a/monai/apps/generation/maisi/networks/diffusion_model_unet_maisi.py b/monai/apps/generation/maisi/networks/diffusion_model_unet_maisi.py
@@ -358,8 +358,9 @@ def _apply_down_blocks(self, h, emb, context, down_block_additional_residuals):
 
     def _apply_up_blocks(self, h, emb, context, down_block_res_samples):
         for upsample_block in self.up_blocks:
-            res_samples = down_block_res_samples[-len(upsample_block.resnets) :]
-            down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)]
+            idx: int = -len(upsample_block.resnets)  # type: ignore
+            res_samples = down_block_res_samples[idx:]
+            down_block_res_samples = down_block_res_samples[:idx]
             h = upsample_block(hidden_states=h, res_hidden_states_list=res_samples, temb=emb, context=context)
 
         return h
diff --git a/monai/data/box_utils.py b/monai/data/box_utils.py
@@ -811,9 +811,9 @@ def _box_inter_union(
 
     # compute size for the intersection region for the NxM combinations
     wh = (rb - lt + TO_REMOVE).clamp(min=0)  # (N,M,spatial_dims)
-    inter = torch.prod(wh, dim=-1, keepdim=False)  # (N,M)
+    inter: torch.Tensor = torch.prod(wh, dim=-1, keepdim=False)  # (N,M)
 
-    union = area1[:, None] + area2 - inter
+    union: torch.Tensor = area1[:, None] + area2 - inter  # type: ignore
     return inter, union
 
 
@@ -981,7 +981,7 @@ def box_pair_giou(boxes1: NdarrayOrTensor, boxes2: NdarrayOrTensor) -> NdarrayOr
     wh = (rb - lt + TO_REMOVE).clamp(min=0)  # (N,spatial_dims)
     enclosure = torch.prod(wh, dim=-1, keepdim=False)  # (N,)
 
-    giou_t = iou - (enclosure - union) / (enclosure + torch.finfo(COMPUTE_DTYPE).eps)
+    giou_t: torch.Tensor = iou - (enclosure - union) / (enclosure + torch.finfo(COMPUTE_DTYPE).eps)  # type: ignore
     giou_t = giou_t.to(dtype=box_dtype)  # (N,spatial_dims)
     if torch.isnan(giou_t).any() or torch.isinf(giou_t).any():
         raise ValueError("Box GIoU is NaN or Inf.")
diff --git a/monai/data/dataset.py b/monai/data/dataset.py
@@ -1353,7 +1353,7 @@ def __len__(self) -> int:
         return len(self.dataset)
 
     def randomize(self, data: Any | None = None) -> None:
-        self._seed = self.R.randint(MAX_SEED, dtype="uint32")
+        self._seed = int(self.R.randint(MAX_SEED, dtype="uint32"))
 
     def __getitem__(self, index: int):
         self.randomize()
diff --git a/monai/data/image_dataset.py b/monai/data/image_dataset.py
@@ -97,7 +97,7 @@ def __len__(self) -> int:
         return len(self.image_files)
 
     def randomize(self, data: Any | None = None) -> None:
-        self._seed = self.R.randint(MAX_SEED, dtype="uint32")
+        self._seed = int(self.R.randint(MAX_SEED, dtype="uint32"))
 
     def __getitem__(self, index: int):
         self.randomize()
diff --git a/monai/data/image_reader.py b/monai/data/image_reader.py
@@ -580,7 +580,7 @@ def _combine_dicom_series(self, data: Iterable, filenames: Sequence[PathLike]):
         shape = first_array.shape
         spacing = getattr(first_slice, "PixelSpacing", [1.0] * len(shape))
         prev_pos = getattr(first_slice, "ImagePositionPatient", (0.0, 0.0, 0.0))[2]
-        stack_array = [first_array]
+        stack_array_list: list = [first_array]
         for idx in range(1, len(slices)):
             slc_array = self._get_array_data(slices[idx][0], slices[idx][1])
             slc_shape = slc_array.shape
@@ -592,22 +592,24 @@ def _combine_dicom_series(self, data: Iterable, filenames: Sequence[PathLike]):
                 warnings.warn(f"the list contains slices that have different shapes {shape} and {slc_shape}.")
             average_distance += abs(prev_pos - slc_pos)
             prev_pos = slc_pos
-            stack_array.append(slc_array)
+            stack_array_list.append(slc_array)
 
         if len(slices) > 1:
             average_distance /= len(slices) - 1
             spacing.append(average_distance)
             if self.to_gpu:
-                stack_array = cp.stack(stack_array, axis=-1)
+                stack_array = cp.stack(stack_array_list, axis=-1)
             else:
-                stack_array = np.stack(stack_array, axis=-1)
+                stack_array = np.stack(stack_array_list, axis=-1)
+
+            del stack_array_list[:]
             stack_metadata = self._get_meta_dict(first_slice)
             stack_metadata["spacing"] = np.asarray(spacing)
             if hasattr(slices[-1][0], "ImagePositionPatient"):
                 stack_metadata["lastImagePositionPatient"] = np.asarray(slices[-1][0].ImagePositionPatient)
             stack_metadata[MetaKeys.SPATIAL_SHAPE] = shape + (len(slices),)
         else:
-            stack_array = stack_array[0]
+            stack_array = stack_array_list[0]
             stack_metadata = self._get_meta_dict(first_slice)
             stack_metadata["spacing"] = np.asarray(spacing)
             stack_metadata[MetaKeys.SPATIAL_SHAPE] = shape
diff --git a/monai/networks/nets/diffusion_model_unet.py b/monai/networks/nets/diffusion_model_unet.py
@@ -1795,8 +1795,9 @@ def forward(
 
         # 6. up
         for upsample_block in self.up_blocks:
-            res_samples = down_block_res_samples[-len(upsample_block.resnets) :]
-            down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)]
+            idx: int = -len(upsample_block.resnets)  # type: ignore
+            res_samples = down_block_res_samples[idx:]
+            down_block_res_samples = down_block_res_samples[:idx]
             h = upsample_block(hidden_states=h, res_hidden_states_list=res_samples, temb=emb, context=context)
 
         # 7. output block
diff --git a/monai/networks/nets/dints.py b/monai/networks/nets/dints.py
@@ -492,7 +492,7 @@ def forward(self, x: torch.Tensor):
         inputs = []
         for d in range(self.num_depths):
             # allow multi-resolution input
-            _mod_w: StemInterface = self.stem_down[str(d)]
+            _mod_w: StemInterface = self.stem_down[str(d)]  # type: ignore[assignment]
             x_out = _mod_w.forward(x)
             if self.node_a[0][d]:
                 inputs.append(x_out)
@@ -505,7 +505,7 @@ def forward(self, x: torch.Tensor):
         start = False
         _temp: torch.Tensor = torch.empty(0)
         for res_idx in range(self.num_depths - 1, -1, -1):
-            _mod_up: StemInterface = self.stem_up[str(res_idx)]
+            _mod_up: StemInterface = self.stem_up[str(res_idx)]  # type: ignore[assignment]
             if start:
                 _temp = _mod_up.forward(outputs[res_idx] + _temp)
             elif self.node_a[blk_idx + 1][res_idx]:
@@ -680,7 +680,7 @@ def forward(self, x: list[torch.Tensor]) -> list[torch.Tensor]:
             outputs = [torch.tensor(0.0, dtype=x[0].dtype, device=x[0].device)] * self.num_depths
             for res_idx, activation in enumerate(self.arch_code_a[blk_idx].data):
                 if activation:
-                    mod: CellInterface = self.cell_tree[str((blk_idx, res_idx))]
+                    mod: CellInterface = self.cell_tree[str((blk_idx, res_idx))]  # type: ignore[assignment]
                     _out = mod.forward(x=inputs[self.arch_code2in[res_idx]], weight=None)
                     outputs[self.arch_code2out[res_idx]] = outputs[self.arch_code2out[res_idx]] + _out
             inputs = outputs
@@ -782,12 +782,10 @@ def __init__(
         for blk_idx in range(self.num_blocks):
             for res_idx in range(len(self.arch_code2out)):
                 if self.arch_code_a[blk_idx, res_idx] == 1:
+                    cell_inter: Cell = self.cell_tree[str((blk_idx, res_idx))]  # type: ignore
                     self.ram_cost[blk_idx, res_idx] = np.array(
-                        [
-                            op.ram_cost + self.cell_tree[str((blk_idx, res_idx))].preprocess.ram_cost
-                            for op in self.cell_tree[str((blk_idx, res_idx))].op.ops[: self.num_cell_ops]
-                        ]
-                    )
+                        [op.ram_cost + cell_inter.preprocess.ram_cost for op in cell_inter.op.ops[: self.num_cell_ops]]
+                    )  # type: ignore
 
         # define cell and macro architecture probabilities
         self.log_alpha_c = nn.Parameter(
diff --git a/monai/networks/nets/efficientnet.py b/monai/networks/nets/efficientnet.py
@@ -416,8 +416,10 @@ def set_swish(self, memory_efficient: bool = True) -> None:
 
         """
         self._swish = Act["memswish"]() if memory_efficient else Act["swish"](alpha=1.0)
-        for sub_stack in self._blocks:
-            for block in sub_stack:
+        sub_stack: nn.Sequential
+        block: MBConvBlock
+        for sub_stack in self._blocks:  # type: ignore[assignment]
+            for block in sub_stack:  # type: ignore[assignment]
                 block.set_swish(memory_efficient)
 
     def forward(self, inputs: torch.Tensor):
diff --git a/monai/networks/nets/segresnet_ds.py b/monai/networks/nets/segresnet_ds.py
@@ -218,7 +218,8 @@ def _forward(self, x: torch.Tensor) -> list[torch.Tensor]:
         outputs = []
         x = self.conv_init(x)
 
-        for level in self.layers:
+        level: nn.ModuleDict
+        for level in self.layers:  # type: ignore[assignment]
             x = level["blocks"](x)
             outputs.append(x)
             x = level["downsample"](x)
@@ -406,7 +407,8 @@ def _forward(self, x: torch.Tensor) -> Union[None, torch.Tensor, list[torch.Tens
         outputs: list[torch.Tensor] = []
 
         i = 0
-        for level in self.up_layers:
+        level: nn.ModuleDict
+        for level in self.up_layers:  # type: ignore
             x = level["upsample"](x)
             x += x_down.pop(0)
             x = level["blocks"](x)
@@ -508,12 +510,13 @@ def forward(  # type: ignore
 
         outputs: list[torch.Tensor] = []
         outputs_auto: list[torch.Tensor] = []
+        level: nn.ModuleDict
         x_ = x
         if with_point:
             if with_label:
                 x_ = x.clone()
             i = 0
-            for level in self.up_layers:
+            for level in self.up_layers:  # type: ignore
                 x = level["upsample"](x)
                 x = x + x_down[i]
                 x = level["blocks"](x)
@@ -526,7 +529,7 @@ def forward(  # type: ignore
         x = x_
         if with_label:
             i = 0
-            for level in self.up_layers_auto:
+            for level in self.up_layers_auto:  # type: ignore
                 x = level["upsample"](x)
                 x = x + x_down[i]
                 x = level["blocks"](x)
diff --git a/monai/networks/nets/spade_diffusion_model_unet.py b/monai/networks/nets/spade_diffusion_model_unet.py
@@ -961,8 +961,9 @@ def forward(
 
         # 6. up
         for upsample_block in self.up_blocks:
-            res_samples = down_block_res_samples[-len(upsample_block.resnets) :]
-            down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)]
+            idx: int = -len(upsample_block.resnets)  # type: ignore
+            res_samples = down_block_res_samples[idx:]
+            down_block_res_samples = down_block_res_samples[:idx]
             h = upsample_block(hidden_states=h, res_hidden_states_list=res_samples, seg=seg, temb=emb, context=context)
 
         # 7. output block
diff --git a/monai/transforms/compose.py b/monai/transforms/compose.py
@@ -271,7 +271,7 @@ def set_random_state(self, seed: int | None = None, state: np.random.RandomState
         for _transform in self.transforms:
             if not isinstance(_transform, Randomizable):
                 continue
-            _transform.set_random_state(seed=self.R.randint(MAX_SEED, dtype="uint32"))
+            _transform.set_random_state(seed=int(self.R.randint(MAX_SEED, dtype="uint32")))
         return self
 
     def randomize(self, data: Any | None = None) -> None:
diff --git a/monai/transforms/croppad/dictionary.py b/monai/transforms/croppad/dictionary.py
@@ -694,7 +694,7 @@ def __call__(
 
         lazy_ = self.lazy if lazy is None else lazy
         for key in self.key_iterator(dict(data)):
-            self.cropper.set_random_state(seed=self.sub_seed)
+            self.cropper.set_random_state(seed=int(self.sub_seed))
             for i, im in enumerate(self.cropper(data[key], lazy=lazy_)):
                 ret[i][key] = im
         return ret
diff --git a/monai/transforms/intensity/array.py b/monai/transforms/intensity/array.py
@@ -900,27 +900,28 @@ def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor:
         """
         Apply the transform to `img`, assuming `img` is a channel-first array if `self.channel_wise` is True,
         """
-        img = convert_to_tensor(img, track_meta=get_track_meta())
+        img_t: torch.Tensor = convert_to_tensor(img, track_meta=get_track_meta())  # type: ignore[assignment]
         dtype = self.dtype or img.dtype
+        img_len = len(img_t)
         if self.channel_wise:
-            if self.subtrahend is not None and len(self.subtrahend) != len(img):
-                raise ValueError(f"img has {len(img)} channels, but subtrahend has {len(self.subtrahend)} components.")
-            if self.divisor is not None and len(self.divisor) != len(img):
-                raise ValueError(f"img has {len(img)} channels, but divisor has {len(self.divisor)} components.")
+            if self.subtrahend is not None and len(self.subtrahend) != img_len:
+                raise ValueError(f"img has {img_len} channels, but subtrahend has {len(self.subtrahend)} components.")
+            if self.divisor is not None and len(self.divisor) != img_len:
+                raise ValueError(f"img has {img_len} channels, but divisor has {len(self.divisor)} components.")
 
-            if not img.dtype.is_floating_point:
-                img, *_ = convert_data_type(img, dtype=torch.float32)
+            if not img_t.dtype.is_floating_point:
+                img_t, *_ = convert_data_type(img_t, dtype=torch.float32)
 
-            for i, d in enumerate(img):
-                img[i] = self._normalize(  # type: ignore
+            for i, d in enumerate(img_t):
+                img_t[i] = self._normalize(  # type: ignore
                     d,
                     sub=self.subtrahend[i] if self.subtrahend is not None else None,
                     div=self.divisor[i] if self.divisor is not None else None,
                 )
         else:
-            img = self._normalize(img, self.subtrahend, self.divisor)
+            img_t = self._normalize(img_t, self.subtrahend, self.divisor)  # type: ignore[assignment]
 
-        out = convert_to_dst_type(img, img, dtype=dtype)[0]
+        out = convert_to_dst_type(img_t, img, dtype=dtype)[0]
         return out
 
 
@@ -2764,7 +2765,7 @@ def __init__(self, dtype: DtypeLike = "float32") -> None:
         self.dtype = dtype
 
     def __call__(self, mask: NdarrayOrTensor):
-        instance_mask = convert_data_type(mask, np.ndarray)[0]
+        instance_mask: np.ndarray = convert_data_type(mask, np.ndarray)[0]  # type: ignore[assignment]
 
         h_map = instance_mask.astype(self.dtype, copy=True)
         v_map = instance_mask.astype(self.dtype, copy=True)
diff --git a/monai/transforms/spatial/array.py b/monai/transforms/spatial/array.py
@@ -1740,6 +1740,8 @@ def __call__(
 
         """
         lazy_ = self.lazy if lazy is None else lazy
+        _device: torch.device | None
+
         if not lazy_:
             if grid is None:  # create grid from spatial_size
                 if spatial_size is None:
@@ -1749,10 +1751,10 @@ def __call__(
                 grid_ = grid
             _dtype = self.dtype or grid_.dtype
             grid_: torch.Tensor = convert_to_tensor(grid_, dtype=_dtype, track_meta=get_track_meta())  # type: ignore
-            _device = grid_.device  # type: ignore
+            _device = torch.device(grid_.device)  # type: ignore
             spatial_dims = len(grid_.shape) - 1
         else:
-            _device = self.device
+            _device = self.device  # type: ignore[assignment]
             spatial_dims = len(spatial_size)  # type: ignore
         _b = TransformBackends.TORCH
         affine: torch.Tensor
@@ -3309,6 +3311,7 @@ def __call__(self, array: NdarrayOrTensor) -> MetaTensor:
             **self.pad_kwargs,
         )
         patches = list(zip(*patch_iterator))
+        patched_image: NdarrayOrTensor
         patched_image = np.stack(patches[0]) if isinstance(array, np.ndarray) else torch.stack(patches[0])
         locations = np.stack(patches[1])[:, 1:, 0]  # only keep the starting location
 
@@ -3516,7 +3519,7 @@ def __call__(self, img: torch.Tensor, randomize: bool = True) -> torch.Tensor:
 
         if self._do_transform:
             input_shape = img.shape[1:]
-            target_shape = np.round(np.array(input_shape) * self.zoom_factor).astype(np.int_)
+            target_shape = tuple(np.round(np.array(input_shape) * self.zoom_factor).astype(np.int_).tolist())
 
             resize_tfm_downsample = Resize(
                 spatial_size=target_shape, size_mode="all", mode=self.downsample_mode, anti_aliasing=False
diff --git a/monai/transforms/utility/array.py b/monai/transforms/utility/array.py
@@ -941,7 +941,7 @@ def __call__(
             data = where(in1d(img, select_labels), True, False).reshape(img.shape)
 
         if merge_channels or self.merge_channels:
-            return data.any(0)[None]
+            return data.any(0)[None]  # type: ignore
 
         return data
 
diff --git a/monai/transforms/utils.py b/monai/transforms/utils.py
@@ -508,7 +508,7 @@ def map_classes_to_indices(
     img_flat: NdarrayOrTensor | None = None
     if image is not None:
         check_non_lazy_pending_ops(image, name="map_classes_to_indices")
-        img_flat = ravel((image > image_threshold).any(0))
+        img_flat = ravel((image > image_threshold).any(0))  # type: ignore
 
     # assuming the first dimension is channel
     channels = len(label)
diff --git a/monai/transforms/utils_pytorch_numpy_unification.py b/monai/transforms/utils_pytorch_numpy_unification.py
@@ -216,7 +216,7 @@ def floor_divide(a: NdarrayOrTensor, b) -> NdarrayOrTensor:
     if isinstance(a, torch.Tensor):
         return torch.floor_divide(a, b)
     else:
-        return np.floor_divide(a, b)
+        return np.asarray(np.floor_divide(a, b))
 
 
 def unravel_index(idx, shape) -> NdarrayOrTensor:
diff --git a/monai/visualize/img2tensorboard.py b/monai/visualize/img2tensorboard.py
@@ -200,13 +200,14 @@ def plot_2d_or_3d_image(
     if d.ndim >= 4:
         spatial = d.shape[-3:]
         d = d.reshape([-1] + list(spatial))
-        if d.shape[0] == 3 and max_channels == 3 and has_tensorboardx and isinstance(writer, SummaryWriterX):  # RGB
+        d_chans = d.shape[0]  # type: ignore
+        if d_chans == 3 and max_channels == 3 and has_tensorboardx and isinstance(writer, SummaryWriterX):  # RGB
             # move the expected frame dim to the end as `T` dim for video
             d = np.moveaxis(d, frame_dim, -1)
             writer.add_video(tag, d[None], step, fps=max_frames, dataformats="NCHWT")
             return
         # scale data to 0 - 255 for visualization
-        max_channels = min(max_channels, d.shape[0])
+        max_channels = min(max_channels, d_chans)
         d = np.stack([rescale_array(i, 0, 255) for i in d[:max_channels]], axis=0)
         # will plot every channel as a separate GIF image
         add_animated_gif(writer, f"{tag}_HWD", d, max_out=max_channels, frame_dim=frame_dim, global_step=step)
diff --git a/monai/visualize/utils.py b/monai/visualize/utils.py
