Add schema version detection and feature flags (#2924)

* Add schema version detection and feature flags

* Refactor to use pattern matching and function-style tests

* Use TypeAlias for version patterns dict

* Simplify  heuristic to default to Draft 2020-12

* Add format registry with separation of OpenAPI-specific formats (#2927)

* Add format registry with separation of OpenAPI-specific formats

* Use snapshot for full format comparison in tests

* Integrate format registry with parsers (backward compatible)

Author: koxudaxi

src/datamodel_code_generator/__init__.py

@@ -43,12 +43,15 @@
     GraphQLScope,
     InputFileType,
     InputModelRefStrategy,
+    JsonSchemaVersion,
     ModuleSplitMode,
     NamingStrategy,
     OpenAPIScope,
+    OpenAPIVersion,
     ReadOnlyWriteOnlyModelType,
     ReuseScope,
     TargetPydanticVersion,
+    VersionMode,
 )
 from datamodel_code_generator.format import (
     DEFAULT_FORMATTERS,
@@ -930,6 +933,8 @@ def infer_input_type(text: str) -> InputFileType:
 
 _LAZY_IMPORTS = {
     "clear_dynamic_models_cache": "datamodel_code_generator.dynamic",
+    "detect_jsonschema_version": "datamodel_code_generator.parser.schema_version",
+    "detect_openapi_version": "datamodel_code_generator.parser.schema_version",
     "generate_dynamic_models": "datamodel_code_generator.dynamic",
 }
 
@@ -966,17 +971,22 @@ def __getattr__(name: str) -> Any:
     "InputModelRefStrategy",
     "InvalidClassNameError",
     "InvalidFileFormatError",
+    "JsonSchemaVersion",
     "LiteralType",
     "ModuleSplitMode",
     "NamingStrategy",
     "OpenAPIScope",
+    "OpenAPIVersion",
     "PythonVersion",
     "PythonVersionMin",
     "ReadOnlyWriteOnlyModelType",
     "ReuseScope",
     "SchemaParseError",
     "TargetPydanticVersion",
+    "VersionMode",
     "clear_dynamic_models_cache",  # noqa: F822
+    "detect_jsonschema_version",  # noqa: F822
+    "detect_openapi_version",  # noqa: F822
     "generate",
     "generate_dynamic_models",  # noqa: F822
 ]

src/datamodel_code_generator/enums.py

@@ -240,6 +240,42 @@ class StrictTypes(Enum):
     bool = "bool"
 
 
+class JsonSchemaVersion(Enum):
+    """JSON Schema draft versions.
+
+    Auto: Auto-detect from $schema field or heuristics (default).
+    """
+
+    Draft4 = "draft-04"
+    Draft6 = "draft-06"
+    Draft7 = "draft-07"
+    Draft201909 = "2019-09"
+    Draft202012 = "2020-12"
+    Auto = "auto"
+
+
+class OpenAPIVersion(Enum):
+    """OpenAPI specification versions.
+
+    Auto: Auto-detect from openapi field (default).
+    """
+
+    V30 = "3.0"
+    V31 = "3.1"
+    Auto = "auto"
+
+
+class VersionMode(Enum):
+    """Schema version validation mode.
+
+    Lenient: Accept all features regardless of declared version (default).
+    Strict: Warn on features outside declared/detected version.
+    """
+
+    Lenient = "lenient"
+    Strict = "strict"
+
+
 __all__ = [
     "DEFAULT_SHARED_MODULE_NAME",
     "MAX_VERSION",
@@ -256,12 +292,15 @@ class StrictTypes(Enum):
     "GraphQLScope",
     "InputFileType",
     "InputModelRefStrategy",
+    "JsonSchemaVersion",
     "ModuleSplitMode",
     "NamingStrategy",
     "OpenAPIScope",
+    "OpenAPIVersion",
     "ReadOnlyWriteOnlyModelType",
     "ReuseScope",
     "StrictTypes",
     "TargetPydanticVersion",
     "UnionMode",
+    "VersionMode",
 ]

src/datamodel_code_generator/parser/jsonschema.py

@@ -509,15 +509,21 @@ def get_ref_type(ref: str) -> JSONReference:
     return JSONReference.REMOTE
 
 
-def _get_type(type_: str, format__: str | None = None) -> Types:
+def _get_type(
+    type_: str,
+    format__: str | None = None,
+    data_formats: dict[str, dict[str, Types]] | None = None,
+) -> Types:
     """Get the appropriate Types enum for a given JSON Schema type and format."""
-    if type_ not in json_schema_data_formats:
+    if data_formats is None:
+        data_formats = json_schema_data_formats
+    if type_ not in data_formats:
         return Types.any
-    if (data_formats := json_schema_data_formats[type_].get("default" if format__ is None else format__)) is not None:
-        return data_formats
+    if (type_format := data_formats[type_].get("default" if format__ is None else format__)) is not None:
+        return type_format
 
     warn(f"format of {format__!r} not understood for {type_!r} - using default", stacklevel=2)
-    return json_schema_data_formats[type_]["default"]
+    return data_formats[type_]["default"]
 
 
 JsonSchemaObject.model_rebuild()
@@ -732,21 +738,31 @@ def get_field_extras(self, obj: JsonSchemaObject) -> dict[str, Any]:
             extras.update(self.default_field_extras)
         return extras
 
+    @cached_property
+    def _data_formats(self) -> dict[str, dict[str, Types]]:
+        """Get data format mappings for this parser type.
+
+        Returns all formats for backward compatibility.
+        OpenAPI-specific formats will be separated in Strict mode (future).
+        """
+        return json_schema_data_formats
+
     def _get_type_with_mappings(self, type_: str, format_: str | None = None) -> Types:
         """Get the Types enum for a given type and format, applying custom type mappings.
 
         Custom mappings from --type-mappings are checked first, then falls back to
-        the default json_schema_data_formats mappings.
+        the parser's data format mappings.
         """
+        data_formats = self._data_formats
         if self.type_mappings and format_ is not None and (type_, format_) in self.type_mappings:
             target_format = self.type_mappings[type_, format_]
-            for type_formats in json_schema_data_formats.values():
+            for type_formats in data_formats.values():
                 if target_format in type_formats:
                     return type_formats[target_format]
-            if target_format in json_schema_data_formats:
-                return json_schema_data_formats[target_format]["default"]
+            if target_format in data_formats:
+                return data_formats[target_format]["default"]
 
-        return _get_type(type_, format_)
+        return _get_type(type_, format_, data_formats)
 
     @cached_property
     def schema_paths(self) -> list[tuple[str, list[str]]]: