Reenable checks and fix errors (#717)

* Set set_type_checking_flag for autodoc-typehints

Fixes 11 out of the 17 warnings when running 'make html'

WARNING: Cannot resolve forward reference in type annotations of "{}":
name 'ignite' is not defined

* Reenable and fix flake8-bugbear errors

B007
Loop control variable '{}' not used within the loop body. If this is
intended, start the name with an underscore.

B008
See #727

* Reenable and fix flake8-comprehensions errors

C402
Unnecessary generator - rewrite as a dict comprehension.

C407
Unnecessary list comprehension - '{}' can take a generator.

C416
Unnecessary list comprehension - rewrite using list().

* Reenable and fix flake8 unused import errors

F401
'{}' imported but unused

* Remove flake8-mypy configurations

See #550

* Reenable and fix mypy-torch errors

- Argument "{}" to "{}" has incompatible type "{}"; expected "{}"
- Incompatible types in assignment (expression has type "{}", variable has type "{}")
- Module "{}" is not valid as a type
- Module has no attribute "{}"
- Name '{}' is not defined
- No overload variant of "{}" of "{}" matches argument types

* Update the issue number of signature incompatible

See #729

Author: Benjamin Gorman

docs/source/conf.py

@@ -95,6 +95,7 @@ def setup(app):
 add_module_names = True
 autosectionlabel_prefix_document = True
 napoleon_use_param = True
+set_type_checking_flag = True
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ["_templates"]

monai/apps/datasets.py

@@ -89,7 +89,7 @@ def randomize(self) -> None:
         self.rann = self.R.random()
 
     def _generate_data_list(self, dataset_dir: str):
-        class_names = sorted([x for x in os.listdir(dataset_dir) if os.path.isdir(os.path.join(dataset_dir, x))])
+        class_names = sorted((x for x in os.listdir(dataset_dir) if os.path.isdir(os.path.join(dataset_dir, x))))
         num_class = len(class_names)
         image_files = [
             [

monai/config/deviceconfig.py

@@ -116,4 +116,4 @@ def get_torch_version_tuple():
     Returns:
         tuple of ints represents the pytorch major/minor version.
     """
-    return tuple([int(x) for x in torch.__version__.split(".")[:2]])
+    return tuple((int(x) for x in torch.__version__.split(".")[:2]))

monai/data/csv_saver.py

@@ -77,6 +77,7 @@ def save(self, data: Union[torch.Tensor, np.ndarray], meta_data: Optional[dict]
         self._data_index += 1
         if torch.is_tensor(data):
             data = data.detach().cpu().numpy()
+        assert isinstance(data, np.ndarray)
         self._cache_dict[save_key] = data.astype(np.float32)
 
     def save_batch(self, batch_data: Union[torch.Tensor, np.ndarray], meta_data: Optional[dict] = None) -> None:

monai/data/dataloader.py

@@ -63,7 +63,7 @@ def __init__(
         timeout: float = 0.0,
         multiprocessing_context: Optional[Callable] = None,
     ) -> None:
-        super().__init__(
+        super().__init__(  # type: ignore # No overload variant matches argument types
             dataset=dataset,
             batch_size=batch_size,
             shuffle=shuffle,

monai/data/dataset.py

@@ -336,7 +336,7 @@ def __init__(self, datasets, transform: Optional[Callable] = None) -> None:
         super().__init__(list(datasets), transform=transform)
 
     def __len__(self) -> int:
-        return min([len(dataset) for dataset in self.data])
+        return min((len(dataset) for dataset in self.data))
 
     def __getitem__(self, index: int):
         def to_list(x):

monai/data/synthetic.py

@@ -38,7 +38,7 @@ def create_test_image_2d(
     image = np.zeros((width, height))
     rs = np.random if random_state is None else random_state
 
-    for i in range(num_objs):
+    for _ in range(num_objs):
         x = rs.randint(rad_max, width - rad_max)
         y = rs.randint(rad_max, height - rad_max)
         rad = rs.randint(5, rad_max)
@@ -85,7 +85,7 @@ def create_test_image_3d(
     image = np.zeros((width, height, depth))
     rs = np.random if random_state is None else random_state
 
-    for i in range(num_objs):
+    for _ in range(num_objs):
         x = rs.randint(rad_max, width - rad_max)
         y = rs.randint(rad_max, height - rad_max)
         z = rs.randint(rad_max, depth - rad_max)

monai/data/utils.py

@@ -452,7 +452,7 @@ def compute_importance_map(
     patch_size,
     mode: Union[BlendMode, str] = BlendMode.CONSTANT,
     sigma_scale: float = 0.125,
-    device: Optional[Union[torch.device, str]] = None,
+    device: Optional[torch.device] = None,
 ):
     """Get importance map for different weight modes.
 

monai/engines/multi_gpu_supervised_trainer.py

@@ -15,6 +15,7 @@
     import ignite.metrics
 
 import torch
+from torch.optim.optimizer import Optimizer
 
 from monai.utils import exact_version, optional_import
 from monai.engines.utils import get_devices_spec
@@ -34,7 +35,7 @@ def _default_eval_transform(x, y, y_pred):
 
 def create_multigpu_supervised_trainer(
     net: torch.nn.Module,
-    optimizer: torch.optim.Optimizer,
+    optimizer: Optimizer,
     loss_fn,
     devices=None,
     non_blocking: bool = False,

monai/engines/trainer.py

@@ -16,6 +16,7 @@
     import ignite.metrics
 
 import torch
+from torch.optim.optimizer import Optimizer
 from torch.utils.data import DataLoader
 
 from monai.inferers import Inferer, SimpleInferer
@@ -78,7 +79,7 @@ def __init__(
         max_epochs: int,
         train_data_loader: DataLoader,
         network,
-        optimizer: torch.optim.Optimizer,
+        optimizer: Optimizer,
         loss_function,
         prepare_batch: Callable = default_prepare_batch,
         iteration_update: Optional[Callable] = None,

monai/engines/workflow.py

@@ -18,7 +18,7 @@
 import torch
 from torch.utils.data import DataLoader
 
-from monai.transforms import apply_transform, Transform
+from monai.transforms import apply_transform
 from monai.utils import exact_version, optional_import, ensure_tuple
 from monai.engines.utils import default_prepare_batch
 

monai/handlers/lr_schedule_handler.py

@@ -9,15 +9,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Callable, Optional, TYPE_CHECKING
+from typing import Callable, Optional, Union, TYPE_CHECKING
 
 if TYPE_CHECKING:
     import ignite.engine
 
-import torch
-
 import logging
 
+from torch.optim.lr_scheduler import _LRScheduler, ReduceLROnPlateau
+
 from monai.utils import ensure_tuple, exact_version, optional_import
 
 Events, _ = optional_import("ignite.engine", "0.3.0", exact_version, "Events")
@@ -30,7 +30,7 @@ class LrScheduleHandler:
 
     def __init__(
         self,
-        lr_scheduler: torch.optim.lr_scheduler,
+        lr_scheduler: Union[_LRScheduler, ReduceLROnPlateau],
         print_lr: bool = True,
         name: Optional[str] = None,
         epoch_level: bool = True,
@@ -73,4 +73,6 @@ def __call__(self, engine: "ignite.engine.Engine") -> None:
         args = ensure_tuple(self.step_transform(engine))
         self.lr_scheduler.step(*args)
         if self.print_lr:
-            self.logger.info(f"Current learning rate: {self.lr_scheduler._last_lr[0]}")
+            self.logger.info(
+                f"Current learning rate: {self.lr_scheduler._last_lr[0]}"  # type: ignore # Module has no attribute
+            )

monai/handlers/mean_dice.py

@@ -9,7 +9,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Callable, Optional, Sequence, Union
+from typing import Callable, Optional, Sequence
 
 import torch
 
@@ -72,13 +72,13 @@ def reset(self) -> None:
         self._num_examples = 0
 
     @reinit__is_reduced
-    def update(self, output: Sequence[Union[torch.Tensor, dict]]) -> None:
+    def update(self, output: Sequence[torch.Tensor]) -> None:
         if not len(output) == 2:
             raise ValueError("MeanDice metric can only support y_pred and y.")
         y_pred, y = output
         score = self.dice(y_pred, y)
         assert self.dice.not_nans is not None
-        not_nans = self.dice.not_nans.item()
+        not_nans = int(self.dice.not_nans.item())
 
         # add all items in current batch
         self._sum += score.item() * not_nans

monai/handlers/roc_auc.py

@@ -63,8 +63,8 @@ def __init__(
         self.average: Average = Average(average)
 
     def reset(self) -> None:
-        self._predictions: List[float] = []
-        self._targets: List[float] = []
+        self._predictions: List[torch.Tensor] = []
+        self._targets: List[torch.Tensor] = []
 
     def update(self, output: Sequence[torch.Tensor]) -> None:
         y_pred, y = output

monai/losses/dice.py

@@ -66,7 +66,7 @@ def __init__(
             ValueError: sigmoid=True and softmax=True are not compatible.
 
         """
-        super().__init__(reduction=LossReduction(reduction))
+        super().__init__(reduction=LossReduction(reduction).value)
 
         if sigmoid and softmax:
             raise ValueError("sigmoid=True and softmax=True are not compatible.")
@@ -133,11 +133,11 @@ def forward(self, input: torch.Tensor, target: torch.Tensor, smooth: float = 1e-
 
         f = 1.0 - (2.0 * intersection + smooth) / (denominator + smooth)
 
-        if self.reduction == LossReduction.MEAN:
+        if self.reduction == LossReduction.MEAN.value:
             f = torch.mean(f)  # the batch and channel average
-        elif self.reduction == LossReduction.SUM:
+        elif self.reduction == LossReduction.SUM.value:
             f = torch.sum(f)  # sum over the batch and channel dims
-        elif self.reduction == LossReduction.NONE:
+        elif self.reduction == LossReduction.NONE.value:
             pass  # returns [N, n_classes] losses
         else:
             raise ValueError(f"reduction={self.reduction} is invalid.")
@@ -219,7 +219,7 @@ def __init__(
             ValueError: sigmoid=True and softmax=True are not compatible.
 
         """
-        super().__init__(reduction=LossReduction(reduction))
+        super().__init__(reduction=LossReduction(reduction).value)
 
         self.include_background = include_background
         self.to_onehot_y = to_onehot_y
@@ -286,11 +286,11 @@ def forward(self, input: torch.Tensor, target: torch.Tensor, smooth: float = 1e-
 
         f = 1.0 - (2.0 * (intersection * w).sum(1) + smooth) / ((denominator * w).sum(1) + smooth)
 
-        if self.reduction == LossReduction.MEAN:
+        if self.reduction == LossReduction.MEAN.value:
             f = torch.mean(f)  # the batch and channel average
-        elif self.reduction == LossReduction.SUM:
+        elif self.reduction == LossReduction.SUM.value:
             f = torch.sum(f)  # sum over the batch and channel dims
-        elif self.reduction == LossReduction.NONE:
+        elif self.reduction == LossReduction.NONE.value:
             pass  # returns [N, n_classes] losses
         else:
             raise ValueError(f"reduction={self.reduction} is invalid.")

monai/losses/focal_loss.py

@@ -57,7 +57,7 @@ def __init__(
                 fl(pred, grnd)
 
         """
-        super(FocalLoss, self).__init__(weight=weight, reduction=LossReduction(reduction))
+        super(FocalLoss, self).__init__(weight=weight, reduction=LossReduction(reduction).value)
         self.gamma = gamma
         self.weight: Optional[torch.Tensor]
 
@@ -129,10 +129,10 @@ def forward(self, input: torch.Tensor, target: torch.Tensor):
         else:
             loss = torch.mean(-weight * t * logpt, dim=-1)  # N,C
 
-        if self.reduction == LossReduction.SUM:
+        if self.reduction == LossReduction.SUM.value:
             return loss.sum()
-        if self.reduction == LossReduction.NONE:
+        if self.reduction == LossReduction.NONE.value:
             return loss
-        if self.reduction == LossReduction.MEAN:
+        if self.reduction == LossReduction.MEAN.value:
             return loss.mean()
         raise ValueError(f"reduction={self.reduction} is invalid.")

monai/losses/tversky.py

@@ -63,7 +63,7 @@ def __init__(
 
         """
 
-        super().__init__(reduction=LossReduction(reduction))
+        super().__init__(reduction=LossReduction(reduction).value)
         self.include_background = include_background
         self.to_onehot_y = to_onehot_y
 
@@ -125,10 +125,10 @@ def forward(self, input: torch.Tensor, target: torch.Tensor, smooth: float = 1e-
 
         score = 1.0 - numerator / denominator
 
-        if self.reduction == LossReduction.SUM:
+        if self.reduction == LossReduction.SUM.value:
             return score.sum()  # sum over the batch and channel dims
-        if self.reduction == LossReduction.NONE:
+        if self.reduction == LossReduction.NONE.value:
             return score  # returns [N, n_classes] losses
-        if self.reduction == LossReduction.MEAN:
+        if self.reduction == LossReduction.MEAN.value:
             return score.mean()
         raise ValueError(f"reduction={self.reduction} is invalid.")

monai/metrics/rocauc.py

@@ -9,7 +9,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, Union
+from typing import cast, Union
 
 import warnings
 
@@ -34,7 +34,7 @@ def _calculate(y: torch.Tensor, y_pred: torch.Tensor):
     nneg = auc = tmp_pos = tmp_neg = 0.0
 
     for i in range(n):
-        y_i = y[i]
+        y_i = cast(float, y[i])
         if i + 1 < n and y_pred[i] == y_pred[i + 1]:
             tmp_pos += y_i
             tmp_neg += 1 - y_i

monai/networks/blocks/aspp.py

@@ -9,8 +9,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Sequence, Tuple
-
 import torch
 import torch.nn as nn
 

monai/networks/blocks/convolutions.py

@@ -9,8 +9,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Tuple, Union
-
 import numpy as np
 import torch.nn as nn
 

monai/networks/blocks/upsample.py

@@ -48,7 +48,7 @@ def __init__(
             align_corners: set the align_corners parameter of `torch.nn.Upsample`. Defaults to True.
         """
         super().__init__()
-        scale_factor = ensure_tuple_rep(scale_factor, spatial_dims)
+        scale_factor_ = ensure_tuple_rep(scale_factor, spatial_dims)
         if not out_channels:
             out_channels = in_channels
         if not with_conv:
@@ -58,11 +58,11 @@ def __init__(
                 mode = linear_mode[spatial_dims - 1]
             self.upsample = nn.Sequential(
                 Conv[Conv.CONV, spatial_dims](in_channels=in_channels, out_channels=out_channels, kernel_size=1),
-                nn.Upsample(scale_factor=scale_factor, mode=mode.value, align_corners=align_corners),
+                nn.Upsample(scale_factor=scale_factor_, mode=mode.value, align_corners=align_corners),
             )
         else:
             self.upsample = Conv[Conv.CONVTRANS, spatial_dims](
-                in_channels=in_channels, out_channels=out_channels, kernel_size=scale_factor, stride=scale_factor
+                in_channels=in_channels, out_channels=out_channels, kernel_size=scale_factor_, stride=scale_factor_
             )
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:

monai/networks/layers/factories.py

@@ -204,8 +204,8 @@ def batch_factory(dim: int):
 Act.add_factory_callable("gelu", lambda: nn.modules.GELU)
 Act.add_factory_callable("sigmoid", lambda: nn.modules.Sigmoid)
 Act.add_factory_callable("tanh", lambda: nn.modules.Tanh)
-Act.add_factory_callable("softmax", lambda: nn.modules.SoftMax)
-Act.add_factory_callable("logsoftmax", lambda: nn.modules.LogSoftMax)
+Act.add_factory_callable("softmax", lambda: nn.modules.Softmax)
+Act.add_factory_callable("logsoftmax", lambda: nn.modules.LogSoftmax)
 
 
 @Conv.factory_function("conv")

monai/networks/layers/spatial_transforms.py

@@ -147,7 +147,7 @@ def forward(self, src, theta, spatial_size: Optional[Union[Sequence[int], int]]
                 )
             )
 
-        grid = nn.functional.affine_grid(theta=theta[:, :sr], size=dst_size, align_corners=self.align_corners)
+        grid = nn.functional.affine_grid(theta=theta[:, :sr], size=list(dst_size), align_corners=self.align_corners)
         dst = nn.functional.grid_sample(
             input=src.contiguous(),
             grid=grid,

monai/networks/nets/classifier.py

@@ -9,12 +9,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, Sequence, Tuple, Union
+from typing import Optional, Sequence, Union
 
 import torch.nn as nn
 from monai.networks.layers.factories import Norm, Act, split_args
 from monai.networks.nets.regressor import Regressor
-from monai.utils import ensure_tuple
 
 
 class Classifier(Regressor):

monai/networks/nets/densenet.py

@@ -10,7 +10,7 @@
 # limitations under the License.
 
 from collections import OrderedDict
-from typing import Callable, Sequence, Tuple
+from typing import Callable, Sequence
 
 import torch
 import torch.nn as nn
@@ -144,7 +144,7 @@ def __init__(
                 [
                     ("relu", nn.ReLU(inplace=True)),
                     ("norm", avg_pool_type(1)),
-                    ("flatten", nn.Flatten(1)),
+                    ("flatten", nn.Flatten(1)),  # type: ignore # Module has no attribute
                     ("class", nn.Linear(in_channels, out_channels)),
                 ]
             )