Use validate_default=True for structured union defaults (#3050)

* Use validate_default=True instead of model_validate/TypeAdapter for structured defaults

Replace the ValidatedDefault/TypeAdapter mechanism from #3040 and the
original model_validate() codegen with Pydantic's native validate_default=True.

Instead of generating complex default_factory lambdas like:
  default_factory=lambda: A.model_validate({'type': 'b'})
  default_factory=lambda: TypeAdapter(A | B).validate_python({'type': 'b'})

Now generates:
  Field({'type': 'b'}, validate_default=True)

This lets Pydantic handle union branch selection, dict-to-model coercion,
and RootModel wrapping at runtime. Fixes #3034, fixes #3035.

Removed:
- ValidatedDefault class and SUPPORTS_VALIDATED_DEFAULT flag
- TypeAdapter import in generated code
- 70-line branch-matching loop in _get_default_as_pydantic_model
- Helper functions: _supports_validated_default_model,
  _uses_existing_model_factory_path, _default_matches_plain_container_branch,
  _get_validated_default_type_name

Added:
- _needs_validate_default: simple check (is default dict/list/scalar
  and does the type contain a model reference?)
- __set_validate_default_on_fields: sets extras["validate_default"] = True

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Remove dead None guard from _needs_validate_default to fix coverage

The caller already filters None/UNDEFINED defaults before calling this
function, so the None check was unreachable. Removed the unused `default`
parameter entirely.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Remove WrappedDefault in favor of validate_default=True for RootModel defaults

WrappedDefault wrapped RootModel scalar defaults (e.g., CountType(10)) in
default_factory lambdas. Since validate_default=True handles this natively,
the entire mechanism is redundant.

Removed: WrappedDefault class, _types.py module, SUPPORTS_WRAPPED_DEFAULT
flag, __wrap_root_model_default_values method, _get_default_as_pydantic_model
method.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Make GraphQL scalar types extend TypeAliasBase

_DataTypeScalarBase generated the same type alias syntax as TypeAliasBase
but didn't inherit from it, causing _unwrap_type_alias to not see through
scalar references. This led to unnecessary validate_default=True on fields
like `String | None = 'default_user'`.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix required fields with validate_default losing their default value

When a required field had validate_default=True set (e.g., empty list
default on list[Container]), the rendering logic prepended ... instead
of the actual default value. Now skips the ... override when
validate_default is set, since the default is needed for Pydantic to
validate at runtime.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix inaccurate docstring in test_needs_validate_default test

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: butvinm

src/datamodel_code_generator/model/_types.py

@@ -25,7 +25,6 @@
     IMPORT_UNION,
     Import,
 )
-from datamodel_code_generator.model._types import ValidatedDefault, WrappedDefault
 from datamodel_code_generator.reference import Reference, _BaseModel
 from datamodel_code_generator.types import (
     ANY,
@@ -38,8 +37,6 @@
     get_optional_type,
 )
 
-__all__ = ["ValidatedDefault", "WrappedDefault"]
-
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
@@ -598,8 +595,6 @@ class DataModel(TemplateBase, Nullable, ABC):  # noqa: PLR0904
     SUPPORTS_GENERIC_BASE_CLASS: ClassVar[bool] = True
     SUPPORTS_DISCRIMINATOR: ClassVar[bool] = False
     SUPPORTS_FIELD_RENAMING: ClassVar[bool] = False
-    SUPPORTS_WRAPPED_DEFAULT: ClassVar[bool] = False
-    SUPPORTS_VALIDATED_DEFAULT: ClassVar[bool] = False
     SUPPORTS_KW_ONLY: ClassVar[bool] = False
     REQUIRES_RUNTIME_IMPORTS_WITH_RUFF_CHECK: ClassVar[bool] = False
     has_forward_reference: bool = False

src/datamodel_code_generator/model/base.py

@@ -19,15 +19,13 @@
     DataModel,
     DataModelFieldBase,
 )
-from datamodel_code_generator.model._types import ValidatedDefault, WrappedDefault
 from datamodel_code_generator.model.base import UNDEFINED, repr_set_sorted
-from datamodel_code_generator.types import STANDARD_DICT, STANDARD_LIST, UnionIntFloat, chain_as_tuple
+from datamodel_code_generator.types import UnionIntFloat, chain_as_tuple
 
 # Defined here instead of importing from pydantic_v2.imports to avoid circular import
 # (pydantic_base -> pydantic_v2.imports -> pydantic_v2/__init__ -> pydantic_v2.base_model -> pydantic_base)
 IMPORT_ANYURL = Import.from_full_path("pydantic.AnyUrl")
 IMPORT_FIELD = Import.from_full_path("pydantic.Field")
-IMPORT_TYPE_ADAPTER = Import.from_full_path("pydantic.TypeAdapter")
 
 if TYPE_CHECKING:
     from collections import defaultdict
@@ -126,81 +124,6 @@ def _get_strict_field_constraint_value(self, constraint: str, value: Any) -> Any
             return value
         return int(value)
 
-    def _get_default_as_pydantic_model(self) -> str | None:  # noqa: PLR0911, PLR0912
-        if isinstance(self.default, (ValidatedDefault, WrappedDefault)):
-            return f"lambda :{self.default!r}"
-        if self.data_type.is_list and len(self.data_type.data_types) == 1:
-            data_type_child = self.data_type.data_types[0]
-            if (
-                data_type_child.reference
-                and isinstance(data_type_child.reference.source, BaseModelBase)
-                and isinstance(self.default, list)
-            ):
-                if not self.default:
-                    return STANDARD_LIST
-                return (  # pragma: no cover
-                    f"lambda :[{data_type_child.alias or data_type_child.reference.source.class_name}."
-                    f"{self._PARSE_METHOD}(v) for v in {self.default!r}]"
-                )
-        if self.data_type.is_dict and len(self.data_type.data_types) == 1:
-            data_type_value = self.data_type.data_types[0]
-            if (
-                data_type_value.reference
-                and isinstance(data_type_value.reference.source, BaseModelBase)
-                and isinstance(self.default, dict)
-            ):
-                if not self.default:
-                    return STANDARD_DICT
-                return (
-                    f"lambda :{{k: {data_type_value.alias or data_type_value.reference.source.class_name}."
-                    f"{self._PARSE_METHOD}(v) for k, v in {self.default!r}.items()}}"
-                )
-
-        for data_type in self.data_type.data_types or (self.data_type,):
-            # TODO: Check nested data_types
-            if data_type.is_dict:
-                if len(data_type.data_types) == 1:
-                    data_type_value = data_type.data_types[0]
-                    if (
-                        data_type_value.reference
-                        and isinstance(data_type_value.reference.source, BaseModelBase)
-                        and isinstance(self.default, dict)
-                    ):
-                        if not self.default:
-                            return STANDARD_DICT
-                        return (
-                            f"lambda :{{k: {data_type_value.alias or data_type_value.reference.source.class_name}."
-                            f"{self._PARSE_METHOD}(v) for k, v in {self.default!r}.items()}}"
-                        )
-                continue
-            if data_type.is_list and len(data_type.data_types) == 1:
-                data_type_child = data_type.data_types[0]
-                if (
-                    data_type_child.reference
-                    and isinstance(data_type_child.reference.source, BaseModelBase)
-                    and isinstance(self.default, list)
-                ):  # pragma: no cover
-                    if not self.default:
-                        return STANDARD_LIST
-                    return (
-                        f"lambda :[{data_type_child.alias or data_type_child.reference.source.class_name}."
-                        f"{self._PARSE_METHOD}(v) for v in {self.default!r}]"
-                    )
-            elif data_type.reference and isinstance(data_type.reference.source, BaseModelBase):
-                source = data_type.reference.source
-                is_root_model = hasattr(source, "BASE_CLASS") and source.BASE_CLASS == "pydantic.RootModel"
-                if self.data_type.is_union:
-                    if not isinstance(self.default, (dict, list)):
-                        if not is_root_model:
-                            continue
-                    elif isinstance(self.default, dict) and any(dt.is_dict for dt in self.data_type.data_types):
-                        continue
-                class_name = data_type.alias or source.class_name
-                if is_root_model:
-                    return f"lambda :{class_name}({self.default!r})"
-                return f"lambda :{class_name}.{self._PARSE_METHOD}({self.default!r})"
-        return None
-
     def _get_default_factory_for_optional_nested_model(self) -> str | None:
         """Get default_factory for optional nested Pydantic model fields.
 
@@ -259,10 +182,10 @@ def __str__(self) -> str:  # noqa: PLR0912
             elif isinstance(discriminator, dict):  # pragma: no cover
                 data["discriminator"] = discriminator["propertyName"]
 
-        if self.required and not self.has_default:
+        if (self.required and not self.has_default) or (
+            self.default is not UNDEFINED and self.default is not None and "default_factory" not in data
+        ):
             default_factory = None
-        elif self.default is not UNDEFINED and self.default is not None and "default_factory" not in data:
-            default_factory = self._get_default_as_pydantic_model()
         else:
             default_factory = data.pop("default_factory", None)
 
@@ -288,7 +211,7 @@ def __str__(self) -> str:  # noqa: PLR0912
 
         if self.use_annotated:
             field_arguments = self._process_annotated_field_arguments(field_arguments)
-        elif self.required and not default_factory:
+        elif self.required and not default_factory and not self.extras.get("validate_default"):
             field_arguments = ["...", *field_arguments]
         elif not default_factory:
             default_repr = repr_set_sorted(self.default) if isinstance(self.default, set) else repr(self.default)
@@ -323,12 +246,8 @@ def annotated(self) -> str | None:
     @property
     def imports(self) -> tuple[Import, ...]:
         """Get all required imports including Field if needed."""
-        field = self.field
-        if field:
-            extra_imports = [IMPORT_FIELD]
-            if isinstance(self.default, ValidatedDefault):
-                extra_imports.append(IMPORT_TYPE_ADAPTER)
-            return chain_as_tuple(super().imports, extra_imports)
+        if self.field:
+            return chain_as_tuple(super().imports, (IMPORT_FIELD,))
         return super().imports
 
 

src/datamodel_code_generator/model/pydantic_base.py

@@ -222,8 +222,6 @@ class BaseModel(BaseModelBase):
     BASE_CLASS_ALIAS: ClassVar[str] = "_BaseModel"
     SUPPORTS_DISCRIMINATOR: ClassVar[bool] = True
     SUPPORTS_FIELD_RENAMING: ClassVar[bool] = True
-    SUPPORTS_WRAPPED_DEFAULT: ClassVar[bool] = True
-    SUPPORTS_VALIDATED_DEFAULT: ClassVar[bool] = True
     # In Pydantic 2.11+, populate_by_name is deprecated in favor of validate_by_name + validate_by_alias
     # Default to V2 compatible (populate_by_name) unless target_pydantic_version is specified
     _CONFIG_ATTRIBUTES_V2: ClassVar[list[ConfigAttribute]] = [

src/datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -13,12 +13,13 @@
     IMPORT_TYPE_ALIAS_TYPE,
     Import,
 )
-from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.base import UNDEFINED
+from datamodel_code_generator.model.type_alias import TypeAliasBase
 
 if TYPE_CHECKING:
     from pathlib import Path
 
+    from datamodel_code_generator.model import DataModelFieldBase
     from datamodel_code_generator.reference import Reference
 
 _INT: str = "int"
@@ -38,7 +39,7 @@
 }
 
 
-class _DataTypeScalarBase(DataModel):
+class _DataTypeScalarBase(TypeAliasBase):
     """Base class for GraphQL scalar types with shared __init__ logic."""
 
     def __init__(  # noqa: PLR0913