cli-command-parser 2024.4.20__tar.gz → 2024.5.18.post1__tar.gz

{cli_command_parser-2024.4.20/lib/cli_command_parser.egg-info → cli_command_parser-2024.5.18.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cli_command_parser
-Version: 2024.4.20
+Version: 2024.5.18.post1
 Summary: CLI Command Parser
 Home-page: https://github.com/dskrypa/cli_command_parser
 Author: Doug Skrypa
@@ -34,7 +34,7 @@ Requires-Dist: astunparse; python_version < "3.9" and extra == "conversion"
 CLI Command Parser
 ##################
 
-|downloads| |py_version| |coverage_badge| |build_status| |Blue|
+|downloads| |py_version| |coverage_badge| |build_status| |Ruff|
 
 .. |py_version| image:: https://img.shields.io/badge/python-3.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20-blue
     :target: https://pypi.org/project/cli-command-parser/
@@ -45,8 +45,8 @@ CLI Command Parser
 .. |build_status| image:: https://github.com/dskrypa/cli_command_parser/actions/workflows/run-tests.yml/badge.svg
     :target: https://github.com/dskrypa/cli_command_parser/actions/workflows/run-tests.yml
 
-.. |Blue| image:: https://img.shields.io/badge/code%20style-blue-blue.svg
-    :target: https://blue.readthedocs.io/
+.. |Ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
+    :target: https://docs.astral.sh/ruff/
 
 .. |downloads| image:: https://img.shields.io/pypi/dm/cli-command-parser
     :target: https://pypistats.org/packages/cli-command-parser

{cli_command_parser-2024.4.20 → cli_command_parser-2024.5.18.post1}/lib/cli_command_parser/__version__.py

@@ -1,7 +1,7 @@
 __title__ = 'cli_command_parser'
 __description__ = 'CLI Command Parser'
 __url__ = 'https://github.com/dskrypa/cli_command_parser'
-__version__ = '2024.04.20'
+__version__ = '2024.05.18-1'
 __author__ = 'Doug Skrypa'
 __author_email__ = 'dskrypa@gmail.com'
 __license__ = 'Apache 2.0'

{cli_command_parser-2024.4.20 → cli_command_parser-2024.5.18.post1}/lib/cli_command_parser/annotations.py

@@ -5,8 +5,9 @@ Utilities for extracting types from annotations.
 """
 
 from collections.abc import Collection, Iterable
+from functools import lru_cache
 from inspect import isclass
-from typing import Union, Optional, get_type_hints, get_origin, get_args as _get_args  # pylint: disable=C0412
+from typing import Union, Optional, get_type_hints as _get_type_hints, get_origin, get_args as _get_args
 
 try:
     from types import NoneType
@@ -15,9 +16,10 @@ except ImportError:  # Added in 3.10
 
 __all__ = ['get_descriptor_value_type']
 
+get_type_hints = lru_cache()(_get_type_hints)  # Cache the attr:annotation mapping for each Command class
+
 
 def get_descriptor_value_type(command_cls: type, attr: str) -> Optional[type]:
-    # TODO: Optimize this to cache get_type_hints for a given class?
     try:
         annotation = get_type_hints(command_cls)[attr]
     except (KeyError, NameError):  # KeyError due to attr missing; NameError for forward references

{cli_command_parser-2024.4.20 → cli_command_parser-2024.5.18.post1}/lib/cli_command_parser/command_parameters.py

@@ -12,25 +12,26 @@ from __future__ import annotations
 
 from collections import defaultdict
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Collection, Iterator, List, Dict, Set, Tuple
+from typing import TYPE_CHECKING, Collection, Iterator, Optional
 
-from .config import CommandConfig, AmbiguousComboMode
-from .exceptions import CommandDefinitionError, ParameterDefinitionError, AmbiguousShortForm, AmbiguousCombo
-from .parameters.base import ParamBase, Parameter, BaseOption, BasePositional
-from .parameters import SubCommand, PassThru, ActionFlag, ParamGroup, Action, help_action
+from .config import AmbiguousComboMode, CommandConfig
+from .exceptions import AmbiguousCombo, AmbiguousShortForm, CommandDefinitionError, ParameterDefinitionError
+from .parameters import Action, ActionFlag, ParamGroup, PassThru, SubCommand, help_action
+from .parameters.base import BaseOption, BasePositional, ParamBase, Parameter
 
 if TYPE_CHECKING:
     from .context import Context
     from .formatting.commands import CommandHelpFormatter
     from .typing import CommandCls, Strings
 
-__all__ = ['CommandParameters']
+    OptionMap = dict[str, BaseOption]
+    ActionFlags = list[ActionFlag]
 
-OptionMap = Dict[str, BaseOption]
-ActionFlags = List[ActionFlag]
+__all__ = ['CommandParameters']
 
 
 class CommandParameters:
+    # fmt: off
     command: CommandCls                                  #: The Command associated with this CommandParameters object
     formatter: CommandHelpFormatter                      #: The formatter used for this Command's help text
     command_parent: Optional[CommandCls]                 #: The parent Command, if any
@@ -39,13 +40,14 @@ class CommandParameters:
     _pass_thru: Optional[PassThru] = None                #: A PassThru Parameter, if specified
     sub_command: Optional[SubCommand] = None             #: A SubCommand Parameter, if specified
     action_flags: ActionFlags                            #: List of action flags
-    split_action_flags: Tuple[ActionFlags, ActionFlags]  #: Action flags split by before/after main
-    options: List[BaseOption]                            #: List of optional Parameters
+    split_action_flags: tuple[ActionFlags, ActionFlags]  #: Action flags split by before/after main
+    options: list[BaseOption]                            #: List of optional Parameters
     combo_option_map: OptionMap                          #: Mapping of {short opt: Parameter} (no dash characters)
-    groups: List[ParamGroup]                             #: List of ParamGroup objects
-    positionals: List[BasePositional]                    #: List of positional Parameters
-    _deferred_positionals: List[BasePositional] = ()     #: Positional Parameters that are deferred to sub commands
+    groups: list[ParamGroup]                             #: List of ParamGroup objects
+    positionals: list[BasePositional]                    #: List of positional Parameters
+    _deferred_positionals: list[BasePositional] = ()     #: Positional Parameters that are deferred to sub commands
     option_map: OptionMap                                #: Mapping of {--opt / -opt: Parameter}
+    # fmt: on
 
     def __init__(
         self,
@@ -83,7 +85,7 @@ class CommandParameters:
     # endregion
 
     @cached_property
-    def all_positionals(self) -> List[BasePositional]:
+    def all_positionals(self) -> list[BasePositional]:
         try:
             if not self.parent.sub_command:
                 return self.parent.all_positionals + self.positionals
@@ -91,7 +93,7 @@ class CommandParameters:
             pass
         return self.positionals
 
-    def get_positionals_to_parse(self, ctx: Context) -> List[BasePositional]:
+    def get_positionals_to_parse(self, ctx: Context) -> list[BasePositional]:
         if self.all_positionals:
             for i, param in enumerate(self.all_positionals):
                 if not ctx.num_provided(param):
@@ -170,13 +172,13 @@ class CommandParameters:
         self._process_options(options)
         self._process_groups(groups)
 
-    def _process_groups(self, groups: Set[ParamGroup]):
+    def _process_groups(self, groups: set[ParamGroup]):
         if self.parent:
             self.groups = sorted((*self.parent.groups, *groups)) if groups else self.parent.groups.copy()
         else:
             self.groups = sorted(groups) if groups else []
 
-    def _process_positionals(self, params: List[BasePositional]):
+    def _process_positionals(self, params: list[BasePositional]):
         unfollowable = action_or_sub_cmd = split_index = None
         if self.parent and (deferred := self.parent._deferred_positionals):
             params = deferred + params
@@ -216,7 +218,7 @@ class CommandParameters:
 
         self.positionals = params
 
-    def _process_options(self, params: List[BaseOption]):
+    def _process_options(self, params: list[BaseOption]):
         if parent := self.parent:
             option_map = parent.option_map.copy()
             combo_option_map = parent.combo_option_map.copy()
@@ -298,7 +300,7 @@ class CommandParameters:
     # region Ambiguous Short Combo Handling
 
     @cached_property
-    def _classified_combo_options(self) -> Tuple[OptionMap, OptionMap]:
+    def _classified_combo_options(self) -> tuple[OptionMap, OptionMap]:
         multi_char_combos = {}
         items = self.combo_option_map.items()
         for combo, param in items:
@@ -308,7 +310,7 @@ class CommandParameters:
         return {}, multi_char_combos
 
     @cached_property
-    def _potentially_ambiguous_combo_opts(self) -> Dict[str, Tuple[BaseOption, OptionMap]]:
+    def _potentially_ambiguous_combo_opts(self) -> dict[str, tuple[BaseOption, OptionMap]]:
         return _find_ambiguous_combos(*self._classified_combo_options)
 
     @cached_property
@@ -357,7 +359,7 @@ class CommandParameters:
 
     def short_option_to_param_value_pairs(
         self, option: str
-    ) -> Tuple[List[Tuple[str, BaseOption, Optional[str]]], bool]:
+    ) -> tuple[list[tuple[str, BaseOption, Optional[str]]], bool]:
         option, eq, value = option.partition('=')
         if eq:  # An `=` was present in the string
             # Note: if the option is not in this Command's option_map, the KeyError is handled by CommandParser
@@ -404,7 +406,7 @@ class CommandParameters:
 
 def _find_ambiguous_combos(
     single_char_combos: OptionMap, multi_char_combos: OptionMap
-) -> Dict[str, Tuple[BaseOption, OptionMap]]:
+) -> dict[str, tuple[BaseOption, OptionMap]]:
     ambiguous_combo_options = {}
     for combo, param in multi_char_combos.items():
         if singles := {c: single_char_combos[c] for c in combo if c in single_char_combos}:

{cli_command_parser-2024.4.20 → cli_command_parser-2024.5.18.post1}/lib/cli_command_parser/commands.py

@@ -9,10 +9,10 @@ from __future__ import annotations
 import logging
 from abc import ABC
 from contextlib import ExitStack
-from typing import TYPE_CHECKING, Type, Sequence, Optional, overload
+from typing import TYPE_CHECKING, Optional, Sequence, Type, overload
 
-from .core import CommandMeta, get_top_level_commands, get_params
-from .context import Context, ActionPhase, get_or_create_context
+from .context import ActionPhase, Context, get_or_create_context
+from .core import CommandMeta, get_params, get_top_level_commands
 from .exceptions import ParamConflict
 from .parser import parse_args_and_get_next_cmd
 from .utils import maybe_await
@@ -20,7 +20,7 @@ from .utils import maybe_await
 if TYPE_CHECKING:
     from .typing import Bool, CommandObj
 
-__all__ = ['Command', 'main']
+__all__ = ['Command', 'AsyncCommand', 'main']
 log = logging.getLogger(__name__)
 
 Argv = Sequence[str]
@@ -54,12 +54,12 @@ class Command(ABC, metaclass=CommandMeta):
     @classmethod
     @overload
     def parse_and_run(cls: Type[CommandObj], argv: Argv = None, **kwargs) -> Optional[CommandObj]:
-        ...  # These overloads indicate that an instance of the same type or another may be returned
+        # These overloads indicate that an instance of the same type or another may be returned
+        ...
 
     @classmethod
     @overload
-    def parse_and_run(cls, argv: Argv = None, **kwargs) -> Optional[CommandObj]:
-        ...
+    def parse_and_run(cls, argv: Argv = None, **kwargs) -> Optional[CommandObj]: ...
 
     @classmethod
     def parse_and_run(cls, argv=None, **kwargs):
@@ -94,13 +94,11 @@ class Command(ABC, metaclass=CommandMeta):
 
     @classmethod
     @overload
-    def parse(cls: Type[CommandObj], argv: Argv = None) -> CommandObj:
-        ...
+    def parse(cls: Type[CommandObj], argv: Argv = None) -> CommandObj: ...
 
     @classmethod
     @overload
-    def parse(cls, argv: Argv = None) -> CommandObj:
-        ...
+    def parse(cls, argv: Argv = None) -> CommandObj: ...
 
     @classmethod
     def parse(cls, argv=None):

{cli_command_parser-2024.4.20 → cli_command_parser-2024.5.18.post1}/lib/cli_command_parser/compat.py

@@ -8,8 +8,9 @@ The :class:`WCTextWrapper` in this module extends the stdlib :class:`python:text
 characters.
 """
 
+from __future__ import annotations
+
 from textwrap import TextWrapper
-from typing import List
 
 from .utils import wcswidth
 
@@ -24,7 +25,7 @@ class WCTextWrapper(TextWrapper):
     optional ``wcwidth`` dependency is available).  Minimal formatting changes are applied.  No logic has been changed.
     """
 
-    def _wrap_chunks(self, chunks: List[str]) -> List[str]:
+    def _wrap_chunks(self, chunks: list[str]) -> list[str]:
         """
         _wrap_chunks(chunks : [string]) -> [string]
 

{cli_command_parser-2024.4.20 → cli_command_parser-2024.5.18.post1}/lib/cli_command_parser/config.py

@@ -8,8 +8,10 @@ from __future__ import annotations
 
 from collections import ChainMap
 from enum import Enum
-from typing import TYPE_CHECKING, Optional, Any, Union, Callable, Type, TypeVar, Generic, overload, Dict
+from string import whitespace
+from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, Sequence, Type, TypeVar, Union, overload
 
+from .exceptions import CommandDefinitionError
 from .utils import FixedFlag, MissingMixin, _NotSet, positive_int
 
 if TYPE_CHECKING:
@@ -17,7 +19,7 @@ if TYPE_CHECKING:
     from .error_handling import ErrorHandler
     from .formatting.commands import CommandHelpFormatter
     from .formatting.params import ParamHelpFormatter
-    from .typing import Bool, ParamOrGroup, CommandType
+    from .typing import Bool, CommandType, ParamOrGroup
 
 __all__ = [
     'CommandConfig',
@@ -49,11 +51,13 @@ class ShowDefaults(FixedFlag):
     is equivalent to ``ShowDefaults.MISSING | ShowDefaults.NEVER``, which will result in no default values being shown.
     """
 
+    # fmt: off
     NEVER = 1       #: Never include the default value in help text
     MISSING = 2     #: Only include the default value if ``default:`` is not already present
     TRUTHY = 4      #: Only include the default value if it is treated as True in a boolean context
     NON_EMPTY = 8   #: Only include the default value if it is not ``None`` or an empty container
     ANY = 16        #: Any default value, regardless of truthiness, will be included
+    # fmt: on
 
     @classmethod
     def _missing_(cls, value: Union[str, int]) -> ShowDefaults:
@@ -104,6 +108,7 @@ class OptionNameMode(FixedFlag):
         - ``'underscore'`` or ``'dash'`` or ``'both'`` or ``'both_underscore'`` or ``'both_dash'`` or ``'none'``
     """
 
+    # fmt: off
     UNDERSCORE = 1
     DASH = 2
     BOTH = 3                # = 1|2
@@ -111,6 +116,7 @@ class OptionNameMode(FixedFlag):
     BOTH_UNDERSCORE = 15    # & 8  -> show only underscore version
     BOTH_DASH = 23          # & 16 -> show only dash version
     NONE = 32
+    # fmt: on
 
     @classmethod
     def _missing_(cls, value: Union[str, int, None]) -> OptionNameMode:
@@ -153,9 +159,11 @@ class SubcommandAliasHelpMode(MissingMixin, Enum):
       ``Alias of: <first choice/alias value>``.
     """
 
+    # fmt: off
     REPEAT = 'repeat'       # Repeat the description as if it was a separate subcommand
     COMBINE = 'combine'     # Combine aliases onto a single line
     ALIAS = 'alias'         # Indicate the subcommand that it is an alias for; do not repeat the description
+    # fmt: on
 
 
 CmdAliasMode = Union[SubcommandAliasHelpMode, str]
@@ -176,9 +184,11 @@ class AmbiguousComboMode(MissingMixin, Enum):
       input.
     """
 
+    # fmt: off
     IGNORE = 'ignore'           # Ignore potentially ambiguous combinations of short options entirely
     PERMISSIVE = 'permissive'   # Allow multi-char short options that overlap with a single char one for exact matches
     STRICT = 'strict'           # Reject multi-char short options that overlap with a single char one before parsing
+    # fmt: on
 
 
 class AllowLeadingDash(Enum):
@@ -193,9 +203,11 @@ class AllowLeadingDash(Enum):
     :NEVER: Never allow values with a leading dash.
     """
 
+    # fmt: off
     NUMERIC = 'numeric'     # Allow a leading dash when the value is numeric
     ALWAYS = 'always'       # Always allow a leading dash
     NEVER = 'never'         # Never allow a leading dash
+    # fmt: on
 
     @classmethod
     def _missing_(cls, value):
@@ -218,6 +230,13 @@ class AllowLeadingDash(Enum):
 
 
 class ConfigItem(Generic[CV, DV]):
+    """
+    A single configurable setting in the :class:`CommandConfig`.
+
+    :param default: Default config value to use if no explicit value is provided
+    :param type: A class or other callable that will be called to validate/normalize provided values
+    """
+
     __slots__ = ('default', 'type', 'name')
 
     def __init__(self, default: DV, type: Callable[..., CV] = None):  # noqa
@@ -229,17 +248,16 @@ class ConfigItem(Generic[CV, DV]):
         owner.FIELDS.add(name)
 
     @overload
-    def __get__(self, instance: None, owner: Type[CommandConfig]) -> ConfigItem[CV, DV]:
-        ...
+    def __get__(self, instance: None, owner: Type[CommandConfig]) -> ConfigItem[CV, DV]: ...
 
     @overload
-    def __get__(self, instance: CommandConfig, owner: Type[CommandConfig]) -> ConfigValue:
-        ...
+    def __get__(self, instance: CommandConfig, owner: Type[CommandConfig]) -> ConfigValue: ...
 
     def __get__(self, instance, owner):
-        if instance is None:
+        try:
+            return instance._data.get(self.name, self.default)
+        except AttributeError:  # instance is None
             return self
-        return instance._data.get(self.name, self.default)
 
     def __set__(self, instance: CommandConfig, value: ConfigValue):
         if instance._read_only:
@@ -261,6 +279,8 @@ class ConfigItem(Generic[CV, DV]):
 
 
 class DynamicConfigItem(ConfigItem):
+    # A ConfigItem with a setter :paramref:`.ConfigItem.type` defined as a method in :class:`CommandConfig`.
+
     __slots__ = ('__doc__',)
 
     def __init__(self, default: DV, type: Callable[..., CV]):  # noqa
@@ -372,6 +392,35 @@ class CommandConfig:
     #: Whether there should be a visual indicator in help text for the parameters that are members of a given group
     show_group_tree: Bool = ConfigItem(False, bool)
 
+    @config_item(('\u00a6 ', '\u2551 ', '\u2502 '))
+    def group_tree_spacers(self, value: tuple[str, str, str] | Sequence[str]) -> tuple[str, str, str]:
+        """
+        The spacer characters to use at the beginning of each line when :attr:`.show_group_tree` is True.
+
+        The default spacers:
+
+        +--------------------+-----------+------------------------------+
+        | Parameter Type     | Character | Character Name               |
+        +====================+===========+==============================+
+        | Mutually Exclusive | \u00a6         | BROKEN BAR                   |
+        +--------------------+-----------+------------------------------+
+        | Mutually dependent | \u2551         | BOX DRAWINGS DOUBLE VERTICAL |
+        +--------------------+-----------+------------------------------+
+        | Other              | \u2502         | BOX DRAWINGS LIGHT VERTICAL  |
+        +--------------------+-----------+------------------------------+
+
+        :param value: A 3-tuple (or other sequence with 3 items) of spacer strings to be used for
+          (mutually exclusive, mutually dependent, other) group members, respectively.
+        :return: The validated and normalized value (or the default value if this property is accessed without
+          providing explicit values)
+        """
+        # Note: extra spaces in the docstring table are intentional - the escape sequences each collapse to one char
+        if isinstance(value, Sequence) and len(value) == 3 and all(isinstance(v, str) for v in value):
+            return tuple(f'{v} ' if v and v[-1] not in whitespace else v for v in value)  # noqa
+        raise CommandDefinitionError(
+            f'Invalid group_tree_spacers={value!r} - expected a 3-tuple of 2-character strings'
+        )
+
     #: Whether mutually exclusive / dependent groups should include that fact in their descriptions
     show_group_type: Bool = ConfigItem(True, bool)
 
@@ -386,16 +435,17 @@ class CommandConfig:
     #: they were successfully detected
     extended_epilog: Bool = ConfigItem(True, bool)
 
-    #: Width (in characters) for the usage column in help text
+    #: Width (in characters) for the usage column in help text, after which the parameter descriptions begin.
     usage_column_width: int = ConfigItem(30, int)
 
-    #: Min width (in chars) for the usage column in help text after adjusting for group indentation / terminal width
-    min_usage_column_width: int = ConfigItem(20, int)
+    #: Whether the :attr:`.usage_column_width` should be enforced for parameters with usage text parts that exceed it.
+    #: By default, that setting only defines where the parameter descriptions begin.
+    strict_usage_column_width: bool = ConfigItem(False, bool)
 
     @config_item(False)
     def wrap_usage_str(self, value: Any) -> Union[int, bool]:
         """
-        Wrap the basic usage string after the specified number of characters, or automatically based on terminal size
+        Wrap the basic usage line after the specified number of characters, or automatically based on terminal size
         if ``True`` is specified instead.
         """
         if value is True or value is False:
@@ -432,7 +482,7 @@ class CommandConfig:
         settings = ', '.join(f'{k}={v!r}' for k, v in self.as_dict(False).items())
         return f'<{self.__class__.__name__}[depth={len(self._data.maps)}]({settings})>'
 
-    def as_dict(self, full: Bool = True) -> Dict[str, Any]:
+    def as_dict(self, full: Bool = True) -> dict[str, Any]:
         """Return a dict representing the configured options."""
         if full:
             return {key: getattr(self, key) for key in self.FIELDS}

{cli_command_parser-2024.4.20 → cli_command_parser-2024.5.18.post1}/lib/cli_command_parser/context.py

@@ -13,20 +13,19 @@ from contextlib import AbstractContextManager
 from contextvars import ContextVar
 from enum import Enum
 from functools import cached_property
-from inspect import Signature, Parameter as _Parameter
-from typing import TYPE_CHECKING, Any, Callable, Union, Sequence, Optional, Iterator, Collection, cast
-from typing import Dict, Tuple, List
+from inspect import Parameter as _Parameter, Signature
+from typing import TYPE_CHECKING, Any, Callable, Collection, Iterator, Optional, Sequence, Union, cast
 
-from .config import CommandConfig, DEFAULT_CONFIG
+from .config import DEFAULT_CONFIG, CommandConfig
 from .error_handling import ErrorHandler, NullErrorHandler, extended_error_handler
 from .exceptions import NoActiveContext
-from .utils import _NotSet, Terminal
+from .utils import Terminal, _NotSet
 
 if TYPE_CHECKING:
     from .command_parameters import CommandParameters
     from .commands import Command
-    from .parameters import Parameter, Option, ActionFlag
-    from .typing import Bool, ParamOrGroup, CommandType, CommandObj, AnyConfig, OptStr, StrSeq, PathLike  # noqa
+    from .parameters import ActionFlag, Option, Parameter
+    from .typing import AnyConfig, Bool, CommandObj, CommandType, OptStr, ParamOrGroup, PathLike, StrSeq  # noqa
 
 __all__ = ['Context', 'ctx', 'get_current_context', 'get_or_create_context', 'get_context', 'get_parsed', 'get_raw_arg']
 
@@ -49,7 +48,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
     allow_argv_prog: Bool = True
     _command_obj: CommandObj = None
     _terminal_width: Optional[int]
-    _provided: Dict[ParamOrGroup, int]
+    _provided: dict[ParamOrGroup, int]
 
     def __init__(
         self,
@@ -158,7 +157,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
         recursive: Bool = True,
         default: Any = None,
         include_defaults: Bool = True,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """
         Returns all of the parsed arguments as a dictionary.
 
@@ -247,7 +246,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
         """Not intended to be called by users.  Used by Parameters during parsing to handle nargs."""
         return self._provided[param]
 
-    def get_missing(self) -> List[Parameter]:
+    def get_missing(self) -> list[Parameter]:
         """Not intended to be called by users.  Used during parsing to determine if any Parameters are missing."""
         return [p for p in self.params.required_check_params() if not self._provided[p]]
 
@@ -260,7 +259,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
     # region Actions
 
     @cached_property
-    def _parsed_action_flags(self) -> Tuple[int, List[ActionFlag], List[ActionFlag]]:
+    def _parsed_action_flags(self) -> tuple[int, list[ActionFlag], list[ActionFlag]]:
         """
         Not intended to be accessed by users.  Returns a tuple containing the total number of action flags provided, the
         action flags to run before main, and the action flags to run after main.
@@ -281,13 +280,13 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
         return self._parsed_action_flags[0]
 
     @cached_property
-    def all_action_flags(self) -> List[ActionFlag]:
+    def all_action_flags(self) -> list[ActionFlag]:
         """Not intended to be accessed by users.  Returns all parsed action flags."""
         _, before_main, after_main = self._parsed_action_flags
         return before_main + after_main
 
     @cached_property
-    def categorized_action_flags(self) -> Dict[ActionPhase, Sequence[ActionFlag]]:
+    def categorized_action_flags(self) -> dict[ActionPhase, Sequence[ActionFlag]]:
         """
         Not intended to be accessed by users.  Returns a dict of parsed action flags, categorized by the
         :class:`ActionPhase` during which they will run.
@@ -321,7 +320,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
 
 
 def _normalize_config(
-    config: AnyConfig, kwargs: Dict[str, Any], parent: Context | None, command: CommandType | None
+    config: AnyConfig, kwargs: dict[str, Any], parent: Context | None, command: CommandType | None
 ) -> CommandConfig:
     if config is not None:
         if kwargs:
@@ -469,7 +468,7 @@ def get_context(command: Command) -> Context:
 
 def get_parsed(
     command: Command, to_call: Callable = None, default: Any = None, include_defaults: Bool = True
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     Provides a way to obtain all of the arguments that were parsed for the given Command as a dictionary.