Add version-specific schema processing using schema_features

Author: koxudaxi

src/datamodel_code_generator/parser/jsonschema.py

@@ -192,7 +192,12 @@ class JSONReference(_enum.Enum):
 
 
 class Discriminator(BaseModel):
-    """Represent OpenAPI discriminator object."""
+    """Represent OpenAPI discriminator object.
+
+    This is an OpenAPI-specific concept for supporting polymorphism.
+    It identifies which schema applies based on a property value.
+    Kept in jsonschema.py to avoid circular imports with openapi.py.
+    """
 
     propertyName: str  # noqa: N815
     mapping: Optional[dict[str, str]] = None  # noqa: UP045
@@ -517,7 +522,7 @@ def _get_type(
     data_formats: dict[str, dict[str, Types]] | None = None,
 ) -> Types:
     """Get the appropriate Types enum for a given JSON Schema type and format."""
-    if data_formats is None:
+    if data_formats is None:  # pragma: no cover
         data_formats = json_schema_data_formats
     if type_ not in data_formats:
         return Types.any
@@ -768,8 +773,16 @@ def _get_type_with_mappings(self, type_: str, format_: str | None = None) -> Typ
 
     @cached_property
     def schema_paths(self) -> list[tuple[str, list[str]]]:
-        """Get schema paths for definitions and defs."""
-        return [(s, s.lstrip("#/").split("/")) for s in self.SCHEMA_PATHS]
+        """Get schema paths for definitions and defs.
+
+        Prioritizes the version-appropriate key based on detected schema version,
+        but checks both for lenient compatibility with mixed-version schemas.
+        - Draft 4-7: definitions (standard), then $defs (fallback)
+        - Draft 2019-09+: $defs (standard), then definitions (fallback)
+        """
+        primary_key = self.schema_features.definitions_key
+        ordered_paths = ["#/$defs", "#/definitions"] if primary_key == "$defs" else ["#/definitions", "#/$defs"]
+        return [(s, s.lstrip("#/").split("/")) for s in ordered_paths]
 
     @cached_property
     def schema_features(self) -> JsonSchemaFeatures:
@@ -3589,9 +3602,15 @@ def parse_id(self, obj: JsonSchemaObject, path: list[str]) -> None:
 
     @contextmanager
     def root_id_context(self, root_raw: dict[str, Any]) -> Generator[None, None, None]:
-        """Context manager to temporarily set the root $id during parsing."""
+        """Context manager to temporarily set the root $id during parsing.
+
+        Uses schema_features.id_field to support both "id" (Draft 4) and "$id" (Draft 6+).
+        Falls back to checking both fields for lenient compatibility.
+        """
         previous_root_id = self.root_id
-        self.root_id = root_raw.get("$id") or None
+        # Try version-specific field first, then fallback to alternative for compatibility
+        id_field = self.schema_features.id_field
+        self.root_id = root_raw.get(id_field) or root_raw.get("$id") or root_raw.get("id") or None
         yield
         self.root_id = previous_root_id
 

src/datamodel_code_generator/parser/openapi.py

@@ -240,10 +240,11 @@ def get_ref_model(self, ref: str) -> dict[str, Any]:
 
     def get_data_type(self, obj: JsonSchemaObject) -> DataType:
         """Get data type from JSON schema object, handling OpenAPI nullable semantics."""
-        # OpenAPI 3.0 doesn't allow `null` in the `type` field and list of types
+        # OpenAPI 3.0 uses `nullable: true` flag for null support (nullable_keyword=True)
+        # OpenAPI 3.1 uses `type: ["string", "null"]` instead (nullable_keyword=False)
         # https://swagger.io/docs/specification/data-models/data-types/#null
-        # OpenAPI 3.1 does allow `null` in the `type` field and is equivalent to
-        # a `nullable` flag on the property itself
+        # When strict_nullable is enabled, convert nullable flag to type array for
+        # consistent handling regardless of OpenAPI version
         if obj.nullable and self.strict_nullable and isinstance(obj.type, str):
             obj.type = [obj.type, "null"]
 

src/datamodel_code_generator/parser/schema_version.py

@@ -272,7 +272,7 @@ def get_data_formats(*, is_openapi: bool = False) -> DataFormatMapping:
         for type_key, type_formats in _get_openapi_only_formats().items():
             if type_key in formats:
                 formats[type_key] = {**formats[type_key], **type_formats}
-            else:
+            else:  # pragma: no cover
                 formats[type_key] = type_formats
     return formats
 

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

@@ -18,15 +18,6 @@ class Pet(BaseModel):
     tag: str | None = None
 
 
-class Error(BaseModel):
-    code: int
-    message: str
-
-
-class Resolved(BaseModel):
-    resolved: list[str] | None = None
-
-
 class PetsModel(BaseModel):
     __root__: list[Pet]