And that's the last of it. Passes mypy.

Author: anselor

cmd2/argparse_completer.py

@@ -14,11 +14,11 @@
 )
 from typing import (
     Any,
-    cast,
     Dict,
     List,
     Optional,
     Union,
+    cast,
 )
 
 from . import (
@@ -32,6 +32,8 @@
     ATTR_NARGS_RANGE,
     ATTR_SUPPRESS_TAB_HINT,
     ChoicesCallable,
+    ChoicesProviderFuncBase,
+    ChoicesProviderFuncWithTokens,
     CompletionItem,
     generate_range_error,
 )
@@ -317,9 +319,11 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
             # Handle '--' which tells argparse all remaining arguments are non-flags
             elif token == '--' and not skip_remaining_flags:
                 # Check if there is an unfinished flag
-                if flag_arg_state is not None \
-                        and isinstance(flag_arg_state.min, int) \
-                        and flag_arg_state.count < flag_arg_state.min:
+                if (
+                    flag_arg_state is not None
+                    and isinstance(flag_arg_state.min, int)
+                    and flag_arg_state.count < flag_arg_state.min
+                ):
                     raise _UnfinishedFlagError(flag_arg_state)
 
                 # Otherwise end the current flag
@@ -332,9 +336,11 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
             if _looks_like_flag(token, self._parser) and not skip_remaining_flags:
 
                 # Check if there is an unfinished flag
-                if flag_arg_state is not None \
-                        and isinstance(flag_arg_state.min, int) \
-                        and flag_arg_state.count < flag_arg_state.min:
+                if (
+                    flag_arg_state is not None
+                    and isinstance(flag_arg_state.min, int)
+                    and flag_arg_state.count < flag_arg_state.min
+                ):
                     raise _UnfinishedFlagError(flag_arg_state)
 
                 # Reset flag arg state but not positional tracking because flags can be
@@ -438,9 +444,11 @@ def update_mutex_groups(arg_action: argparse.Action) -> None:
         # the current argument. We will handle the completion of flags that start with only one prefix
         # character (-f) at the end.
         if _looks_like_flag(text, self._parser) and not skip_remaining_flags:
-            if flag_arg_state is not None \
-                    and isinstance(flag_arg_state.min, int) \
-                    and flag_arg_state.count < flag_arg_state.min:
+            if (
+                flag_arg_state is not None
+                and isinstance(flag_arg_state.min, int)
+                and flag_arg_state.count < flag_arg_state.min
+            ):
                 raise _UnfinishedFlagError(flag_arg_state)
             return self._complete_flags(text, line, begidx, endidx, matched_flags)
 
@@ -692,17 +700,23 @@ def _complete_arg(
         # Check if the argument uses a specific tab completion function to provide its choices
         if isinstance(arg_choices, ChoicesCallable) and arg_choices.is_completer:
             args.extend([text, line, begidx, endidx])
-            results = arg_choices.to_call(*args, **kwargs)  # type: ignore[arg-type]
+            results = arg_choices.completer(*args, **kwargs)  # type: ignore[arg-type]
 
         # Otherwise use basic_complete on the choices
         else:
             # Check if the choices come from a function
-            completion_items: List[str]
+            completion_items: List[str] = []
             if isinstance(arg_choices, ChoicesCallable):
                 if not arg_choices.is_completer:
-                    completion_items = arg_choices.to_call(*args, **kwargs)  # type: ignore[arg-type]
-                else:
-                    completion_items = []
+                    choices_func = arg_choices.choices_provider
+                    if isinstance(choices_func, ChoicesProviderFuncWithTokens):
+                        completion_items = choices_func(*args, **kwargs)  # type: ignore[arg-type]
+                    else:  # pragma: no cover
+                        # This won't hit because runtime checking doesn't check function argument types and will always
+                        # resolve true above. Mypy, however, does see the difference and gives an error that can't be
+                        # ignored. Mypy issue #5485 discusses this problem
+                        completion_items = choices_func(*args)  # type: ignore[arg-type]
+                # else case is already covered above
             else:
                 completion_items = arg_choices
 

cmd2/argparse_custom.py

@@ -214,7 +214,7 @@ def my_completer(self, text, line, begidx, endidx, arg_tokens)
     Sequence,
     Tuple,
     Type,
-    Union, runtime_checkable,
+    Union,
 )
 
 from . import (
@@ -225,10 +225,12 @@ def my_completer(self, text, line, begidx, endidx, arg_tokens)
 try:
     from typing import (
         Protocol,
+        runtime_checkable,
     )
 except ImportError:
     from typing_extensions import (  # type: ignore[misc]
         Protocol,
+        runtime_checkable,
     )
 
 ############################################################################################################
@@ -359,6 +361,7 @@ def __call__(
 
 CompleterFunc = Union[CompleterFuncBase, CompleterFuncWithTokens]
 
+
 class ChoicesCallable:
     """
     Enables using a callable as the choices provider for an argparse argument.
@@ -377,10 +380,35 @@ def __init__(
         :param to_call: the callable object that will be called to provide choices for the argument
         """
         self.is_completer = is_completer
-        if not isinstance(to_call, (CompleterFuncBase, CompleterFuncWithTokens)):
-            raise ValueError('With is_completer set to true, to_call must be either CompleterFunc, CompleterFuncWithTokens')
+        if is_completer:
+            if not isinstance(to_call, (CompleterFuncBase, CompleterFuncWithTokens)):  # pragma: no cover
+                # runtime checking of Protocols do not currently check the parameters of a function.
+                raise ValueError(
+                    'With is_completer set to true, to_call must be either CompleterFunc, CompleterFuncWithTokens'
+                )
+        else:
+            if not isinstance(to_call, (ChoicesProviderFuncBase, ChoicesProviderFuncWithTokens)):  # pragma: no cover
+                # runtime checking of Protocols do not currently check the parameters of a function.
+                raise ValueError(
+                    'With is_completer set to false, to_call must be either: '
+                    'ChoicesProviderFuncBase, ChoicesProviderFuncWithTokens'
+                )
         self.to_call = to_call
 
+    @property
+    def completer(self) -> CompleterFunc:
+        if not isinstance(self.to_call, (CompleterFuncBase, CompleterFuncWithTokens)):  # pragma: no cover
+            # this should've been caught in the constructor, just a backup check
+            raise ValueError('Function is not a CompleterFunc')
+        return self.to_call
+
+    @property
+    def choices_provider(self) -> ChoicesProviderFunc:
+        if not isinstance(self.to_call, (ChoicesProviderFuncBase, ChoicesProviderFuncWithTokens)):  # pragma: no cover
+            # this should've been caught in the constructor, just a backup check
+            raise ValueError('Function is not a ChoicesProviderFunc')
+        return self.to_call
+
 
 def _set_choices_callable(action: argparse.Action, choices_callable: ChoicesCallable) -> None:
     """

cmd2/cmd2.py

@@ -80,7 +80,6 @@
     DEFAULT_ARGUMENT_PARSER,
     ChoicesProviderFunc,
     CompleterFunc,
-    CompleterFuncWithTokens,
     CompletionItem,
 )
 from .clipboard import (
@@ -3706,11 +3705,12 @@ def select(self, opts: Union[str, List[str], List[Tuple[Any, Optional[str]]]], p
           | a list of tuples -> interpreted as (value, text), so
                                 that the return value can differ from
                                 the text advertised to the user"""
-
-        local_opts = opts
+        local_opts: Union[List[str], List[Tuple[Any, Optional[str]]]]
         if isinstance(opts, str):
-            local_opts = list(zip(opts.split(), opts.split()))
-        fulloptions = []
+            local_opts = cast(List[Tuple[Any, Optional[str]]], list(zip(opts.split(), opts.split())))
+        else:
+            local_opts = opts
+        fulloptions: List[Tuple[Any, Optional[str]]] = []
         for opt in local_opts:
             if isinstance(opt, str):
                 fulloptions.append((opt, opt))
@@ -3739,7 +3739,7 @@ def select(self, opts: Union[str, List[str], List[Tuple[Any, Optional[str]]]], p
                 choice = int(response)
                 if choice < 1:
                     raise IndexError
-                return fulloptions[choice - 1][0]
+                return str(fulloptions[choice - 1][0])
             except (ValueError, IndexError):
                 self.poutput("{!r} isn't a valid choice. Pick a number between 1 and {}:".format(response, len(fulloptions)))
 
@@ -4192,18 +4192,16 @@ def do_ipy(self, _: argparse.Namespace) -> Optional[bool]:  # pragma: no cover
         """
         # Detect whether IPython is installed
         try:
-            from IPython import (
+            import traitlets.config.loader as TraitletsLoader  # type: ignore[import]
+            from IPython import (  # type: ignore[import]
                 start_ipython,
             )
-            from IPython.terminal.interactiveshell import (
+            from IPython.terminal.interactiveshell import (  # type: ignore[import]
                 TerminalInteractiveShell,
             )
-            from IPython.terminal.ipapp import (
+            from IPython.terminal.ipapp import (  # type: ignore[import]
                 TerminalIPythonApp,
             )
-            from traitlets.config.loader import (
-                Config as TraitletsConfig,
-            )
         except ImportError:
             self.perror("IPython package is not installed")
             return None
@@ -4229,7 +4227,7 @@ def do_ipy(self, _: argparse.Namespace) -> Optional[bool]:  # pragma: no cover
                 local_vars['self'] = self
 
             # Configure IPython
-            config = TraitletsConfig()
+            config = TraitletsLoader.Config()
             config.InteractiveShell.banner2 = (
                 'Entering an IPython shell. Type exit, quit, or Ctrl-D to exit.\n'
                 f'Run CLI commands with: {self.py_bridge_name}("command ...")\n'
@@ -5210,10 +5208,11 @@ def register_cmdfinalization_hook(
         self._validate_cmdfinalization_callable(func)
         self._cmdfinalization_hooks.append(func)
 
-    def _resolve_func_self(self,
-                           cmd_support_func: Callable[..., Any],
-                           cmd_self: Union[CommandSet, 'Cmd', None],
-                           ) -> Optional[object]:
+    def _resolve_func_self(
+        self,
+        cmd_support_func: Callable[..., Any],
+        cmd_self: Union[CommandSet, 'Cmd', None],
+    ) -> Optional[object]:
         """
         Attempt to resolve a candidate instance to pass as 'self' for an unbound class method that was
         used when defining command's argparse object. Since we restrict registration to only a single CommandSet

cmd2/decorators.py

@@ -8,8 +8,9 @@
     Dict,
     List,
     Optional,
+    Sequence,
     Tuple,
-    Union, Sequence, runtime_checkable, Protocol,
+    Union,
 )
 
 from . import (
@@ -106,7 +107,7 @@ def _arg_swap(args: Union[Sequence[Any]], search_arg: Any, *replace_arg: Any) ->
     """
     index = args.index(search_arg)
     args_list = list(args)
-    args_list[index: index + 1] = replace_arg
+    args_list[index : index + 1] = replace_arg
     return args_list
 
 
@@ -134,11 +135,10 @@ def _arg_swap(args: Union[Sequence[Any]], search_arg: Any, *replace_arg: Any) ->
 
 
 def with_argument_list(
-    func_arg: Optional[ArgListCommandFunc] = None, *, preserve_quotes: bool = False,
-) -> Union[
-    RawCommandFuncOptionalBoolReturn,
-    Callable[[ArgListCommandFunc], RawCommandFuncOptionalBoolReturn]
-]:
+    func_arg: Optional[ArgListCommandFunc] = None,
+    *,
+    preserve_quotes: bool = False,
+) -> Union[RawCommandFuncOptionalBoolReturn, Callable[[ArgListCommandFunc], RawCommandFuncOptionalBoolReturn]]:
     """
     A decorator to alter the arguments passed to a ``do_*`` method. Default
     passes a string of whatever the user typed. With this decorator, the
@@ -166,6 +166,7 @@ def arg_decorator(func: ArgListCommandFunc) -> RawCommandFuncOptionalBoolReturn:
         :param func: The defined argument list command function
         :return: Function that takes raw input and converts to an argument list to pass to the wrapped function.
         """
+
         @functools.wraps(func)
         def cmd_wrapper(*args: Any, **kwargs: Any) -> Optional[bool]:
             """
@@ -182,7 +183,7 @@ def cmd_wrapper(*args: Any, **kwargs: Any) -> Optional[bool]:
             args_list = _arg_swap(args, statement, parsed_arglist)
             return func(*args_list, **kwargs)  # type: ignore[call-arg]
 
-        command_name = func.__name__[len(constants.COMMAND_FUNC_PREFIX):]
+        command_name = func.__name__[len(constants.COMMAND_FUNC_PREFIX) :]
         cmd_wrapper.__doc__ = func.__doc__
         return cmd_wrapper
 

cmd2/history.py

@@ -9,8 +9,11 @@
 )
 from typing import (
     Callable,
+    Iterable,
+    List,
     Optional,
-    Union, List, Iterable, overload,
+    Union,
+    overload,
 )
 
 import attr
@@ -124,22 +127,19 @@ def _zero_based_index(self, onebased: Union[int, str]) -> int:
 
     @overload
     def append(self, new: HistoryItem) -> None:
-        ...
+        ...  # pragma: no cover
 
     @overload
     def append(self, new: Statement) -> None:
-        ...
+        ...  # pragma: no cover
 
     def append(self, new: Union[Statement, HistoryItem]) -> None:
         """Append a new statement to the end of the History list.
 
         :param new: Statement object which will be composed into a HistoryItem
                     and added to the end of the list
         """
-        if isinstance(new, Statement):
-            history_item = HistoryItem(new)
-        else:
-            history_item = new
+        history_item = HistoryItem(new) if isinstance(new, Statement) else new
         super(History, self).append(history_item)
 
     def clear(self) -> None: