Use validate_default=True for structured union defaults

src/datamodel_code_generator/model/base.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/pydantic_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 @@
             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 @@
             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 @@
 
         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 @@
     @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_v2/base_model.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/scalar.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