Fixes for non-stdlib dataclass-like types

CHANGELOG.rst

@@ -11,6 +11,23 @@ The semantic versioning only considers the public API as described in
 :ref:`api-ref`. Components not mentioned in :ref:`api-ref` or different import
 paths are considered internals and can change in minor and patch releases.
 
+v4.28.1 (2024-0?-??)
+--------------------
+
+Added
+^^^^^
+- `TypeAliasType` support added (`#480
+  <https://github.com/omni-us/jsonargparse/issues/480>`__).
+
+Fixed
+^^^^^
+- Attrs and Pydantic 2 dataclasses with non-init fields fail to instantiate
+  (`#480 <https://github.com/omni-us/jsonargparse/issues/480>`__).
+- Default values/factories for Pydantic 2 dataclasses with `Field` initializers
+  are not right (`#480 <https://github.com/omni-us/jsonargparse/issues/480>`__).
+- `Annotated` fields in dataclass-likes (eg FastAPI types) resolve incorrectly
+  (`#480 <https://github.com/omni-us/jsonargparse/issues/480>`__).
+
 
 v4.28.0 (2024-03-??)
 --------------------

DOCUMENTATION.rst

@@ -447,6 +447,9 @@ Some notes about this support are:
   see :ref:`callable-type`. Currently the callable's argument and return types
   are not validated.
 
+- ``TypeAliasType`` is supported with values parsed as the aliased type and the
+  alias shown as the argument type in help.
+
 
 .. _restricted-numbers:
 

jsonargparse/_common.py

@@ -19,7 +19,13 @@
 )
 
 from ._namespace import Namespace
-from ._optionals import import_reconplogger, reconplogger_support
+from ._optionals import (
+    get_alias_target,
+    import_reconplogger,
+    is_alias_type,
+    is_annotated,
+    reconplogger_support,
+)
 from ._type_checking import ArgumentParser
 
 __all__ = [
@@ -99,6 +105,19 @@ def get_generic_origin(cls):
     return cls.__origin__ if is_generic_class(cls) else cls
 
 
+def get_unaliased_type(cls):
+    new_cls = cls
+    while True:
+        cur_cls = new_cls
+        if is_annotated(new_cls):
+            new_cls = new_cls.__origin__
+        if is_alias_type(new_cls):
+            new_cls = get_alias_target(new_cls)
+        if new_cls == cur_cls:
+            break
+    return cur_cls
+
+
 def is_dataclass_like(cls) -> bool:
     if is_generic_class(cls):
         return is_dataclass_like(cls.__origin__)

jsonargparse/_optionals.py

@@ -37,7 +37,7 @@
 
 def typing_extensions_import(name):
     if typing_extensions_support:
-        return getattr(__import__("typing_extensions"), name)
+        return getattr(__import__("typing_extensions"), name, False)
     else:
         return getattr(__import__("typing"), name, False)
 
@@ -313,6 +313,17 @@ def is_annotated(typehint: type) -> bool:
     return annotated_alias and isinstance(typehint, annotated_alias)
 
 
+type_alias_type = typing_extensions_import("TypeAliasType")
+
+
+def is_alias_type(typehint: type) -> bool:
+    return type_alias_type and isinstance(typehint, type_alias_type)
+
+
+def get_alias_target(typehint: type) -> bool:
+    return typehint.__value__  # type: ignore[attr-defined]
+
+
 def get_pydantic_support() -> int:
     support = "0"
     if find_spec("pydantic"):
@@ -331,6 +342,24 @@ def get_pydantic_support() -> int:
 pydantic_support = get_pydantic_support()
 
 
+def get_pydantic_supports_field_init() -> bool:
+    if find_spec("pydantic"):
+        try:
+            from importlib.metadata import version
+
+            support = version("pydantic")
+        except ImportError:
+            import pydantic
+
+            support = pydantic.version.VERSION
+        major, minor = tuple(int(x) for x in support.split(".")[:2])
+        return major > 2 or (major == 2 and minor >= 4)
+    return False
+
+
+pydantic_supports_field_init = get_pydantic_supports_field_init()
+
+
 def is_pydantic_model(class_type) -> int:
     classes = inspect.getmro(class_type) if pydantic_support and inspect.isclass(class_type) else []
     for cls in classes:

jsonargparse/_parameter_resolvers.py

@@ -13,7 +13,15 @@
 from types import MethodType
 from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
 
-from ._common import LoggerProperty, get_generic_origin, is_dataclass_like, is_generic_class, is_subclass, parse_logger
+from ._common import (
+    LoggerProperty,
+    get_generic_origin,
+    get_unaliased_type,
+    is_dataclass_like,
+    is_generic_class,
+    is_subclass,
+    parse_logger,
+)
 from ._optionals import is_pydantic_model, parse_docs
 from ._postponed_annotations import evaluate_postponed_annotations
 from ._stubs_resolver import get_stub_types
@@ -861,9 +869,26 @@ def get_field_data_pydantic1_model(field, name, doc_params):
 
 
 def get_field_data_pydantic2_dataclass(field, name, doc_params):
+    from pydantic.fields import FieldInfo
+    from pydantic_core import PydanticUndefined
+
+    default = inspect._empty
+    if isinstance(field.default, FieldInfo):
+        # Pydantic 2 dataclasses stuff their FieldInfo into a
+        # stdlib dataclasses.field's `default`; this is where the
+        # actual default and default_factory live.
+        if field.default.default is not PydanticUndefined:
+            default = field.default.default
+        elif field.default.default_factory is not PydanticUndefined:
+            default = field.default.default_factory()
+    elif field.default is not dataclasses.MISSING:
+        default = field.default
+    elif field.default_factory is not dataclasses.MISSING:
+        default = field.default_factory()
+
     return dict(
         annotation=field.type,
-        default=field.default,
+        default=default,
         doc=doc_params.get(name),
     )
 
@@ -898,6 +923,19 @@ def get_field_data_attrs(field, name, doc_params):
     )
 
 
+def is_init_field_pydantic2_dataclass(field) -> bool:
+    from pydantic.fields import FieldInfo
+
+    if isinstance(field.default, FieldInfo):
+        # FieldInfo.init is new in pydantic 2.6
+        return getattr(field.default, "init", None) is not False
+    return field.init is not False
+
+
+def is_init_field_attrs(field) -> bool:
+    return field.init is not False
+
+
 def get_parameters_from_pydantic_or_attrs(
     function_or_class: Union[Callable, Type],
     method_or_property: Optional[str],
@@ -907,42 +945,47 @@ def get_parameters_from_pydantic_or_attrs(
 
     if method_or_property or not (pydantic_support or attrs_support):
         return None
-
+    function_or_class = get_unaliased_type(function_or_class)
     fields_iterator = get_field_data = None
     if pydantic_support:
         pydantic_model = is_pydantic_model(function_or_class)
         if pydantic_model == 1:
-            fields_iterator = function_or_class.__fields__.items()  # type: ignore[union-attr]
+            fields_iterator = function_or_class.__fields__.items()
             get_field_data = get_field_data_pydantic1_model
+            is_init_field = lambda _: True
         elif pydantic_model > 1:
-            fields_iterator = function_or_class.model_fields.items()  # type: ignore[union-attr]
+            fields_iterator = function_or_class.model_fields.items()
             get_field_data = get_field_data_pydantic2_model
+            is_init_field = lambda _: True
         elif dataclasses.is_dataclass(function_or_class) and hasattr(function_or_class, "__pydantic_fields__"):
             fields_iterator = dataclasses.fields(function_or_class)
             fields_iterator = {v.name: v for v in fields_iterator}.items()
             get_field_data = get_field_data_pydantic2_dataclass
+            is_init_field = is_init_field_pydantic2_dataclass
 
     if not fields_iterator and attrs_support:
         import attrs
 
         if attrs.has(function_or_class):
             fields_iterator = {f.name: f for f in attrs.fields(function_or_class)}.items()
             get_field_data = get_field_data_attrs
+            is_init_field = is_init_field_attrs
 
     if not fields_iterator or not get_field_data:
         return None
 
     params = []
     doc_params = parse_docs(function_or_class, None, logger)
     for name, field in fields_iterator:
-        params.append(
-            ParamData(
-                name=name,
-                kind=kinds.KEYWORD_ONLY,
-                component=function_or_class,
-                **get_field_data(field, name, doc_params),
+        if is_init_field(field):
+            params.append(
+                ParamData(
+                    name=name,
+                    kind=kinds.KEYWORD_ONLY,
+                    component=function_or_class,
+                    **get_field_data(field, name, doc_params),
+                )
             )
-        )
     evaluate_postponed_annotations(params, function_or_class, None, logger)
     return params
 

jsonargparse/_signatures.py

@@ -8,7 +8,14 @@
 from typing import Any, Callable, List, Optional, Set, Tuple, Type, Union
 
 from ._actions import _ActionConfigLoad
-from ._common import LoggerProperty, get_class_instantiator, get_generic_origin, is_dataclass_like, is_subclass
+from ._common import (
+    LoggerProperty,
+    get_class_instantiator,
+    get_generic_origin,
+    get_unaliased_type,
+    is_dataclass_like,
+    is_subclass,
+)
 from ._optionals import get_doc_short_description, is_pydantic_model, pydantic_support
 from ._parameter_resolvers import (
     ParamData,
@@ -72,7 +79,7 @@ def add_class_arguments(
             ValueError: When not given a class.
             ValueError: When there are required parameters without at least one valid type.
         """
-        if not inspect.isclass(get_generic_origin(theclass)):
+        if not inspect.isclass(get_generic_origin(get_unaliased_type(theclass))):
             raise ValueError(f'Expected "theclass" parameter to be a class type, got: {theclass}.')
         if default and not (isinstance(default, LazyInitBaseClass) and isinstance(default, theclass)):
             raise ValueError(f'Expected "default" parameter to be a lazy instance of the class, got: {default}.')
@@ -133,9 +140,10 @@ def add_method_arguments(
             ValueError: When not given a class or the name of a method of the class.
             ValueError: When there are required parameters without at least one valid type.
         """
-        if not inspect.isclass(get_generic_origin(theclass)):
+        unaliased_type = get_unaliased_type(theclass)
+        if not inspect.isclass(get_generic_origin(unaliased_type)):
             raise ValueError('Expected "theclass" argument to be a class object.')
-        if not hasattr(theclass, themethod) or not callable(getattr(theclass, themethod)):
+        if not hasattr(unaliased_type, themethod) or not callable(getattr(unaliased_type, themethod)):
             raise ValueError('Expected "themethod" argument to be a callable member of the class.')
 
         return self._add_signature_arguments(
@@ -440,7 +448,7 @@ def add_dataclass_arguments(
             if isinstance(default, dict):
                 with suppress(TypeError):
                     default = theclass(**default)
-            if not isinstance(default, theclass):
+            if not isinstance(default, get_unaliased_type(theclass)):
                 raise ValueError(
                     f'Expected "default" argument to be an instance of "{theclass.__name__}" '
                     f"or its kwargs dict, given {default}"

jsonargparse/_typehints.py

@@ -43,6 +43,7 @@
 )
 from ._common import (
     get_class_instantiator,
+    get_unaliased_type,
     is_dataclass_like,
     is_subclass,
     nested_links,
@@ -58,7 +59,9 @@
 from ._namespace import Namespace
 from ._optionals import (
     argcomplete_warn_redraw_prompt,
+    get_alias_target,
     get_files_completer,
+    is_alias_type,
     is_annotated,
     is_annotated_validator,
     typing_extensions_import,
@@ -234,8 +237,8 @@ def prepare_add_argument(args, kwargs, enable_path, container, logger, sub_add_k
     @staticmethod
     def is_supported_typehint(typehint, full=False):
         """Whether the given type hint is supported."""
-        if is_annotated(typehint):
-            typehint = get_typehint_origin(typehint)
+        typehint = get_unaliased_type(typehint)
+
         supported = (
             typehint in root_types
             or get_typehint_origin(typehint) in root_types
@@ -269,6 +272,7 @@ def is_subclass_typehint(typehint, all_subtypes=True, also_lists=False):
         typehint = typehint_from_action(typehint)
         if typehint is None:
             return False
+        typehint = get_unaliased_type(typehint)
         typehint_origin = get_typehint_origin(typehint)
         if typehint_origin == Union or (also_lists and typehint_origin in sequence_origin_types):
             subtypes = [a for a in typehint.__args__ if a != NoneType]
@@ -287,7 +291,7 @@ def is_subclass_typehint(typehint, all_subtypes=True, also_lists=False):
 
     @staticmethod
     def is_return_subclass_typehint(typehint):
-        typehint = get_optional_arg(typehint)
+        typehint = get_unaliased_type(get_optional_arg(get_unaliased_type(typehint)))
         typehint_origin = get_typehint_origin(typehint)
         if typehint_origin in callable_origin_types:
             return_type = get_callable_return_type(typehint)
@@ -297,6 +301,7 @@ def is_return_subclass_typehint(typehint):
 
     @staticmethod
     def is_mapping_typehint(typehint):
+        typehint = get_unaliased_type(typehint)
         typehint_origin = get_typehint_origin(typehint) or typehint
         if (
             typehint in mapping_origin_types
@@ -308,6 +313,7 @@ def is_mapping_typehint(typehint):
 
     @staticmethod
     def is_callable_typehint(typehint, all_subtypes=True):
+        typehint = get_unaliased_type(typehint)
         typehint_origin = get_typehint_origin(typehint)
         if typehint_origin == Union:
             subtypes = [a for a in typehint.__args__ if a != NoneType]
@@ -911,6 +917,10 @@ def adapt_typehints(
             error = indent_text(str(ex))
             raise_unexpected_value(f"Problem with given class_path {class_path!r}:\n{error}", exception=ex)
 
+    # TypeAliasType -- 3.12 `type x = y` or manually via typing_extensions
+    elif is_alias_type(typehint):
+        return adapt_typehints(val, get_alias_target(typehint), **adapt_kwargs)
+
     return val