Renamed set_default_argument_parser_type() to set_default_argument_parser().

Renamed set_default_ap_completer_type() to set_default_argparse_completer().
Renamed Cmd2ArgumentParser.ap_completer_type to completer_class.

Author: kmvanbrunt

CHANGELOG.md

@@ -67,8 +67,10 @@ prompt is displayed.
     - Removed `Cmd.ruler` since `cmd2` no longer uses it.
     - All parsers used with `cmd2` commands must be an instance of `Cmd2ArgumentParser` or a child
       class of it.
-    - Removed `set_ap_completer_type()` and `get_ap_completer_type()` since `ap_completer_type` is
-      now a public member of `Cmd2ArgumentParser`.
+    - Renamed `set_default_argument_parser_type()` to `set_default_argument_parser()`.
+    - Renamed `set_default_ap_completer_type()` to `set_default_argparse_completer()`.
+    - Removed `set_ap_completer_type()` and `get_ap_completer_type()` since `completer_class` is now
+      a public member of `Cmd2ArgumentParser`.
     - Moved `set_parser_prog()` to `Cmd2ArgumentParser.update_prog()`.
     - Renamed `cmd2_handler` to `cmd2_subcommand_func` in the `argparse.Namespace` for clarity.
     - Removed `Cmd2AttributeWrapper` class. `argparse.Namespace` objects passed to command functions

cmd2/__init__.py

@@ -12,12 +12,12 @@
     string_utils,
 )
 from .annotated import with_annotated
-from .argparse_completer import set_default_ap_completer_type
+from .argparse_completer import set_default_argparse_completer
 from .argparse_utils import (
     Cmd2ArgumentParser,
     SubcommandRecord,
     register_argparse_argument_parameter,
-    set_default_argument_parser_type,
+    set_default_argument_parser,
 )
 from .cmd2 import Cmd
 from .colors import Color
@@ -75,8 +75,8 @@
     "Cmd2ArgumentParser",
     "SubcommandRecord",
     "register_argparse_argument_parameter",
-    "set_default_ap_completer_type",
-    "set_default_argument_parser_type",
+    "set_default_argparse_completer",
+    "set_default_argument_parser",
     # Cmd2
     "Cmd",
     "CommandResult",

cmd2/annotated.py

@@ -118,7 +118,7 @@ def do_paint(
 692 ``**parser_kwargs: Unpack[Cmd2ParserKwargs]``.  Anything the parser ctor accepts -- ``description``,
 ``epilog``, ``prog``, ``usage``, ``parents``, ``argument_default``, ``prefix_chars``,
 ``fromfile_prefix_chars``, ``conflict_handler``, ``add_help``, ``allow_abbrev``, ``exit_on_error``,
-``formatter_class``, ``ap_completer_type``, and on Python >= 3.14 ``suggest_on_error`` / ``color`` --
+``formatter_class``, ``completer_class``, and on Python >= 3.14 ``suggest_on_error`` / ``color`` --
 flows straight through; the [`Cmd2ParserKwargs`][cmd2.annotated.Cmd2ParserKwargs] ``TypedDict`` is the single source of truth
 and gives type-checkers/IDEs autocomplete on the decorator's call site.  ``parser_class`` stays as
 its own explicit kwarg because it selects the class itself, not a value passed to it.  Two
@@ -257,7 +257,7 @@ class Cmd2ParserKwargs(TypedDict, total=False):
     exit_on_error: bool
     suggest_on_error: bool
     color: bool
-    ap_completer_type: "type[ArgparseCompleter] | None"
+    completer_class: "type[ArgparseCompleter] | None"
 
 
 # ---------------------------------------------------------------------------

cmd2/argparse_completer.py

@@ -366,8 +366,7 @@ def consume_argument(arg_state: _ArgumentState, arg_token: str) -> None:
                                 parent_tokens[action.dest] = [token]
 
                             parser = self._subcommand_action.choices[token]
-                            completer_type = self._cmd_app._determine_ap_completer_type(parser)
-                            completer = completer_type(parser, self._cmd_app, parent_tokens=parent_tokens)
+                            completer = parser.completer_class(parser, self._cmd_app, parent_tokens=parent_tokens)
                             return completer.complete(text, line, begidx, endidx, tokens[token_index + 1 :], cmd_set=cmd_set)
 
                         # Invalid subcommand entered, so no way to complete remaining tokens
@@ -668,8 +667,7 @@ def complete_subcommand_help(self, text: str, line: str, begidx: int, endidx: in
             for token_index, token in enumerate(tokens):
                 if token in self._subcommand_action.choices:
                     parser = self._subcommand_action.choices[token]
-                    completer_type = self._cmd_app._determine_ap_completer_type(parser)
-                    completer = completer_type(parser, self._cmd_app)
+                    completer = parser.completer_class(parser, self._cmd_app)
                     return completer.complete_subcommand_help(text, line, begidx, endidx, tokens[token_index + 1 :])
 
                 if token_index == len(tokens) - 1:
@@ -690,8 +688,7 @@ def print_help(self, tokens: Sequence[str], file: IO[str] | None = None) -> None
         if tokens and self._subcommand_action is not None:
             parser = self._subcommand_action.choices.get(tokens[0])
             if parser is not None:
-                completer_type = self._cmd_app._determine_ap_completer_type(parser)
-                completer = completer_type(parser, self._cmd_app)
+                completer = parser.completer_class(parser, self._cmd_app)
                 completer.print_help(tokens[1:], file)
                 return
         self._parser.print_help(file)
@@ -800,13 +797,13 @@ def _complete_arg(
 
 
 # The default ArgparseCompleter class for a cmd2 app
-DEFAULT_AP_COMPLETER: type[ArgparseCompleter] = ArgparseCompleter
+DEFAULT_ARGPARSE_COMPLETER: type[ArgparseCompleter] = ArgparseCompleter
 
 
-def set_default_ap_completer_type(completer_type: type[ArgparseCompleter]) -> None:
+def set_default_argparse_completer(completer_class: type[ArgparseCompleter]) -> None:
     """Set the default ArgparseCompleter class for a cmd2 app.
 
-    :param completer_type: Type that is a subclass of ArgparseCompleter.
+    :param completer_class: Type that is a subclass of ArgparseCompleter.
     """
-    global DEFAULT_AP_COMPLETER  # noqa: PLW0603
-    DEFAULT_AP_COMPLETER = completer_type
+    global DEFAULT_ARGPARSE_COMPLETER  # noqa: PLW0603
+    DEFAULT_ARGPARSE_COMPLETER = completer_class

cmd2/argparse_utils.py

@@ -728,13 +728,13 @@ def __init__(
         suggest_on_error: bool = False,
         color: bool = False,
         *,
-        ap_completer_type: type["ArgparseCompleter"] | None = None,
+        completer_class: type["ArgparseCompleter"] | None = None,
     ) -> None:
         """Initialize the Cmd2ArgumentParser instance.
 
-        :param ap_completer_type: optional parameter which specifies a subclass of ArgparseCompleter for custom completion
-                                  behavior on this parser. If this is None or not present, then cmd2 will use
-                                  argparse_completer.DEFAULT_AP_COMPLETER when completing this parser's arguments
+        :param completer_class: optional parameter which specifies a subclass of ArgparseCompleter
+                                for custom completion behavior on this parser. If this is None, then
+                                it will be set to argparse_completer.DEFAULT_ARGPARSE_COMPLETER.
         """
         kwargs: dict[str, bool] = {}
         if sys.version_info >= (3, 14):
@@ -761,7 +761,11 @@ def __init__(
             **kwargs,
         )
 
-        self.ap_completer_type = ap_completer_type
+        if completer_class is None:
+            from . import argparse_completer
+
+            completer_class = argparse_completer.DEFAULT_ARGPARSE_COMPLETER
+        self.completer_class = completer_class
 
         # To assist type checkers, recast these to reflect our usage of rich-argparse.
         self.formatter_class: type[Cmd2HelpFormatter]
@@ -1087,11 +1091,11 @@ def _check_value(self, action: argparse.Action, value: Any) -> None:
 
 
 # Parser type used by cmd2's built-in commands.
-# Set it using cmd2.set_default_argument_parser_type().
+# Set it using cmd2.set_default_argument_parser().
 DEFAULT_ARGUMENT_PARSER: type[Cmd2ArgumentParser] = Cmd2ArgumentParser
 
 
-def set_default_argument_parser_type(parser_type: type[Cmd2ArgumentParser]) -> None:
+def set_default_argument_parser(parser_class: type[Cmd2ArgumentParser]) -> None:
     """Set the default Cmd2ArgumentParser class for cmd2's built-in commands.
 
     Since built-in commands rely on customizations made in Cmd2ArgumentParser,
@@ -1102,4 +1106,4 @@ def set_default_argument_parser_type(parser_type: type[Cmd2ArgumentParser]) -> N
     See examples/custom_parser.py.
     """
     global DEFAULT_ARGUMENT_PARSER  # noqa: PLW0603
-    DEFAULT_ARGUMENT_PARSER = parser_type
+    DEFAULT_ARGUMENT_PARSER = parser_class

cmd2/cmd2.py

@@ -1213,7 +1213,7 @@ def get_root_parser_and_subcmd_path(self, command: str) -> tuple[Cmd2ArgumentPar
         root_command = tokens[0]
         subcommand_path = tokens[1:]
 
-        # Search for the base command function and verify it has an argparser defined
+        # Search for the base command function and verify it has a parser defined
         command_func = self.get_command_func(root_command)
         if command_func is None:
             raise ValueError(f"Root command '{root_command}' does not exist")
@@ -2449,18 +2449,6 @@ def _redirect_complete(self, text: str, line: str, begidx: int, endidx: int, com
         # Call the command's completer function
         return compfunc(text, line, begidx, endidx)
 
-    @staticmethod
-    def _determine_ap_completer_type(parser: Cmd2ArgumentParser) -> type[argparse_completer.ArgparseCompleter]:
-        """Determine what type of ArgparseCompleter to use on a given parser.
-
-        If the parser does not have one set, then use argparse_completer.DEFAULT_AP_COMPLETER.
-        :param parser: the parser to examine
-        :return: type of ArgparseCompleter
-        """
-        if parser.ap_completer_type is None:
-            return argparse_completer.DEFAULT_AP_COMPLETER
-        return parser.ap_completer_type
-
     def _perform_completion(
         self, text: str, line: str, begidx: int, endidx: int, custom_settings: utils.CustomCompletionSettings | None = None
     ) -> Completions:
@@ -2526,16 +2514,15 @@ def _perform_completion(
                 else:
                     # There's no completer function, next see if the command uses argparse
                     command_func = self.get_command_func(command)
-                    argparser = None if command_func is None else self.command_parsers.get(command_func)
+                    parser = None if command_func is None else self.command_parsers.get(command_func)
 
-                    if command_func is not None and argparser is not None:
+                    if command_func is not None and parser is not None:
                         # Get arguments for complete()
                         spec: ArgparseCommandSpec = getattr(command_func, constants.ARGPARSE_COMMAND_ATTR_SPEC)
                         cmd_set = self.find_commandset_for_command(command)
 
                         # Create the argparse completer
-                        completer_type = self._determine_ap_completer_type(argparser)
-                        completer = completer_type(argparser, self)
+                        completer = parser.completer_class(parser, self)
 
                         completer_func = functools.partial(
                             completer.complete, tokens=raw_tokens[1:] if spec.preserve_quotes else tokens[1:], cmd_set=cmd_set
@@ -2550,8 +2537,7 @@ def _perform_completion(
         # Otherwise we are completing the command token or performing custom completion
         else:
             # Create the argparse completer
-            completer_type = self._determine_ap_completer_type(custom_settings.parser)
-            completer = completer_type(custom_settings.parser, self)
+            completer = custom_settings.parser.completer_class(custom_settings.parser, self)
 
             completer_func = functools.partial(
                 completer.complete, tokens=raw_tokens if custom_settings.preserve_quotes else tokens, cmd_set=None
@@ -4274,11 +4260,11 @@ def complete_help_subcommands(
 
         # Check if this command uses argparse
         if (command_func := self.get_command_func(command)) is None or (
-            argparser := self.command_parsers.get(command_func)
+            parser := self.command_parsers.get(command_func)
         ) is None:
             return Completions()
 
-        completer = argparse_completer.DEFAULT_AP_COMPLETER(argparser, self)
+        completer = parser.completer_class(parser, self)
         return completer.complete_subcommand_help(text, line, begidx, endidx, arg_tokens["subcommands"])
 
     def _build_command_info(self) -> tuple[dict[str, list[str]], list[str]]:
@@ -4382,11 +4368,11 @@ def do_help(self, args: argparse.Namespace) -> None:
                 return
 
             command_func = self.get_command_func(args.command)
-            argparser = None if command_func is None else self.command_parsers.get(command_func)
+            parser = None if command_func is None else self.command_parsers.get(command_func)
 
             # If the command function uses argparse, then use argparse's help
-            if command_func is not None and argparser is not None:
-                completer = argparse_completer.DEFAULT_AP_COMPLETER(argparser, self)
+            if command_func is not None and parser is not None:
+                completer = parser.completer_class(parser, self)
                 completer.print_help(args.subcommands, self.stdout)
 
             # If the command has a custom help function, then call it
@@ -4700,7 +4686,7 @@ def complete_set_value(
             completer=settable.completer,
         )
 
-        completer = argparse_completer.DEFAULT_AP_COMPLETER(settable_parser, self)
+        completer = settable_parser.completer_class(settable_parser, self)
 
         # Use raw_tokens since quotes have been preserved
         _, raw_tokens = self.tokens_for_completion(line, begidx, endidx)

docs/features/annotated.md

@@ -308,7 +308,7 @@ annotated decorator picks it up automatically.
 
 The forwarded kwargs are `description`, `epilog`, `prog`, `usage`, `parents`, `argument_default`,
 `prefix_chars`, `fromfile_prefix_chars`, `conflict_handler`, `add_help`, `allow_abbrev`,
-`exit_on_error`, `formatter_class`, `ap_completer_type`, and on Python ≥ 3.14 `suggest_on_error` /
+`exit_on_error`, `formatter_class`, `completer_class`, and on Python ≥ 3.14 `suggest_on_error` /
 `color`. Two of them layer extra behavior on top of the raw passthrough:
 
 - `description` -- when omitted, it is filled from the function's docstring (detailed below); pass

examples/custom_parser.py

@@ -9,7 +9,7 @@
     Cmd2ArgumentParser,
     Cmd2Style,
     cmd2,
-    set_default_argument_parser_type,
+    set_default_argument_parser,
     stylize,
 )
 
@@ -46,7 +46,7 @@ def error(self, message: str) -> NoReturn:
     import sys
 
     # Set the default parser type before instantiating app.
-    set_default_argument_parser_type(CustomParser)
+    set_default_argument_parser(CustomParser)
 
     app = cmd2.Cmd(include_ipy=True, persistent_history_file="cmd2_history.dat")
     app.self_in_py = True  # Enable access to "self" within the py command

tests/test_annotated.py

@@ -1100,41 +1100,43 @@ class MyParser(cmd2.Cmd2ArgumentParser):
         parser = build_parser_from_function(_make_func(str), parser_class=MyParser)
         assert isinstance(parser, MyParser)
 
-    def test_ap_completer_type(self) -> None:
+    def test_completer_class(self) -> None:
         from cmd2.argparse_completer import ArgparseCompleter
 
         class MyCompleter(ArgparseCompleter):
             pass
 
-        parser = build_parser_from_function(_make_func(str), ap_completer_type=MyCompleter)
-        assert parser.ap_completer_type is MyCompleter
+        parser = build_parser_from_function(_make_func(str), completer_class=MyCompleter)
+        assert parser.completer_class is MyCompleter
 
-    def test_ap_completer_type_defaults_to_none(self) -> None:
-        assert build_parser_from_function(_make_func(str)).ap_completer_type is None
+    def test_default_completer_class(self) -> None:
+        from cmd2 import argparse_completer
 
-    def test_ap_completer_type_via_decorator(self) -> None:
+        assert build_parser_from_function(_make_func(str)).completer_class is argparse_completer.DEFAULT_ARGPARSE_COMPLETER
+
+    def test_completer_class_via_decorator(self) -> None:
         from cmd2.argparse_completer import ArgparseCompleter
 
         class MyCompleter(ArgparseCompleter):
             pass
 
-        @with_annotated(ap_completer_type=MyCompleter)
+        @with_annotated(completer_class=MyCompleter)
         def do_run(self, name: str) -> None: ...
 
         builder = getattr(do_run, constants.ARGPARSE_COMMAND_ATTR_SPEC).parser_source
-        assert builder().ap_completer_type is MyCompleter
+        assert builder().completer_class is MyCompleter
 
-    def test_ap_completer_type_threads_to_subcommand(self) -> None:
+    def test_completer_class_threads_to_subcommand(self) -> None:
         from cmd2.argparse_completer import ArgparseCompleter
 
         class MyCompleter(ArgparseCompleter):
             pass
 
-        @with_annotated(subcommand_to="team", ap_completer_type=MyCompleter)
+        @with_annotated(subcommand_to="team", completer_class=MyCompleter)
         def team_create(self, name: str) -> None: ...
 
         spec = getattr(team_create, constants.SUBCOMMAND_ATTR_SPEC)
-        assert spec.parser_source().ap_completer_type is MyCompleter
+        assert spec.parser_source().completer_class is MyCompleter
 
     def test_customization_via_decorator(self) -> None:
         """description/epilog/titled Group flow through @with_annotated end-to-end."""