Apply pyupgrade jsonargparse.* modules to use Python 3.9+ syntax (#798)

Author: mauvilsa

CHANGELOG.rst

@@ -35,6 +35,8 @@ Changed
   <https://github.com/omni-us/jsonargparse/pull/792>`__).
 - Non-parsing actions now have a common base class to ease identification
   (`#793 <https://github.com/omni-us/jsonargparse/pull/793>`__).
+- ``jsonargparse.*`` modules now use Python 3.9+ syntax (`#798
+  <https://github.com/omni-us/jsonargparse/pull/798>`__).
 
 Deprecated
 ^^^^^^^^^^

jsonargparse/_actions.py

@@ -7,7 +7,7 @@
 from argparse import Action as ArgparseAction
 from contextlib import contextmanager
 from contextvars import ContextVar
-from typing import Any, Dict, List, Optional, Tuple, Type, Union
+from typing import Any, Optional, Union
 
 from ._common import Action, NonParsingAction, is_not_subclass_type, is_subclass, parser_context
 from ._loaders_dumpers import get_loader_exceptions, load_value
@@ -48,8 +48,8 @@ def _is_branch_key(parser, key: str) -> bool:
 def _find_action_and_subcommand(
     parser: Union[ArgumentParser, ActionsContainer],
     dest: str,
-    exclude: Optional[Union[Type[ArgparseAction], Tuple[Type[ArgparseAction], ...]]] = None,
-) -> Tuple[Optional[ArgparseAction], Optional[str]]:
+    exclude: Optional[Union[type[ArgparseAction], tuple[type[ArgparseAction], ...]]] = None,
+) -> tuple[Optional[ArgparseAction], Optional[str]]:
     """Finds an action in a parser given its destination key.
 
     Args:
@@ -85,16 +85,16 @@ def _find_action_and_subcommand(
 def _find_action(
     parser: Union[ArgumentParser, ActionsContainer],
     dest: str,
-    exclude: Optional[Union[Type[ArgparseAction], Tuple[Type[ArgparseAction], ...]]] = None,
+    exclude: Optional[Union[type[ArgparseAction], tuple[type[ArgparseAction], ...]]] = None,
 ) -> Optional[ArgparseAction]:
     return _find_action_and_subcommand(parser, dest, exclude=exclude)[0]
 
 
 def _find_parent_action_and_subcommand(
     parser: ArgumentParser,
     key: str,
-    exclude: Optional[Union[Type[ArgparseAction], Tuple[Type[ArgparseAction], ...]]] = None,
-) -> Tuple[Optional[ArgparseAction], Optional[str]]:
+    exclude: Optional[Union[type[ArgparseAction], tuple[type[ArgparseAction], ...]]] = None,
+) -> tuple[Optional[ArgparseAction], Optional[str]]:
     action, subcommand = _find_action_and_subcommand(parser, key, exclude=exclude)
     if action is None and "." in key:
         parts = split_key(key)
@@ -108,7 +108,7 @@ def _find_parent_action_and_subcommand(
 def _find_parent_action(
     parser: ArgumentParser,
     key: str,
-    exclude: Optional[Union[Type[ArgparseAction], Tuple[Type[ArgparseAction], ...]]] = None,
+    exclude: Optional[Union[type[ArgparseAction], tuple[type[ArgparseAction], ...]]] = None,
 ) -> Optional[ArgparseAction]:
     return _find_parent_action_and_subcommand(parser, key, exclude=exclude)[0]
 
@@ -304,7 +304,7 @@ def is_print_config_requested(parser):
 
 
 class _ActionConfigLoad(Action):
-    def __init__(self, basetype: Optional[Type] = None, **kwargs):
+    def __init__(self, basetype: Optional[type] = None, **kwargs):
         if len(kwargs) == 0:
             self._basetype = basetype
         else:
@@ -344,7 +344,7 @@ def check_type(self, value, parser):
 
 
 class _ActionHelpClassPath(NonParsingAction):
-    sub_add_kwargs: Dict[str, Any] = {}
+    sub_add_kwargs: dict[str, Any] = {}
 
     @classmethod
     def get_help_types(cls, typehint) -> Optional[tuple]:
@@ -727,7 +727,7 @@ def get_subcommands(
         cfg: Namespace,
         prefix: str = "",
         fail_no_subcommand: bool = True,
-    ) -> Tuple[Optional[List[str]], Optional[List[ArgumentParser]]]:
+    ) -> tuple[Optional[list[str]], Optional[list[ArgumentParser]]]:
         """Returns subcommand names and corresponding subparsers."""
         if parser._subcommands_action is None:
             return None, None
@@ -783,7 +783,7 @@ def get_subcommand(
         cfg: Namespace,
         prefix: str = "",
         fail_no_subcommand: bool = True,
-    ) -> Tuple[Optional[str], Optional[ArgumentParser]]:
+    ) -> tuple[Optional[str], Optional[ArgumentParser]]:
         """Returns a single subcommand name and corresponding subparser."""
         subcommands, subparsers = _ActionSubCommands.get_subcommands(
             parser,

jsonargparse/_cli.py

@@ -1,7 +1,7 @@
 """Simple creation of command line interfaces."""
 
 import inspect
-from typing import Any, Callable, Dict, List, Optional, Type, Union
+from typing import Any, Callable, Optional, Union
 
 from ._actions import ActionConfigFile, _ActionPrintConfig, remove_actions
 from ._core import ArgumentParser
@@ -17,9 +17,9 @@
 ]
 
 
-ComponentType = Union[Callable, Type]
-DictComponentsType = Dict[str, Union[ComponentType, "DictComponentsType"]]
-ComponentsType = Optional[Union[ComponentType, List[ComponentType], DictComponentsType]]
+ComponentType = Union[Callable, type]
+DictComponentsType = dict[str, Union[ComponentType, "DictComponentsType"]]
+ComponentsType = Optional[Union[ComponentType, list[ComponentType], DictComponentsType]]
 
 
 def CLI(*args, **kwargs):
@@ -29,12 +29,12 @@ def CLI(*args, **kwargs):
 
 def auto_cli(
     components: ComponentsType = None,
-    args: Optional[List[str]] = None,
+    args: Optional[list[str]] = None,
     config_help: str = default_config_option_help,
-    set_defaults: Optional[Dict[str, Any]] = None,
+    set_defaults: Optional[dict[str, Any]] = None,
     as_positional: bool = True,
     fail_untyped: bool = True,
-    parser_class: Type[ArgumentParser] = ArgumentParser,
+    parser_class: type[ArgumentParser] = ArgumentParser,
     **kwargs,
 ):
     """Simple creation of command line interfaces.

jsonargparse/_common.py

@@ -7,13 +7,9 @@
 from contextvars import ContextVar
 from typing import (  # type: ignore[attr-defined]
     Callable,
-    Dict,
     Generic,
-    List,
     Optional,
     Protocol,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     _GenericAlias,
@@ -51,11 +47,11 @@
 
 
 class InstantiatorCallable(Protocol):
-    def __call__(self, class_type: Type[ClassType], *args, **kwargs) -> ClassType:
+    def __call__(self, class_type: type[ClassType], *args, **kwargs) -> ClassType:
         pass  # pragma: no cover
 
 
-InstantiatorsDictType = Dict[Tuple[type, bool], InstantiatorCallable]
+InstantiatorsDictType = dict[tuple[type, bool], InstantiatorCallable]
 
 
 parent_parser: ContextVar[Optional[ArgumentParser]] = ContextVar("parent_parser", default=None)
@@ -64,7 +60,7 @@ def __call__(self, class_type: Type[ClassType], *args, **kwargs) -> ClassType:
 lenient_check: ContextVar[Union[bool, str]] = ContextVar("lenient_check", default=False)
 load_value_mode: ContextVar[Optional[str]] = ContextVar("load_value_mode", default=None)
 class_instantiators: ContextVar[Optional[InstantiatorsDictType]] = ContextVar("class_instantiators", default=None)
-nested_links: ContextVar[List[dict]] = ContextVar("nested_links", default=[])
+nested_links: ContextVar[list[dict]] = ContextVar("nested_links", default=[])
 applied_instantiation_links: ContextVar[Optional[set]] = ContextVar("applied_instantiation_links", default=None)
 path_dump_preserve_relative: ContextVar[bool] = ContextVar("path_dump_preserve_relative", default=False)
 
@@ -287,7 +283,7 @@ def is_pure_dataclass(cls) -> bool:
     return all(dataclasses.is_dataclass(c) for c in classes)
 
 
-not_subclass_type_selectors: Dict[str, Callable[[Type], Union[bool, int]]] = {
+not_subclass_type_selectors: dict[str, Callable[[type], Union[bool, int]]] = {
     "final": is_final_class,
     "dataclass": is_pure_dataclass,
     "pydantic": is_pydantic_model,
@@ -303,15 +299,15 @@ def is_not_subclass_type(cls) -> bool:
     return any(validator(cls) for validator in not_subclass_type_selectors.values())
 
 
-def default_class_instantiator(class_type: Type[ClassType], *args, **kwargs) -> ClassType:
+def default_class_instantiator(class_type: type[ClassType], *args, **kwargs) -> ClassType:
     return class_type(*args, **kwargs)
 
 
 class ClassInstantiator:
     def __init__(self, instantiators: InstantiatorsDictType) -> None:
         self.instantiators = instantiators
 
-    def __call__(self, class_type: Type[ClassType], *args, **kwargs) -> ClassType:
+    def __call__(self, class_type: type[ClassType], *args, **kwargs) -> ClassType:
         for (cls, subclasses), instantiator in self.instantiators.items():
             if class_type is cls or (subclasses and is_subclass(class_type, cls)):
                 param_names = set(inspect.signature(instantiator).parameters)

jsonargparse/_completions.py

@@ -10,7 +10,7 @@
 from enum import Enum
 from importlib.util import find_spec
 from subprocess import PIPE, Popen
-from typing import List, Literal, Union
+from typing import Literal, Union
 
 from ._actions import ActionConfigFile, _ActionConfigLoad, _ActionHelpClassPath, remove_actions
 from ._common import NonParsingAction, get_optionals_as_positionals_actions, get_parsing_setting
@@ -153,10 +153,12 @@ def shtab_prepare_action(action, parser) -> None:
     elif isinstance(action, ActionTypeHint):
         typehint = action._typehint
         if get_typehint_origin(typehint) == Union:
+            assert hasattr(typehint, "__args__")
             subtypes = [s for s in typehint.__args__ if s not in {NoneType, str, dict, list, tuple, bytes}]
             if len(subtypes) == 1:
                 typehint = subtypes[0]
         if is_subclass(typehint, Path):
+            assert hasattr(typehint, "_mode")
             if "f" in typehint._mode:
                 complete = shtab.FILE
             elif "d" in typehint._mode:
@@ -230,7 +232,7 @@ def add_bash_typehint_completion(parser, action, message, choices) -> None:
     action.complete = {"bash": fn_name}
 
 
-def get_typehint_choices(typehint, prefix, parser, skip, choices=None, added_subclasses=None) -> List[str]:
+def get_typehint_choices(typehint, prefix, parser, skip, choices=None, added_subclasses=None) -> list[str]:
     if choices is None:
         choices = []
     if not added_subclasses:
@@ -265,7 +267,7 @@ def get_typehint_choices(typehint, prefix, parser, skip, choices=None, added_sub
     return [] if choices == ["null"] else choices
 
 
-def add_subactions_and_get_subclass_choices(typehint, prefix, parser, skip, added_subclasses) -> List[str]:
+def add_subactions_and_get_subclass_choices(typehint, prefix, parser, skip, added_subclasses) -> list[str]:
     choices = []
     paths = get_all_subclass_paths(typehint)
     init_args = defaultdict(list)
@@ -303,7 +305,7 @@ def add_subactions_and_get_subclass_choices(typehint, prefix, parser, skip, adde
     return choices
 
 
-def get_help_class_choices(typehint) -> List[str]:
+def get_help_class_choices(typehint) -> list[str]:
     choices = []
     if get_typehint_origin(typehint) == Union:
         for subtype in typehint.__args__: