Add --schema-version and --schema-version-mode CLI options

Author: koxudaxi

src/datamodel_code_generator/__init__.py

@@ -65,7 +65,12 @@
 from datamodel_code_generator.parser import DefaultPutDict, LiteralType
 
 if TYPE_CHECKING:
-    from datamodel_code_generator._types import GraphQLParserConfigDict, OpenAPIParserConfigDict, ParserConfigDict
+    from datamodel_code_generator._types import (
+        GraphQLParserConfigDict,
+        JSONSchemaParserConfigDict,
+        OpenAPIParserConfigDict,
+        ParserConfigDict,
+    )
     from datamodel_code_generator._types.generate_config_dict import GenerateConfigDict
     from datamodel_code_generator.config import GenerateConfig, ParserConfig
 
@@ -456,7 +461,10 @@ def _build_module_content(
 def _create_parser_config(
     config_class: type[_ConfigT],
     generate_config: GenerateConfig,
-    additional_options: ParserConfigDict | OpenAPIParserConfigDict | GraphQLParserConfigDict,
+    additional_options: ParserConfigDict
+    | JSONSchemaParserConfigDict
+    | OpenAPIParserConfigDict
+    | GraphQLParserConfigDict,
 ) -> _ConfigT:
     """Create a parser config from GenerateConfig with additional options.
 
@@ -735,6 +743,28 @@ def get_header_and_first_line(csv_file: IO[str]) -> dict[str, Any]:
         ),
     }
 
+    # Convert schema_version string to appropriate enum based on input type
+    jsonschema_version: JsonSchemaVersion | None = None
+    openapi_version: OpenAPIVersion | None = None
+    if config.schema_version and config.schema_version != "auto":
+        if input_file_type == InputFileType.OpenAPI:
+            try:
+                openapi_version = OpenAPIVersion(config.schema_version)
+            except ValueError:
+                valid = [v.value for v in OpenAPIVersion]
+                msg = f"Invalid OpenAPI version: {config.schema_version}. Valid values: {valid}"
+                raise Error(msg) from None
+        elif input_file_type == InputFileType.GraphQL:
+            msg = f"--schema-version is not supported for {input_file_type.value}"
+            raise Error(msg)
+        else:
+            try:
+                jsonschema_version = JsonSchemaVersion(config.schema_version)
+            except ValueError:
+                valid = [v.value for v in JsonSchemaVersion]
+                msg = f"Invalid JSON Schema version: {config.schema_version}. Valid values: {valid}"
+                raise Error(msg) from None
+
     if input_file_type == InputFileType.OpenAPI:
         from datamodel_code_generator.parser.openapi import OpenAPIParser  # noqa: PLC0415
 
@@ -743,6 +773,7 @@ def get_header_and_first_line(csv_file: IO[str]) -> dict[str, Any]:
             "include_path_parameters": config.include_path_parameters,
             "use_status_code_in_response_name": config.use_status_code_in_response_name,
             "openapi_include_paths": config.openapi_include_paths,
+            "openapi_version": openapi_version,
             **additional_options,
         }
         parser_config = _create_parser_config(OpenAPIParserConfig, config, openapi_additional_options)
@@ -760,7 +791,11 @@ def get_header_and_first_line(csv_file: IO[str]) -> dict[str, Any]:
     else:
         from datamodel_code_generator.parser.jsonschema import JsonSchemaParser  # noqa: PLC0415
 
-        parser_config = _create_parser_config(JSONSchemaParserConfig, config, additional_options)
+        jsonschema_additional_options: JSONSchemaParserConfigDict = {
+            "jsonschema_version": jsonschema_version,
+            **additional_options,
+        }
+        parser_config = _create_parser_config(JSONSchemaParserConfig, config, jsonschema_additional_options)
         parser = JsonSchemaParser(source=source, config=parser_config)  # ty: ignore
 
     with chdir(config.output):

src/datamodel_code_generator/__main__.py

@@ -69,6 +69,7 @@
     ReadOnlyWriteOnlyModelType,
     ReuseScope,
     TargetPydanticVersion,
+    VersionMode,
     enable_debug_message,
     generate,
 )
@@ -620,6 +621,8 @@ def validate_class_name_affix_scope(cls, v: str | ClassNameAffixScope | None) ->
     module_split_mode: Optional[ModuleSplitMode] = None  # noqa: UP045
     watch: bool = False
     watch_delay: float = 0.5
+    schema_version: Optional[str] = None  # noqa: UP045
+    schema_version_mode: Optional[VersionMode] = None  # noqa: UP045
 
     def merge_args(self, args: Namespace) -> None:
         """Merge command-line arguments into config."""
@@ -1063,6 +1066,8 @@ def run_generate_from_config(  # noqa: PLR0913, PLR0917
         module_split_mode=config.module_split_mode,
         validators=validators,
         default_value_overrides=default_value_overrides,
+        schema_version=config.schema_version,
+        schema_version_mode=config.schema_version_mode,
     )
 
     if output is None and result is not None:  # pragma: no cover

src/datamodel_code_generator/_types/generate_config_dict.py

@@ -32,6 +32,7 @@
         StrictTypes,
         TargetPydanticVersion,
         UnionMode,
+        VersionMode,
     )
     from datamodel_code_generator.format import DateClassType, DatetimeClassType, Formatter, PythonVersion
     from datamodel_code_generator.parser import LiteralType
@@ -168,6 +169,8 @@ class GenerateConfigDict(TypedDict, closed=True):
     field_type_collision_strategy: NotRequired[FieldTypeCollisionStrategy | None]
     module_split_mode: NotRequired[ModuleSplitMode | None]
     default_value_overrides: NotRequired[Mapping[str, Any] | None]
+    schema_version: NotRequired[str | None]
+    schema_version_mode: NotRequired[VersionMode | None]
 
 
 class ValidatorDefinition(TypedDict):

src/datamodel_code_generator/arguments.py

@@ -26,16 +26,15 @@
     FieldTypeCollisionStrategy,
     InputFileType,
     InputModelRefStrategy,
-    JsonSchemaVersion,
     ModuleSplitMode,
     NamingStrategy,
     OpenAPIScope,
-    OpenAPIVersion,
     ReadOnlyWriteOnlyModelType,
     ReuseScope,
     StrictTypes,
     TargetPydanticVersion,
     UnionMode,
+    VersionMode,
 )
 from datamodel_code_generator.format import DateClassType, DatetimeClassType, Formatter, PythonVersion
 from datamodel_code_generator.parser import LiteralType
@@ -986,22 +985,23 @@ def start_section(self, heading: str | None) -> None:
     action="store_true",
     default=None,
 )
-openapi_options.add_argument(
-    "--openapi-version",
-    help="OpenAPI version to use (default: auto-detect from 'openapi' field). "
-    "Use 'auto' for auto-detection, '3.0' for OpenAPI 3.0.x, '3.1' for OpenAPI 3.1.x.",
-    choices=[v.value for v in OpenAPIVersion],
-    default=None,
-)
-
 # ======================================================================================
-# Options specific to JSON Schema input
+# Schema version options (for both JSON Schema and OpenAPI)
 # ======================================================================================
 base_options.add_argument(
-    "--jsonschema-version",
-    help="JSON Schema version to use (default: auto-detect from '$schema' field). "
-    "Use 'auto' for auto-detection, or specify a draft version explicitly.",
-    choices=[v.value for v in JsonSchemaVersion],
+    "--schema-version",
+    help="Schema version. Valid values depend on input type: "
+    "JsonSchema: auto, draft-04, draft-06, draft-07, 2019-09, 2020-12. "
+    "OpenAPI: auto, 3.0, 3.1. "
+    "(default: auto - detected from $schema or openapi field)",
+    default=None,
+)
+base_options.add_argument(
+    "--schema-version-mode",
+    help="Schema version validation mode. "
+    "'lenient': accept all features regardless of version (default). "
+    "'strict': warn on features outside declared/detected version.",
+    choices=[m.value for m in VersionMode],
     default=None,
 )
 

src/datamodel_code_generator/cli_options.py

@@ -70,6 +70,8 @@ class CLIOptionMeta:
     "--input-model-ref-strategy": CLIOptionMeta(name="--input-model-ref-strategy", category=OptionCategory.BASE),
     "--input-file-type": CLIOptionMeta(name="--input-file-type", category=OptionCategory.BASE),
     "--encoding": CLIOptionMeta(name="--encoding", category=OptionCategory.BASE),
+    "--schema-version": CLIOptionMeta(name="--schema-version", category=OptionCategory.BASE),
+    "--schema-version-mode": CLIOptionMeta(name="--schema-version-mode", category=OptionCategory.BASE),
     # ==========================================================================
     # Model Customization
     # ==========================================================================

src/datamodel_code_generator/config.py

@@ -30,6 +30,7 @@
     ReadOnlyWriteOnlyModelType,
     ReuseScope,
     TargetPydanticVersion,
+    VersionMode,
 )
 from datamodel_code_generator.format import (
     DateClassType,
@@ -207,6 +208,8 @@ class Config:
     field_type_collision_strategy: FieldTypeCollisionStrategy | None = None
     module_split_mode: ModuleSplitMode | None = None
     default_value_overrides: Mapping[str, Any] | None = None
+    schema_version: str | None = None
+    schema_version_mode: VersionMode | None = None
 
 
 class ParserConfig(BaseModel):

src/datamodel_code_generator/parser/jsonschema.py

@@ -664,7 +664,7 @@ class JsonSchemaParser(Parser["JSONSchemaParserConfig"]):
     })
 
     @classmethod
-    def _create_default_config(cls, options: JSONSchemaParserConfigDict) -> JSONSchemaParserConfig:
+    def _create_default_config(cls, options: JSONSchemaParserConfigDict) -> JSONSchemaParserConfig:  # type: ignore[override]
         """Create a JSONSchemaParserConfig from options."""
         from datamodel_code_generator import types as types_module  # noqa: PLC0415
         from datamodel_code_generator.config import JSONSchemaParserConfig  # noqa: PLC0415

tests/data/expected/main/input_model/config_class.py

@@ -114,6 +114,9 @@ class DataclassArguments(TypedDict, closed=True):
 ValidatorMode: TypeAlias = Literal['before', 'after', 'wrap', 'plain']
 
 
+VersionMode: TypeAlias = Literal['lenient', 'strict']
+
+
 class GenerateConfig(TypedDict, closed=True):
     input_filename: NotRequired[str | None]
     input_file_type: NotRequired[InputFileType]
@@ -246,6 +249,8 @@ class GenerateConfig(TypedDict, closed=True):
     field_type_collision_strategy: NotRequired[FieldTypeCollisionStrategy | None]
     module_split_mode: NotRequired[ModuleSplitMode | None]
     default_value_overrides: NotRequired[Mapping[str, Any] | None]
+    schema_version: NotRequired[str | None]
+    schema_version_mode: NotRequired[VersionMode | None]
 
 
 class ValidatorDefinition(TypedDict):

tests/main/test_public_api_signature_baseline.py

@@ -28,6 +28,7 @@
     ReadOnlyWriteOnlyModelType,
     ReuseScope,
     TargetPydanticVersion,
+    VersionMode,
 )
 from datamodel_code_generator.format import PythonVersionMin
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
@@ -187,6 +188,8 @@ def _baseline_generate(
     all_exports_collision_strategy: AllExportsCollisionStrategy | None = None,
     field_type_collision_strategy: FieldTypeCollisionStrategy | None = None,
     module_split_mode: ModuleSplitMode | None = None,
+    schema_version: str | None = None,
+    schema_version_mode: VersionMode | None = None,
 ) -> str | object | None:
     raise NotImplementedError
 

tests/parser/test_schema_version.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from pathlib import Path
+
 import pytest
 from inline_snapshot import snapshot
 
@@ -14,6 +16,9 @@
     detect_openapi_version,
 )
 
+# Path to test data
+JSON_SCHEMA_DATA_PATH = Path(__file__).parent.parent / "data" / "jsonschema"
+
 
 def test_detect_jsonschema_version_draft4() -> None:
     """Test detection of Draft 4 from $schema field."""
@@ -421,3 +426,72 @@ def test_openapi_parser_schema_features_detection() -> None:
     features = parser.schema_features
     assert features.nullable_keyword == snapshot(False)
     assert features.null_in_type_array == snapshot(True)
+
+
+def test_jsonschema_parser_config_version_override() -> None:
+    """Test that JsonSchemaParser uses config version over auto-detection."""
+    from datamodel_code_generator.parser.jsonschema import JsonSchemaParser
+
+    parser = JsonSchemaParser("", jsonschema_version=JsonSchemaVersion.Draft4)
+    parser.raw_obj = {"$schema": "http://json-schema.org/draft-07/schema#"}
+    features = parser.schema_features
+    assert features.id_field == snapshot("id")
+    assert features.boolean_schemas == snapshot(False)
+
+
+def test_openapi_parser_config_version_override() -> None:
+    """Test that OpenAPIParser uses config version over auto-detection."""
+    from datamodel_code_generator.parser.openapi import OpenAPIParser
+
+    parser = OpenAPIParser("", openapi_version=OpenAPIVersion.V30)
+    parser.raw_obj = {"openapi": "3.1.0"}
+    features = parser.schema_features
+    assert features.nullable_keyword == snapshot(True)
+    assert features.null_in_type_array == snapshot(False)
+
+
+@pytest.mark.cli_doc(
+    options=["--schema-version"],
+    option_description="""Schema version to use for parsing.
+
+The `--schema-version` option specifies the schema version to use instead of auto-detection.
+Valid values depend on input type: JsonSchema (draft-04, draft-06, draft-07, 2019-09, 2020-12)
+or OpenAPI (3.0, 3.1). Default is 'auto' (detected from $schema or openapi field).""",
+    input_schema="jsonschema/simple_string.json",
+    cli_args=["--schema-version", "draft-07"],
+    golden_output="jsonschema/simple_string.py",
+)
+def test_cli_schema_version_jsonschema() -> None:
+    """Test --schema-version option with JSON Schema input."""
+    from datamodel_code_generator import generate
+
+    result = generate(
+        JSON_SCHEMA_DATA_PATH / "simple_string.json",
+        input_file_type=datamodel_code_generator.InputFileType.JsonSchema,
+        schema_version="draft-07",
+    )
+    assert result is not None
+    assert "class Model" in result or "Model" in result
+
+
+@pytest.mark.cli_doc(
+    options=["--schema-version-mode"],
+    option_description="""Schema version validation mode.
+
+The `--schema-version-mode` option controls how schema version validation is performed.
+'lenient' (default): accept all features regardless of version.
+'strict': warn on features outside the declared/detected version.""",
+    input_schema="jsonschema/simple_string.json",
+    cli_args=["--schema-version-mode", "lenient"],
+    golden_output="jsonschema/simple_string.py",
+)
+def test_cli_schema_version_mode() -> None:
+    """Test --schema-version-mode option."""
+    from datamodel_code_generator import generate
+
+    result = generate(
+        JSON_SCHEMA_DATA_PATH / "simple_string.json",
+        input_file_type=datamodel_code_generator.InputFileType.JsonSchema,
+        schema_version_mode=VersionMode.Lenient,
+    )
+    assert result is not None