Use default_factory for $ref with default values when using --use-annotated (#2618)

* Add support for computed default factories in BaseModel fields

* Use default factories for model fields in RootModel and non-root models

* Refactor handling of computed default factories in BaseModel fields

Author: koxudaxi

src/datamodel_code_generator/model/pydantic/base_model.py

@@ -69,6 +69,11 @@ class DataModelField(DataModelFieldBase):
     constraints: Optional[Constraints] = None  # noqa: UP045
     _PARSE_METHOD: ClassVar[str] = "parse_obj"
 
+    @property
+    def has_default_factory_in_field(self) -> bool:
+        """Check if this field has a default_factory in Field() including computed ones."""
+        return "default_factory" in self.extras or self.__dict__.get("_computed_default_factory") is not None
+
     @property
     def method(self) -> str | None:
         """Get the validation method name."""
@@ -200,20 +205,23 @@ def __str__(self) -> str:  # noqa: PLR0912
         else:
             default_factory = data.pop("default_factory", None)
 
+        self.__dict__["_computed_default_factory"] = default_factory
+
         field_arguments = sorted(f"{k}={v!r}" for k, v in data.items() if v is not None)
 
         if not field_arguments and not default_factory:
             if self.nullable and self.required:
                 return "Field(...)"  # Field() is for mypy
             return ""
 
+        if default_factory:
+            field_arguments = [f"default_factory={default_factory}", *field_arguments]
+
         if self.use_annotated:
             field_arguments = self._process_annotated_field_arguments(field_arguments)
         elif self.required:
             field_arguments = ["...", *field_arguments]
-        elif default_factory:
-            field_arguments = [f"default_factory={default_factory}", *field_arguments]
-        else:
+        elif not default_factory:
             field_arguments = [f"{self.default!r}", *field_arguments]
 
         return f"Field({', '.join(field_arguments)})"

src/datamodel_code_generator/model/template/pydantic/BaseModel.jinja2

@@ -24,7 +24,7 @@ class {{ class_name }}({{ base_class }}):{% if comment is defined %}  # {{ comme
     {%- else %}
     {{ field.name }}: {{ field.type_hint }}
     {%- endif %}
-    {%- if not (field.required or (field.represented_default == 'None' and field.strip_default_none))
+    {%- if not field.has_default_factory_in_field and not (field.required or (field.represented_default == 'None' and field.strip_default_none))
             %} = {{ field.represented_default }}
     {%- endif -%}
     {%- endif %}

src/datamodel_code_generator/model/template/pydantic/BaseModel_root.jinja2

@@ -24,7 +24,7 @@ class {{ class_name }}({{ base_class }}):{% if comment is defined %}  # {{ comme
     {%- else %}
     __root__: {{ field.type_hint }}
     {%- endif %}
-    {%- if not (field.required or (field.represented_default == 'None' and field.strip_default_none))
+    {%- if not field.has_default_factory_in_field and not (field.required or (field.represented_default == 'None' and field.strip_default_none))
             %} = {{ field.represented_default }}
     {%- endif -%}
     {%- endif %}

src/datamodel_code_generator/model/template/pydantic_v2/BaseModel.jinja2

@@ -32,7 +32,7 @@ class {{ class_name }}({{ base_class }}):{% if comment is defined %}  # {{ comme
     {%- else %}
     {{ field.name }}: {{ field.type_hint }}
     {%- endif %}
-    {%- if not (field.required or (field.represented_default == 'None' and field.strip_default_none)) or field.data_type.is_optional
+    {%- if not field.has_default_factory_in_field and (not (field.required or (field.represented_default == 'None' and field.strip_default_none)) or field.data_type.is_optional)
             %} = {{ field.represented_default }}
     {%- endif -%}
     {%- endif %}

src/datamodel_code_generator/model/template/pydantic_v2/RootModel.jinja2

@@ -33,7 +33,7 @@ class {{ class_name }}({{ base_class }}{%- if fields -%}[{{get_type_hint(fields)
     {%- else %}
     root: {{ field.type_hint }}
     {%- endif %}
-    {%- if not (field.required or (field.represented_default == 'None' and field.strip_default_none))
+    {%- if not field.has_default_factory_in_field and not (field.required or (field.represented_default == 'None' and field.strip_default_none))
             %} = {{ field.represented_default }}
     {%- endif -%}
     {%- endif %}

tests/data/expected/main/jsonschema/root_model_default_value.py

@@ -25,5 +25,13 @@ class NameType(RootModel[str]):
 
 class Model(BaseModel):
     admin_state: Optional[AdminStateLeaf] = AdminStateLeaf.enable
-    count: Annotated[Optional[CountType], Field()] = CountType(10)
-    name: Annotated[Optional[NameType], Field()] = NameType('default_name')
+    count: Annotated[
+        Optional[CountType],
+        Field(default_factory=lambda: CountType.model_validate(CountType(10))),
+    ]
+    name: Annotated[
+        Optional[NameType],
+        Field(
+            default_factory=lambda: NameType.model_validate(NameType('default_name'))
+        ),
+    ]

tests/data/expected/main/jsonschema/root_model_default_value_branches.py

@@ -14,6 +14,12 @@ class CountType(RootModel[int]):
 
 
 class Model(BaseModel):
-    count_with_default: Annotated[Optional[CountType], Field()] = CountType(10)
+    count_with_default: Annotated[
+        Optional[CountType],
+        Field(default_factory=lambda: CountType.model_validate(CountType(10))),
+    ]
     count_no_default: Optional[CountType] = None
-    count_list_default: Annotated[Optional[List[CountType]], Field()] = [1, 2, 3]
+    count_list_default: Annotated[
+        Optional[List[CountType]],
+        Field(default_factory=lambda: [CountType.model_validate(v) for v in [1, 2, 3]]),
+    ]

tests/data/expected/main/jsonschema/root_model_default_value_non_root.py

@@ -18,6 +18,12 @@ class PersonType(BaseModel):
 
 
 class Model(BaseModel):
-    root_model_field: Annotated[Optional[CountType], Field()] = CountType(10)
-    non_root_model_field: Annotated[Optional[PersonType], Field()] = {'name': 'John'}
+    root_model_field: Annotated[
+        Optional[CountType],
+        Field(default_factory=lambda: CountType.model_validate(CountType(10))),
+    ]
+    non_root_model_field: Annotated[
+        Optional[PersonType],
+        Field(default_factory=lambda: PersonType.model_validate({'name': 'John'})),
+    ]
     primitive_field: Optional[str] = 'hello'

tests/data/expected/main/openapi/referenced_default_use_annotated.py

@@ -0,0 +1,21 @@
+# generated by datamodel-codegen:
+#   filename:  referenced_default.yaml
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from typing import Annotated, Optional
+
+from pydantic import BaseModel, Field, RootModel
+
+
+class ModelSettingB(RootModel[float]):
+    root: Annotated[float, Field(ge=0.0, le=10.0)]
+
+
+class Model(BaseModel):
+    settingA: Annotated[Optional[float], Field(ge=0.0, le=10.0)] = 5
+    settingB: Annotated[
+        Optional[ModelSettingB],
+        Field(default_factory=lambda: ModelSettingB.model_validate(ModelSettingB(5))),
+    ]

tests/main/openapi/test_main_openapi.py

@@ -2390,6 +2390,18 @@ def test_main_openapi_referenced_default(output_file: Path) -> None:
     )
 
 
+def test_main_openapi_referenced_default_use_annotated(output_file: Path) -> None:
+    """Test OpenAPI generation with referenced default values using --use-annotated."""
+    run_main_and_assert(
+        input_path=OPEN_API_DATA_PATH / "referenced_default.yaml",
+        output_path=output_file,
+        input_file_type="openapi",
+        assert_func=assert_file_content,
+        expected_file="referenced_default_use_annotated.py",
+        extra_args=["--output-model-type", "pydantic_v2.BaseModel", "--use-annotated"],
+    )
+
+
 def test_duplicate_models(output_file: Path) -> None:
     """Test OpenAPI generation with duplicate models."""
     run_main_and_assert(