Remove WithJsonSchema from ExtraTemplateDataType

src/datamodel_code_generator/__main__.py

@@ -915,8 +915,13 @@ def _serialize_python_type(tp: type) -> str | None:  # noqa: PLR0911
 
 def _simple_type_name(tp: type) -> str:
     """Get a simple string representation of a type."""
+    from typing import get_origin  # noqa: PLC0415
+
     if tp is type(None):
         return "None"
+    # For generic types (e.g., dict[str, Any]), use full string representation
+    if get_origin(tp) is not None:
+        return str(tp).replace("typing.", "")
     if hasattr(tp, "__name__"):
         return tp.__name__
     return str(tp).replace("typing.", "")  # pragma: no cover

src/datamodel_code_generator/config.py

@@ -7,7 +7,7 @@
 from pathlib import Path  # noqa: TC003 - used at runtime by Pydantic
 from typing import TYPE_CHECKING, Annotated, Any
 
-from pydantic import BaseModel, Field, WithJsonSchema
+from pydantic import BaseModel, Field
 
 from datamodel_code_generator.enums import (
     DEFAULT_SHARED_MODULE_NAME,
@@ -48,10 +48,12 @@
 CallableSchema = Callable[[str], str]
 DumpResolveReferenceAction = Callable[[Iterable[str]], str]
 DefaultPutDictSchema = DefaultPutDict[str, str]
-ExtraTemplateDataType = Annotated[
-    defaultdict[str, Annotated[dict[str, Any], Field(default_factory=dict)]],
-    WithJsonSchema({"type": "object", "x-python-type": "defaultdict[str, dict[str, Any]]"}),
-]
+if TYPE_CHECKING:
+    ExtraTemplateDataType = defaultdict[str, dict[str, Any]]
+elif is_pydantic_v2():
+    ExtraTemplateDataType = defaultdict[str, Annotated[dict[str, Any], Field(default_factory=dict)]]
+else:
+    ExtraTemplateDataType = defaultdict[str, dict[str, Any]]
 
 
 class GenerateConfig(BaseModel):

src/datamodel_code_generator/parser/jsonschema.py

@@ -629,6 +629,12 @@ class JsonSchemaParser(Parser):
     PYTHON_TYPE_OVERRIDE_ALWAYS: ClassVar[frozenset[str]] = frozenset({
         "Callable",
         "Type",
+        # collections types that have no JSON Schema equivalent
+        "defaultdict",
+        "OrderedDict",
+        "Counter",
+        "deque",
+        "ChainMap",
     })
 
     def __init__(  # noqa: PLR0913
@@ -1391,6 +1397,10 @@ def _is_compatible_python_type(self, schema_type: str | None, python_type: str)
         all_type_names = self._extract_all_type_names(python_type)
         if any(t in self.PYTHON_TYPE_OVERRIDE_ALWAYS for t in all_type_names):
             return False
+        # Check for lowercase types in PYTHON_TYPE_OVERRIDE_ALWAYS (e.g., defaultdict, deque)
+        for override_type in self.PYTHON_TYPE_OVERRIDE_ALWAYS:
+            if override_type[0].islower() and override_type in python_type:
+                return False
         if schema_type is None:
             return True
         if base_type in {"Union", "Optional"}:
@@ -1471,6 +1481,13 @@ def _get_python_type_override(self, obj: JsonSchemaObject) -> DataType | None:
                 if nested_import:
                     nested_imports.append(self.data_type(import_=nested_import))
 
+        # Collect imports for lowercase types in PYTHON_TYPE_OVERRIDE_ALWAYS (e.g., defaultdict, deque)
+        for override_type in self.PYTHON_TYPE_OVERRIDE_ALWAYS:
+            if override_type[0].islower() and override_type in type_str and override_type != base_type:
+                override_import = self._resolve_type_import(override_type)
+                if override_import:
+                    nested_imports.append(self.data_type(import_=override_import))
+
         result = self.data_type(type=type_str, import_=import_)
         if nested_imports:
             result.data_types.extend(nested_imports)