Minor improvements

Author: mauvilsa

DOCUMENTATION.rst

@@ -505,11 +505,11 @@ Some notes about this support are:
   are not required to be ``runtime_checkable``. But the accepted classes must
   match exactly the signature of the protocol's public methods.
 
-- ``dataclasses`` are supported even when nested. Final classes, attrs'
-  ``define`` decorator, and pydantic's ``dataclass`` decorator and ``BaseModel``
-  classes are supported and behave like standard dataclasses. For more details
-  see :ref:`subclasses-disabled`. If a dataclass is mixed inheriting from a normal
-  class, it is considered a subclass type instead of a dataclass.
+- ``dataclasses`` are supported even when nested and by default don't accept
+  subclasses. Final classes, attrs' ``define``, pydantic's ``dataclass`` and
+  pydantic's ``BaseModel`` classes are supported and behave like standard
+  dataclasses. For more details see :ref:`subclasses-disabled`. If a dataclass
+  is mixed inheriting from a normal class, by default it will accept subclasses.
 
 - User-defined ``Generic`` types are supported. For more details see
   :ref:`generic-types`.
@@ -2374,6 +2374,13 @@ specific dataclass, the following can be done:
         subclasses_disabled=[DataClassBaseType],
     )
 
+.. note::
+
+    Enabling subclass support for types is currently experimental. While the
+    interface and behavior is expected to be stable, fundamental issues may
+    arise that require changes to the design, which could result in breaking
+    changes in future releases.
+
 
 .. _argument-linking:
 

jsonargparse/_common.py

@@ -140,17 +140,16 @@ def set_parsing_settings(
             with ``omegaconf+`` parser mode, absolute interpolation paths are
             converted to relative. This is only intended for backward
             compatibility with ``omegaconf`` parser mode.
-        subclasses_disabled: List of types or functions, to configure that
-            when parsing only the exact type hints (not their subclasses) are
-            accepted. Descendants of the configured types are also disabled.
-            Functions should return True for types to disable.
-        subclasses_enabled: List of types or disable function names, to
-            configure that subclasses are accepted. Types given here have
-            precedence over those in ``subclasses_disabled``. Giving a function
-            name removes the corresponding function from
-            ``subclasses_disabled``. By default, the following disable functions
-            are registered: ``is_pure_dataclass``, ``is_pydantic_model``,
-            ``is_attrs_class`` and ``is_final_class``.
+        subclasses_disabled: List of types or functions, so that when parsing
+            only the exact type hints (not their subclasses) are accepted.
+            Descendants of the configured types are also disabled. Functions
+            should return ``True`` for types to disable.
+        subclasses_enabled: List of types or disable function names, so that
+            subclasses are accepted. Types given here have precedence over those
+            in ``subclasses_disabled``. Giving a function name removes the
+            corresponding function from ``subclasses_disabled``. By default, the
+            following disable functions are registered: ``is_pure_dataclass``,
+            ``is_pydantic_model``, ``is_attrs_class`` and ``is_final_class``.
     """
     # validate_defaults
     if isinstance(validate_defaults, bool):
@@ -187,8 +186,8 @@ def set_parsing_settings(
     # subclass behavior
     if subclasses_disabled or subclasses_enabled:
         subclass_type_behavior(
-            subclasses_disabled=subclasses_disabled or [],
-            subclasses_enabled=subclasses_enabled or [],
+            subclasses_disabled=subclasses_disabled,
+            subclasses_enabled=subclasses_enabled,
         )
 
 
@@ -326,11 +325,11 @@ def is_subclasses_disabled(cls) -> bool:
 
 
 def subclass_type_behavior(
-    subclasses_disabled: list[Union[type, Callable[[type], bool]]] = [],
-    subclasses_enabled: list[Union[type, str]] = [],
+    subclasses_disabled: Optional[list[Union[type, Callable[[type], bool]]]] = None,
+    subclasses_enabled: Optional[list[Union[type, str]]] = None,
 ) -> None:
     """Configures whether class types accept or not subclasses."""
-    for enable_item in subclasses_enabled:
+    for enable_item in subclasses_enabled or []:
         if isinstance(enable_item, str):
             if enable_item not in subclasses_disabled_selectors:
                 raise ValueError(f"There is no function '{enable_item}' registered in subclasses_disabled")
@@ -342,7 +341,7 @@ def subclass_type_behavior(
                 f"Expected 'subclasses_enabled' list items to be types or strings, but got {enable_item!r}"
             )
 
-    for disable_item in subclasses_disabled:
+    for disable_item in subclasses_disabled or []:
         if inspect.isclass(disable_item):
             subclasses_disabled_types.add(disable_item)
         elif inspect.isfunction(disable_item):