Make Cmd._command_parsers and Cmd._get_root_parser_and_subcmd_path() public.

Author: kmvanbrunt

cmd2/cmd2.py

@@ -223,13 +223,17 @@ def __init__(self) -> None:
 DisabledCommand = namedtuple("DisabledCommand", ["command_function", "help_function", "completer_function"])  # noqa: PYI024
 
 
-class _CommandParsers:
+class CommandParsers:
     """Create and store all command method argument parsers for a given Cmd instance.
 
     Parser creation and retrieval are accomplished through the get() method.
     """
 
     def __init__(self, cmd: "Cmd") -> None:
+        """Initialize CommandParsers.
+
+        :param cmd: the Cmd instance whose parsers are being managed
+        """
         self._cmd = cmd
 
         # Keyed by the fully qualified method names. This is more reliable than
@@ -620,7 +624,7 @@ def __init__(
         self.disabled_categories: dict[str, str] = {}
 
         # Command parsers for this Cmd instance.
-        self._command_parsers: _CommandParsers = _CommandParsers(self)
+        self.command_parsers: CommandParsers = CommandParsers(self)
 
         # Members related to printing asynchronous alerts
         self._alert_queue: deque[AsyncAlert] = deque()
@@ -935,7 +939,7 @@ def _install_command_function(self, command_func_name: str, command_method: Boun
         if not command_func_name.startswith(COMMAND_FUNC_PREFIX):
             raise CommandSetRegistrationError(f"{command_func_name} does not begin with '{COMMAND_FUNC_PREFIX}'")
 
-        # command_method must start with COMMAND_FUNC_PREFIX for use in self._command_parsers.
+        # command_method must start with COMMAND_FUNC_PREFIX for use in self.command_parsers.
         if not command_method.__name__.startswith(COMMAND_FUNC_PREFIX):
             raise CommandSetRegistrationError(f"{command_method.__name__} does not begin with '{COMMAND_FUNC_PREFIX}'")
 
@@ -1009,7 +1013,7 @@ def unregister_command_set(self, cmdset: CommandSet[Any]) -> None:
                 # Only remove the parser if this is the actual
                 # command since command synonyms don't own it.
                 if cmd_func_name == command_method.__name__:
-                    self._command_parsers.remove(command_method)
+                    self.command_parsers.remove(command_method)
 
                 if hasattr(self, COMPLETER_FUNC_PREFIX + command):
                     delattr(self, COMPLETER_FUNC_PREFIX + command)
@@ -1059,7 +1063,7 @@ def check_parser_uninstallable(parser: Cmd2ArgumentParser) -> None:
             # We only need to check if it's safe to remove the parser if this
             # is the actual command since command synonyms don't own it.
             if cmd_func_name == command_method.__name__:
-                command_parser = self._command_parsers.get(command_method)
+                command_parser = self.command_parsers.get(command_method)
                 if command_parser is not None:
                     check_parser_uninstallable(command_parser)
 
@@ -1140,7 +1144,7 @@ def _unregister_subcommands(self, cmdset: CmdOrSet) -> None:
             with contextlib.suppress(ValueError):
                 self.detach_subcommand(full_command_name, subcommand_name)
 
-    def _get_root_parser_and_subcmd_path(self, command: str) -> tuple[Cmd2ArgumentParser, list[str]]:
+    def get_root_parser_and_subcmd_path(self, command: str) -> tuple[Cmd2ArgumentParser, list[str]]:
         """Tokenize a command string and resolve the associated root parser and relative subcommand path.
 
         This helper handles the initial resolution of a command string (e.g., 'foo bar baz') by
@@ -1170,7 +1174,7 @@ def _get_root_parser_and_subcmd_path(self, command: str) -> tuple[Cmd2ArgumentPa
         if command_func is None:
             raise ValueError(f"Root command '{root_command}' not found")
 
-        root_parser = self._command_parsers.get(command_func)
+        root_parser = self.command_parsers.get(command_func)
         if root_parser is None:
             raise ValueError(f"Command '{root_command}' does not use argparse")
 
@@ -1195,7 +1199,7 @@ def attach_subcommand(
                            2. The parser_class configured for the target subcommand group
         :raises ValueError: if the command path is invalid or doesn't support subcommands
         """
-        root_parser, subcommand_path = self._get_root_parser_and_subcmd_path(command)
+        root_parser, subcommand_path = self.get_root_parser_and_subcmd_path(command)
         root_parser.attach_subcommand(subcommand_path, subcommand, subcommand_parser, **add_parser_kwargs)
 
     def detach_subcommand(self, command: str, subcommand: str) -> Cmd2ArgumentParser:
@@ -1207,7 +1211,7 @@ def detach_subcommand(self, command: str, subcommand: str) -> Cmd2ArgumentParser
         :return: the detached parser
         :raises ValueError: if the command path is invalid or the subcommand doesn't exist
         """
-        root_parser, subcommand_path = self._get_root_parser_and_subcmd_path(command)
+        root_parser, subcommand_path = self.get_root_parser_and_subcmd_path(command)
         return root_parser.detach_subcommand(subcommand_path, subcommand)
 
     @property
@@ -2448,7 +2452,7 @@ def _perform_completion(
                 else:
                     # There's no completer function, next see if the command uses argparse
                     func = self.get_command_func(command)
-                    argparser = None if func is None else self._command_parsers.get(func)
+                    argparser = None if func is None else self.command_parsers.get(func)
 
                     if func is not None and argparser is not None:
                         # Get arguments for complete()
@@ -4218,7 +4222,7 @@ def complete_help_subcommands(
             return Completions()
 
         # Check if this command uses argparse
-        if (func := self.get_command_func(command)) is None or (argparser := self._command_parsers.get(func)) is None:
+        if (func := self.get_command_func(command)) is None or (argparser := self.command_parsers.get(func)) is None:
             return Completions()
 
         completer = argparse_completer.DEFAULT_AP_COMPLETER(argparser, self)
@@ -4312,7 +4316,7 @@ def do_help(self, args: argparse.Namespace) -> None:
             # Getting help for a specific command
             func = self.get_command_func(args.command)
             help_func = getattr(self, constants.HELP_FUNC_PREFIX + args.command, None)
-            argparser = None if func is None else self._command_parsers.get(func)
+            argparser = None if func is None else self.command_parsers.get(func)
 
             # If the command function uses argparse, then use argparse's help
             if func is not None and argparser is not None:

cmd2/decorators.py

@@ -287,7 +287,7 @@ def cmd_wrapper(*args: Any, **kwargs: Any) -> bool | None:
             )
 
             # Pass cmd_wrapper instead of func, since it contains the parser info.
-            arg_parser = cmd2_app._command_parsers.get(cmd_wrapper)
+            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

docs/features/argument_processing.md

@@ -50,7 +50,7 @@ stores internally. A consequence is that parsers don't need to be unique across
 
     Since the `@with_argparser` decorator is making a deep-copy of the parser provided, if you wish
     to dynamically modify this parser at a later time, you need to retrieve this deep copy. This can
-    be done using `self._command_parsers.get(self.do_commandname)`.
+    be done using `self.command_parsers.get(self.do_commandname)`.
 
 ## Argument Parsing
 

examples/scripts/save_help_text.py

@@ -88,7 +88,7 @@ def main() -> None:
                     continue
 
                 cmd_func = self.get_command_func(item)
-                parser = self._command_parsers.get(cmd_func)
+                parser = self.command_parsers.get(cmd_func)
                 if parser is None:
                     continue
 

tests/test_cmd2.py

@@ -4115,10 +4115,10 @@ def test_startup_script_with_odd_file_names(startup_script) -> None:
 def test_command_parser_retrieval(outsim_app: cmd2.Cmd) -> None:
     # Pass something that isn't a method
     not_a_method = "just a string"
-    assert outsim_app._command_parsers.get(not_a_method) is None
+    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
+    assert outsim_app.command_parsers.get(outsim_app.__init__) is None
 
 
 def test_command_synonym_parser() -> None:
@@ -4128,8 +4128,8 @@ class SynonymApp(cmd2.cmd2.Cmd):
 
     app = SynonymApp()
 
-    synonym_parser = app._command_parsers.get(app.do_synonym)
-    help_parser = app._command_parsers.get(app.do_help)
+    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
@@ -4481,7 +4481,7 @@ def do_root(self, _args: argparse.Namespace) -> None:
     app = SubcmdApp()
 
     # Verify root exists and uses argparse
-    root_parser = app._command_parsers.get(app.do_root)
+    root_parser = app.command_parsers.get(app.do_root)
     assert root_parser is not None
 
     # Attach child to root

tests/test_commandset.py

@@ -173,13 +173,13 @@ def do_builtin(self, _) -> None:
     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)
+    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
 
-    alias_parser = app._command_parsers.get(cmd2.Cmd.do_alias)
-    alias_synonym_parser = app._command_parsers.get(app.do_alias_synonym)
+    alias_parser = app.command_parsers.get(cmd2.Cmd.do_alias)
+    alias_synonym_parser = app.command_parsers.get(app.do_alias_synonym)
     assert alias_parser is not None
     assert alias_parser is alias_synonym_parser
 
@@ -190,7 +190,7 @@ def do_builtin(self, _) -> None:
     assert not hasattr(app, "do_alias_synonym")
 
     # Make sure the alias command still exists, has the same parser, and works.
-    assert alias_parser is app._command_parsers.get(cmd2.Cmd.do_alias)
+    assert alias_parser is app.command_parsers.get(cmd2.Cmd.do_alias)
     out, _err = run_cmd(app, "alias --help")
     assert normalize(alias_parser.format_help())[0] in out