Minor formatting fixes. Injecting a function into namespace objects before passing to command handlers to access sub-command handlers

Author: anselor

cmd2/argparse_custom.py

@@ -584,7 +584,6 @@ class so cmd2 can remove subcommands from a parser.
         del self.choices[name]
 
 
-
 # noinspection PyProtectedMember
 setattr(argparse._SubParsersAction, 'remove_parser', _SubParsersAction_remove_parser)
 

cmd2/cmd2.py

@@ -413,9 +413,9 @@ def _autoload_commands(self) -> None:
         existing_commandset_types = [type(command_set) for command_set in self._installed_command_sets]
         for cmdset_type in all_commandset_defs:
             init_sig = inspect.signature(cmdset_type.__init__)
-            if not (cmdset_type in existing_commandset_types or
-                    len(init_sig.parameters) != 1 or
-                    'self' not in init_sig.parameters):
+            if not (cmdset_type in existing_commandset_types
+                    or len(init_sig.parameters) != 1
+                    or 'self' not in init_sig.parameters):
                 cmdset = cmdset_type()
                 self.install_command_set(cmdset)
 
@@ -550,7 +550,7 @@ def _check_uninstallable(self, cmdset: CommandSet):
         methods = inspect.getmembers(
             cmdset,
             predicate=lambda meth: isinstance(meth, Callable)
-                                   and hasattr(meth, '__name__') and meth.__name__.startswith(COMMAND_FUNC_PREFIX))
+            and hasattr(meth, '__name__') and meth.__name__.startswith(COMMAND_FUNC_PREFIX))
 
         for method in methods:
             command_name = method[0][len(COMMAND_FUNC_PREFIX):]
@@ -562,6 +562,7 @@ def _check_uninstallable(self, cmdset: CommandSet):
                 command_func = self.cmd_func(command_name)
 
             command_parser = getattr(command_func, constants.CMD_ATTR_ARGPARSER, None)
+
             def check_parser_uninstallable(parser):
                 for action in parser._actions:
                     if isinstance(action, argparse._SubParsersAction):
@@ -621,7 +622,7 @@ def _register_subcommands(self, cmdset: Union[CommandSet, 'Cmd']) -> None:
                 command_handler = _partial_passthru(method, self)
             else:
                 command_handler = method
-            subcmd_parser.set_defaults(handler=command_handler)
+            subcmd_parser.set_defaults(cmd2_handler=command_handler)
 
             def find_subcommand(action: argparse.ArgumentParser, subcmd_names: List[str]) -> argparse.ArgumentParser:
                 if not subcmd_names:
@@ -671,8 +672,8 @@ def _unregister_subcommands(self, cmdset: Union[CommandSet, 'Cmd']) -> None:
                 command_func = self.cmd_func(command_name)
 
             if command_func is None:  # pragma: no cover
-                    # This really shouldn't be possible since _register_subcommands would prevent this from happening
-                    # but keeping in case it does for some strange reason
+                # This really shouldn't be possible since _register_subcommands would prevent this from happening
+                # but keeping in case it does for some strange reason
                 raise CommandSetRegistrationError('Could not find command "{}" needed by subcommand: {}'
                                                   .format(command_name, str(method)))
             command_parser = getattr(command_func, constants.CMD_ATTR_ARGPARSER, None)

cmd2/constants.py

@@ -50,6 +50,9 @@
 # Whether or not tokens are unquoted before sending to argparse
 CMD_ATTR_PRESERVE_QUOTES = 'preserve_quotes'
 
+# optional attribute
+SUBCMD_HANDLER = 'cmd2_handler'
+
 # subcommand attributes for the base command name and the subcommand name
 SUBCMD_ATTR_COMMAND = 'parent_command'
 SUBCMD_ATTR_NAME = 'subcommand_name'

cmd2/decorators.py

@@ -1,6 +1,7 @@
 # coding=utf-8
 """Decorators for ``cmd2`` commands"""
 import argparse
+import types
 from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
 
 from . import constants
@@ -231,6 +232,12 @@ def cmd_wrapper(*args: Tuple[Any, ...], **kwargs: Dict[str, Any]) -> Optional[bo
                 raise Cmd2ArgparseError
             else:
                 setattr(ns, '__statement__', statement)
+
+                def get_handler(self: argparse.Namespace) -> Optional[Callable]:
+                    return getattr(self, constants.SUBCMD_HANDLER, None)
+
+                setattr(ns, 'get_handler', types.MethodType(get_handler, ns))
+
                 args_list = _arg_swap(args, statement, ns, unknown)
                 return func(*args_list, **kwargs)
 
@@ -316,6 +323,12 @@ def cmd_wrapper(*args: Any, **kwargs: Dict[str, Any]) -> Optional[bool]:
                 raise Cmd2ArgparseError
             else:
                 setattr(ns, '__statement__', statement)
+
+                def get_handler(self: argparse.Namespace) -> Optional[Callable]:
+                    return getattr(self, constants.SUBCMD_HANDLER, None)
+
+                setattr(ns, 'get_handler', types.MethodType(get_handler, ns))
+
                 args_list = _arg_swap(args, statement, ns)
                 return func(*args_list, **kwargs)
 

cmd2/exceptions.py

@@ -31,6 +31,7 @@ class CommandSetRegistrationError(Exception):
 # The following exceptions are NOT part of the public API and are intended for internal use only.
 ############################################################################################################
 
+
 class Cmd2ShlexError(Exception):
     """Raised when shlex fails to parse a command line string in StatementParser"""
     pass

docs/features/modular_commands.rst

@@ -314,10 +314,10 @@ command and each CommandSet
 
         @with_argparser(cut_parser)
         def do_cut(self, ns: argparse.Namespace):
-            func = getattr(ns, 'handler', None)
-            if func is not None:
+            handler = ns.get_handler()
+            if handler is not None:
                 # Call whatever subcommand function was selected
-                func(ns)
+                handler(ns)
             else:
                 # No subcommand was provided, so call help
                 self.poutput('This command does nothing without sub-parsers registered')

examples/modular_subcommands.py

@@ -95,10 +95,10 @@ def do_unload(self, ns: argparse.Namespace):
 
     @with_argparser(cut_parser)
     def do_cut(self, ns: argparse.Namespace):
-        func = getattr(ns, 'handler', None)
-        if func is not None:
+        handler = ns.get_handler()
+        if handler is not None:
             # Call whatever subcommand function was selected
-            func(ns)
+            handler(ns)
         else:
             # No subcommand was provided, so call help
             self.poutput('This command does nothing without sub-parsers registered')

isolated_tests/test_commandset/test_commandset.py

@@ -281,13 +281,13 @@ def __init__(self, dummy):
     @cmd2.with_argparser(cut_parser)
     def do_cut(self, cmd: cmd2.Cmd, ns: argparse.Namespace):
         """Cut something"""
-        func = getattr(ns, 'handler', None)
-        if func is not None:
+        handler = ns.get_handler()
+        if handler is not None:
             # Call whatever subcommand function was selected
-            func(ns)
+            handler(ns)
         else:
             # No subcommand was provided, so call help
-            cmd.poutput('This command does nothing without sub-parsers registered')
+            cmd.pwarning('This command does nothing without sub-parsers registered')
             cmd.do_help('cut')
 
 
@@ -297,13 +297,13 @@ def do_cut(self, cmd: cmd2.Cmd, ns: argparse.Namespace):
     @cmd2.with_argparser(stir_parser)
     def do_stir(self, cmd: cmd2.Cmd, ns: argparse.Namespace):
         """Stir something"""
-        func = getattr(ns, 'handler', None)
-        if func is not None:
+        handler = ns.get_handler()
+        if handler is not None:
             # Call whatever subcommand function was selected
-            func(ns)
+            handler(ns)
         else:
             # No subcommand was provided, so call help
-            cmd.poutput('This command does nothing without sub-parsers registered')
+            cmd.pwarning('This command does nothing without sub-parsers registered')
             cmd.do_help('stir')
 
     stir_pasta_parser = cmd2.Cmd2ArgumentParser('pasta', add_help=False)
@@ -312,10 +312,10 @@ def do_stir(self, cmd: cmd2.Cmd, ns: argparse.Namespace):
 
     @cmd2.as_subcommand_to('stir', 'pasta', stir_pasta_parser)
     def stir_pasta(self, cmd: cmd2.Cmd, ns: argparse.Namespace):
-        func = getattr(ns, 'handler', None)
-        if func is not None:
+        handler = ns.get_handler()
+        if handler is not None:
             # Call whatever subcommand function was selected
-            func(ns)
+            handler(ns)
         else:
             cmd.poutput('Stir pasta haphazardly')
 
@@ -327,10 +327,10 @@ def __init__(self, dummy):
 
     def do_cut(self, cmd: cmd2.Cmd, ns: argparse.Namespace):
         """Cut something"""
-        func = getattr(ns, 'handler', None)
-        if func is not None:
+        handler = ns.get_handler()
+        if handler is not None:
             # Call whatever subcommand function was selected
-            func(ns)
+            handler(ns)
         else:
             # No subcommand was provided, so call help
             cmd.poutput('This command does nothing without sub-parsers registered')
@@ -417,6 +417,9 @@ def test_subcommands(command_sets_manual):
     with pytest.raises(CommandSetRegistrationError):
         command_sets_manual._register_subcommands(fruit_cmds)
 
+    cmd_result = command_sets_manual.app_cmd('cut')
+    assert 'This command does nothing without sub-parsers registered' in cmd_result.stderr
+
     # verify that command set install without problems
     command_sets_manual.install_command_set(fruit_cmds)
     command_sets_manual.install_command_set(veg_cmds)
@@ -433,6 +436,9 @@ def test_subcommands(command_sets_manual):
     # check that the alias shows up correctly
     assert ['banana', 'bananer', 'bokchoy'] == command_sets_manual.completion_matches
 
+    cmd_result = command_sets_manual.app_cmd('cut banana discs')
+    assert 'cutting banana: discs' in cmd_result.stdout
+
     text = ''
     line = 'cut bokchoy {}'.format(text)
     endidx = len(line)
@@ -546,10 +552,10 @@ def __init__(self, *args, **kwargs):
     @cmd2.with_argparser(cut_parser)
     def do_cut(self, ns: argparse.Namespace):
         """Cut something"""
-        func = getattr(ns, 'handler', None)
-        if func is not None:
+        handler = ns.get_handler()
+        if handler is not None:
             # Call whatever subcommand function was selected
-            func(ns)
+            handler(ns)
         else:
             # No subcommand was provided, so call help
             self.poutput('This command does nothing without sub-parsers registered')