Enforcing that a subparser's type match the _SubparsersAction's parser class.

Author: kmvanbrunt

cmd2/argparse_custom.py

@@ -890,7 +890,7 @@ def _find_parser(self, subcommand_path: Iterable[str]) -> 'Cmd2ArgumentParser':
         """Find a parser in the hierarchy based on a sequence of subcommand names.
 
         :param subcommand_path: sequence of subcommand names leading to the target parser
-        :return: the discovered Cmd2ArgumentParser
+        :return: the discovered parser
         :raises ValueError: if any subcommand in the path is not found or a level doesn't support subcommands
         """
         parser = self
@@ -905,34 +905,43 @@ def attach_subcommand(
         self,
         subcommand_path: Iterable[str],
         subcommand: str,
-        parser: 'Cmd2ArgumentParser',
+        subcommand_parser: 'Cmd2ArgumentParser',
         **add_parser_kwargs: Any,
     ) -> None:
         """Attach a parser as a subcommand to a command at the specified path.
 
         :param subcommand_path: sequence of subcommand names leading to the parser that will
                                 host the new subcommand. An empty sequence indicates this parser.
         :param subcommand: name of the new subcommand
-        :param parser: the parser to attach
+        :param subcommand_parser: the parser to attach
         :param add_parser_kwargs: additional arguments for the subparser registration (e.g. help, aliases)
+        :raises TypeError: if the subcommand parser's type does not match the 'parser_class' configured
+                           for the target subcommand group.
         :raises ValueError: if the command path is invalid or doesn't support subcommands
         """
         target_parser = self._find_parser(subcommand_path)
         subparsers_action = target_parser._get_subparsers_action()
 
+        if type(subcommand_parser) is not subparsers_action._parser_class:
+            raise TypeError(
+                f"The attached parser must be of type '{subparsers_action._parser_class.__name__}' "
+                f"to match the 'parser_class' configured for this subparsers action. "
+                f"Received '{type(subcommand_parser).__name__}'."
+            )
+
         # Use add_parser to register the subcommand name and any aliases
-        new_parser = subparsers_action.add_parser(subcommand, **add_parser_kwargs)
+        placeholder_parser = subparsers_action.add_parser(subcommand, **add_parser_kwargs)
 
         # To ensure accurate usage strings, recursively update 'prog' values
         # within the injected parser to match its new location in the command hierarchy.
-        parser.update_prog(new_parser.prog)
+        subcommand_parser.update_prog(placeholder_parser.prog)
 
         # Replace the parser created by add_parser() with our pre-configured one
-        subparsers_action._name_parser_map[subcommand] = parser
+        subparsers_action._name_parser_map[subcommand] = subcommand_parser
 
         # Remap any aliases to our pre-configured parser
         for alias in add_parser_kwargs.get("aliases", ()):
-            subparsers_action._name_parser_map[alias] = parser
+            subparsers_action._name_parser_map[alias] = subcommand_parser
 
     def detach_subcommand(self, subcommand_path: Iterable[str], subcommand: str) -> 'Cmd2ArgumentParser':
         """Detach a subcommand from a command at the specified path.

cmd2/cmd2.py

@@ -1179,20 +1179,22 @@ def attach_subcommand(
         self,
         command: str,
         subcommand: str,
-        parser: Cmd2ArgumentParser,
+        subcommand_parser: Cmd2ArgumentParser,
         **add_parser_kwargs: Any,
     ) -> None:
         """Attach a parser as a subcommand to a command at the specified path.
 
         :param command: full command path (space-delimited) leading to the parser that will
                         host the new subcommand (e.g. 'foo bar')
         :param subcommand: name of the new subcommand
-        :param parser: the parser to attach
+        :param subcommand_parser: the parser to attach
         :param add_parser_kwargs: additional arguments for the subparser registration (e.g. help, aliases)
+        :raises TypeError: if the subcommand parser's type does not match 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.attach_subcommand(subcommand_path, subcommand, parser, **add_parser_kwargs)
+        root_parser.attach_subcommand(subcommand_path, subcommand, subcommand_parser, **add_parser_kwargs)
 
     def detach_subcommand(self, command: str, subcommand: str) -> Cmd2ArgumentParser:
         """Detach a subcommand from a command at the specified path.

tests/test_argparse_custom.py

@@ -425,6 +425,33 @@ def test_subcommand_attachment_errors() -> None:
     with pytest.raises(ValueError, match="Subcommand 'fake' not found in 'root'"):
         root_parser.detach_subcommand([], "fake")
 
+    # Verify TypeError when attaching a parser of a different type
+    class SubParser(Cmd2ArgumentParser):
+        pass
+
+    subclass_parser = SubParser(prog="sub")
+    with pytest.raises(TypeError, match="The attached parser must be of type 'Cmd2ArgumentParser'"):
+        root_parser.attach_subcommand([], "sub", subclass_parser)
+
+
+def test_subcommand_attachment_parser_class_override() -> None:
+    class MyParser(Cmd2ArgumentParser):
+        pass
+
+    root_parser = Cmd2ArgumentParser(prog="root")
+
+    # Explicitly override parser_class for this subparsers action
+    root_parser.add_subparsers(parser_class=MyParser)
+
+    # Attaching a MyParser instance should succeed
+    my_parser = MyParser(prog="sub")
+    root_parser.attach_subcommand([], "sub", my_parser)
+
+    # Attaching a standard Cmd2ArgumentParser instance should fail
+    standard_parser = Cmd2ArgumentParser(prog="standard")
+    with pytest.raises(TypeError, match="The attached parser must be of type 'MyParser'"):
+        root_parser.attach_subcommand([], "fail", standard_parser)
+
 
 def test_completion_items_as_choices(capsys) -> None:
     """Test cmd2's patch to Argparse._check_value() which supports CompletionItems as choices.

tests/test_cmd2.py

@@ -4534,3 +4534,9 @@ def do_no_argparse(self, _statement: cmd2.Statement) -> None:
     # Test command that doesn't use argparse
     with pytest.raises(ValueError, match="Command 'no_argparse' does not use argparse"):
         app.attach_subcommand("no_argparse", "sub", cmd2.Cmd2ArgumentParser())
+
+    # Test type mismatch
+    import argparse
+
+    with pytest.raises(TypeError, match="to match the 'parser_class' configured for this subparsers action"):
+        app.attach_subcommand("alias", "sub", argparse.ArgumentParser())  # type: ignore[arg-type]