- Fixed dataclass from pydantic not working (#100 comment).

- Added support for pydantic models and attr defines similar to dataclasses.
- Support for python 3.6 will be removed in v5.0.0. New features added in future v4 releases are not guaranteed to work with python 3.6.

Author: mauvilsa

CHANGELOG.rst

@@ -15,12 +15,18 @@ paths are considered internals and can change in minor and patch releases.
 v4.21.0 (2023-04-??)
 --------------------
 
+Added
+^^^^^
+- Support for pydantic models and attr defines similar to dataclasses.
+
 Fixed
 ^^^^^
 - `str` parameter in subclass incorrectly parsed as dict with implicit `null`
   value (`#262 <https://github.com/omni-us/jsonargparse/issues/262>`__).
 - Wrong error indentation for subclass in union (`pytorch-lightning#17254
   <https://github.com/Lightning-AI/lightning/issues/17254>`__).
+- ``dataclass`` from pydantic not working (`#100 (comment)
+  <https://github.com/omni-us/jsonargparse/issues/100#issuecomment-1408413796>`__).
 
 Changed
 ^^^^^^^
@@ -30,6 +36,11 @@ Changed
   (`pytorch-lightning#17247
   <https://github.com/Lightning-AI/lightning/issues/17247>`__).
 
+Deprecated
+^^^^^^^^^^
+- Support for python 3.6 will be removed in v5.0.0. New features added in
+  future v4 releases are not guaranteed to work with python 3.6.
+
 
 v4.20.1 (2023-03-30)
 --------------------

README.rst

@@ -433,7 +433,9 @@ Some notes about this support are:
 - ``dataclasses`` are supported as a type but only for pure data classes and not
   nested in a type. By pure it is meant that the class only inherits from data
   classes. Not a mixture of normal classes and data classes. Data classes as
-  fields of other data classes is supported.
+  fields of other data classes is supported. Pydantic's ``dataclass`` decorator
+  and ``BaseModel`` classes, and attrs' ``define`` decorator are supported
+  like standard dataclasses. Though, this support is currently experimental.
 
 - To set a value to ``None`` it is required to use ``null`` since this is how
   json/yaml defines it. To avoid confusion in the help, ``NoneType`` is

jsonargparse/optionals.py

@@ -25,6 +25,8 @@
 ruyaml_support = find_spec('ruyaml') is not None
 omegaconf_support = find_spec('omegaconf') is not None
 reconplogger_support = find_spec('reconplogger') is not None
+pydantic_support = find_spec('pydantic') is not None
+attrs_support = find_spec('attrs') is not None
 
 _config_read_mode = 'fr'
 _docstring_parse_options = {
@@ -133,6 +135,18 @@ def import_reconplogger(importer):
     return reconplogger
 
 
+def import_pydantic(importer):
+    with missing_package_raise('pydantic', importer):
+        import pydantic
+    return pydantic
+
+
+def import_attrs(importer):
+    with missing_package_raise('attrs', importer):
+        import attrs
+    return attrs
+
+
 def set_config_read_mode(
     urls_enabled: bool = False,
     fsspec_enabled: bool = False,
@@ -207,15 +221,16 @@ def parse_docstring(component, params=False, logger=None):
 
 
 def parse_docs(component, parent, logger):
-    docs = []
+    docs = {}
     if docstring_parser_support:
         doc_sources = [component]
         if inspect.isclass(parent) and component.__name__ == '__init__':
-            doc_sources = [parent] + doc_sources
+            doc_sources += [parent]
         for src in doc_sources:
             doc = parse_docstring(src, params=True, logger=logger)
             if doc:
-                docs.append(doc)
+                for param in doc.params:
+                    docs[param.arg_name] = param.description
     return docs
 
 

jsonargparse/parameter_resolvers.py

@@ -80,7 +80,7 @@ def is_staticmethod(attr) -> bool:
 
 
 def is_method(attr) -> bool:
-    return inspect.isfunction(attr) and not is_staticmethod(attr)
+    return (inspect.isfunction(attr) or attr.__class__.__name__ == 'cython_function_or_method') and not is_staticmethod(attr)
 
 
 def is_property(attr) -> bool:
@@ -265,10 +265,7 @@ def get_signature_parameters_and_indexes(component, parent, logger):
         params = params[1:]
     args_idx = get_arg_kind_index(params, kinds.VAR_POSITIONAL)
     kwargs_idx = get_arg_kind_index(params, kinds.VAR_KEYWORD)
-    doc_params = {}
-    for doc in parse_docs(component, parent, logger):
-        for param in doc.params:
-            doc_params[param.arg_name] = param.description
+    doc_params = parse_docs(component, parent, logger)
     for num, param in enumerate(params):
         params[num] = ParamData(
             doc=doc_params.get(param.name),
@@ -767,6 +764,37 @@ def get_parameters_by_assumptions(
     return params
 
 
+def get_parameters_from_pydantic(
+    function_or_class: Union[Callable, Type],
+    method_or_property: Optional[str],
+    logger: logging.Logger,
+) -> Optional[ParamList]:
+    from .optionals import import_pydantic, pydantic_support
+    if not pydantic_support or method_or_property:
+        return None
+    pydantic = import_pydantic('get_parameters_from_pydantic')
+    if not is_subclass(function_or_class, pydantic.BaseModel):
+        return None
+    params = []
+    doc_params = parse_docs(function_or_class, None, logger)
+    for field in function_or_class.__fields__.values():  # type: ignore
+        if field.required:
+            default = inspect._empty
+        elif field.default_factory:
+            default = field.default_factory()
+        else:
+            default = field.default
+        params.append(ParamData(
+            name=field.name,
+            annotation=field.annotation,
+            default=default,
+            kind=kinds.KEYWORD_ONLY,
+            doc=field.field_info.description or doc_params.get(field.name),
+            component=function_or_class,
+        ))
+    return params
+
+
 def get_signature_parameters(
     function_or_class: Union[Callable, Type],
     method_or_property: Optional[str] = None,
@@ -787,6 +815,9 @@ def get_signature_parameters(
     """
     logger = parse_logger(logger, 'get_signature_parameters')
     try:
+        params = get_parameters_from_pydantic(function_or_class, method_or_property, logger)
+        if params is not None:
+            return params
         visitor = ParametersVisitor(function_or_class, method_or_property, logger=logger)
         return visitor.get_parameters()
     except Exception as ex:

jsonargparse/signatures.py

@@ -8,7 +8,13 @@
 from typing import Any, Callable, List, Optional, Set, Tuple, Type, Union
 
 from .actions import _ActionConfigLoad
-from .optionals import get_doc_short_description
+from .optionals import (
+    attrs_support,
+    get_doc_short_description,
+    import_attrs,
+    import_pydantic,
+    pydantic_support,
+)
 from .parameter_resolvers import (
     ParamData,
     get_parameter_origins,
@@ -411,20 +417,18 @@ def add_dataclass_arguments(
                     default = theclass(**default)
             if not isinstance(default, theclass):
                 raise ValueError(f'Expected "default" argument to be an instance of "{theclass.__name__}" or its kwargs dict, given {default}')
-            defaults = dataclasses.asdict(default)
+            defaults = dataclass_to_dict(default)
 
         added_args: List[str] = []
-        params = {p.name: p for p in get_signature_parameters(theclass, None, logger=self.logger)}
-        for field in dataclasses.fields(theclass):
-            if field.name in params:
-                self._add_signature_parameter(
-                    group,
-                    nested_key,
-                    params[field.name],
-                    added_args,
-                    fail_untyped=fail_untyped,
-                    default=defaults.get(field.name, inspect_empty),
-                )
+        for param in get_signature_parameters(theclass, None, logger=self.logger):
+            self._add_signature_parameter(
+                group,
+                nested_key,
+                param,
+                added_args,
+                fail_untyped=fail_untyped,
+                default=defaults.get(param.name, inspect_empty),
+            )
 
         return added_args
 
@@ -550,7 +554,24 @@ def is_pure_dataclass(value):
     if not inspect.isclass(value):
         return False
     classes = [c for c in inspect.getmro(value) if c != object]
-    return all(dataclasses.is_dataclass(c) for c in classes)
+    all_dataclasses = all(dataclasses.is_dataclass(c) for c in classes)
+    if not all_dataclasses and pydantic_support:
+        pydantic = import_pydantic('is_pure_dataclass')
+        classes = [c for c in classes if c != pydantic.utils.Representation]
+        all_dataclasses = all(is_subclass(c, pydantic.BaseModel) for c in classes)
+    if not all_dataclasses and attrs_support:
+        attrs = import_attrs('is_pure_dataclass')
+        if attrs.has(value):
+            return True
+    return all_dataclasses
+
+
+def dataclass_to_dict(value):
+    if pydantic_support:
+        pydantic = import_pydantic('dataclass_to_dict')
+        if isinstance(value, pydantic.BaseModel):
+            return value.dict()
+    return dataclasses.asdict(value)
 
 
 def compose_dataclasses(*args):