cmd2 2.4.2__py3-none-any.whl → 2.5.9__py3-none-any.whl

cmd2/command_definition.py

@@ -2,6 +2,7 @@
 """
 Supports the definition of commands in separate classes to be composed into cmd2.Cmd
 """
+
 from typing import (
     TYPE_CHECKING,
     Callable,
@@ -9,6 +10,7 @@ from typing import (
     Mapping,
     Optional,
     Type,
+    TypeVar,
 )
 
 from .constants import (
@@ -29,8 +31,10 @@ if TYPE_CHECKING:  # pragma: no cover
 #: Further refinements are needed to define the input parameters
 CommandFunc = Callable[..., Optional[bool]]
 
+CommandSetType = TypeVar('CommandSetType', bound=Type['CommandSet'])
+
 
-def with_default_category(category: str, *, heritable: bool = True) -> Callable[[Type['CommandSet']], Type['CommandSet']]:
+def with_default_category(category: str, *, heritable: bool = True) -> Callable[[CommandSetType], CommandSetType]:
     """
     Decorator that applies a category to all ``do_*`` command methods in a class that do not already
     have a category specified.
@@ -41,7 +45,7 @@ def with_default_category(category: str, *, heritable: bool = True) -> Callable[
     override the default category.
 
     If `heritable` is set to False, then only the commands declared locally to this CommandSet will be placed in the
-    specified category. Dynamically created commands, and commands declared in sub-classes will not receive this
+    specified category. Dynamically created commands and commands declared in sub-classes will not receive this
     category.
 
     :param category: category to put all uncategorized commands in
@@ -49,7 +53,7 @@ def with_default_category(category: str, *, heritable: bool = True) -> Callable[
     :return: decorator function
     """
 
-    def decorate_class(cls: Type[CommandSet]) -> Type[CommandSet]:
+    def decorate_class(cls: CommandSetType) -> CommandSetType:
         if heritable:
             setattr(cls, CLASS_ATTR_DEFAULT_HELP_CATEGORY, category)
 
@@ -91,10 +95,31 @@ class CommandSet(object):
     """
 
     def __init__(self) -> None:
-        self._cmd: Optional[cmd2.Cmd] = None
+        # Private reference to the CLI instance in which this CommandSet running.
+        # This will be set when the CommandSet is registered and it should be
+        # accessed by child classes using the self._cmd property.
+        self.__cmd_internal: Optional[cmd2.Cmd] = None
+
         self._settables: Dict[str, Settable] = {}
         self._settable_prefix = self.__class__.__name__
 
+    @property
+    def _cmd(self) -> 'cmd2.Cmd':
+        """
+        Property for child classes to access self.__cmd_internal.
+
+        Using this property ensures that self.__cmd_internal has been set
+        and it tells type checkers that it's no longer a None type.
+
+        Override this property if you need to change its return type to a
+        child class of Cmd.
+
+        :raises: CommandSetRegistrationError if CommandSet is not registered.
+        """
+        if self.__cmd_internal is None:
+            raise CommandSetRegistrationError('This CommandSet is not registered')
+        return self.__cmd_internal
+
     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
@@ -102,9 +127,10 @@ class CommandSet(object):
         requiring access to the Cmd object (e.g. configure commands and their parsers based on CLI state data).
 
         :param cmd: The cmd2 main application
+        :raises: CommandSetRegistrationError if CommandSet is already registered.
         """
-        if self._cmd is None:
-            self._cmd = cmd
+        if self.__cmd_internal is None:
+            self.__cmd_internal = cmd
         else:
             raise CommandSetRegistrationError('This CommandSet has already been registered')
 
@@ -128,7 +154,7 @@ class CommandSet(object):
         Called by ``cmd2.Cmd`` after a CommandSet has been unregistered and all its commands removed from the CLI.
         Subclasses can override this to perform remaining cleanup steps.
         """
-        self._cmd = None
+        self.__cmd_internal = None
 
     @property
     def settable_prefix(self) -> str:
@@ -144,7 +170,7 @@ class CommandSet(object):
 
         :param settable: Settable object being added
         """
-        if self._cmd:
+        if self.__cmd_internal is not None:
             if not self._cmd.always_prefix_settables:
                 if settable.name in self._cmd.settables.keys() and settable.name not in self._settables.keys():
                     raise KeyError(f'Duplicate settable: {settable.name}')
@@ -165,3 +191,12 @@ class CommandSet(object):
             del self._settables[name]
         except KeyError:
             raise KeyError(name + " is not a settable parameter")
+
+    def sigint_handler(self) -> bool:
+        """
+        Handle a SIGINT that occurred for a command in this CommandSet.
+
+        :return: True if this completes the interrupt handling and no KeyboardInterrupt will be raised.
+                 False to raise a KeyboardInterrupt.
+        """
+        return False

cmd2/constants.py

@@ -57,3 +57,6 @@ PARSER_ATTR_COMMANDSET = 'command_set'
 
 # custom attributes added to argparse Namespaces
 NS_ATTR_SUBCMD_HANDLER = '__subcmd_handler__'
+
+# For cases prior to Python 3.11 when shutil.get_terminal_size().columns can return 0.
+DEFAULT_TERMINAL_WIDTH = 80

cmd2/decorators.py

@@ -1,5 +1,6 @@
 # coding=utf-8
 """Decorators for ``cmd2`` commands"""
+
 import argparse
 from typing import (
     TYPE_CHECKING,
@@ -10,6 +11,8 @@ from typing import (
     Optional,
     Sequence,
     Tuple,
+    Type,
+    TypeVar,
     Union,
 )
 
@@ -29,9 +32,6 @@ from .exceptions import (
 from .parsing import (
     Statement,
 )
-from .utils import (
-    strip_doc_annotations,
-)
 
 if TYPE_CHECKING:  # pragma: no cover
     import cmd2
@@ -43,15 +43,17 @@ def with_category(category: str) -> Callable[[CommandFunc], CommandFunc]:
     :param category: the name of the category in which this command should
                      be grouped when displaying the list of commands.
 
-    :Example:
+    Example:
 
-    >>> class MyApp(cmd2.Cmd):
-    >>>   @cmd2.with_category('Text Functions')
-    >>>   def do_echo(self, args)
-    >>>     self.poutput(args)
+    ```py
+    class MyApp(cmd2.Cmd):
+        @cmd2.with_category('Text Functions')
+        def do_echo(self, args)
+            self.poutput(args)
+    ```
 
     For an alternative approach to categorizing commands using a function, see
-    :func:`~cmd2.utils.categorize`
+    [cmd2.utils.categorize][]
     """
 
     def cat_decorator(func: CommandFunc) -> CommandFunc:
@@ -65,16 +67,18 @@ def with_category(category: str) -> Callable[[CommandFunc], CommandFunc]:
     return cat_decorator
 
 
+CommandParent = TypeVar('CommandParent', bound=Union['cmd2.Cmd', CommandSet])
+CommandParentType = TypeVar('CommandParentType', bound=Union[Type['cmd2.Cmd'], Type[CommandSet]])
+
+
+RawCommandFuncOptionalBoolReturn = Callable[[CommandParent, Union[Statement, str]], Optional[bool]]
+
+
 ##########################
 # The _parse_positionals and _arg_swap functions allow for additional positional args to be preserved
 # in cmd2 command functions/callables. As long as the 2-ple of arguments we expect to be there can be
 # found we can swap out the statement with each decorator's specific parameters
 ##########################
-
-
-RawCommandFuncOptionalBoolReturn = Callable[[Union[CommandSet, 'cmd2.Cmd'], Union[Statement, str]], Optional[bool]]
-
-
 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
@@ -87,7 +91,7 @@ def _parse_positionals(args: Tuple[Any, ...]) -> Tuple['cmd2.Cmd', Union[Stateme
             Cmd,
         )
 
-        if (isinstance(arg, Cmd) or isinstance(arg, CommandSet)) and len(args) > pos:
+        if isinstance(arg, (Cmd, CommandSet)) and len(args) > pos + 1:
             if isinstance(arg, CommandSet):
                 arg = arg._cmd
             next_arg = args[pos + 1]
@@ -96,7 +100,7 @@ def _parse_positionals(args: Tuple[Any, ...]) -> Tuple['cmd2.Cmd', Union[Stateme
 
     # This shouldn't happen unless we forget to pass statement in `Cmd.onecmd` or
     # somehow call the unbound class method.
-    raise TypeError('Expected arguments: cmd: cmd2.Cmd, statement: Union[Statement, str] Not found')  # pragma: no cover
+    raise TypeError('Expected arguments: cmd: cmd2.Cmd, statement: Union[Statement, str] Not found')
 
 
 def _arg_swap(args: Union[Sequence[Any]], search_arg: Any, *replace_arg: Any) -> List[Any]:
@@ -114,54 +118,53 @@ def _arg_swap(args: Union[Sequence[Any]], search_arg: Any, *replace_arg: Any) ->
     return args_list
 
 
-#: Function signature for an Command Function that accepts a pre-processed argument list from user input
+#: Function signature for a command function that accepts a pre-processed argument list from user input
 #: and optionally returns a boolean
-ArgListCommandFuncOptionalBoolReturn = Union[
-    Callable[['cmd2.Cmd', List[str]], Optional[bool]],
-    Callable[[CommandSet, List[str]], Optional[bool]],
-]
-#: Function signature for an Command Function that accepts a pre-processed argument list from user input
+ArgListCommandFuncOptionalBoolReturn = Callable[[CommandParent, List[str]], Optional[bool]]
+#: Function signature for a command function that accepts a pre-processed argument list from user input
 #: and returns a boolean
-ArgListCommandFuncBoolReturn = Union[
-    Callable[['cmd2.Cmd', List[str]], bool],
-    Callable[[CommandSet, List[str]], bool],
-]
-#: Function signature for an Command Function that accepts a pre-processed argument list from user input
+ArgListCommandFuncBoolReturn = Callable[[CommandParent, List[str]], bool]
+#: Function signature for a command function that accepts a pre-processed argument list from user input
 #: and returns Nothing
-ArgListCommandFuncNoneReturn = Union[
-    Callable[['cmd2.Cmd', List[str]], None],
-    Callable[[CommandSet, List[str]], None],
-]
+ArgListCommandFuncNoneReturn = Callable[[CommandParent, List[str]], None]
 
-#: Aggregate of all accepted function signatures for Command Functions that accept a pre-processed argument list
-ArgListCommandFunc = Union[ArgListCommandFuncOptionalBoolReturn, ArgListCommandFuncBoolReturn, ArgListCommandFuncNoneReturn]
+#: Aggregate of all accepted function signatures for command functions that accept a pre-processed argument list
+ArgListCommandFunc = Union[
+    ArgListCommandFuncOptionalBoolReturn[CommandParent],
+    ArgListCommandFuncBoolReturn[CommandParent],
+    ArgListCommandFuncNoneReturn[CommandParent],
+]
 
 
 def with_argument_list(
-    func_arg: Optional[ArgListCommandFunc] = None,
+    func_arg: Optional[ArgListCommandFunc[CommandParent]] = None,
     *,
     preserve_quotes: bool = False,
-) -> Union[RawCommandFuncOptionalBoolReturn, Callable[[ArgListCommandFunc], RawCommandFuncOptionalBoolReturn]]:
+) -> Union[
+    RawCommandFuncOptionalBoolReturn[CommandParent],
+    Callable[[ArgListCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]],
+]:
     """
     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 func_arg: Single-element positional argument list containing ``do_*`` method
+    :param func_arg: Single-element positional argument list containing ``doi_*`` 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
 
-    :Example:
-
-    >>> class MyApp(cmd2.Cmd):
-    >>>     @cmd2.with_argument_list
-    >>>     def do_echo(self, arglist):
-    >>>         self.poutput(' '.join(arglist)
+    Example:
+    ```py
+    class MyApp(cmd2.Cmd):
+        @cmd2.with_argument_list
+        def do_echo(self, arglist):
+            self.poutput(' '.join(arglist)
+    ```
     """
     import functools
 
-    def arg_decorator(func: ArgListCommandFunc) -> RawCommandFuncOptionalBoolReturn:
+    def arg_decorator(func: ArgListCommandFunc[CommandParent]) -> RawCommandFuncOptionalBoolReturn[CommandParent]:
         """
         Decorator function that ingests an Argument List function and returns a raw command function.
         The returned function will process the raw input into an argument list to be passed to the wrapped function.
@@ -191,14 +194,11 @@ def with_argument_list(
         return cmd_wrapper
 
     if callable(func_arg):
-        # noinspection PyTypeChecker
         return arg_decorator(func_arg)
     else:
-        # noinspection PyTypeChecker
         return arg_decorator
 
 
-# noinspection PyProtectedMember
 def _set_parser_prog(parser: argparse.ArgumentParser, prog: str) -> None:
     """
     Recursively set prog attribute of a parser and all of its subparsers so that the root command
@@ -209,6 +209,7 @@ def _set_parser_prog(parser: argparse.ArgumentParser, prog: str) -> None:
     """
     # Set the prog value for this parser
     parser.prog = prog
+    req_args: List[str] = []
 
     # Set the prog value for the parser's subcommands
     for action in parser._actions:
@@ -233,94 +234,107 @@ def _set_parser_prog(parser: argparse.ArgumentParser, prog: str) -> None:
                 if subcmd_parser in processed_parsers:
                     continue
 
-                subcmd_prog = parser.prog + ' ' + subcmd_name
+                subcmd_prog = parser.prog
+                if req_args:
+                    subcmd_prog += " " + " ".join(req_args)
+                subcmd_prog += " " + subcmd_name
                 _set_parser_prog(subcmd_parser, subcmd_prog)
                 processed_parsers.append(subcmd_parser)
 
             # We can break since argparse only allows 1 group of subcommands per level
             break
 
+        # Need to save required args so they can be prepended to the subcommand usage
+        elif action.required:
+            req_args.append(action.dest)
 
-#: Function signature for a Command Function that uses an argparse.ArgumentParser to process user input
-#: and optionally returns a boolean
-ArgparseCommandFuncOptionalBoolReturn = Union[
-    Callable[['cmd2.Cmd', argparse.Namespace], Optional[bool]],
-    Callable[[CommandSet, argparse.Namespace], Optional[bool]],
-]
-#: Function signature for a Command Function that uses an argparse.ArgumentParser to process user input
-#: and returns a boolean
-ArgparseCommandFuncBoolReturn = Union[
-    Callable[['cmd2.Cmd', argparse.Namespace], bool],
-    Callable[[CommandSet, argparse.Namespace], bool],
-]
-#: Function signature for an Command Function that uses an argparse.ArgumentParser to process user input
-#: and returns nothing
-ArgparseCommandFuncNoneReturn = Union[
-    Callable[['cmd2.Cmd', argparse.Namespace], None],
-    Callable[[CommandSet, argparse.Namespace], None],
-]
 
-#: Aggregate of all accepted function signatures for an argparse Command Function
+#: Function signatures for command functions that use an argparse.ArgumentParser to process user input
+#: and optionally return a boolean
+ArgparseCommandFuncOptionalBoolReturn = Callable[[CommandParent, argparse.Namespace], Optional[bool]]
+ArgparseCommandFuncWithUnknownArgsOptionalBoolReturn = Callable[[CommandParent, argparse.Namespace, List[str]], Optional[bool]]
+
+#: Function signatures for command functions that use an argparse.ArgumentParser to process user input
+#: and return a boolean
+ArgparseCommandFuncBoolReturn = Callable[[CommandParent, argparse.Namespace], bool]
+ArgparseCommandFuncWithUnknownArgsBoolReturn = Callable[[CommandParent, argparse.Namespace, List[str]], bool]
+
+#: Function signatures for command functions that use an argparse.ArgumentParser to process user input
+#: and return nothing
+ArgparseCommandFuncNoneReturn = Callable[[CommandParent, argparse.Namespace], None]
+ArgparseCommandFuncWithUnknownArgsNoneReturn = Callable[[CommandParent, argparse.Namespace, List[str]], None]
+
+#: Aggregate of all accepted function signatures for an argparse command function
 ArgparseCommandFunc = Union[
-    ArgparseCommandFuncOptionalBoolReturn,
-    ArgparseCommandFuncBoolReturn,
-    ArgparseCommandFuncNoneReturn,
+    ArgparseCommandFuncOptionalBoolReturn[CommandParent],
+    ArgparseCommandFuncWithUnknownArgsOptionalBoolReturn[CommandParent],
+    ArgparseCommandFuncBoolReturn[CommandParent],
+    ArgparseCommandFuncWithUnknownArgsBoolReturn[CommandParent],
+    ArgparseCommandFuncNoneReturn[CommandParent],
+    ArgparseCommandFuncWithUnknownArgsNoneReturn[CommandParent],
 ]
 
 
 def with_argparser(
-    parser: argparse.ArgumentParser,
+    parser: Union[
+        argparse.ArgumentParser,  # existing parser
+        Callable[[], argparse.ArgumentParser],  # function or staticmethod
+        Callable[[CommandParentType], argparse.ArgumentParser],  # Cmd or CommandSet classmethod
+    ],
     *,
     ns_provider: Optional[Callable[..., argparse.Namespace]] = None,
     preserve_quotes: bool = False,
     with_unknown_args: bool = False,
-) -> Callable[[ArgparseCommandFunc], RawCommandFuncOptionalBoolReturn]:
+) -> Callable[[ArgparseCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]]:
     """A decorator to alter a cmd2 method to populate its ``args`` argument by parsing arguments
     with the given instance of argparse.ArgumentParser.
 
-    :param parser: unique instance of ArgumentParser
+    :param parser: unique instance of ArgumentParser or a callable that returns an ArgumentParser
     :param ns_provider: An optional function that accepts a cmd2.Cmd or cmd2.CommandSet object as an argument and returns an
                         argparse.Namespace. This is useful if the Namespace needs to be prepopulated with state data that
                         affects parsing.
     :param preserve_quotes: if ``True``, then arguments passed to argparse maintain their quotes
     :param with_unknown_args: if true, then capture unknown args
     :return: function that gets passed argparse-parsed args in a ``Namespace``
-             A :class:`cmd2.argparse_custom.Cmd2AttributeWrapper` called ``cmd2_statement`` is included
-             in the ``Namespace`` to provide access to the :class:`cmd2.Statement` object that was created when
+             A [cmd2.argparse_custom.Cmd2AttributeWrapper][] called ``cmd2_statement`` is included
+             in the ``Namespace`` to provide access to the [cmd2.Statement][] object that was created when
              parsing the command line. This can be useful if the command function needs to know the command line.
 
-    :Example:
-
-    >>> parser = cmd2.Cmd2ArgumentParser()
-    >>> parser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
-    >>> parser.add_argument('-s', '--shout', action='store_true', help='N00B EMULATION MODE')
-    >>> parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
-    >>> parser.add_argument('words', nargs='+', help='words to print')
-    >>>
-    >>> class MyApp(cmd2.Cmd):
-    >>>     @cmd2.with_argparser(parser, preserve_quotes=True)
-    >>>     def do_argprint(self, args):
-    >>>         "Print the options and argument list this options command was called with."
-    >>>         self.poutput(f'args: {args!r}')
-
-    :Example with unknown args:
-
-    >>> parser = cmd2.Cmd2ArgumentParser()
-    >>> parser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
-    >>> parser.add_argument('-s', '--shout', action='store_true', help='N00B EMULATION MODE')
-    >>> parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
-    >>>
-    >>> class MyApp(cmd2.Cmd):
-    >>>     @cmd2.with_argparser(parser, with_unknown_args=True)
-    >>>     def do_argprint(self, args, unknown):
-    >>>         "Print the options and argument list this options command was called with."
-    >>>         self.poutput(f'args: {args!r}')
-    >>>         self.poutput(f'unknowns: {unknown}')
-
+    Example:
+
+    ```py
+    parser = cmd2.Cmd2ArgumentParser()
+    parser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
+    parser.add_argument('-s', '--shout', action='store_true', help='N00B EMULATION MODE')
+    parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
+    parser.add_argument('words', nargs='+', help='words to print')
+
+    class MyApp(cmd2.Cmd):
+        @cmd2.with_argparser(parser, preserve_quotes=True)
+        def do_argprint(self, args):
+            "Print the options and argument list this options command was called with."
+            self.poutput(f'args: {args!r}')
+    ```
+
+    Example with unknown args:
+
+    ```py
+    parser = cmd2.Cmd2ArgumentParser()
+    parser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
+    parser.add_argument('-s', '--shout', action='store_true', help='N00B EMULATION MODE')
+    parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
+
+    class MyApp(cmd2.Cmd):
+        @cmd2.with_argparser(parser, with_unknown_args=True)
+        def do_argprint(self, args, unknown):
+            "Print the options and argument list this options command was called with."
+            self.poutput(f'args: {args!r}')
+            self.poutput(f'unknowns: {unknown}')
+    ```
     """
     import functools
 
-    def arg_decorator(func: ArgparseCommandFunc) -> RawCommandFuncOptionalBoolReturn:
+    def arg_decorator(func: ArgparseCommandFunc[CommandParent]) -> RawCommandFuncOptionalBoolReturn[CommandParent]:
         """
         Decorator function that ingests an Argparse Command Function and returns a raw command function.
         The returned function will process the raw input into an argparse Namespace to be passed to the wrapped function.
@@ -347,6 +361,12 @@ def with_argparser(
                 command_name, statement_arg, preserve_quotes
             )
 
+            # Pass cmd_wrapper instead of func, since it contains the parser info.
+            arg_parser = cmd2_app._command_parsers.get(cmd_wrapper)
+            if arg_parser is None:
+                # This shouldn't be possible to reach
+                raise ValueError(f'No argument parser found for {command_name}')  # pragma: no cover
+
             if ns_provider is None:
                 namespace = None
             else:
@@ -359,9 +379,9 @@ def with_argparser(
             try:
                 new_args: Union[Tuple[argparse.Namespace], Tuple[argparse.Namespace, List[str]]]
                 if with_unknown_args:
-                    new_args = parser.parse_known_args(parsed_arglist, namespace)
+                    new_args = arg_parser.parse_known_args(parsed_arglist, namespace)
                 else:
-                    new_args = (parser.parse_args(parsed_arglist, namespace),)
+                    new_args = (arg_parser.parse_args(parsed_arglist, namespace),)
                 ns = new_args[0]
             except SystemExit:
                 raise Cmd2ArgparseError
@@ -381,16 +401,7 @@ def with_argparser(
                 args_list = _arg_swap(args, statement_arg, *new_args)
                 return func(*args_list, **kwargs)  # type: ignore[call-arg]
 
-        # argparser defaults the program name to sys.argv[0], but we want it to be the name of our command
         command_name = func.__name__[len(constants.COMMAND_FUNC_PREFIX) :]
-        _set_parser_prog(parser, command_name)
-
-        # If the description has not been set, then use the method docstring if one exists
-        if parser.description is None and func.__doc__:
-            parser.description = strip_doc_annotations(func.__doc__)
-
-        # Set the command's help text as argparser.description (which can be None)
-        cmd_wrapper.__doc__ = parser.description
 
         # Set some custom attributes for this command
         setattr(cmd_wrapper, constants.CMD_ATTR_ARGPARSER, parser)
@@ -398,18 +409,21 @@ def with_argparser(
 
         return cmd_wrapper
 
-    # noinspection PyTypeChecker
     return arg_decorator
 
 
 def as_subcommand_to(
     command: str,
     subcommand: str,
-    parser: argparse.ArgumentParser,
+    parser: Union[
+        argparse.ArgumentParser,  # existing parser
+        Callable[[], argparse.ArgumentParser],  # function or staticmethod
+        Callable[[CommandParentType], argparse.ArgumentParser],  # Cmd or CommandSet classmethod
+    ],
     *,
     help: Optional[str] = None,
     aliases: Optional[List[str]] = None,
-) -> Callable[[ArgparseCommandFunc], ArgparseCommandFunc]:
+) -> Callable[[ArgparseCommandFunc[CommandParent]], ArgparseCommandFunc[CommandParent]]:
     """
     Tag this method as a subcommand to an existing argparse decorated command.
 
@@ -417,25 +431,19 @@ def as_subcommand_to(
     :param subcommand: Subcommand name
     :param parser: argparse Parser for this subcommand
     :param help: Help message for this subcommand which displays in the list of subcommands of the command we are adding to.
-                 This is passed as the help argument to ArgumentParser.add_subparser().
+                 This is passed as the help argument to subparsers.add_parser().
     :param aliases: Alternative names for this subcommand. This is passed as the alias argument to
-                    ArgumentParser.add_subparser().
+                    subparsers.add_parser().
     :return: Wrapper function that can receive an argparse.Namespace
     """
 
-    def arg_decorator(func: ArgparseCommandFunc) -> ArgparseCommandFunc:
-        _set_parser_prog(parser, command + ' ' + subcommand)
-
-        # If the description has not been set, then use the method docstring if one exists
-        if parser.description is None and func.__doc__:
-            parser.description = func.__doc__
-
+    def arg_decorator(func: ArgparseCommandFunc[CommandParent]) -> ArgparseCommandFunc[CommandParent]:
         # Set some custom attributes for this command
         setattr(func, constants.SUBCMD_ATTR_COMMAND, command)
         setattr(func, constants.CMD_ATTR_ARGPARSER, parser)
         setattr(func, constants.SUBCMD_ATTR_NAME, subcommand)
 
-        # Keyword arguments for ArgumentParser.add_subparser()
+        # Keyword arguments for subparsers.add_parser()
         add_parser_kwargs: Dict[str, Any] = dict()
         if help is not None:
             add_parser_kwargs['help'] = help
@@ -446,5 +454,4 @@ def as_subcommand_to(
 
         return func
 
-    # noinspection PyTypeChecker
     return arg_decorator

cmd2/exceptions.py

@@ -61,7 +61,6 @@ class CompletionError(Exception):
         """
         self.apply_style = apply_style
 
-        # noinspection PyArgumentList
         super().__init__(*args)