cmd2 4.0.0b2__tar.gz → 4.0.0b4__tar.gz

{cmd2-4.0.0b2 → cmd2-4.0.0b4}/.pre-commit-config.yaml

@@ -14,7 +14,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.15.6"
+    rev: "v0.15.8"
     hooks:
       - id: ruff-format
         args: [--config=ruff.toml]

{cmd2-4.0.0b2 → cmd2-4.0.0b4}/CHANGELOG.md

@@ -64,6 +64,38 @@ prompt is displayed.
       before calling it like the previous functions did.
     - Removed `Cmd.default_to_shell`.
     - 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`.
+    - Moved `set_parser_prog()` to `Cmd2ArgumentParser.update_prog()`.
+    - Renamed `cmd2_handler` to `cmd2_subcmd_handler` in the `argparse.Namespace` for clarity.
+    - Removed `Cmd2AttributeWrapper` class. `argparse.Namespace` objects passed to command functions
+      now contain direct attributes for `cmd2_statement` and `cmd2_subcmd_handler`.
+    - Renamed `cmd2/command_definition.py` to `cmd2/command_set.py`.
+    - Removed `Cmd.doc_header` and the `with_default_category` decorator. Help categorization is now
+      driven by the `DEFAULT_CATEGORY` class variable (see **Simplified command categorization** in
+      the Enhancements section below for details).
+    - Removed `Cmd.undoc_header` since all commands are now considered categorized.
+    - Renamed `Cmd.cmd_func()` to `Cmd.get_command_func()`.
+    - `cmd2` no longer sets a default title for a subparsers group. If you desire a title, you will
+      need to pass one in like this `parser.add_subparsers(title="subcommands")`. This is standard
+      `argparse` behavior.
+    - `TextGroup` is now a standalone Rich renderable.
+        - Removed `formatter_creator` parameter from `TextGroup.__init__()`.
+        - Removed `Cmd2ArgumentParser.create_text_group()` method.
+    - `argparse` and `Rich` integration refactoring:
+        - Renamed `argparse_custom` module to `argparse_utils`.
+        - Moved the following classes from `argparse_utils` to `rich_utils`:
+            - `Cmd2HelpFormatter`
+            - `ArgumentDefaultsCmd2HelpFormatter`
+            - `MetavarTypeCmd2HelpFormatter`
+            - `RawDescriptionCmd2HelpFormatter`
+            - `RawTextCmd2HelpFormatter`
+            - `TextGroup`
+        - Replaced the global `APP_THEME` constant in `rich_utils.py` with `get_theme()` and
+          `set_theme()` functions to support lazy initialization and safer in-place updates of the
+          theme.
 - Enhancements
     - New `cmd2.Cmd` parameters
         - **auto_suggest**: (boolean) if `True`, provide fish shell style auto-suggestions. These
@@ -79,6 +111,7 @@ prompt is displayed.
         - **pre_prompt**: hook method that is called before the prompt is displayed, but after
           `prompt-toolkit` event loop has started
         - **read_secret**: read secrets like passwords without displaying them to the terminal
+        - **ppretty**: a cmd2-compatible replacement for `rich.pretty.pprint()`
     - New settables:
         - **max_column_completion_results**: (int) the maximum number of completion results to
           display in a single column
@@ -88,6 +121,20 @@ prompt is displayed.
     - Add support for Python 3.15 by fixing various bugs related to internal `argparse` changes
     - Added `common_prefix` method to `cmd2.string_utils` module as a replacement for
       `os.path.commonprefix` since that is now deprecated in Python 3.15
+    - Simplified command categorization:
+        - By default, all commands in a class are grouped under its `DEFAULT_CATEGORY`.
+        - Individual commands can still be manually moved using the `with_category()` decorator.
+        - For more details and examples, see the [Help](docs/features/help.md) documentation and the
+          `examples/default_categories.py` file.
+    - `CommandSet` is now a generic class, which allows developers to parameterize it with their
+      specific `cmd2.Cmd` subclass (e.g.,`class MyCommandSet(CommandSet[MyApp]):`). This provides
+      full type hints and IDE autocompletion for `self._cmd` without needing to override and cast
+      the property.
+
+## 3.5.0 (April 13, 2026)
+
+- Bug Fixes
+    - Fixed issue where Rich stripped colors from text in test environments where TERM=dumb.
 
 ## 3.4.0 (March 3, 2026)
 

{cmd2-4.0.0b2 → cmd2-4.0.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 4.0.0b2
+Version: 4.0.0b4
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT
@@ -25,8 +25,8 @@ License-File: LICENSE
 Requires-Dist: backports.strenum; python_version == "3.10"
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pyperclip>=1.8.2
-Requires-Dist: rich>=14.3.0
-Requires-Dist: rich-argparse>=1.7.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: rich-argparse>=1.7.2
 Requires-Dist: typing-extensions; python_version == "3.10"
 Dynamic: license-file
 

{cmd2-4.0.0b2 → cmd2-4.0.0b4}/cmd2/__init__.py

@@ -12,18 +12,14 @@ from . import (
     string_utils,
 )
 from .argparse_completer import set_default_ap_completer_type
-from .argparse_custom import (
+from .argparse_utils import (
     Cmd2ArgumentParser,
-    Cmd2AttributeWrapper,
     register_argparse_argument_parameter,
     set_default_argument_parser_type,
 )
 from .cmd2 import Cmd
 from .colors import Color
-from .command_definition import (
-    CommandSet,
-    with_default_category,
-)
+from .command_set import CommandSet
 from .completion import (
     Choices,
     CompletionItem,
@@ -48,7 +44,17 @@ from .exceptions import (
 )
 from .parsing import Statement
 from .py_bridge import CommandResult
-from .rich_utils import RichPrintKwargs
+from .rich_utils import (
+    ArgumentDefaultsCmd2HelpFormatter,
+    Cmd2HelpFormatter,
+    MetavarTypeCmd2HelpFormatter,
+    RawDescriptionCmd2HelpFormatter,
+    RawTextCmd2HelpFormatter,
+    RichPrintKwargs,
+    TextGroup,
+    get_theme,
+    set_theme,
+)
 from .string_utils import stylize
 from .styles import Cmd2Style
 from .utils import (
@@ -59,50 +65,56 @@ from .utils import (
 )
 
 __all__: list[str] = [  # noqa: RUF022
-    'COMMAND_NAME',
-    'DEFAULT_SHORTCUTS',
+    "COMMAND_NAME",
+    "DEFAULT_SHORTCUTS",
     # Argparse Exports
-    'Cmd2ArgumentParser',
-    'Cmd2AttributeWrapper',
-    'register_argparse_argument_parameter',
-    'set_default_ap_completer_type',
-    'set_default_argument_parser_type',
+    "Cmd2ArgumentParser",
+    "register_argparse_argument_parameter",
+    "set_default_ap_completer_type",
+    "set_default_argument_parser_type",
     # Cmd2
-    'Cmd',
-    'CommandResult',
-    'CommandSet',
-    'Statement',
+    "Cmd",
+    "CommandResult",
+    "CommandSet",
+    "Statement",
     # Colors
     "Color",
     # Completion
-    'Choices',
-    'CompletionItem',
-    'Completions',
+    "Choices",
+    "CompletionItem",
+    "Completions",
     # Decorators
-    'with_argument_list',
-    'with_argparser',
-    'with_category',
-    'with_default_category',
-    'as_subcommand_to',
+    "with_argument_list",
+    "with_argparser",
+    "with_category",
+    "as_subcommand_to",
     # Exceptions
-    'Cmd2ArgparseError',
-    'CommandSetRegistrationError',
-    'CompletionError',
-    'PassThroughException',
-    'SkipPostcommandHooks',
+    "Cmd2ArgparseError",
+    "CommandSetRegistrationError",
+    "CompletionError",
+    "PassThroughException",
+    "SkipPostcommandHooks",
     # modules
-    'plugin',
-    'rich_utils',
-    'string_utils',
+    "plugin",
+    "rich_utils",
+    "string_utils",
     # Rich Utils
-    'RichPrintKwargs',
+    "ArgumentDefaultsCmd2HelpFormatter",
+    "Cmd2HelpFormatter",
+    "get_theme",
+    "MetavarTypeCmd2HelpFormatter",
+    "RawDescriptionCmd2HelpFormatter",
+    "RawTextCmd2HelpFormatter",
+    "RichPrintKwargs",
+    "set_theme",
+    "TextGroup",
     # String Utils
-    'stylize',
+    "stylize",
     # Styles,
-    'Cmd2Style',
+    "Cmd2Style",
     # Utilities
-    'categorize',
-    'CustomCompletionSettings',
-    'Settable',
-    'set_default_str_sort_key',
+    "categorize",
+    "CustomCompletionSettings",
+    "Settable",
+    "set_default_str_sort_key",
 ]

{cmd2-4.0.0b2 → cmd2-4.0.0b4}/cmd2/argparse_completer.py

@@ -1,15 +1,12 @@
 """Module defines the ArgparseCompleter class which provides argparse-based completion to cmd2 apps.
 
-See the header of argparse_custom.py for instructions on how to use these features.
+See the header of argparse_utils.py for instructions on how to use these features.
 """
 
 import argparse
 import dataclasses
 import inspect
-from collections import (
-    defaultdict,
-    deque,
-)
+from collections import deque
 from collections.abc import (
     Mapping,
     MutableSequence,
@@ -22,39 +19,42 @@ from typing import (
     cast,
 )
 
-from rich.text import Text
-
-from .constants import INFINITY
-from .rich_utils import Cmd2SimpleTable
-
-if TYPE_CHECKING:  # pragma: no cover
-    from .cmd2 import Cmd
-
 from rich.table import Column
+from rich.text import Text
 
-from .argparse_custom import (
-    ChoicesCallable,
-    generate_range_error,
+from .argparse_utils import (
+    Cmd2ArgumentParser,
+    build_range_error,
 )
-from .command_definition import CommandSet
+from .command_set import CommandSet
 from .completion import (
     CompletionItem,
     Completions,
-    all_display_numeric,
 )
+from .constants import INFINITY
 from .exceptions import CompletionError
+from .rich_utils import Cmd2SimpleTable
+from .types import (
+    CmdOrSetT,
+    UnboundChoicesProvider,
+    UnboundCompleter,
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .cmd2 import Cmd
+
 
 # Name of the choice/completer function argument that, if present, will be passed a dictionary of
 # command line tokens up through the token being completed mapped to their argparse destination name.
-ARG_TOKENS = 'arg_tokens'
+ARG_TOKENS = "arg_tokens"
 
 
-def _build_hint(parser: argparse.ArgumentParser, arg_action: argparse.Action) -> str:
+def _build_hint(parser: Cmd2ArgumentParser, arg_action: argparse.Action) -> str:
     """Build completion hint for a given argument."""
     # Check if hinting is disabled for this argument
     suppress_hint = arg_action.get_suppress_tab_hint()  # type: ignore[attr-defined]
     if suppress_hint or arg_action.help == argparse.SUPPRESS:
-        return ''
+        return ""
 
     # Use the parser's help formatter to display just this action's help text
     formatter = parser._get_formatter()
@@ -64,12 +64,12 @@ def _build_hint(parser: argparse.ArgumentParser, arg_action: argparse.Action) ->
     return formatter.format_help()
 
 
-def _single_prefix_char(token: str, parser: argparse.ArgumentParser) -> bool:
+def _single_prefix_char(token: str, parser: Cmd2ArgumentParser) -> bool:
     """Is a token just a single flag prefix character."""
     return len(token) == 1 and token[0] in parser.prefix_chars
 
 
-def _looks_like_flag(token: str, parser: argparse.ArgumentParser) -> bool:
+def _looks_like_flag(token: str, parser: Cmd2ArgumentParser) -> bool:
     """Determine if a token looks like a flag.
 
     Unless an argument has nargs set to argparse.REMAINDER, then anything that looks like a flag
@@ -90,7 +90,7 @@ def _looks_like_flag(token: str, parser: argparse.ArgumentParser) -> bool:
         return False
 
     # Flags can't have a space
-    return ' ' not in token
+    return " " not in token
 
 
 class _ArgumentState:
@@ -133,19 +133,19 @@ class _UnfinishedFlagError(CompletionError):
 
         :param flag_arg_state: information about the unfinished flag action.
         """
-        arg = f'{argparse._get_action_name(flag_arg_state.action)}'
-        err = f'{generate_range_error(flag_arg_state.min, flag_arg_state.max)}'
+        arg = f"{argparse._get_action_name(flag_arg_state.action)}"
+        err = f"{build_range_error(flag_arg_state.min, flag_arg_state.max)}"
         error = f"Error: argument {arg}: {err} ({flag_arg_state.count} entered)"
         super().__init__(error)
 
 
 class _NoResultsError(CompletionError):
-    def __init__(self, parser: argparse.ArgumentParser, arg_action: argparse.Action) -> None:
+    def __init__(self, parser: Cmd2ArgumentParser, arg_action: argparse.Action) -> None:
         """CompletionError which occurs when there are no results.
 
         If hinting is allowed on this argument, then its hint text will display.
 
-        :param parser: ArgumentParser instance which owns the action being completed
+        :param parser: Cmd2ArgumentParser instance which owns the action being completed
         :param arg_action: action being completed.
         """
         # Set apply_style to False because we don't want hints to look like errors
@@ -157,14 +157,14 @@ class ArgparseCompleter:
 
     def __init__(
         self,
-        parser: argparse.ArgumentParser,
-        cmd2_app: 'Cmd',
+        parser: Cmd2ArgumentParser,
+        cmd2_app: "Cmd",
         *,
         parent_tokens: Mapping[str, MutableSequence[str]] | None = None,
     ) -> None:
         """Create an ArgparseCompleter.
 
-        :param parser: ArgumentParser instance
+        :param parser: Cmd2ArgumentParser instance
         :param cmd2_app: reference to the Cmd2 application that owns this ArgparseCompleter
         :param parent_tokens: optional Mapping of parent parsers' arg names to their tokens
                               This is only used by ArgparseCompleter when recursing on subcommand parsers
@@ -187,7 +187,7 @@ class ArgparseCompleter:
         self._positional_actions: list[argparse.Action] = []
 
         # This will be set if self._parser has subcommands
-        self._subcommand_action: argparse._SubParsersAction[argparse.ArgumentParser] | None = None
+        self._subcommand_action: argparse._SubParsersAction[Cmd2ArgumentParser] | None = None
 
         # Start digging through the argparse structures.
         # _actions is the top level container of parameter definitions
@@ -214,7 +214,7 @@ class ArgparseCompleter:
         endidx: int,
         tokens: Sequence[str],
         *,
-        cmd_set: CommandSet | None = None,
+        cmd_set: CommandSet[Any] | None = None,
     ) -> Completions:
         """Complete text using argparse metadata.
 
@@ -248,7 +248,7 @@ class ArgparseCompleter:
         used_flags: set[str] = set()
 
         # Keeps track of arguments we've seen and any tokens they consumed
-        consumed_arg_values: dict[str, list[str]] = defaultdict(list)
+        consumed_arg_values: dict[str, list[str]] = {}
 
         # Completed mutually exclusive groups
         completed_mutex_groups: dict[argparse._MutuallyExclusiveGroup, argparse.Action] = {}
@@ -256,7 +256,7 @@ class ArgparseCompleter:
         def consume_argument(arg_state: _ArgumentState, arg_token: str) -> None:
             """Consume token as an argument."""
             arg_state.count += 1
-            consumed_arg_values[arg_state.action.dest].append(arg_token)
+            consumed_arg_values.setdefault(arg_state.action.dest, []).append(arg_token)
 
         #############################################################################################
         # Parse all but the last token
@@ -269,14 +269,14 @@ class ArgparseCompleter:
 
             # If we're in a flag REMAINDER arg, force all future tokens to go to that until a double dash is hit
             if flag_arg_state is not None and flag_arg_state.is_remainder:
-                if token == '--':  # noqa: S105
+                if token == "--":  # noqa: S105
                     flag_arg_state = None
                 else:
                     consume_argument(flag_arg_state, token)
                 continue
 
             # Handle '--' which tells argparse all remaining arguments are non-flags
-            if token == '--' and not skip_remaining_flags:  # noqa: S105
+            if token == "--" and not skip_remaining_flags:  # noqa: S105
                 # Check if there is an unfinished flag
                 if (
                     flag_arg_state is not None
@@ -333,7 +333,7 @@ class ArgparseCompleter:
                         # filter them from future completion results and clear any previously
                         # recorded values for this destination.
                         used_flags.update(action.option_strings)
-                        consumed_arg_values[action.dest].clear()
+                        consumed_arg_values[action.dest] = []
 
                     new_arg_state = _ArgumentState(action)
 
@@ -357,9 +357,8 @@ class ArgparseCompleter:
                     action = remaining_positionals.popleft()
 
                     # Are we at a subcommand? If so, forward to the matching completer
-                    if action == self._subcommand_action:
+                    if self._subcommand_action is not None and action == self._subcommand_action:
                         if token in self._subcommand_action.choices:
-                            # Merge self._parent_tokens and consumed_arg_values
                             parent_tokens = {**self._parent_tokens, **consumed_arg_values}
 
                             # Include the subcommand name if its destination was set
@@ -438,8 +437,8 @@ class ArgparseCompleter:
                     if arg_action == completer_action:
                         return
 
-                    arg_str = f'{argparse._get_action_name(arg_action)}'
-                    completer_str = f'{argparse._get_action_name(completer_action)}'
+                    arg_str = f"{argparse._get_action_name(arg_action)}"
+                    completer_str = f"{argparse._get_action_name(completer_action)}"
                     error = f"Error: argument {arg_str}: not allowed with argument {completer_str}"
                     raise CompletionError(error)
 
@@ -470,7 +469,7 @@ class ArgparseCompleter:
         consumed_arg_values: dict[str, list[str]],
         used_flags: set[str],
         skip_remaining_flags: bool,
-        cmd_set: CommandSet | None,
+        cmd_set: CommandSet[Any] | None,
     ) -> Completions:
         """Perform final completion step handling positionals and flags."""
         # Check if we are completing a flag name. This check ignores strings with a length of one, like '-'.
@@ -554,7 +553,7 @@ class ArgparseCompleter:
                     match_against.append(flag)
 
         # Build a dictionary linking actions with their matched flag names
-        matched_actions: dict[argparse.Action, list[str]] = defaultdict(list)
+        matched_actions: dict[argparse.Action, list[str]] = {}
 
         # Keep flags sorted in the order provided by argparse so our completion
         # suggestions display the same as argparse help text.
@@ -562,23 +561,23 @@ class ArgparseCompleter:
 
         for flag in matched_flags.to_strings():
             action = self._flag_to_action[flag]
-            matched_actions[action].append(flag)
+            matched_actions.setdefault(action, []).append(flag)
 
         # For completion suggestions, group matched flags by action
         items: list[CompletionItem] = []
         for action, option_strings in matched_actions.items():
-            flag_text = ', '.join(option_strings)
+            flag_text = ", ".join(option_strings)
 
             # Mark optional flags with brackets
             if not action.required:
-                flag_text = '[' + flag_text + ']'
+                flag_text = "[" + flag_text + "]"
 
             # Use the first option string as the completion result for this action
             items.append(
                 CompletionItem(
                     option_strings[0],
                     display=flag_text,
-                    display_meta=action.help or '',
+                    display_meta=action.help or "",
                 )
             )
 
@@ -643,12 +642,15 @@ class ArgparseCompleter:
             # the 3rd or more argument here.
             destination = destination[min(len(destination) - 1, arg_state.count)]
 
-        # Determine if all display values are numeric so we can right-align them
-        all_nums = all_display_numeric(completions.items)
-
         # Build header row
         rich_columns: list[Column] = []
-        rich_columns.append(Column(destination.upper(), justify="right" if all_nums else "left", no_wrap=True))
+        rich_columns.append(
+            Column(
+                destination.upper(),
+                justify="right" if completions.numeric_display else "left",
+                no_wrap=True,
+            )
+        )
         rich_columns.extend(
             column if isinstance(column, Column) else Column(column, overflow="fold") for column in table_columns
         )
@@ -707,51 +709,50 @@ class ArgparseCompleter:
                 return
         self._parser.print_help(file=file)
 
-    def _get_raw_choices(self, arg_state: _ArgumentState) -> list[CompletionItem] | ChoicesCallable | None:
-        """Extract choices from action or return the choices_callable."""
-        if arg_state.action.choices is not None:
-            # If choices are subcommands, then get their help text to populate display_meta.
-            if isinstance(arg_state.action, argparse._SubParsersAction):
-                parser_help = {}
-                for action in arg_state.action._choices_actions:
-                    if action.dest in arg_state.action.choices:
-                        subparser = arg_state.action.choices[action.dest]
-                        parser_help[subparser] = action.help or ''
-
-                return [
-                    CompletionItem(name, display_meta=parser_help.get(subparser, ''))
-                    for name, subparser in arg_state.action.choices.items()
-                ]
-
-            # Standard choices
+    def _choices_to_items(self, arg_state: _ArgumentState) -> list[CompletionItem]:
+        """Convert choices from action to list of CompletionItems."""
+        if arg_state.action.choices is None:
+            return []
+
+        # If choices are subcommands, then get their help text to populate display_meta.
+        if isinstance(arg_state.action, argparse._SubParsersAction):
+            parser_help = {}
+            for action in arg_state.action._choices_actions:
+                if action.dest in arg_state.action.choices:
+                    subparser = arg_state.action.choices[action.dest]
+                    parser_help[subparser] = action.help or ""
+
             return [
-                choice if isinstance(choice, CompletionItem) else CompletionItem(choice) for choice in arg_state.action.choices
+                CompletionItem(name, display_meta=parser_help.get(subparser, ""))
+                for name, subparser in arg_state.action.choices.items()
             ]
 
-        choices_callable: ChoicesCallable | None = arg_state.action.get_choices_callable()  # type: ignore[attr-defined]
-        return choices_callable
+        # Standard choices
+        return [
+            choice if isinstance(choice, CompletionItem) else CompletionItem(choice) for choice in arg_state.action.choices
+        ]
 
     def _prepare_callable_params(
         self,
-        choices_callable: ChoicesCallable,
+        to_call: UnboundChoicesProvider[CmdOrSetT] | UnboundCompleter[CmdOrSetT],
         arg_state: _ArgumentState,
         text: str,
         consumed_arg_values: dict[str, list[str]],
-        cmd_set: CommandSet | None,
+        cmd_set: CommandSet[Any] | None,
     ) -> tuple[list[Any], dict[str, Any]]:
         """Resolve the instance and arguments required to call a choices/completer function."""
         args: list[Any] = []
         kwargs: dict[str, Any] = {}
 
         # Resolve the 'self' instance for the method
-        self_arg = self._cmd2_app._resolve_func_self(choices_callable.to_call, cmd_set)
+        self_arg = self._cmd2_app._resolve_func_self(to_call, cmd_set)
         if self_arg is None:
-            raise CompletionError("Could not find CommandSet instance matching defining type for completer")
+            raise CompletionError("Could not find CommandSet instance matching defining type")
 
         args.append(self_arg)
 
         # Check if the function expects 'arg_tokens'
-        to_call_params = inspect.signature(choices_callable.to_call).parameters
+        to_call_params = inspect.signature(to_call).parameters
         if ARG_TOKENS in to_call_params:
             arg_tokens = {**self._parent_tokens, **consumed_arg_values}
             arg_tokens.setdefault(arg_state.action.dest, []).append(text)
@@ -768,33 +769,40 @@ class ArgparseCompleter:
         arg_state: _ArgumentState,
         consumed_arg_values: dict[str, list[str]],
         *,
-        cmd_set: CommandSet | None = None,
+        cmd_set: CommandSet[Any] | None = None,
     ) -> Completions:
         """Completion routine for an argparse argument.
 
         :return: a Completions object
         :raises CompletionError: if the completer or choices function this calls raises one
         """
-        raw_choices = self._get_raw_choices(arg_state)
-        if not raw_choices:
-            return Completions()
-
-        # Check if the argument uses a completer function
-        if isinstance(raw_choices, ChoicesCallable) and raw_choices.is_completer:
-            args, kwargs = self._prepare_callable_params(raw_choices, arg_state, text, consumed_arg_values, cmd_set)
+        # Check if the argument uses a completer
+        completer = arg_state.action.get_completer()  # type: ignore[attr-defined]
+        if completer is not None:
+            args, kwargs = self._prepare_callable_params(
+                completer,
+                arg_state,
+                text,
+                consumed_arg_values,
+                cmd_set,
+            )
             args.extend([text, line, begidx, endidx])
-            completions = raw_choices.completer(*args, **kwargs)
+            completions: Completions = completer(*args, **kwargs)
 
-        # Otherwise it uses a choices list or choices provider function
+        # Otherwise it uses a choices provider or choices list
         else:
-            all_choices: list[CompletionItem] = []
-
-            if isinstance(raw_choices, ChoicesCallable):
-                args, kwargs = self._prepare_callable_params(raw_choices, arg_state, text, consumed_arg_values, cmd_set)
-                choices_func = raw_choices.choices_provider
-                all_choices = list(choices_func(*args, **kwargs))
+            choices_provider = arg_state.action.get_choices_provider()  # type: ignore[attr-defined]
+            if choices_provider is not None:
+                args, kwargs = self._prepare_callable_params(
+                    choices_provider,
+                    arg_state,
+                    text,
+                    consumed_arg_values,
+                    cmd_set,
+                )
+                all_choices = list(choices_provider(*args, **kwargs))
             else:
-                all_choices = raw_choices
+                all_choices = self._choices_to_items(arg_state)
 
             # Filter used values and run basic completion
             used_values = consumed_arg_values.get(arg_state.action.dest, [])