cli-command-parser 2025.7.13__tar.gz → 2025.11.1__tar.gz

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2022 Doug Skrypa
+   Copyright 2025 Doug Skrypa
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

{cli_command_parser-2025.7.13/lib/cli_command_parser.egg-info → cli_command_parser-2025.11.1}/PKG-INFO

@@ -1,11 +1,8 @@
 Metadata-Version: 2.4
 Name: cli_command_parser
-Version: 2025.7.13
+Version: 2025.11.1
 Summary: CLI Command Parser
-Home-page: https://github.com/dskrypa/cli_command_parser
-Author: Doug Skrypa
-Author-email: dskrypa@gmail.com
-License: Apache 2.0
+Author-email: Doug Skrypa <dskrypa@gmail.com>
 Project-URL: Source, https://github.com/dskrypa/cli_command_parser
 Project-URL: Documentation, https://dskrypa.github.io/cli_command_parser
 Project-URL: Issues, https://github.com/dskrypa/cli_command_parser/issues
@@ -16,14 +13,14 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: User Interfaces
 Classifier: Topic :: Text Processing
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Provides-Extra: wcwidth
@@ -35,7 +32,7 @@ CLI Command Parser
 
 |downloads| |py_version| |coverage_badge| |build_status| |Ruff| |OpenSSF Best Practices|
 
-.. |py_version| image:: https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20-blue
+.. |py_version| image:: https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14%20-blue
     :target: https://pypi.org/project/cli-command-parser/
 
 .. |coverage_badge| image:: https://codecov.io/gh/dskrypa/cli_command_parser/branch/main/graph/badge.svg
@@ -120,8 +117,8 @@ with optional dependencies::
 Python Version Compatibility
 ============================
 
-Python versions 3.9 and above are currently supported.  The last release of CLI Command Parser that supported 3.8 was
-2024-09-07.  Support for Python 3.8 `officially ended on 2024-10-07 <https://devguide.python.org/versions/>`__.
+Python versions 3.10 and above are currently supported.  The last release of CLI Command Parser that supported 3.9 was
+2025-09-27.  Support for Python 3.9 `officially ended on 2025-10-31 <https://devguide.python.org/versions/>`__.
 
 
 Links

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/lib/cli_command_parser/__init__.py

@@ -4,7 +4,7 @@ Command Parser
 :author: Doug Skrypa
 """
 
-from .commands import AsyncCommand, Command, main
+from .commands import AsyncCommand, Command, main, print_help
 from .config import (
     AllowLeadingDash,
     AmbiguousComboMode,

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/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__ = '2025.07.13'
+__version__ = '2025.11.01'
 __author__ = 'Doug Skrypa'
 __author_email__ = 'dskrypa@gmail.com'
 __license__ = 'Apache 2.0'

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/lib/cli_command_parser/annotations.py

@@ -7,19 +7,15 @@ Utilities for extracting types from annotations.
 from collections.abc import Collection, Iterable
 from functools import lru_cache
 from inspect import isclass
-from typing import Optional, Union, get_args, get_origin, get_type_hints as _get_type_hints
-
-try:
-    from types import NoneType
-except ImportError:  # Added in 3.10
-    NoneType = type(None)
+from types import NoneType, UnionType
+from typing import Union, get_args, get_origin, get_type_hints as _get_type_hints
 
 __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]:
+def get_descriptor_value_type(command_cls: type, attr: str) -> type | None:
     try:
         annotation = get_type_hints(command_cls)[attr]
     except (KeyError, NameError):  # KeyError due to attr missing; NameError for forward references
@@ -30,19 +26,19 @@ def get_descriptor_value_type(command_cls: type, attr: str) -> Optional[type]:
     return get_annotation_value_type(annotation)
 
 
-def get_annotation_value_type(annotation, from_union: bool = True, from_collection: bool = True) -> Optional[type]:
+def get_annotation_value_type(annotation, from_union: bool = True, from_collection: bool = True) -> type | None:
     origin = get_origin(annotation)
     # Note: get_origin returns `list` for `List[str]`, `List`, and `list[str]`; it returns `None` for `list`
     if origin is None and isinstance(annotation, type):
         return annotation
     elif from_collection and isclass(origin) and issubclass(origin, (Collection, Iterable)):
         return _type_from_collection(origin, annotation)
-    elif from_union and origin is Union:
+    elif from_union and (origin is Union or origin is UnionType):
         return _type_from_union(annotation)
     return None
 
 
-def _type_from_union(annotation) -> Optional[type]:
+def _type_from_union(annotation) -> type | None:
     args = get_args(annotation)
     # Note: Unions of a single argument return the argument; i.e., Union[T] returns T, so the len can never be 1
     if len(args) == 2 and NoneType in args:
@@ -50,7 +46,7 @@ def _type_from_union(annotation) -> Optional[type]:
     return None
 
 
-def _type_from_collection(origin, annotation) -> Optional[type]:
+def _type_from_collection(origin, annotation) -> type | None:
     if not (args := get_args(annotation)):
         return origin  # The annotation was a collection with no content types specified
     n_args = len(args)

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/lib/cli_command_parser/command_parameters.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 
 from collections import defaultdict
 from functools import cached_property
-from typing import TYPE_CHECKING, Collection, Iterator, Optional
+from typing import TYPE_CHECKING, Collection, Iterator
 
 from .config import AmbiguousComboMode, CommandConfig
 from .exceptions import AmbiguousCombo, AmbiguousShortForm, CommandDefinitionError, ParameterDefinitionError
@@ -34,11 +34,11 @@ 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
-    parent: Optional[CommandParameters]                  #: The parent Command's CommandParameters
-    action: Optional[Action] = None                      #: An Action Parameter, if specified
-    _pass_thru: Optional[PassThru] = None                #: A PassThru Parameter, if specified
-    sub_command: Optional[SubCommand] = None             #: A SubCommand Parameter, if specified
+    command_parent: CommandCls | None                    #: The parent Command, if any
+    parent: CommandParameters | None                     #: The parent Command's CommandParameters
+    action: Action | None = None                         #: An Action Parameter, if specified
+    _pass_thru: PassThru | None = None                   #: A PassThru Parameter, if specified
+    sub_command: SubCommand | None = 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
@@ -52,8 +52,8 @@ class CommandParameters:
     def __init__(
         self,
         command: CommandCls,
-        command_parent: Optional[CommandCls],
-        parent_params: Optional[CommandParameters],
+        command_parent: CommandCls | None,
+        parent_params: CommandParameters | None,
         config: CommandConfig,
     ):
         self.command = command
@@ -65,13 +65,12 @@ class CommandParameters:
     def __repr__(self) -> str:
         positionals = len(self.positionals)
         options = len(self.options)
-        cls_name = self.__class__.__name__
-        return f'<{cls_name}[command={self.command.__name__}, {positionals=}, {options=}]>'
+        return f'<{self.__class__.__name__}[command={self.command.__name__}, {positionals=}, {options=}]>'
 
     # region PassThru Properties
 
     @property
-    def pass_thru(self) -> Optional[PassThru]:
+    def pass_thru(self) -> PassThru | None:
         if self._pass_thru:
             return self._pass_thru
         elif self.parent:
@@ -143,23 +142,26 @@ class CommandParameters:
         groups = set()
 
         for param in self._iter_parameters():
-            if isinstance(param, BasePositional):
-                positionals.append(param)
-            elif isinstance(param, BaseOption):
-                options.append(param)
-            elif isinstance(param, ParamGroup):
-                # Groups will only be discovered here when defined with `as` - ex: `with ParamGroup(...) as foo:`
-                # Group members will always be discovered at the top level since context managers share the outer scope
-                groups.add(param)
-            elif isinstance(param, PassThru):
-                if self.pass_thru:
-                    raise CommandDefinitionError(f'Invalid PassThru {param=} - it cannot follow another PassThru param')
-                self._pass_thru = param
-            else:
-                raise CommandDefinitionError(
-                    f'Unexpected type={param.__class__} for {param=} - custom parameters must extend'
-                    ' BasePositional, BaseOption, or ParamGroup'
-                )
+            match param:
+                case BasePositional():
+                    positionals.append(param)
+                case BaseOption():
+                    options.append(param)
+                case ParamGroup():
+                    # Groups will only be discovered here when defined with `as` - ex: `with ParamGroup(...) as foo:`
+                    # Members will always be discovered at the top level since context managers share the outer scope
+                    groups.add(param)
+                case PassThru():
+                    if self.pass_thru:
+                        raise CommandDefinitionError(
+                            f'Invalid PassThru {param=} - it cannot follow another PassThru param'
+                        )
+                    self._pass_thru = param
+                case _:
+                    raise CommandDefinitionError(
+                        f'Unexpected type={param.__class__} for {param=} - custom parameters must extend'
+                        ' BasePositional, BaseOption, or ParamGroup'
+                    )
 
             param_group = param
             while param_group := param_group.group:
@@ -204,7 +206,7 @@ class CommandParameters:
                     if param.has_choices and 0 in param.nargs:  # It has local choices or is not required
                         unfollowable = param
                 else:  # It's an Action
-                    self.action = action_or_sub_cmd = param
+                    self.action = action_or_sub_cmd = param  # type: ignore
                     if not param.has_choices:
                         raise CommandDefinitionError(f'No choices were registered for {self.action}')
             elif 0 in param.nargs or (param.nargs.variable and not param.has_choices):
@@ -264,7 +266,7 @@ class CommandParameters:
         for param in action_flags:
             if param.func is None:
                 raise ParameterDefinitionError(f'No function was registered for {param=}')
-            grouped_ordered_flags[param.before_main][param.order].append(param)  # noqa  # PyCharm infers the wrong type
+            grouped_ordered_flags[param.before_main][param.order].append(param)
 
         found_non_always = False
         invalid = {}
@@ -301,6 +303,7 @@ class CommandParameters:
 
     @cached_property
     def _classified_combo_options(self) -> tuple[OptionMap, OptionMap]:
+        """Tuple of (single char short:Option map, multi-char short:Option map) for options available in this command"""
         multi_char_combos = {}
         items = self.combo_option_map.items()
         for combo, param in items:
@@ -315,14 +318,9 @@ class CommandParameters:
 
     @cached_property
     def _nested_potentially_ambiguous_combo_options(self):
-        single_char_combos, multi_char_combos = (xcc.copy() for xcc in self._classified_combo_options)
-        for params in self._iter_nested_params():
-            nested_single_char_combos, nested_multi_char_combos = params._classified_combo_options
-            single_char_combos.update(nested_single_char_combos)
-            multi_char_combos.update(nested_multi_char_combos)
-        return _find_ambiguous_combos(single_char_combos, multi_char_combos)
+        return _find_ambiguous_combos(*self.nested_single_and_multi_char_short_options)
 
-    def _is_combo_potentially_ambiguous(self, option: str) -> Optional[bool]:
+    def _is_combo_potentially_ambiguous(self, option: str) -> bool | None:
         # Called by short_option_to_param_value_pairs after ensuring the length is > 1
         to_check = option[1:]  # Strip leading '-'
         # Note: len(to_check) will never be 2 here - this is only called if len(option) > 2
@@ -345,21 +343,34 @@ class CommandParameters:
 
     # endregion
 
+    @cached_property
+    def nested_single_and_multi_char_short_options(self) -> tuple[OptionMap, OptionMap]:
+        single_char_shorts, multi_char_shorts = (xcs.copy() for xcs in self._classified_combo_options)
+        for params in self._iter_nested_params():
+            nested_single_char_shorts, nested_multi_char_shorts = params._classified_combo_options
+            single_char_shorts |= nested_single_char_shorts
+            multi_char_shorts |= nested_multi_char_shorts
+
+        return single_char_shorts, multi_char_shorts
+
     def _iter_nested_params(self) -> Iterator[CommandParameters]:
         if not self.sub_command:
             return
+
         get_params = self.command.__class__.params
+        seen = set()
         for choice in self.sub_command.choices.values():
-            if choice.target is not None:  # None indicates it's a subcommand's local choice
+            # choice.target is the (sub-)Command class that will be used if that choice was selected.  Being None
+            # indicates it's a subcommand's local choice (i.e., get_params would return this CommandParameters object)
+            if choice.target is not None and choice.target not in seen:
+                seen.add(choice.target)  # Some choices may be aliases for the same target Command
                 params: CommandParameters = get_params(choice.target)
                 yield params
                 yield from params._iter_nested_params()
 
     # region Option Processing
 
-    def short_option_to_param_value_pairs(
-        self, option: str
-    ) -> tuple[list[tuple[str, BaseOption, Optional[str]]], bool]:
+    def short_option_to_param_value_pairs(self, option: str) -> tuple[list[tuple[str, BaseOption, str | None]], 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
@@ -393,6 +404,7 @@ class CommandParameters:
         else:
             yield from self.all_positionals
             yield from self.options
+
         if self.pass_thru and self.pass_thru not in exclude:
             yield self.pass_thru
 

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/lib/cli_command_parser/commands.py

@@ -9,18 +9,18 @@ from __future__ import annotations
 import logging
 from abc import ABC
 from contextlib import ExitStack
-from typing import TYPE_CHECKING, Optional, Sequence, Type, overload
+from typing import TYPE_CHECKING, Sequence, TextIO, Type, overload
 
 from .context import ActionPhase, Context, get_or_create_context
 from .core import CommandMeta, get_params, get_top_level_commands
-from .exceptions import ParamConflict
+from .exceptions import ParamConflict, ParserExit
 from .parser import parse_args_and_get_next_cmd
 from .utils import maybe_await
 
 if TYPE_CHECKING:
     from .typing import Bool, CommandObj
 
-__all__ = ['Command', 'AsyncCommand', 'main']
+__all__ = ['Command', 'AsyncCommand', 'main', 'print_help']
 log = logging.getLogger(__name__)
 
 Argv = Sequence[str]
@@ -50,13 +50,13 @@ class Command(ABC, metaclass=CommandMeta):
 
     @classmethod
     @overload
-    def parse_and_run(cls: Type[CommandObj], argv: Argv = None, **kwargs) -> Optional[CommandObj]:
+    def parse_and_run(cls: Type[CommandObj], argv: Argv = None, **kwargs) -> CommandObj | None:
         # 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) -> CommandObj | None: ...
 
     @classmethod
     def parse_and_run(cls, argv=None, **kwargs):
@@ -214,7 +214,7 @@ class Command(ABC, metaclass=CommandMeta):
         """
         self._run_actions_(ActionPhase.BEFORE_MAIN, args, kwargs)
 
-    def main(self, *args, **kwargs) -> Optional[int]:
+    def main(self, *args, **kwargs) -> int | None:
         """
         Primary method that is called when running a Command.
 
@@ -340,7 +340,7 @@ class AsyncCommand(Command, ABC):
         """Asynchronous version of :meth:`Command._before_main_`."""
         await self._run_actions_(ActionPhase.BEFORE_MAIN, args, kwargs)
 
-    async def main(self, *args, **kwargs) -> Optional[int]:
+    async def main(self, *args, **kwargs) -> int | None:
         """Asynchronous version of :meth:`Command.main`."""
         with self._Command__ctx as ctx:  # noqa
             action = get_params(self).action
@@ -355,7 +355,7 @@ class AsyncCommand(Command, ABC):
         await self._run_actions_(ActionPhase.AFTER_MAIN, args, kwargs)
 
 
-def main(argv: Argv = None, return_command: Bool = False, **kwargs) -> Optional[CommandObj]:
+def main(argv: Argv = None, return_command: Bool = False, **kwargs) -> CommandObj | None:
     """
     Convenience function that can be used as the main entry point for a program.
 
@@ -389,3 +389,17 @@ def main(argv: Argv = None, return_command: Bool = False, **kwargs) -> Optional[
 
     command = commands[0].parse_and_run(argv, **kwargs)
     return command if return_command else None
+
+
+def print_help(command: Command, *, exit: bool = True, file: TextIO | None = None):  # noqa
+    """
+    User-callable version of the ``--help`` / ``-h`` action.  Prints help text, then optionally exits.
+
+    :param command: The command for which help text should be printed.
+    :param exit: Whether a :class:`~.ParserExit` exception should be raised after help text is printed.  If True (the
+      default), the program will exit with code 0 (success).  If False, no exception will be raised.
+    :param file: The file-like object (stream) to write to; defaults to the current sys.stdout.
+    """
+    print(get_params(command).formatter.format_help(), file=file)
+    if exit:
+        raise ParserExit

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/lib/cli_command_parser/config.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 from collections import ChainMap
 from enum import Enum
 from string import whitespace
-from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, Sequence, Type, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, Generic, Sequence, Type, TypeVar, overload
 
 from .exceptions import CommandDefinitionError
 from .utils import FixedFlag, MissingMixin, _NotSet, positive_int
@@ -33,7 +33,7 @@ __all__ = [
 
 CV = TypeVar('CV')
 DV = TypeVar('DV')
-ConfigValue = Union[CV, DV]
+ConfigValue = CV | DV
 
 
 # region Config Option Enums
@@ -60,7 +60,7 @@ class ShowDefaults(FixedFlag):
     # fmt: on
 
     @classmethod
-    def _missing_(cls, value: Union[str, int]) -> ShowDefaults:
+    def _missing_(cls, value: str | int) -> ShowDefaults:
         if isinstance(value, str):
             try:
                 return cls._member_map_[value.upper().replace('-', '_')]  # noqa
@@ -119,7 +119,7 @@ class OptionNameMode(FixedFlag):
     # fmt: on
 
     @classmethod
-    def _missing_(cls, value: Union[str, int, None]) -> OptionNameMode:
+    def _missing_(cls, value: str | int | None) -> OptionNameMode:
         try:
             return OPT_NAME_MODE_ALIASES[value]
         except KeyError:
@@ -166,7 +166,7 @@ class SubcommandAliasHelpMode(MissingMixin, Enum):
     # fmt: on
 
 
-CmdAliasMode = Union[SubcommandAliasHelpMode, str]
+CmdAliasMode = SubcommandAliasHelpMode | str
 
 
 class AmbiguousComboMode(MissingMixin, Enum):
@@ -313,7 +313,7 @@ class CommandConfig:
     # region Error Handling Options
 
     #: The :class:`.ErrorHandler` to be used by :meth:`.Command.__call__`
-    error_handler: Optional[ErrorHandler] = ConfigItem(_NotSet)
+    error_handler: ErrorHandler | None = ConfigItem(_NotSet)
 
     #: Whether :meth:`.Command._after_main_` should always be called, even if an exception was raised in
     #: :meth:`.Command.main` (similar to a ``finally`` block)
@@ -443,7 +443,7 @@ class CommandConfig:
     strict_usage_column_width: bool = ConfigItem(False, bool)
 
     @config_item(False)
-    def wrap_usage_str(self, value: Any) -> Union[int, bool]:
+    def wrap_usage_str(self, value: Any) -> int | bool:
         """
         Wrap the basic usage line after the specified number of characters, or automatically based on terminal size
         if ``True`` is specified instead.
@@ -467,7 +467,7 @@ class CommandConfig:
 
     # endregion
 
-    def __init__(self, parent: Optional[CommandConfig] = None, read_only: bool = False, **kwargs):
+    def __init__(self, parent: CommandConfig | None = None, read_only: bool = False, **kwargs):
         self._data = parent._data.new_child() if parent else ChainMap()
         self._read_only = read_only
         if kwargs:

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/lib/cli_command_parser/context.py

@@ -14,7 +14,7 @@ from contextvars import ContextVar
 from enum import Enum
 from functools import cached_property
 from inspect import Parameter as _Parameter, Signature
-from typing import TYPE_CHECKING, Any, Callable, Collection, Iterator, Optional, Sequence, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Collection, Iterator, Sequence, cast
 
 from .config import DEFAULT_CONFIG, CommandConfig
 from .error_handling import ErrorHandler, NullErrorHandler, extended_error_handler
@@ -24,16 +24,16 @@ from .utils import Terminal, _NotSet
 if TYPE_CHECKING:
     from .command_parameters import CommandParameters
     from .commands import Command
-    from .parameters import ActionFlag, BaseOption, Option, Parameter
+    from .parameters import ActionFlag, BaseOption, Parameter
     from .typing import AnyConfig, Bool, CommandObj, CommandType, OptStr, ParamOrGroup, PathLike, StrSeq  # noqa
 
+    Argv = StrSeq | None
+
 __all__ = ['Context', 'ctx', 'get_current_context', 'get_or_create_context', 'get_context', 'get_parsed', 'get_raw_arg']
 
 _context_stack = ContextVar('cli_command_parser.context.stack')
 _TERMINAL = Terminal()
 
-Argv = Optional['StrSeq']
-
 
 class Context(AbstractContextManager):  # Extending AbstractContextManager to make PyCharm's type checker happy
     """
@@ -47,19 +47,19 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
     prog: OptStr = None
     allow_argv_prog: Bool = True
     _command_obj: CommandObj = None
-    _terminal_width: Optional[int]
+    _terminal_width: int | None
     _provided: dict[ParamOrGroup, int]
 
     def __init__(
         self,
         argv: Argv = None,
-        command_cls: Optional[CommandType] = None,
+        command_cls: CommandType | None = None,
         *,
-        parent: Optional[Context] = None,
+        parent: Context | None = None,
         config: AnyConfig = None,
         terminal_width: int = None,
         allow_argv_prog: Bool = None,
-        command: Optional[CommandObj] = None,
+        command: CommandObj | None = None,
         **kwargs,
     ):
         self.command_cls = command_cls
@@ -125,7 +125,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
     def __exit__(self, exc_type, exc_val, exc_tb):
         _context_stack.get().pop()
 
-    def __contains__(self, param: Union[ParamOrGroup, str, Any]) -> bool:
+    def __contains__(self, param: ParamOrGroup | str | Any) -> bool:
         try:
             self._parsed[param]
         except KeyError:
@@ -193,7 +193,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
         return parsed
 
     @cached_property
-    def params(self) -> Optional[CommandParameters]:
+    def params(self) -> CommandParameters | None:
         """
         The :class:`.CommandParameters` object that contains the categorized Parameters from the Command associated
         with this Context.
@@ -202,7 +202,7 @@ class Context(AbstractContextManager):  # Extending AbstractContextManager to ma
             return self.command_cls.__class__.params(self.command_cls)
         return None
 
-    def get_error_handler(self) -> Union[ErrorHandler, NullErrorHandler]:
+    def get_error_handler(self) -> ErrorHandler | NullErrorHandler:
         """Returns the :class:`.ErrorHandler` configured to be used."""
         if (error_handler := self.config.error_handler) is _NotSet:
             return extended_error_handler
@@ -426,7 +426,7 @@ ctx: Context = cast(Context, ContextProxy())
 # region Public / Semi-Public Functions
 
 
-def get_current_context(silent: bool = False) -> Optional[Context]:
+def get_current_context(silent: bool = False) -> Context | None:
     """
     Get the currently active parsing context.
 

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/lib/cli_command_parser/conversion/argparse_ast.py

@@ -8,7 +8,7 @@ from ast import AST, Assign, Call, withitem
 from functools import cached_property, partial
 from inspect import BoundArguments, Signature
 from pathlib import Path
-from typing import TYPE_CHECKING, Callable, Collection, Generic, Iterator, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Callable, Collection, Generic, Iterator, Type, TypeVar
 
 from .argparse_utils import ArgumentParser as _ArgumentParser, SubParsersAction as _SubParsersAction
 from .utils import get_name_repr, iter_module_parents, unparse
@@ -21,8 +21,8 @@ if TYPE_CHECKING:
 __all__ = ['ParserArg', 'ArgGroup', 'MutuallyExclusiveGroup', 'AstArgumentParser', 'SubParser', 'Script']
 log = logging.getLogger(__name__)
 
-InitNode = Union[Call, Assign, withitem]
-OptCall = Union[Call, None]
+InitNode = Call | Assign | withitem
+OptCall = Call | None
 ParserCls = Type['AstArgumentParser']
 ParserObj = TypeVar('ParserObj', bound='AstArgumentParser')
 RepresentedCallable = TypeVar('RepresentedCallable', bound=Callable)
@@ -33,7 +33,7 @@ _NotSet = object()
 
 class Script:
     _parser_classes = {}
-    path: Union[Path, None]
+    path: Path | None
 
     def __init__(self, src_text: str, smart_loop_handling: bool = True, path: PathLike = None):
         self.smart_loop_handling = smart_loop_handling
@@ -162,7 +162,7 @@ class AstCallable:
     def __repr__(self) -> str:
         return f'<{self.__class__.__name__}[{self.init_call_repr()}]>'
 
-    def get_tracked_refs(self, module: str, name: str, default: D = _NotSet) -> Union[set[str], D]:
+    def get_tracked_refs(self, module: str, name: str, default: D = _NotSet) -> set[str] | D:
         for tracked_ref, refs in self._tracked_refs.items():
             if tracked_ref.module == module and tracked_ref.name == name:
                 return refs

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/lib/cli_command_parser/conversion/command_builder.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import keyword
 import logging
 from abc import ABC, abstractmethod
-from ast import Attribute, Constant, DictComp, GeneratorExp, ListComp, Name, SetComp, Str, Subscript, literal_eval
+from ast import Attribute, Constant, DictComp, GeneratorExp, ListComp, Name, SetComp, Subscript, literal_eval
 from dataclasses import dataclass, fields
 from functools import cached_property
 from itertools import count
-from typing import TYPE_CHECKING, Generic, Iterable, Iterator, Optional, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Generic, Iterable, Iterator, Type, TypeVar
 
 from cli_command_parser.nargs import Nargs
 
@@ -45,12 +45,12 @@ class Converter(Generic[AC], ABC):
         if newline_between_members is not None:
             cls.newline_between_members = newline_between_members
 
-    def __init__(self, ast_obj: Union[AC, Script], parent: Optional[Converter] = None):
+    def __init__(self, ast_obj: AC | Script, parent: Converter | None = None):
         self.ast_obj = ast_obj
         self.parent = parent
 
     @classmethod
-    def for_ast_callable(cls, ast_obj: Union[AC, Type[AC]]) -> Type[Converter[AC]]:
+    def for_ast_callable(cls, ast_obj: AC | Type[AC]) -> Type[Converter[AC]]:
         if not isinstance(ast_obj, type):
             ast_obj = ast_obj.__class__
         try:

{cli_command_parser-2025.7.13 → cli_command_parser-2025.11.1}/lib/cli_command_parser/conversion/utils.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 from ast import AST, Attribute, Call, Dict, List, Name, Set, Tuple, expr, unparse
-from typing import Iterator, List as _List, Union
+from typing import Iterator
 
 __all__ = ['get_name_repr', 'iter_module_parents', 'collection_contents']
 
 
-def get_name_repr(node: Union[AST, expr]) -> str:
+def get_name_repr(node: AST | expr) -> str:
     if isinstance(node, Call):
         node = node.func
 
@@ -29,7 +29,7 @@ def iter_module_parents(module: str) -> Iterator[str]:
         module = parent
 
 
-def collection_contents(node: AST) -> _List[str]:
+def collection_contents(node: AST) -> list[str]:
     if isinstance(node, Dict):
         return [unparse(key) for key in node.keys]  # noqa
     elif isinstance(node, (List, Set, Tuple)):