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
@@ -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:
@@ -913,6 +926,19 @@ def is_constraints_field(self, obj: JsonSchemaObject) -> bool:
             )
         )
 
+    @staticmethod
+    def _get_array_items(obj: JsonSchemaObject) -> list[JsonSchemaObject] | JsonSchemaObject | bool | None:
+        """Get array items from schema, handling both prefixItems (2020-12) and items (older).
+
+        In lenient mode (default), checks both fields for compatibility with mixed-version schemas.
+        Prioritizes prefixItems if both are present (2020-12 semantics).
+        """
+        # Check prefixItems first (Draft 2020-12) if schema version supports it or present
+        if obj.prefixItems is not None:
+            return obj.prefixItems
+        # Fall back to items for older drafts or when prefixItems is not present
+        return obj.items
+
     def _is_fixed_length_tuple(self, obj: JsonSchemaObject) -> bool:
         """Check if an array field represents a fixed-length tuple."""
         if obj.prefixItems is not None and obj.items in {None, False}:
@@ -3589,9 +3615,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"]
 

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]