Fixed issue where argument parsers for overridden commands were not being created.

Author: kmvanbrunt

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.5.7 (TBD)
+* Bug Fixes
+   * Fixed issue where argument parsers for overridden commands were not being created.
+
 ## 2.5.6 (November 14, 2024)
 * Bug Fixes
    * Fixed type hint for `with_default_category` decorator which caused type checkers to mistype

cmd2/cmd2.py

@@ -346,7 +346,9 @@ def cmd_wrapper(*args: Any, **kwargs: Dict[str, Any]) -> Optional[bool]:
             statement, parsed_arglist = cmd2_app.statement_parser.get_command_arg_list(
                 command_name, statement_arg, preserve_quotes
             )
-            arg_parser = cmd2_app._command_parsers.get(command_name, None)
+
+            # 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

cmd2/decorators.py

@@ -4,16 +4,143 @@
 This is intended to be a completely bare-bones cmd2 application suitable for rapid testing and debugging.
 """
 
-from cmd2 import (
-    cmd2,
-)
+import argparse
+from typing import List
+
+import cmd2
+
+# class CommandSetBase(cmd2.CommandSet):
+#     pass
+
+# class WithCommandSets(cmd2.Cmd):
+#     """Class for testing custom help_* methods which override docstring help."""
+
+#     def __init__(self, *args, **kwargs):
+#         super(WithCommandSets, self).__init__(*args, **kwargs)
+
+# @cmd2.with_default_category('Fruits')
+# class CommandSetA(CommandSetBase):
+#     def on_register(self, cmd) -> None:
+#         super().on_register(cmd)
+#         print("in on_register now")
+
+#     def on_registered(self) -> None:
+#         super().on_registered()
+#         print("in on_registered now")
+
+#     def on_unregister(self) -> None:
+#         super().on_unregister()
+#         print("in on_unregister now")
+
+#     def on_unregistered(self) -> None:
+#         super().on_unregistered()
+#         print("in on_unregistered now")
+
+#     def do_apple(self, statement: cmd2.Statement):
+#         self._cmd.poutput('Apple!')
+
+#     def do_banana(self, statement: cmd2.Statement):
+#         """Banana Command"""
+#         self._cmd.poutput('Banana!!')
+
+#     cranberry_parser = cmd2.Cmd2ArgumentParser()
+#     cranberry_parser.add_argument('arg1', choices=['lemonade', 'juice', 'sauce'])
+
+#     @cmd2.with_argparser(cranberry_parser, with_unknown_args=True)
+#     def do_cranberry(self, ns: argparse.Namespace, unknown: List[str]):
+#         self._cmd.poutput('Cranberry {}!!'.format(ns.arg1))
+#         if unknown and len(unknown):
+#             self._cmd.poutput('Unknown: ' + ', '.join(['{}'] * len(unknown)).format(*unknown))
+#         self._cmd.last_result = {'arg1': ns.arg1, 'unknown': unknown}
+
+#     def help_cranberry(self):
+#         self._cmd.stdout.write('This command does diddly squat...\n')
+
+#     @cmd2.with_argument_list
+#     @cmd2.with_category('Also Alone')
+#     def do_durian(self, args: List[str]):
+#         """Durian Command"""
+#         self._cmd.poutput('{} Arguments: '.format(len(args)))
+#         self._cmd.poutput(', '.join(['{}'] * len(args)).format(*args))
+#         self._cmd.last_result = {'args': args}
+
+#     def complete_durian(self, text: str, line: str, begidx: int, endidx: int) -> List[str]:
+#         return self._cmd.basic_complete(text, line, begidx, endidx, ['stinks', 'smells', 'disgusting'])
+
+#     elderberry_parser = cmd2.Cmd2ArgumentParser()
+#     elderberry_parser.add_argument('arg1')
+
+#     @cmd2.with_category('Alone')
+#     @cmd2.with_argparser(elderberry_parser)
+#     def do_elderberry(self, ns: argparse.Namespace):
+#         self._cmd.poutput('Elderberry {}!!'.format(ns.arg1))
+#         self._cmd.last_result = {'arg1': ns.arg1}
+
+#     # Test that CommandSet with as_subcommand_to decorator successfully loads
+#     # during `cmd2.Cmd.__init__()`.
+#     main_parser = cmd2.Cmd2ArgumentParser(description="Main Command")
+#     main_parser.add_subparsers(dest='subcommand', metavar='SUBCOMMAND', required=True)
+
+#     @cmd2.with_category('Alone')
+#     @cmd2.with_argparser(main_parser)
+#     def do_main(self, args: argparse.Namespace) -> None:
+#         # Call handler for whatever subcommand was selected
+#         handler = args.cmd2_handler.get()
+#         handler(args)
+
+#     # main -> sub
+#     subcmd_parser = cmd2.Cmd2ArgumentParser(description="Sub Command")
+
+#     @cmd2.as_subcommand_to('main', 'sub', subcmd_parser, help="sub command")
+#     def subcmd_func(self, args: argparse.Namespace) -> None:
+#         self._cmd.poutput("Subcommand Ran")
+
+# class MySet(cmd2.CommandSet):
+#     p = cmd2.Cmd2ArgumentParser(description="This is help")
+#     p.add_argument("command")
+#     p.add_argument("foo")
+
+#     @cmd2.with_argparser(p)
+#     def do_foo(self, args: argparse.Namespace) -> None:
+#         print(f"foo is {args.foo}")
+#         self._cmd.do_help(args.command)
+#         print(self._cmd.do_foo)
+
+#     do_test = cmd2.Cmd.do_alias
+
+#     def do_enable(self, _):
+#         self._cmd.enable_command("foo")
+
+#     def do_disable(self, _):
+#         self._cmd.disable_command("foo", "That's a disabled command.")
+
+#     def on_registered(self) -> None:
+#         super().on_registered()
+
+#     def do_unregister(self, _) -> None:
+#         self._cmd.unregister_command_set(self)
+
+
+# class SynonymCommandSet(CommandSetA):
+
+#     do_synonym = CommandSetA.do_cranberry
+
+#     def do_unregister(self, _) -> None:
+#         self._cmd.unregister_command_set(self)
+
+class App(cmd2.Cmd):
+    do_synonym = cmd2.Cmd.do_alias
+
+    def do_disable(self, _):
+        self.disable_command("synonym", "This is disabled.")
 
 if __name__ == '__main__':
     import sys
 
     # If run as the main application, simply start a bare-bones cmd2 application with only built-in functionality.
     # Enable commands to support interactive Python and IPython shells.
-    app = cmd2.Cmd(include_py=True, include_ipy=True, persistent_history_file='cmd2_history.dat')
+    app = App(include_py=True, include_ipy=True, persistent_history_file='cmd2_history.dat')
     app.self_in_py = True  # Enable access to "self" within the py command
     app.debug = True  # Show traceback if/when an exception occurs
+    print(app.cmd_func("synonym"))
     sys.exit(app.cmdloop())

examples/hello_cmd2.py

@@ -328,6 +328,7 @@ dev-dependencies = [
     "pytest",
     "pytest-cov",
     "pytest-mock",
+    "ruff",
     "sphinx",
     "sphinx-autobuild",
     "sphinx-rtd-theme",

pyproject.toml

@@ -14,7 +14,6 @@
 import cmd2
 
 from .conftest import (
-    find_subcommand,
     run_cmd,
 )
 
@@ -402,8 +401,7 @@ def test_add_another_subcommand(subcommand_app):
     This tests makes sure _set_parser_prog() sets _prog_prefix on every _SubParsersAction so that all future calls
     to add_parser() write the correct prog value to the parser being added.
     """
-    base_parser = subcommand_app._command_parsers.get('base')
-    find_subcommand(subcommand_app._command_parsers.get('base'), [])
+    base_parser = subcommand_app._command_parsers.get(subcommand_app.do_base)
     for sub_action in base_parser._actions:
         if isinstance(sub_action, argparse._SubParsersAction):
             new_parser = sub_action.add_parser('new_sub', help='stuff')

tests/test_argparse.py

@@ -1210,6 +1210,12 @@ def do_multiline_docstr(self, arg):
         """
         pass
 
+    parser_cmd_parser = cmd2.Cmd2ArgumentParser(description="This is the description.")
+    @cmd2.with_argparser(parser_cmd_parser)
+    def do_parser_cmd(self, args):
+        """This is the docstring."""
+        pass
+
 
 @pytest.fixture
 def help_app():
@@ -1249,6 +1255,11 @@ def test_help_multiline_docstring(help_app):
     assert help_app.last_result is True
 
 
+def test_help_verbose_uses_parser_description(help_app: HelpApp):
+    out, err = run_cmd(help_app, 'help --verbose')
+    verify_help_text(help_app, out, verbose_strings=[help_app.parser_cmd_parser.description])
+
+
 class HelpCategoriesApp(cmd2.Cmd):
     """Class for testing custom help_* methods which override docstring help."""
 
@@ -3016,3 +3027,26 @@ def test_columnize_too_wide(outsim_app):
 
     expected = "\n".join(str_list) + "\n"
     assert outsim_app.stdout.getvalue() == expected
+
+
+def test_command_parser_retrieval(outsim_app: cmd2.Cmd):
+    # Pass something that isn't a method
+    not_a_method = "just a string"
+    assert outsim_app._command_parsers.get(not_a_method) is None
+
+    # Pass a non-command method
+    assert outsim_app._command_parsers.get(outsim_app.__init__) is None
+
+
+def test_command_synonym_parser():
+    # Make sure a command synonym returns the same parser as what it aliases
+    class SynonymApp(cmd2.cmd2.Cmd):
+        do_synonym = cmd2.cmd2.Cmd.do_help
+
+    app = SynonymApp()
+
+    synonym_parser = app._command_parsers.get(app.do_synonym)
+    help_parser = app._command_parsers.get(app.do_help)
+
+    assert synonym_parser is not None
+    assert synonym_parser is help_parser

tests/test_cmd2.py

@@ -2,7 +2,7 @@
 # so you can see where they are.
 
 (Cmd) help say
-Usage: say [-h] [-p] [-s] [-r REPEAT]/ */
+Usage: speak [-h] [-p] [-s] [-r REPEAT]/ */
 
 Repeats what you tell me to./ */
 

tests/transcripts/from_cmdloop.txt

@@ -149,6 +149,49 @@ def test_autoload_commands(command_sets_app):
     assert 'Command Set B' not in cmds_cats
 
 
+def test_command_synonyms():
+    """Test the use of command synonyms in CommandSets"""
+    class SynonymCommandSet(cmd2.CommandSet):
+        def __init__(self, arg1):
+            super().__init__()
+            self._arg1 = arg1
+
+        @cmd2.with_argparser(cmd2.Cmd2ArgumentParser(description="Native Command"))
+        def do_builtin(self, _):
+            pass
+
+        # Create a synonym to a command inside of this CommandSet
+        do_builtin_synonym = do_builtin
+
+        # Create a synonym to a command outside of this CommandSet
+        do_help_synonym = cmd2.Cmd.do_help
+
+    cs = SynonymCommandSet("foo")
+    app = WithCommandSets(command_sets=[cs])
+
+    # Make sure the synonyms have the same parser as what they alias
+    builtin_parser = app._command_parsers.get(app.do_builtin)
+    builtin_synonym_parser = app._command_parsers.get(app.do_builtin_synonym)
+    assert builtin_parser is not None
+    assert builtin_parser is builtin_synonym_parser
+
+    help_parser = app._command_parsers.get(cmd2.Cmd.do_help)
+    help_synonym_parser = app._command_parsers.get(app.do_help_synonym)
+    assert help_parser is not None
+    assert help_parser is help_synonym_parser
+
+    # Unregister the CommandSet and make sure built-in command and synonyms are gone
+    app.unregister_command_set(cs)
+    assert not hasattr(app, "do_builtin")
+    assert not hasattr(app, "do_builtin_synonym")
+    assert not hasattr(app, "do_help_synonym")
+
+    # Make sure the help command still exists and works
+    assert hasattr(app, "do_help")
+    out, err = run_cmd(app, 'help')
+    assert app.doc_header in out
+
+
 def test_custom_construct_commandsets():
     command_set_b = CommandSetB('foo')
 
@@ -291,7 +334,7 @@ def test_load_commandset_errors(command_sets_manual, capsys):
     cmd_set = CommandSetA()
 
     # create a conflicting command before installing CommandSet to verify rollback behavior
-    command_sets_manual._install_command_function('durian', cmd_set.do_durian)
+    command_sets_manual._install_command_function('do_durian', cmd_set.do_durian)
     with pytest.raises(CommandSetRegistrationError):
         command_sets_manual.register_command_set(cmd_set)
 
@@ -316,13 +359,21 @@ def test_load_commandset_errors(command_sets_manual, capsys):
     assert "Deleting alias 'banana'" in err
     assert "Deleting macro 'apple'" in err
 
+    # verify command functions which don't start with "do_" raise an exception
+    with pytest.raises(CommandSetRegistrationError):
+        command_sets_manual._install_command_function('new_cmd', cmd_set.do_banana)
+
+    # verify methods which don't start with "do_" raise an exception
+    with pytest.raises(CommandSetRegistrationError):
+        command_sets_manual._install_command_function('do_new_cmd', cmd_set.on_register)
+
     # verify duplicate commands are detected
     with pytest.raises(CommandSetRegistrationError):
-        command_sets_manual._install_command_function('banana', cmd_set.do_banana)
+        command_sets_manual._install_command_function('do_banana', cmd_set.do_banana)
 
     # verify bad command names are detected
     with pytest.raises(CommandSetRegistrationError):
-        command_sets_manual._install_command_function('bad command', cmd_set.do_banana)
+        command_sets_manual._install_command_function('do_bad command', cmd_set.do_banana)
 
     # verify error conflict with existing completer function
     with pytest.raises(CommandSetRegistrationError):