More things to make mypy happy.

Author: anselor

cmd2/argparse_custom.py

@@ -872,7 +872,7 @@ def __init__(
         usage: Optional[str] = None,
         description: Optional[str] = None,
         epilog: Optional[str] = None,
-        parents: Sequence[argparse.ArgumentParser] = [],
+        parents: Sequence[argparse.ArgumentParser] = (),
         formatter_class: Type[argparse.HelpFormatter] = Cmd2HelpFormatter,
         prefix_chars: str = '-',
         fromfile_prefix_chars: Optional[str] = None,
@@ -989,7 +989,7 @@ class Cmd2AttributeWrapper:
     arguments from a parser and which were added by cmd2.
     """
 
-    def __init__(self, attribute: Any):
+    def __init__(self, attribute: Any) -> None:
         self.__attribute = attribute
 
     def get(self) -> Any:

cmd2/cmd2.py

@@ -3,6 +3,7 @@
 Supports the definition of commands in separate classes to be composed into cmd2.Cmd
 """
 from typing import (
+    Callable,
     Dict,
     Mapping,
     Optional,
@@ -33,7 +34,12 @@
     pass
 
 
-def with_default_category(category: str, *, heritable: bool = True):
+#: Callable signature for a basic command  function
+#: Further refinements are needed to define the input parameters
+CommandFunc = Callable[..., Optional[bool]]
+
+
+def with_default_category(category: str, *, heritable: bool = True) -> Callable[[Type['CommandSet']], Type['CommandSet']]:
     """
     Decorator that applies a category to all ``do_*`` command methods in a class that do not already
     have a category specified.
@@ -52,7 +58,7 @@ def with_default_category(category: str, *, heritable: bool = True):
     :return: decorator function
     """
 
-    def decorate_class(cls: Type[CommandSet]):
+    def decorate_class(cls: Type[CommandSet]) -> Type[CommandSet]:
         if heritable:
             setattr(cls, CLASS_ATTR_DEFAULT_HELP_CATEGORY, category)
 
@@ -93,19 +99,18 @@ class CommandSet(object):
     ``do_``, ``help_``, and ``complete_`` functions differ only in that self is the CommandSet instead of the cmd2 app
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._cmd: Optional[cmd2.Cmd] = None
         self._settables: Dict[str, Settable] = {}
         self._settable_prefix = self.__class__.__name__
 
-    def on_register(self, cmd) -> None:
+    def on_register(self, cmd: 'cmd2.Cmd') -> None:
         """
         Called by cmd2.Cmd as the first step to registering a CommandSet. The commands defined in this class have
         not be added to the CLI object at this point. Subclasses can override this to perform any initialization
         requiring access to the Cmd object (e.g. configure commands and their parsers based on CLI state data).
 
         :param cmd: The cmd2 main application
-        :type cmd: cmd2.Cmd
         """
         if self._cmd is None:
             self._cmd = cmd

cmd2/command_definition.py

@@ -6,7 +6,6 @@
     Any,
     Callable,
     Dict,
-    Iterable,
     List,
     Optional,
     Tuple,
@@ -19,6 +18,10 @@
 from .argparse_custom import (
     Cmd2AttributeWrapper,
 )
+from .command_definition import (
+    CommandFunc,
+    CommandSet,
+)
 from .exceptions import (
     Cmd2ArgparseError,
 )
@@ -30,7 +33,7 @@
     import cmd2
 
 
-def with_category(category: str) -> Callable:
+def with_category(category: str) -> Callable[[CommandFunc], CommandFunc]:
     """A decorator to apply a category to a ``do_*`` command method.
 
     :param category: the name of the category in which this command should
@@ -47,7 +50,7 @@ def with_category(category: str) -> Callable:
     :func:`~cmd2.utils.categorize`
     """
 
-    def cat_decorator(func):
+    def cat_decorator(func: CommandFunc) -> CommandFunc:
         from .utils import (
             categorize,
         )
@@ -65,7 +68,7 @@ def cat_decorator(func):
 ##########################
 
 
-def _parse_positionals(args: Tuple) -> Tuple[Union['cmd2.Cmd', 'cmd2.CommandSet'], Union[Statement, str]]:
+def _parse_positionals(args: Tuple[Any, ...]) -> Tuple['cmd2.Cmd', Union[Statement, str]]:
     """
     Helper function for cmd2 decorators to inspect the positional arguments until the cmd2.Cmd argument is found
     Assumes that we will find cmd2.Cmd followed by the command statement object or string.
@@ -75,7 +78,6 @@ def _parse_positionals(args: Tuple) -> Tuple[Union['cmd2.Cmd', 'cmd2.CommandSet'
     for pos, arg in enumerate(args):
         from cmd2 import (
             Cmd,
-            CommandSet,
         )
 
         if (isinstance(arg, Cmd) or isinstance(arg, CommandSet)) and len(args) > pos:
@@ -104,13 +106,15 @@ def _arg_swap(args: Union[Tuple[Any], List[Any]], search_arg: Any, *replace_arg:
     return args_list
 
 
-def with_argument_list(*args: List[Callable], preserve_quotes: bool = False) -> Callable[[List], Optional[bool]]:
+def with_argument_list(
+    func_arg: Optional[Callable[[List[str]], Optional[bool]]] = None, *, preserve_quotes: bool = False
+) -> Union[Callable[[List[str]], Optional[bool]],]:
     """
     A decorator to alter the arguments passed to a ``do_*`` method. Default
     passes a string of whatever the user typed. With this decorator, the
     decorated method will receive a list of arguments parsed from user input.
 
-    :param args: Single-element positional argument list containing ``do_*`` method
+    :param func_arg: Single-element positional argument list containing ``do_*`` method
                  this decorator is wrapping
     :param preserve_quotes: if ``True``, then argument quotes will not be stripped
     :return: function that gets passed a list of argument strings
@@ -124,9 +128,9 @@ def with_argument_list(*args: List[Callable], preserve_quotes: bool = False) ->
     """
     import functools
 
-    def arg_decorator(func: Callable):
+    def arg_decorator(func: Callable[[List[str]], Optional[bool]]) -> Callable[..., Optional[bool]]:
         @functools.wraps(func)
-        def cmd_wrapper(*args, **kwargs: Dict[str, Any]) -> Optional[bool]:
+        def cmd_wrapper(*args: Any, **kwargs: Any) -> Optional[bool]:
             """
             Command function wrapper which translates command line into an argument list and calls actual command function
 
@@ -145,9 +149,9 @@ def cmd_wrapper(*args, **kwargs: Dict[str, Any]) -> Optional[bool]:
         cmd_wrapper.__doc__ = func.__doc__
         return cmd_wrapper
 
-    if len(args) == 1 and callable(args[0]):
+    if callable(func_arg):
         # noinspection PyTypeChecker
-        return arg_decorator(args[0])
+        return arg_decorator(func_arg)
     else:
         # noinspection PyTypeChecker
         return arg_decorator
@@ -196,13 +200,30 @@ def _set_parser_prog(parser: argparse.ArgumentParser, prog: str):
             break
 
 
+ArgparseCommandFunc = Union[
+    Callable[['cmd2.Cmd', argparse.Namespace], Optional[bool]],
+    Callable[[CommandSet, argparse.Namespace], Optional[bool]],
+]
+ArgparseCommandFuncBoolReturn = Union[
+    Callable[['cmd2.Cmd', argparse.Namespace], bool],
+    Callable[[CommandSet, argparse.Namespace], bool],
+]
+ArgparseCommandFuncNoneReturn = Union[
+    Callable[['cmd2.Cmd', argparse.Namespace], None],
+    Callable[[CommandSet, argparse.Namespace], None],
+]
+
+
 def with_argparser(
     parser: argparse.ArgumentParser,
     *,
     ns_provider: Optional[Callable[..., argparse.Namespace]] = None,
     preserve_quotes: bool = False,
-    with_unknown_args: bool = False
-) -> Callable[[argparse.Namespace], Optional[bool]]:
+    with_unknown_args: bool = False,
+) -> Callable[
+    [Union[ArgparseCommandFunc, ArgparseCommandFuncNoneReturn, ArgparseCommandFuncBoolReturn]],
+    Callable[[Union['cmd2.Cmd', CommandSet], str], Optional[bool]],
+]:
     """A decorator to alter a cmd2 method to populate its ``args`` argument by parsing arguments
     with the given instance of argparse.ArgumentParser.
 
@@ -248,7 +269,9 @@ def with_argparser(
     """
     import functools
 
-    def arg_decorator(func: Callable):
+    def arg_decorator(
+        func: Union[ArgparseCommandFunc, ArgparseCommandFuncBoolReturn, ArgparseCommandFuncNoneReturn],
+    ) -> ArgparseCommandFunc:
         @functools.wraps(func)
         def cmd_wrapper(*args: Any, **kwargs: Dict[str, Any]) -> Optional[bool]:
             """
@@ -327,8 +350,11 @@ def as_subcommand_to(
     parser: argparse.ArgumentParser,
     *,
     help: Optional[str] = None,
-    aliases: Iterable[str] = None
-) -> Callable[[argparse.Namespace], Optional[bool]]:
+    aliases: Optional[List[str]] = None,
+) -> Callable[
+    [Union[ArgparseCommandFunc, ArgparseCommandFuncNoneReturn, ArgparseCommandFuncBoolReturn]],
+    Union[ArgparseCommandFunc, ArgparseCommandFuncBoolReturn, ArgparseCommandFuncNoneReturn],
+]:
     """
     Tag this method as a subcommand to an existing argparse decorated command.
 
@@ -342,7 +368,9 @@ def as_subcommand_to(
     :return: Wrapper function that can receive an argparse.Namespace
     """
 
-    def arg_decorator(func: Callable):
+    def arg_decorator(
+        func: Union[ArgparseCommandFunc, ArgparseCommandFuncBoolReturn, ArgparseCommandFuncNoneReturn]
+    ) -> Union[ArgparseCommandFunc, ArgparseCommandFuncBoolReturn, ArgparseCommandFuncNoneReturn]:
         _set_parser_prog(parser, command + ' ' + subcommand)
 
         # If the description has not been set, then use the method docstring if one exists
@@ -355,10 +383,10 @@ def arg_decorator(func: Callable):
         setattr(func, constants.SUBCMD_ATTR_NAME, subcommand)
 
         # Keyword arguments for ArgumentParser.add_subparser()
-        add_parser_kwargs = dict()
+        add_parser_kwargs: Dict[str, Any] = dict()
         if help is not None:
             add_parser_kwargs['help'] = help
-        if aliases is not None:
+        if aliases:
             add_parser_kwargs['aliases'] = aliases[:]
 
         setattr(func, constants.SUBCMD_ATTR_ADD_PARSER_KWARGS, add_parser_kwargs)

cmd2/decorators.py

@@ -35,7 +35,7 @@ def shlex_split(str_to_split: str) -> List[str]:
     return shlex.split(str_to_split, comments=False, posix=False)
 
 
-@attr.s(frozen=True)
+@attr.s(auto_attribs=True, frozen=True)
 class MacroArg:
     """
     Information used to replace or unescape arguments in a macro value when the macro is resolved
@@ -44,15 +44,15 @@ class MacroArg:
     """
 
     # The starting index of this argument in the macro value
-    start_index = attr.ib(validator=attr.validators.instance_of(int))
+    start_index: int = attr.ib(validator=attr.validators.instance_of(int))
 
     # The number string that appears between the braces
     # This is a string instead of an int because we support unicode digits and must be able
     # to reproduce this string later
-    number_str = attr.ib(validator=attr.validators.instance_of(str))
+    number_str: str = attr.ib(validator=attr.validators.instance_of(str))
 
     # Tells if this argument is escaped and therefore needs to be unescaped
-    is_escaped = attr.ib(validator=attr.validators.instance_of(bool))
+    is_escaped: bool = attr.ib(validator=attr.validators.instance_of(bool))
 
     # Pattern used to find normal argument
     # Digits surrounded by exactly 1 brace on a side and 1 or more braces on the opposite side
@@ -68,24 +68,24 @@ class MacroArg:
     digit_pattern = re.compile(r'\d+')
 
 
-@attr.s(frozen=True)
+@attr.s(auto_attribs=True, frozen=True)
 class Macro:
     """Defines a cmd2 macro"""
 
     # Name of the macro
-    name = attr.ib(validator=attr.validators.instance_of(str))
+    name: str = attr.ib(validator=attr.validators.instance_of(str))
 
     # The string the macro resolves to
-    value = attr.ib(validator=attr.validators.instance_of(str))
+    value: str = attr.ib(validator=attr.validators.instance_of(str))
 
     # The minimum number of args the user has to pass to this macro
-    minimum_arg_count = attr.ib(validator=attr.validators.instance_of(int))
+    minimum_arg_count: int = attr.ib(validator=attr.validators.instance_of(int))
 
     # Used to fill in argument placeholders in the macro
-    arg_list = attr.ib(default=attr.Factory(list), validator=attr.validators.instance_of(list))
+    arg_list: List[MacroArg] = attr.ib(default=attr.Factory(list), validator=attr.validators.instance_of(list))
 
 
-@attr.s(frozen=True)
+@attr.s(auto_attribs=True, frozen=True)
 class Statement(str):
     """String subclass with additional attributes to store the results of parsing.
 
@@ -117,34 +117,34 @@ class Statement(str):
     """
 
     # the arguments, but not the command, nor the output redirection clauses.
-    args = attr.ib(default='', validator=attr.validators.instance_of(str))
+    args: str = attr.ib(default='', validator=attr.validators.instance_of(str))
 
     # string containing exactly what we input by the user
-    raw = attr.ib(default='', validator=attr.validators.instance_of(str))
+    raw: str = attr.ib(default='', validator=attr.validators.instance_of(str))
 
     # the command, i.e. the first whitespace delimited word
-    command = attr.ib(default='', validator=attr.validators.instance_of(str))
+    command: str = attr.ib(default='', validator=attr.validators.instance_of(str))
 
     # list of arguments to the command, not including any output redirection or terminators; quoted args remain quoted
-    arg_list = attr.ib(default=attr.Factory(list), validator=attr.validators.instance_of(list))
+    arg_list: List[str] = attr.ib(default=attr.Factory(list), validator=attr.validators.instance_of(list))
 
     # if the command is a multiline command, the name of the command, otherwise empty
-    multiline_command = attr.ib(default='', validator=attr.validators.instance_of(str))
+    multiline_command: str = attr.ib(default='', validator=attr.validators.instance_of(str))
 
     # the character which terminated the multiline command, if there was one
-    terminator = attr.ib(default='', validator=attr.validators.instance_of(str))
+    terminator: str = attr.ib(default='', validator=attr.validators.instance_of(str))
 
     # characters appearing after the terminator but before output redirection, if any
-    suffix = attr.ib(default='', validator=attr.validators.instance_of(str))
+    suffix: str = attr.ib(default='', validator=attr.validators.instance_of(str))
 
     # if output was piped to a shell command, the shell command as a string
-    pipe_to = attr.ib(default='', validator=attr.validators.instance_of(str))
+    pipe_to: str = attr.ib(default='', validator=attr.validators.instance_of(str))
 
     # if output was redirected, the redirection token, i.e. '>>'
-    output = attr.ib(default='', validator=attr.validators.instance_of(str))
+    output: str = attr.ib(default='', validator=attr.validators.instance_of(str))
 
     # if output was redirected, the destination file token (quotes preserved)
-    output_to = attr.ib(default='', validator=attr.validators.instance_of(str))
+    output_to: str = attr.ib(default='', validator=attr.validators.instance_of(str))
 
     def __new__(cls, value: object, *pos_args, **kw_args):
         """Create a new instance of Statement.

cmd2/parsing.py

@@ -1,6 +1,10 @@
 #
 # coding=utf-8
 """Classes for the cmd2 plugin system"""
+from typing import (
+    Optional,
+)
+
 import attr
 
 from .parsing import (
@@ -36,4 +40,4 @@ class CommandFinalizationData:
     """Data class containing information passed to command finalization hook methods"""
 
     stop: bool
-    statement: Statement
+    statement: Optional[Statement]