Wrap RootModel default values with type constructors (#2615)

* Wrap RootModel default values with their type constructors

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* Add default values for RootModel fields with type annotations

* Add docstring to __repr__ method for type constructor representation

* Refactor test docstrings for RootModel default value tests

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: koxudaxi

src/datamodel_code_generator/model/base.py

@@ -10,6 +10,7 @@
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from copy import deepcopy
+from dataclasses import dataclass
 from functools import cached_property, lru_cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar, Union
@@ -98,6 +99,18 @@ def merge_constraints(a: ConstraintsBaseT | None, b: ConstraintsBaseT | None) ->
         })
 
 
+@dataclass(repr=False)
+class WrappedDefault:
+    """Represents a default value wrapped with its type constructor."""
+
+    value: Any
+    type_name: str
+
+    def __repr__(self) -> str:
+        """Return type constructor representation, e.g., 'CountType(10)'."""
+        return f"{self.type_name}({self.value!r})"
+
+
 class DataModelFieldBase(_BaseModel):
     """Base class for model field representation and rendering."""
 

src/datamodel_code_generator/parser/base.py

@@ -56,6 +56,7 @@
     ConstraintsBase,
     DataModel,
     DataModelFieldBase,
+    WrappedDefault,
 )
 from datamodel_code_generator.model.enum import Enum, Member
 from datamodel_code_generator.model.type_alias import TypeAliasBase, TypeStatement
@@ -1498,6 +1499,33 @@ def __set_default_enum_member(  # noqa: PLR0912
                             else:
                                 enum_member.alias = data_type.alias
 
+    def __wrap_root_model_default_values(
+        self,
+        models: list[DataModel],
+    ) -> None:
+        """Wrap RootModel reference default values with their type constructors."""
+        if not self.use_annotated:
+            return
+        for model in models:
+            if isinstance(model, (Enum, self.data_model_root_type)):
+                continue
+            for model_field in model.fields:
+                if model_field.default is None:
+                    continue
+                if isinstance(model_field.default, (WrappedDefault, Member)):
+                    continue
+                if isinstance(model_field.default, list):
+                    continue
+                for data_type in model_field.data_type.all_data_types:
+                    if data_type.reference and isinstance(data_type.reference.source, pydantic_model_v2.RootModel):
+                        # Use alias if available (handles import collisions)
+                        type_name = data_type.alias or data_type.reference.short_name
+                        model_field.default = WrappedDefault(
+                            value=model_field.default,
+                            type_name=type_name,
+                        )
+                        break
+
     def __override_required_field(
         self,
         models: list[DataModel],
@@ -2188,6 +2216,7 @@ class Processed(NamedTuple):
             self.__reuse_model(models, require_update_action_models)
             self.__collapse_root_models(models, unused_models, imports, scoped_model_resolver)
             self.__set_default_enum_member(models)
+            self.__wrap_root_model_default_values(models)
             self.__sort_models(models, imports)
             self.__change_field_name(models)
             self.__apply_discriminator_type(models, imports)

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

@@ -0,0 +1,29 @@
+# generated by datamodel-codegen:
+#   filename:  root_model_default_value.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Annotated, Optional
+
+from pydantic import BaseModel, Field, RootModel
+
+
+class AdminStateLeaf(Enum):
+    enable = 'enable'
+    disable = 'disable'
+
+
+class CountType(RootModel[int]):
+    root: Annotated[int, Field(ge=0, le=100)]
+
+
+class NameType(RootModel[str]):
+    root: Annotated[str, Field(max_length=50, min_length=1)]
+
+
+class Model(BaseModel):
+    admin_state: Optional[AdminStateLeaf] = AdminStateLeaf.enable
+    count: Annotated[Optional[CountType], Field()] = CountType(10)
+    name: Annotated[Optional[NameType], Field()] = NameType('default_name')

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

@@ -0,0 +1,19 @@
+# generated by datamodel-codegen:
+#   filename:  root_model_default_value_branches.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from typing import Annotated, List, Optional
+
+from pydantic import BaseModel, Field, RootModel
+
+
+class CountType(RootModel[int]):
+    root: Annotated[int, Field(ge=0, le=100)]
+
+
+class Model(BaseModel):
+    count_with_default: Annotated[Optional[CountType], Field()] = CountType(10)
+    count_no_default: Optional[CountType] = None
+    count_list_default: Annotated[Optional[List[CountType]], Field()] = [1, 2, 3]

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

@@ -0,0 +1,33 @@
+# generated by datamodel-codegen:
+#   filename:  root_model_default_value.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field, RootModel, conint, constr
+
+
+class AdminStateLeaf(Enum):
+    enable = 'enable'
+    disable = 'disable'
+
+
+class CountType(RootModel[conint(ge=0, le=100)]):
+    root: conint(ge=0, le=100)
+
+
+class NameType(RootModel[constr(min_length=1, max_length=50)]):
+    root: constr(min_length=1, max_length=50)
+
+
+class Model(BaseModel):
+    admin_state: Optional[AdminStateLeaf] = AdminStateLeaf.enable
+    count: Optional[CountType] = Field(
+        default_factory=lambda: CountType.model_validate(10)
+    )
+    name: Optional[NameType] = Field(
+        default_factory=lambda: NameType.model_validate('default_name')
+    )

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

@@ -0,0 +1,23 @@
+# generated by datamodel-codegen:
+#   filename:  root_model_default_value_non_root.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from typing import Annotated, Optional
+
+from pydantic import BaseModel, Field, RootModel
+
+
+class CountType(RootModel[int]):
+    root: Annotated[int, Field(ge=0, le=100)]
+
+
+class PersonType(BaseModel):
+    name: Optional[str] = None
+
+
+class Model(BaseModel):
+    root_model_field: Annotated[Optional[CountType], Field()] = CountType(10)
+    non_root_model_field: Annotated[Optional[PersonType], Field()] = {'name': 'John'}
+    primitive_field: Optional[str] = 'hello'

tests/data/jsonschema/root_model_default_value.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "admin_state": {
+      "$ref": "#/$defs/AdminStateLeaf",
+      "default": "enable"
+    },
+    "count": {
+      "$ref": "#/$defs/CountType",
+      "default": 10
+    },
+    "name": {
+      "$ref": "#/$defs/NameType",
+      "default": "default_name"
+    }
+  },
+  "$defs": {
+    "AdminStateLeaf": {
+      "type": "string",
+      "enum": ["enable", "disable"]
+    },
+    "CountType": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 100
+    },
+    "NameType": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 50
+    }
+  }
+}

tests/data/jsonschema/root_model_default_value_branches.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "count_with_default": {
+      "$ref": "#/$defs/CountType",
+      "default": 10
+    },
+    "count_no_default": {
+      "$ref": "#/$defs/CountType"
+    },
+    "count_list_default": {
+      "type": "array",
+      "items": {
+        "$ref": "#/$defs/CountType"
+      },
+      "default": [1, 2, 3]
+    }
+  },
+  "$defs": {
+    "CountType": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 100
+    }
+  }
+}

tests/data/jsonschema/root_model_default_value_non_root.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "root_model_field": {
+      "$ref": "#/$defs/CountType",
+      "default": 10
+    },
+    "non_root_model_field": {
+      "$ref": "#/$defs/PersonType",
+      "default": {"name": "John"}
+    },
+    "primitive_field": {
+      "type": "string",
+      "default": "hello"
+    }
+  },
+  "$defs": {
+    "CountType": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 100
+    },
+    "PersonType": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}

tests/main/jsonschema/test_main_jsonschema.py

@@ -3189,3 +3189,72 @@ def test_main_jsonschema_file_url_ref_percent_encoded(tmp_path: Path) -> None:
         ignore_whitespace=True,
         extra_args=["--disable-timestamp"],
     )
+
+
+@pytest.mark.benchmark
+def test_main_jsonschema_root_model_default_value(output_file: Path) -> None:
+    """Test RootModel default values are wrapped with type constructors."""
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "root_model_default_value.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        assert_func=assert_file_content,
+        expected_file="root_model_default_value.py",
+        extra_args=[
+            "--output-model-type",
+            "pydantic_v2.BaseModel",
+            "--use-annotated",
+            "--set-default-enum-member",
+        ],
+    )
+
+
+@pytest.mark.benchmark
+def test_main_jsonschema_root_model_default_value_no_annotated(output_file: Path) -> None:
+    """Test RootModel default values without --use-annotated flag."""
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "root_model_default_value.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        assert_func=assert_file_content,
+        expected_file="root_model_default_value_no_annotated.py",
+        extra_args=[
+            "--output-model-type",
+            "pydantic_v2.BaseModel",
+            "--set-default-enum-member",
+        ],
+    )
+
+
+@pytest.mark.benchmark
+def test_main_jsonschema_root_model_default_value_branches(output_file: Path) -> None:
+    """Test RootModel default value branches."""
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "root_model_default_value_branches.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        assert_func=assert_file_content,
+        expected_file="root_model_default_value_branches.py",
+        extra_args=[
+            "--output-model-type",
+            "pydantic_v2.BaseModel",
+            "--use-annotated",
+        ],
+    )
+
+
+@pytest.mark.benchmark
+def test_main_jsonschema_root_model_default_value_non_root(output_file: Path) -> None:
+    """Test that non-RootModel references are not wrapped."""
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "root_model_default_value_non_root.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        assert_func=assert_file_content,
+        expected_file="root_model_default_value_non_root.py",
+        extra_args=[
+            "--output-model-type",
+            "pydantic_v2.BaseModel",
+            "--use-annotated",
+        ],
+    )