src/datamodel_code_generator/model/pydantic_base.py (1)

158-162: Consider updating the TODO in the loop to handle nested dict types.

The new code at lines 144-156 handles direct dict types, but the loop still has a TODO for dict handling. For complex union types where the dict is nested within data_types, the loop would skip it without processing.

This creates asymmetry - direct dicts are handled, but dicts within unions may not be. Consider whether this TODO should be addressed for completeness, or document why it's intentionally left as-is.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/datamodel_code_generator/model/pydantic_base.py` around lines 158 - 162,
The loop over self.data_type.data_types currently skips entries where
data_type.is_dict (TODO) causing nested dicts inside unions to be ignored;
update the loop in the method using self.data_type.data_types to handle nested
dicts the same way as the direct dict branch (the logic implemented earlier at
lines ~144-156) by parsing the dict model to compute the default and not simply
continue when data_type.is_dict is true, using the same helper/parse routine
used for direct dict handling so union-member dict types are correctly
processed.

src/datamodel_code_generator/model/pydantic_base.py (1)

162-174: Consider extracting shared dict-handling logic.

This block is nearly identical to lines 145-157. While the duplication is consistent with how list handling is structured (direct at 132-144, nested at 176-188), a helper method could reduce this repetition.

Since refactoring would also affect the existing list handling, this can be deferred.

♻️ Optional: Extract helper method

def _get_dict_default_factory(self, data_type_value) -> str | None:
    """Get default factory for dict field with BaseModel values."""
    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
        class_name = data_type_value.alias or data_type_value.reference.source.class_name
        return (
            f"lambda :{{k: {class_name}."
            f"{self._PARSE_METHOD}(v) for k, v in {self.default!r}.items()}}"
        )
    return None

Then call this helper in both locations.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/datamodel_code_generator/model/pydantic_base.py` around lines 162 - 174,
Extract the duplicated dict default-factory logic into a helper method (e.g.,
_get_dict_default_factory) that accepts data_type_value and returns either
STANDARD_DICT, the generated lambda string, or None; the helper should check the
same conditions (data_type_value.reference,
isinstance(data_type_value.reference.source, BaseModelBase),
isinstance(self.default, dict)) and use data_type_value.alias or
data_type_value.reference.source.class_name and self._PARSE_METHOD when building
the lambda, then replace the two nearly identical blocks that reference
data_type/data_type_value/self.default with calls to this helper and return its
result when non-None.

tests/main/jsonschema/test_main_jsonschema.py (1)

1938-1950: Add one runtime assertion for the generated defaults.

These tests currently only snapshot the emitted source. Since the regression is about default_factory behavior, I'd also instantiate the generated ParentModel and assert the empty case yields {} and the populated case yields ItemModel values. That makes the regression harder to reintroduce if the expected fixtures are updated alongside the generator.

Example direction

 def test_main_generate_pydantic_v2_model_default_dict_non_empty(tmp_path: Path) -> None:
     ...
     assert_file_content(output_file, "pydantic_v2_model_default_dict_non_empty.py")
+    namespace: dict[str, object] = {}
+    exec(compile(output_file.read_text(encoding="utf-8"), str(output_file), "exec"), namespace)
+    parent = namespace["ParentModel"]()
+    item_model = namespace["ItemModel"]
+    assert parent.dict_with_defaults == {
+        "jedi": item_model(name="Yoda", description="The wise old jedi")
+    }

Also applies to: 1953-1965, 1968-1980, 1983-1995

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/main/jsonschema/test_main_jsonschema.py` around lines 1938 - 1950, Add
runtime assertions to the
test_main_generate_pydantic_v2_model_default_dict_empty test (and the sibling
tests at ranges 1953-1965, 1968-1980, 1983-1995): after generate(...) and
assert_file_content(...), import or load the generated module and instantiate
ParentModel to verify default behavior (e.g., ParentModel() yields items == {}),
and for the populated-case tests instantiate ParentModel with the provided data
and assert the items contain the expected ItemModel instances/values; use the
generated class names ParentModel and ItemModel and keep these assertions
alongside the existing snapshot checks to prevent regressions in default_factory
handling.