datamodel-code-generator 0.56.0__tar.gz → 0.56.1__tar.gz

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.56.0
+Version: 0.56.1
 Summary: Datamodel Code Generator
 Project-URL: Homepage, https://github.com/koxudaxi/datamodel-code-generator
 Project-URL: Source, https://github.com/koxudaxi/datamodel-code-generator
@@ -27,7 +27,7 @@ Requires-Dist: jinja2<4,>=2.10.1
 Requires-Dist: pydantic<3,>=2.12; python_version >= '3.14'
 Requires-Dist: pydantic<3,>=2; python_version < '3.14'
 Requires-Dist: pyyaml>=6.0.1
-Requires-Dist: tomli<3,>=2.2.1; python_version <= '3.11'
+Requires-Dist: tomli<3,>=2.2.1; python_version < '3.11'
 Provides-Extra: all
 Requires-Dist: graphql-core>=3.2.3; extra == 'all'
 Requires-Dist: httpx>=0.24.1; extra == 'all'

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/pyproject.toml

@@ -38,7 +38,7 @@ dependencies = [
   "pydantic>=2,<3; python_version<'3.14'",
   "pydantic>=2.12,<3; python_version>='3.14'",
   "pyyaml>=6.0.1",
-  "tomli>=2.2.1,<3; python_version<='3.11'",
+  "tomli>=2.2.1,<3; python_version<'3.11'",
 ]
 optional-dependencies.all = [
   "datamodel-code-generator[debug]",

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/src/datamodel_code_generator/__main__.py

@@ -553,6 +553,13 @@ class Config(BaseModel):  # noqa: PLR0904
     def merge_args(self, args: Namespace) -> None:
         """Merge command-line arguments into config."""
         set_args = {f: getattr(args, f) for f in self.get_fields() if getattr(args, f) is not None}
+        explicit_input_sources = {
+            field_name for field_name in ("input", "url", "input_model") if field_name in set_args
+        }
+
+        if explicit_input_sources:
+            for field_name in {"input", "url", "input_model"} - explicit_input_sources:
+                setattr(self, field_name, None)
 
         if set_args.get("output_model_type") == DataModelType.MsgspecStruct.value:
             set_args["use_annotated"] = True

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/src/datamodel_code_generator/arguments.py

@@ -88,7 +88,18 @@ def _external_ref_mapping(value: str) -> str:
 def _json_value_or_file(value: str) -> dict[str, object]:
     """Parse a JSON value or load it from a JSON file path."""
     path = Path(value).expanduser()
-    if path.is_file():
+
+    # In Python<=3.13, long json values would cause `path.is_file()` to raise an OSError exception
+    # because the string is too long to be interpreted as a filename.
+    # This changed in Python>=3.14 since now `path.is_file()` catches OSError and returns `false` instead.
+    # Therefore we are going to catch OSError exception raised in Python<=3.13 to replicate Python>=3.14 behavior.
+    is_file: bool
+    try:
+        is_file = path.is_file()
+    except OSError:
+        is_file = False
+
+    if is_file:
         try:
             json_input = path.read_text(encoding=DEFAULT_ENCODING)
         except (OSError, UnicodeDecodeError) as e:
@@ -96,6 +107,7 @@ def _json_value_or_file(value: str) -> dict[str, object]:
             raise ArgumentTypeError(msg) from e
     else:
         json_input = value
+
     try:
         result = json.loads(json_input)
     except json.JSONDecodeError as e:

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/src/datamodel_code_generator/parser/base.py

@@ -1815,6 +1815,8 @@ class Parser(ABC, Generic[ParserConfigT, SchemaFeaturesT]):
         model_cache: dict[tuple[HashableComparable, ...], Reference] = {}
         duplicates = []
         for model in models.copy():
+            if self.collapse_root_models and isinstance(model, self.data_model_root_type):
+                continue
             model_key = model.get_dedup_key()
             cached_model_reference = model_cache.get(model_key)
             if cached_model_reference:

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/src/datamodel_code_generator/prompt_data.py

@@ -72,7 +72,7 @@ OPTION_DESCRIPTIONS: dict[str, str] = {
     "--input-file-type": "Specify the input file type for code generation.",
     "--input-model": "Import a Python type or dict schema from a module.",
     "--input-model-ref-strategy": "Strategy for referenced types when using --input-model.",
-    "--keep-model-order": "Keep model definition order as specified in schema.",
+    "--keep-model-order": "Keep generated model order deterministic while respecting dependency constraints.",
     "--keyword-only": "Generate dataclasses with keyword-only fields (Python 3.10+).",
     "--model-extra-keys": "Add model-level schema extensions to ConfigDict json_schema_extra.",
     "--model-extra-keys-without-x-prefix": "Strip x- prefix from model-level schema extensions and add to ConfigDic...",

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/src/datamodel_code_generator/reference.py

@@ -627,7 +627,7 @@ class ModelResolver:  # noqa: PLR0904
         """Register an identifier mapping to a resolved reference path."""
         self.ids["/".join(self.current_root)][id_] = self.resolve_ref(path)
 
-    def resolve_ref(self, path: Sequence[str] | str) -> str:  # noqa: PLR0911, PLR0912, PLR0914
+    def resolve_ref(self, path: Sequence[str] | str) -> str:  # noqa: PLR0911, PLR0912, PLR0914, PLR0915
         """Resolve a reference path to its canonical form."""
         joined_path = path if isinstance(path, str) else self.join_path(tuple(path))
         if joined_path == "#":
@@ -679,7 +679,9 @@ class ModelResolver:  # noqa: PLR0904
         if self.base_url:
             from .http import join_url  # noqa: PLC0415
 
-            effective_base = self.root_id or self.base_url
+            effective_base = self.base_url
+            if self.root_id:
+                effective_base = self.root_id if is_url(self.root_id) else join_url(self.base_url, self.root_id)
             joined_url = join_url(effective_base, ref)
             if "#" in joined_url:
                 return joined_url

datamodel_code_generator-0.56.1/tests/data/expected/main/jsonschema/reuse_model_collapse_root_models_constraints.py

@@ -0,0 +1,30 @@
+# generated by datamodel-codegen:
+#   filename:  reuse_model_collapse_root_models_constraints.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field, RootModel
+
+
+class Shared(BaseModel):
+    short_code: str = Field(
+        ..., alias='shortCode', max_length=8, min_length=0, title='ShortCode'
+    )
+
+
+class RecordA(Shared):
+    timestamp: str = Field(..., title='Timestamp')
+
+
+class RecordB(Shared):
+    created: str = Field(..., title='Timestamp')
+    label: str = Field(..., title='LongText')
+
+
+class ReproBugs(RootModel[RecordA | RecordB]):
+    root: RecordA | RecordB = Field(
+        ...,
+        description='Minimal schema to reproduce reuse_model + collapse_root_models bugs in datamodel-code-generator 0.55.0',
+        title='ReproBugs',
+    )

datamodel_code_generator-0.56.1/tests/data/jsonschema/reuse_model_collapse_root_models_constraints.json

@@ -0,0 +1,77 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ReproBugs",
+  "description": "Minimal schema to reproduce reuse_model + collapse_root_models bugs in datamodel-code-generator 0.55.0",
+  "$defs": {
+    "Shared": {
+      "type": "object",
+      "title": "Shared",
+      "properties": {
+        "shortCode": {
+          "title": "ShortCode",
+          "type": "string",
+          "maxLength": 8,
+          "minLength": 0
+        }
+      },
+      "required": [
+        "shortCode"
+      ]
+    },
+    "RecordA": {
+      "type": "object",
+      "title": "RecordA",
+      "allOf": [
+        {
+          "$ref": "#/$defs/Shared"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "timestamp": {
+              "title": "Timestamp",
+              "type": "string"
+            }
+          },
+          "required": [
+            "timestamp"
+          ]
+        }
+      ]
+    },
+    "RecordB": {
+      "type": "object",
+      "title": "RecordB",
+      "allOf": [
+        {
+          "$ref": "#/$defs/Shared"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "created": {
+              "title": "Timestamp",
+              "type": "string"
+            },
+            "label": {
+              "title": "LongText",
+              "type": "string"
+            }
+          },
+          "required": [
+            "created",
+            "label"
+          ]
+        }
+      ]
+    }
+  },
+  "oneOf": [
+    {
+      "$ref": "#/$defs/RecordA"
+    },
+    {
+      "$ref": "#/$defs/RecordB"
+    }
+  ]
+}

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/tests/main/jsonschema/test_main_jsonschema.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import itertools
 import json
 import os
 import tempfile
@@ -97,22 +98,32 @@ def test_main_inheritance_forward_ref(output_file: Path, tmp_path: Path) -> None
 @pytest.mark.benchmark
 @pytest.mark.cli_doc(
     options=["--keep-model-order"],
-    option_description="""Keep model definition order as specified in schema.
-
-The `--keep-model-order` flag preserves the original definition order from the schema
-instead of reordering models based on dependencies. This is useful when the order
-of model definitions matters for documentation or readability.""",
+    option_description="""Keep generated model order deterministic while respecting dependency constraints.
+
+The `--keep-model-order` flag produces a stable, deterministic output order. The
+generator starts from class-name order and only moves models when required to
+satisfy dependency or runtime constraints (for example, a base class must appear
+before its subclass, and cyclic groups must stay together).
+
+This option is not equivalent to preserving the raw definition order from the
+input schema, and it does not guarantee a strict unconditional alphabetical
+order either. Inheritance and other runtime ordering requirements can force a
+non-alphabetical arrangement. The value of the flag is that repeated runs on the
+same schema produce the same ordering, which keeps diffs stable.""",
     input_schema="jsonschema/inheritance_forward_ref.json",
     cli_args=["--keep-model-order"],
     golden_output="jsonschema/inheritance_forward_ref_keep_model_order.py",
     related_options=["--collapse-root-models"],
 )
 def test_main_inheritance_forward_ref_keep_model_order(output_file: Path, tmp_path: Path) -> None:
-    """Keep model definition order as specified in schema.
-
-    The `--keep-model-order` flag preserves the original definition order from the schema
-    instead of reordering models based on dependencies. This is useful when the order
-    of model definitions matters for documentation or readability.
+    """Keep generated model order deterministic while respecting dependency constraints.
+
+    The `--keep-model-order` flag produces a stable, deterministic output order.
+    The generator starts from class-name order and only moves models when required
+    to satisfy dependency or runtime constraints. It is not equivalent to
+    preserving the raw schema/spec definition order, and it does not guarantee a
+    strict unconditional alphabetical order either — inheritance and other
+    runtime ordering requirements can force a non-alphabetical arrangement.
     """
     run_main_and_assert(
         input_path=JSON_SCHEMA_DATA_PATH / "inheritance_forward_ref.json",
@@ -991,6 +1002,73 @@ def test_main_root_id_jsonschema_with_absolute_local_file(output_file: Path) ->
     )
 
 
+def test_main_url_with_relative_root_id_resolves_relative_refs(mocker: MockerFixture, tmp_path: Path) -> None:
+    """Test --url input keeps resolving relative refs remotely when root $id is path-only."""
+    main_response = mocker.Mock()
+    main_response.status_code = 200
+    main_response.headers = {}
+    main_response.text = json.dumps({
+        "$id": "/schemas/v1/main.schema.json",
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "title": "Main",
+        "type": "object",
+        "properties": {
+            "sub": {
+                "$ref": "sub.schema.json",
+            }
+        },
+        "required": ["sub"],
+    })
+    sub_response = mocker.Mock()
+    sub_response.status_code = 200
+    sub_response.headers = {}
+    sub_response.text = json.dumps({
+        "$id": "/schemas/v1/sub.schema.json",
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "title": "Sub",
+        "type": "string",
+        "pattern": "^[0-9a-f]{8}$",
+    })
+    httpx_get_mock = mocker.patch("httpx.get", side_effect=[main_response, sub_response])
+    output_dir = tmp_path / "output"
+
+    result = run_main_with_args([
+        "--url",
+        "http://localhost:8888/schemas/v1/main.schema.json",
+        "--output",
+        str(output_dir),
+        "--input-file-type",
+        "jsonschema",
+        "--output-model-type",
+        "pydantic_v2.BaseModel",
+    ])
+
+    assert result == Exit.OK
+    main_content = (output_dir / "__init__.py").read_text(encoding="utf-8")
+    sub_content = (output_dir / "sub.py").read_text(encoding="utf-8")
+    assert "class Main(BaseModel):" in main_content
+    assert "sub: sub_1.Schema" in main_content
+    assert "class Schema(RootModel[constr(pattern=r'^[0-9a-f]{8}$')]):" in sub_content
+    httpx_get_mock.assert_has_calls([
+        call(
+            "http://localhost:8888/schemas/v1/main.schema.json",
+            headers=None,
+            verify=True,
+            follow_redirects=True,
+            params=None,
+            timeout=30.0,
+        ),
+        call(
+            "http://localhost:8888/schemas/v1/sub.schema.json",
+            headers=None,
+            verify=True,
+            follow_redirects=True,
+            params=None,
+            timeout=30.0,
+        ),
+    ])
+
+
 def test_main_remote_ref_emits_deprecation_warning(mocker: MockerFixture, tmp_path: Path) -> None:
     """Test that implicit remote $ref fetching emits a FutureWarning when flag is not set."""
     person_response = mocker.Mock()
@@ -1270,6 +1348,37 @@ def test_main_reuse_model_collapse_nested(output_file: Path) -> None:
     )
 
 
+@pytest.mark.parametrize(
+    "collapse_reuse_model_args",
+    [[], ["--collapse-reuse-models"]],
+)
+def test_main_reuse_model_collapse_root_models_preserves_constraints(
+    output_file: Path, collapse_reuse_model_args: list[str]
+) -> None:
+    """Test root-model collapse keeps distinct field constraints when titles collide."""
+    extra_args = [
+        "--reuse-model",
+        "--collapse-root-models",
+        "--use-title-as-name",
+        "--field-constraints",
+        "--snake-case-field",
+        "--target-python-version",
+        "3.10",
+        "--output-model-type",
+        "pydantic_v2.BaseModel",
+        *collapse_reuse_model_args,
+    ]
+
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "reuse_model_collapse_root_models_constraints.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        assert_func=assert_file_content,
+        expected_file="reuse_model_collapse_root_models_constraints.py",
+        extra_args=extra_args,
+    )
+
+
 @pytest.mark.cli_doc(
     options=["--capitalize-enum-members"],
     option_description="""Capitalize enum member names to UPPER_CASE format.
@@ -3143,6 +3252,21 @@ def test_main_jsonschema_base_class_map_empty_list(output_file: Path) -> None:
     )
 
 
+def test_main_jsonschema_base_class_map_long_json(output_file: Path) -> None:
+    """Test base_class_map with very long json string."""
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "base_class_map_empty_list.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        assert_func=assert_file_content,
+        expected_file="base_class_map_empty_list.py",
+        extra_args=[
+            "--base-class-map",
+            '{"User": [' + ",".join(itertools.repeat('""', 100)) + "]}",
+        ],
+    )
+
+
 def test_long_description(output_file: Path) -> None:
     """Test long description handling."""
     run_main_and_assert(
@@ -4659,6 +4783,22 @@ def test_main_enum_field_as_literal_map_from_file(output_file: Path, tmp_path: P
     )
 
 
+def test_main_enum_field_as_literal_map_long_json(output_file: Path) -> None:
+    """Test enum_field_as_literal_map with very long json string."""
+    long_inline_mapping = '{"status": "literal",' + ",".join(f'"unused_field_{i}": "enum"' for i in range(100)) + "}"
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "enum_field_as_literal_map.json",
+        output_path=output_file,
+        input_file_type=None,
+        assert_func=assert_file_content,
+        expected_file="enum_field_as_literal_map.py",
+        extra_args=[
+            "--enum-field-as-literal-map",
+            long_inline_mapping,
+        ],
+    )
+
+
 def test_main_enum_field_as_literal_map_override_global(output_file: Path) -> None:
     """Test --enum-field-as-literal-map overrides global --enum-field-as-literal."""
     run_main_and_assert(

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/tests/main/test_main_general.py

@@ -1458,6 +1458,99 @@ def test_use_specialized_enum_pyproject_override_with_cli(output_file: Path, tmp
         )
 
 
+def test_cli_input_overrides_pyproject_url(output_file: Path, tmp_path: Path, mocker: MockerFixture) -> None:
+    """Test --input takes precedence over pyproject.toml url setting."""
+    pyproject_toml = tmp_path / "pyproject.toml"
+    pyproject_toml.write_text(
+        '[tool.datamodel-codegen]\nurl = "https://example.com/schema.json"\ninput-file-type = "jsonschema"\n',
+        encoding="utf-8",
+    )
+
+    cli_input = tmp_path / "cli.json"
+    cli_input.write_text(
+        '{"type": "object", "properties": {"from_input": {"type": "string"}}}',
+        encoding="utf-8",
+    )
+
+    httpx_get_mock = mocker.patch("httpx.get")
+
+    with chdir(tmp_path):
+        run_main_and_assert(
+            input_path=cli_input.relative_to(tmp_path),
+            output_path=output_file,
+            extra_args=["--disable-timestamp"],
+            expected_output=snapshot(
+                """\
+# generated by datamodel-codegen:
+#   filename:  cli.json
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Model(BaseModel):
+    from_input: str | None = None
+"""
+            ),
+        )
+
+    httpx_get_mock.assert_not_called()
+
+
+def test_cli_url_overrides_pyproject_input(output_file: Path, tmp_path: Path, mocker: MockerFixture) -> None:
+    """Test --url takes precedence over pyproject.toml input setting."""
+    pyproject_toml = tmp_path / "pyproject.toml"
+    pyproject_toml.write_text(
+        '[tool.datamodel-codegen]\ninput = "config.json"\ninput-file-type = "jsonschema"\n',
+        encoding="utf-8",
+    )
+
+    config_input = tmp_path / "config.json"
+    config_input.write_text(
+        '{"type": "object", "properties": {"from_config": {"type": "string"}}}',
+        encoding="utf-8",
+    )
+
+    mock_response = mocker.Mock()
+    mock_response.status_code = 200
+    mock_response.headers = {}
+    mock_response.text = '{"type": "object", "properties": {"from_url": {"type": "integer"}}}'
+    httpx_get_mock = mocker.patch("httpx.get", return_value=mock_response)
+
+    with chdir(tmp_path):
+        run_main_with_args([
+            "--url",
+            "http://127.0.0.1:8123/schema.json",
+            "--output",
+            str(output_file),
+            "--disable-timestamp",
+        ])
+
+    assert output_file.read_text(encoding="utf-8") == snapshot(
+        """\
+# generated by datamodel-codegen:
+#   filename:  http://127.0.0.1:8123/schema.json
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Model(BaseModel):
+    from_url: int | None = None
+"""
+    )
+    httpx_get_mock.assert_called_once_with(
+        "http://127.0.0.1:8123/schema.json",
+        headers=None,
+        verify=True,
+        follow_redirects=True,
+        params=None,
+        timeout=30.0,
+    )
+
+
 @pytest.mark.cli_doc(
     options=["--module-split-mode"],
     option_description="""Split generated models into separate files, one per model class.

{datamodel_code_generator-0.56.0 → datamodel_code_generator-0.56.1}/tests/test_reference.py

@@ -213,6 +213,16 @@ def test_resolve_ref_with_root_id_differs_from_base_url() -> None:
     assert result == "https://example.com/common/types.json#"
 
 
+def test_resolve_ref_with_relative_root_id_and_base_url() -> None:
+    """Relative root $id should be resolved against the retrieval URL before $ref resolution."""
+    resolver = ModelResolver(base_url="http://localhost:8888/schemas/v1/main.schema.json")
+    resolver.set_root_id("/schemas/v1/main.schema.json")
+
+    result = resolver.resolve_ref("sub.schema.json")
+
+    assert result == "http://localhost:8888/schemas/v1/sub.schema.json#"
+
+
 @pytest.mark.parametrize(
     ("base_url", "ref", "expected"),
     [