More typing for cmdline.params module (#7009)

* More typing for cmdline.params.{arguments,types} modules
* More precise Callable type
* Better types for cmdline.params.types.strings module
* More accurate return types of convert methods
* Strict typing for cmdline.params.options
* Don't ignore errors from plumpy
* Enable strict settings for aiida.cmdline.params
* Upgrade mypy to 1.18.1
* Strict typing for cmdline.groups module

Author: danielhollas

docs/source/nitpick-exceptions

@@ -117,8 +117,10 @@ py:func aiida.orm.implementation.BackendQueryBuilder
 py:obj aiida.engine.processes.functions.P
 py:obj aiida.engine.processes.functions.N
 py:obj aiida.engine.processes.functions.R_co
+py:class FC
 py:class P
 py:class N
+py:class aiida.common.lang.T
 py:class aiida.engine.processes.functions.N
 py:class aiida.engine.processes.functions.R_co
 

pyproject.toml

@@ -231,7 +231,7 @@ notebook = [
 ]
 pre-commit = [
   'aiida-core[atomic_tools,rest,tests,tui]',
-  'mypy~=1.17.0',
+  'mypy~=1.18.0',
   'packaging~=23.0',
   'pre-commit~=3.5',
   'sqlalchemy[mypy]~=2.0',
@@ -324,6 +324,18 @@ module = 'aiida'
 disallow_untyped_decorators = false
 module = 'aiida.cmdline.commands.*'
 
+[[tool.mypy.overrides]]
+disallow_any_generics = true
+disallow_incomplete_defs = true
+disallow_subclassing_any = true
+disallow_untyped_calls = true
+disallow_untyped_defs = true
+module = [
+  'aiida.cmdline.params.*',
+  'aiida.cmdline.groups.*'
+]
+warn_return_any = true
+
 [[tool.mypy.overrides]]
 check_untyped_defs = false
 module = 'tests.*'
@@ -374,10 +386,6 @@ module = [
   'upf_to_json.*'
 ]
 
-[[tool.mypy.overrides]]
-ignore_errors = true
-module = 'plumpy'
-
 [tool.pytest.ini_options]
 addopts = '--benchmark-skip --durations=5 --durations-min=1 --strict-config --strict-markers -ra --cov-report xml --cov-append '
 filterwarnings = [

src/aiida/cmdline/groups/dynamic.py

@@ -16,6 +16,9 @@
 from ..params.options.interactive import InteractiveOption
 from .verdi import VerdiCommandGroup
 
+if t.TYPE_CHECKING:
+    from click.decorators import FC
+
 __all__ = ('DynamicEntryPointCommandGroup',)
 
 
@@ -44,11 +47,11 @@ def cmd_create():
 
     def __init__(
         self,
-        command: t.Callable,
+        command: click.Command,
         entry_point_group: str,
         entry_point_name_filter: str = r'.*',
-        shared_options: list[t.Callable[[t.Any], t.Any]] | None = None,
-        **kwargs,
+        shared_options: list[FC] | None = None,
+        **kwargs: t.Any,
     ):
         super().__init__(**kwargs)
         self._command = command
@@ -88,7 +91,7 @@ def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None
             command = super().get_command(ctx, cmd_name)
         return command
 
-    def call_command(self, ctx, cls, non_interactive, **kwargs):
+    def call_command(self, ctx: click.Context, cls: t.Any, non_interactive: bool, **kwargs: t.Any) -> t.Any:
         """Call the ``command`` after validating the provided inputs."""
         from pydantic import ValidationError
 
@@ -116,13 +119,13 @@ def create_command(self, ctx: click.Context, entry_point: str) -> click.Command:
         command.__doc__ = cls.__doc__
         return click.command(entry_point)(self.create_options(entry_point)(command))
 
-    def create_options(self, entry_point: str) -> t.Callable:
+    def create_options(self, entry_point: str) -> t.Callable[[FC], FC]:
         """Create the option decorators for the command function for the given entry point.
 
         :param entry_point: The entry point.
         """
 
-        def apply_options(func):
+        def apply_options(func: FC) -> FC:
             """Decorate the command function with the appropriate options for the given entry point."""
             func = options.NON_INTERACTIVE()(func)
             func = options.CONFIG_FILE()(func)
@@ -143,7 +146,7 @@ def apply_options(func):
 
         return apply_options
 
-    def list_options(self, entry_point: str) -> list[t.Callable[[t.Any], t.Any]]:
+    def list_options(self, entry_point: str) -> list[t.Callable[[FC], FC]]:
         """Return the list of options that should be applied to the command for the given entry point.
 
         :param entry_point: The entry point.
@@ -207,7 +210,7 @@ def list_options(self, entry_point: str) -> list[t.Callable[[t.Any], t.Any]]:
         return options_ordered
 
     @staticmethod
-    def create_option(name, spec: dict) -> t.Callable[[t.Any], t.Any]:
+    def create_option(name: str, spec: dict[str, t.Any]) -> t.Callable[[FC], FC]:
         """Create a click option from a name and a specification."""
         is_flag = spec.pop('is_flag', False)
         name_dashed = name.replace('_', '-')

src/aiida/cmdline/groups/verdi.py

@@ -48,7 +48,7 @@ class LazyVerdiObjAttributeDict(AttributeDict):
     _KEY_PROFILE = 'profile'
 
     def __init__(self, ctx: click.Context, dictionary: dict[str, t.Any] | None = None):
-        super().__init__(dictionary)
+        super().__init__(dictionary)  # type: ignore[no-untyped-call]
         self.ctx = ctx
 
     def __getattr__(self, attr: str) -> t.Any:
@@ -68,13 +68,13 @@ def __getattr__(self, attr: str) -> t.Any:
             except ConfigurationError as exception:
                 self.ctx.fail(str(exception))
 
-        return super().__getattr__(attr)
+        return super().__getattr__(attr)  # type: ignore[no-untyped-call]
 
 
 class VerdiContext(click.Context):
     """Custom context implementation that defines the ``obj`` user object and adds the ``Config`` instance."""
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: t.Any, **kwargs: t.Any):
         super().__init__(*args, **kwargs)
         if self.obj is None:
             self.obj = LazyVerdiObjAttributeDict(self)
@@ -190,7 +190,7 @@ def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None
 
         return None
 
-    def group(self, *args, **kwargs) -> click.Group:
+    def group(self, *args: t.Any, **kwargs: t.Any) -> click.Group:
         """Ensure that sub command groups use the same class but do not override an explicitly set value."""
         kwargs.setdefault('cls', self.__class__)
-        return super().group(*args, **kwargs)
+        return super().group(*args, **kwargs)  # type: ignore[no-any-return]

src/aiida/cmdline/params/arguments/overridable.py

@@ -8,8 +8,15 @@
 ###########################################################################
 """Convenience class which can be used to defined a set of commonly used arguments that can be easily reused."""
 
+from __future__ import annotations
+
+import typing as t
+
 import click
 
+if t.TYPE_CHECKING:
+    from click.decorators import FC
+
 __all__ = ('OverridableArgument',)
 
 
@@ -35,12 +42,12 @@ def print_code_pks(codes):
     the function argument name is determined, can be overridden.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: t.Any, **kwargs: t.Any):
         """Store the default args and kwargs"""
         self.args = args
         self.kwargs = kwargs
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Callable[[FC], FC]:
         """Override the stored kwargs with the passed kwargs and return the argument.
 
         The stored args are used only if they are not provided. This allows the user to override the variable name,

src/aiida/cmdline/params/options/commands/code.py

@@ -15,15 +15,15 @@
 from aiida.cmdline.params.options.overridable import OverridableOption
 
 
-def is_on_computer(ctx):
+def is_on_computer(ctx: click.Context) -> bool:
     return bool(ctx.params.get('on_computer'))
 
 
-def is_not_on_computer(ctx):
+def is_not_on_computer(ctx: click.Context) -> bool:
     return bool(not is_on_computer(ctx))
 
 
-def validate_label_uniqueness(ctx, _, value):
+def validate_label_uniqueness(ctx: click.Context, _: None, value: str) -> str:
     """Validate the uniqueness of the label of the code.
 
     The exact uniqueness criterion depends on the type of the code, whether it is "local" or "remote". For the former,

src/aiida/cmdline/params/options/commands/computer.py

@@ -8,21 +8,27 @@
 ###########################################################################
 """Reusable command line interface options for Computer commands."""
 
+import typing as t
+
 import click
 
 from aiida.cmdline.params import options, types
 from aiida.cmdline.params.options.interactive import InteractiveOption, TemplateInteractiveOption
 from aiida.cmdline.params.options.overridable import OverridableOption
 
+if t.TYPE_CHECKING:
+    from aiida.schedulers.datastructures import JobResource
+
 
-def get_job_resource_cls(ctx):
+def get_job_resource_cls(ctx: click.Context) -> 'type[JobResource]':
     """Return job resource cls from ctx."""
     from aiida.common.exceptions import ValidationError
+    from aiida.schedulers import Scheduler
 
     scheduler_ep = ctx.params['scheduler']
     if scheduler_ep is not None:
         try:
-            scheduler_cls = scheduler_ep.load()
+            scheduler_cls = t.cast(Scheduler, scheduler_ep.load())
         except ImportError:
             raise ImportError(f"Unable to load the '{scheduler_ep.name}' scheduler")
     else:
@@ -33,22 +39,21 @@ def get_job_resource_cls(ctx):
     return scheduler_cls.job_resource_class
 
 
-def should_call_default_mpiprocs_per_machine(ctx):
+def should_call_default_mpiprocs_per_machine(ctx: click.Context) -> bool:
     """Return whether the selected scheduler type accepts `default_mpiprocs_per_machine`.
 
     :return: `True` if the scheduler type accepts `default_mpiprocs_per_machine`, `False`
         otherwise. If the scheduler class could not be loaded `False` is returned by default.
     """
     job_resource_cls = get_job_resource_cls(ctx)
-
     if job_resource_cls is None:
         # Odd situation...
-        return False
+        return False  # type: ignore[unreachable]
 
     return job_resource_cls.accepts_default_mpiprocs_per_machine()
 
 
-def should_call_default_memory_per_machine(ctx):
+def should_call_default_memory_per_machine(ctx: click.Context) -> bool:
     """Return whether the selected scheduler type accepts `default_memory_per_machine`.
 
     :return: `True` if the scheduler type accepts `default_memory_per_machine`, `False`
@@ -58,7 +63,7 @@ def should_call_default_memory_per_machine(ctx):
 
     if job_resource_cls is None:
         # Odd situation...
-        return False
+        return False  # type: ignore[unreachable]
 
     return job_resource_cls.accepts_default_memory_per_machine()
 

src/aiida/cmdline/params/options/conditional.py

@@ -8,8 +8,15 @@
 ###########################################################################
 """Option whose requiredness is determined by a callback function."""
 
+from __future__ import annotations
+
+import typing as t
+
 import click
 
+if t.TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class ConditionalOption(click.Option):
     """Option whose requiredness is determined by a callback function.
@@ -24,7 +31,12 @@ class ConditionalOption(click.Option):
         is typically used when the condition depends on other parameters specified on the command line.
     """
 
-    def __init__(self, param_decls=None, required_fn=None, **kwargs):
+    def __init__(
+        self,
+        param_decls: Sequence[str] | None = None,
+        required_fn: t.Callable[[click.Context], bool] | None = None,
+        **kwargs: t.Any,
+    ):
         self.required_fn = required_fn
 
         # If there is not callback to determine requiredness, assume the option is not required.
@@ -33,7 +45,7 @@ def __init__(self, param_decls=None, required_fn=None, **kwargs):
 
         super().__init__(param_decls=param_decls, **kwargs)
 
-    def process_value(self, ctx, value):
+    def process_value(self, ctx: click.Context, value: t.Any) -> t.Any:
         try:
             value = super().process_value(ctx, value)
         except click.MissingParameter:
@@ -45,7 +57,7 @@ def process_value(self, ctx, value):
 
         return value
 
-    def is_required(self, ctx):
+    def is_required(self, ctx: click.Context) -> bool:
         """Runs the given check on the context to determine requiredness"""
         if self.required_fn:
             return self.required_fn(ctx)

src/aiida/cmdline/params/options/config.py

@@ -25,10 +25,13 @@
 
 from .overridable import OverridableOption
 
+if t.TYPE_CHECKING:
+    from click.decorators import FC
+
 __all__ = ('ConfigFileOption',)
 
 
-def yaml_config_file_provider(handle, cmd_name):
+def yaml_config_file_provider(handle: t.Any, _cmd_name: t.Any) -> t.Any:
     """Read yaml config file from file handle."""
     import yaml
 
@@ -45,7 +48,7 @@ def configuration_callback(
     ctx: click.Context,
     param: click.Parameter,
     value: t.Any,
-):
+) -> t.Any:
     """Callback for reading the config file.
 
     Also takes care of calling user specified custom callback afterwards.
@@ -89,7 +92,7 @@ def configuration_callback(
     return saved_callback(ctx, param, value) if saved_callback else value
 
 
-def configuration_option(*param_decls, **attrs):
+def configuration_option(*param_decls: t.Any, **attrs: t.Any) -> t.Callable[[FC], FC]:
     """Adds configuration file support to a click application.
 
     This will create an option of type ``click.File`` expecting the path to a configuration file. When specified, it
@@ -114,7 +117,7 @@ def configuration_option(*param_decls, **attrs):
     param_decls = param_decls or ('--config',)
     option_name = param_decls[0]
 
-    def decorator(func):
+    def decorator(func: FC) -> FC:
         attrs.setdefault('is_eager', True)
         attrs.setdefault('help', 'Read configuration from FILE.')
         attrs.setdefault('expose_value', False)
@@ -164,7 +167,7 @@ def computer_setup(computer_name):
 
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: t.Any, **kwargs: t.Any):
         """Store the default args and kwargs.
 
         :param args: default arguments to be used for the option
@@ -173,7 +176,7 @@ def __init__(self, *args, **kwargs):
         kwargs.update({'provider': yaml_config_file_provider, 'implicit': False})
         super().__init__(*args, **kwargs)
 
-    def __call__(self, **kwargs):
+    def __call__(self, **kwargs: t.Any) -> t.Any:
         """Override the stored kwargs, (ignoring args as we do not allow option name changes) and return the option.
 
         :param kwargs: keyword arguments that will override those set in the construction