datamodel-code-generator 0.75.0__tar.gz → 0.75.1__tar.gz

{datamodel_code_generator-0.75.0 → datamodel_code_generator-0.75.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: datamodel-code-generator
-Version: 0.75.0
+Version: 0.75.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

{datamodel_code_generator-0.75.0 → datamodel_code_generator-0.75.1}/src/datamodel_code_generator/__init__.py

@@ -14,6 +14,7 @@ from collections import OrderedDict, defaultdict
 from collections.abc import Callable, Iterator, Mapping
 from datetime import datetime, timezone
 from functools import lru_cache as _lru_cache
+from functools import partial as _partial
 from hashlib import sha256
 from pathlib import Path
 from threading import RLock
@@ -623,6 +624,10 @@ class Error(Exception):
         return self.message
 
 
+class _CollapseRootModelsRecursionError(RecursionError):
+    """Signal that collapsing root models needs its circular-reference fallback."""
+
+
 def _normalized_absolute_path(path: Path, *, resolve_aliases: bool = False) -> Path:
     """Return a normalized absolute path, resolving aliases only when needed."""
     expanded_path = path.expanduser()
@@ -2009,6 +2014,55 @@ def _build_generation_parser(  # noqa: PLR0913, PLR0917
     return parser
 
 
+def _build_generation_retry_parser(  # noqa: PLR0913, PLR0917
+    input_: _GenerationInput,
+    input_text: str | None,
+    input_file_type: InputFileType,
+    source_override: Mapping[str, Any] | None,
+    config: GenerateConfig,
+    extra_template_data: defaultdict[str, dict[str, Any]] | None,
+    dataclass_arguments: DataclassArguments,
+    schema_versions: _SchemaVersions,
+    diagnostic_source_path: Path | None,
+    remote_text_cache: DefaultPutDict[str, str],
+    reference_cache: Any | None,
+    base_path: Path,
+    *,
+    skip_root_model: bool,
+    preserve_circular_root_models: bool = False,
+) -> tuple[Any, DataModelSet, bool]:
+    """Build one fresh parser for an internal compatibility retry."""
+    data_model_types, parser_source, defer_formatting, parser_options, python_type_expressions = (
+        _prepare_parser_common_options(
+            input_,
+            input_text,
+            input_file_type,
+            source_override,
+            config,
+            extra_template_data,
+            dataclass_arguments,
+            skip_root_model=skip_root_model,
+            remote_text_cache=remote_text_cache,
+        )
+    )
+    parser_options["base_path"] = base_path
+    parser = _build_generation_parser(
+        input_,
+        input_file_type,
+        parser_source,
+        config,
+        parser_options,
+        data_model_types,
+        schema_versions,
+        diagnostic_source_path,
+        reference_cache=reference_cache,
+        python_type_expressions=python_type_expressions,
+    )
+    if preserve_circular_root_models:
+        parser._preserve_circular_root_models = True  # noqa: SLF001
+    return parser, data_model_types, defer_formatting
+
+
 def _prepare_generation_input(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     input_: _GenerationInput,
     config: GenerateConfig,
@@ -2182,9 +2236,13 @@ def _parse_with_disposal(  # noqa: PLR0913
                 module_split_mode=config.module_split_mode,
                 collect_model_metadata=config.emit_model_metadata is not None,
             )
-    except BaseException:
-        with contextlib.suppress(BaseException):
-            parser._dispose()  # noqa: SLF001
+    except BaseException as exc:
+        match exc:
+            case _CollapseRootModelsRecursionError():
+                parser._dispose()  # noqa: SLF001
+            case _:
+                with contextlib.suppress(BaseException):
+                    parser._dispose()  # noqa: SLF001
         raise
     finally:
         if not use_output_cwd:
@@ -2192,6 +2250,48 @@ def _parse_with_disposal(  # noqa: PLR0913
     return results
 
 
+def _parse_collapse_root_models_retry(  # noqa: PLR0913
+    input_: _GenerationInput,
+    parser: Any,
+    config: GenerateConfig,
+    *,
+    parser_settings_path: Path | None,
+    use_output_cwd: bool,
+    output_context_path: Path,
+) -> _ParserResults:
+    """Parse the compatibility retry without repeating user-visible warnings."""
+
+    def suppress_warnings(callback: Callable[[], None]) -> None:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            callback()
+
+    parser.parse_raw = _partial(suppress_warnings, parser.parse_raw)
+    parser._report_parse_diagnostics = _partial(  # noqa: SLF001
+        suppress_warnings,
+        parser._report_parse_diagnostics,  # noqa: SLF001
+    )
+    try:
+        return _parse_with_disposal(
+            input_,
+            parser,
+            config,
+            parser_settings_path=parser_settings_path,
+            use_output_cwd=use_output_cwd,
+            output_context_path=output_context_path,
+        )
+    except _CollapseRootModelsRecursionError as retry_exc:
+        match retry_exc.__cause__:
+            case RecursionError() as retry_cause:
+                public_error = retry_cause
+            case _:
+                public_error = RecursionError(str(retry_exc))
+        raise public_error from None
+    finally:
+        parser.__dict__.pop("parse_raw", None)
+        parser.__dict__.pop("_report_parse_diagnostics", None)
+
+
 def _parse_generation(  # noqa: PLR0913, PLR0914, PLR0917
     input_: _GenerationInput,
     input_text: str | None,
@@ -2213,7 +2313,7 @@ def _parse_generation(  # noqa: PLR0913, PLR0914, PLR0917
     use_output_cwd: bool,
     output_context_path: Path,
 ) -> _ParsedGeneration:
-    """Parse, dispose, and optionally retry invalid dotted stdout inside the output cwd."""
+    """Parse, dispose, and retry narrow compatibility failures inside the output cwd."""
     # Phase 3: build before chdir so initial reference resolution keeps the caller's cwd.
     parser = _build_generation_parser(
         input_,
@@ -2228,14 +2328,47 @@ def _parse_generation(  # noqa: PLR0913, PLR0914, PLR0917
     )
     # Phase 4: initial parse, disposal, and the complete retry flow share the output cwd.
     with chdir(output_context_path if use_output_cwd else None):
-        results = _parse_with_disposal(
-            input_,
-            parser,
-            config,
-            parser_settings_path=parser_settings_path,
-            use_output_cwd=use_output_cwd,
-            output_context_path=output_context_path,
-        )
+        try:
+            results = _parse_with_disposal(
+                input_,
+                parser,
+                config,
+                parser_settings_path=parser_settings_path,
+                use_output_cwd=use_output_cwd,
+                output_context_path=output_context_path,
+            )
+        except _CollapseRootModelsRecursionError:
+            retry_remote_text_cache = parser.remote_text_cache
+            retry_reference_cache = getattr(parser, "remote_object_cache", None)
+            retry_base_path = parser.base_path
+            del parser
+
+            retry_extra_template_data = _copy_generation_extra_template_data(config)
+            parser, data_model_types, defer_formatting = _build_generation_retry_parser(
+                input_,
+                input_text,
+                input_file_type,
+                source_override,
+                config,
+                retry_extra_template_data,
+                dataclass_arguments,
+                schema_versions,
+                diagnostic_source_path,
+                retry_remote_text_cache,
+                retry_reference_cache,
+                retry_base_path,
+                skip_root_model=skip_root_model,
+                preserve_circular_root_models=True,
+            )
+            extra_template_data = retry_extra_template_data
+            results = _parse_collapse_root_models_retry(
+                input_,
+                parser,
+                config,
+                parser_settings_path=parser_settings_path,
+                use_output_cwd=use_output_cwd,
+                output_context_path=output_context_path,
+            )
         model_metadata = parser.model_metadata
         if repair_modules := parser.invalid_dotted_stdout_repair_modules:
             legacy_inventory = parser.generated_model_inventory
@@ -2243,6 +2376,7 @@ def _parse_generation(  # noqa: PLR0913, PLR0914, PLR0917
             retry_remote_text_cache = parser.remote_text_cache
             retry_reference_cache = getattr(parser, "remote_object_cache", None)
             retry_base_path = parser.base_path
+            preserve_circular_root_models = getattr(parser, "_preserve_circular_root_models", False)
         parser._dispose()  # noqa: SLF001
         del parser
 
@@ -2253,17 +2387,10 @@ def _parse_generation(  # noqa: PLR0913, PLR0914, PLR0917
                     "forced_invalid_dotted_stdout_repair_modules": repair_modules,
                 }
             )
-            retry_options: ParserConfigDict | None = None
             retry_completed = False
             with contextlib.suppress(Exception), warnings.catch_warnings():
                 warnings.simplefilter("ignore", DanglingRefWarning)
-                (
-                    retry_data_model_types,
-                    retry_source,
-                    retry_defer_formatting,
-                    retry_options,
-                    retry_python_type_expressions,
-                ) = _prepare_parser_common_options(
+                retry_parser, retry_data_model_types, retry_defer_formatting = _build_generation_retry_parser(
                     input_,
                     input_text,
                     input_file_type,
@@ -2271,21 +2398,13 @@ def _parse_generation(  # noqa: PLR0913, PLR0914, PLR0917
                     retry_config,
                     extra_template_data,
                     dataclass_arguments,
-                    skip_root_model=skip_root_model,
-                    remote_text_cache=retry_remote_text_cache,
-                )
-                retry_options["base_path"] = retry_base_path
-                retry_parser = _build_generation_parser(
-                    input_,
-                    input_file_type,
-                    retry_source,
-                    retry_config,
-                    retry_options,
-                    retry_data_model_types,
                     schema_versions,
                     diagnostic_source_path,
-                    reference_cache=retry_reference_cache,
-                    python_type_expressions=retry_python_type_expressions,
+                    retry_remote_text_cache,
+                    retry_reference_cache,
+                    retry_base_path,
+                    skip_root_model=skip_root_model,
+                    preserve_circular_root_models=preserve_circular_root_models,
                 )
                 retry_results = _parse_with_disposal(
                     input_,
@@ -2316,7 +2435,6 @@ def _parse_generation(  # noqa: PLR0913, PLR0914, PLR0917
                 del retry_parser
 
             del retry_reference_cache, retry_remote_text_cache
-            del retry_options
     return results, model_metadata, data_model_types, defer_formatting
 
 

datamodel_code_generator-0.75.1/src/datamodel_code_generator/_version.py

@@ -0,0 +1 @@
+__version__ = '0.75.1'

{datamodel_code_generator-0.75.0 → datamodel_code_generator-0.75.1}/src/datamodel_code_generator/parser/base.py

@@ -51,6 +51,7 @@ from datamodel_code_generator import (
     ReadOnlyWriteOnlyModelType,
     ReuseScope,
     YamlValue,
+    _CollapseRootModelsRecursionError,
     _internal_utils,
     _is_parsed_source_cache_enabled,
     _read_parser_source_data_from_path,
@@ -3220,6 +3221,7 @@ class Parser(ABC, Generic[ParserConfigT, SchemaFeaturesT]):
 
         generation_store = self.generation_store
         generation_index = generation_store.index
+        circular_root_model_paths = getattr(self, "_circular_root_model_paths", ())
 
         for model in models:  # noqa: PLR1702
             for model_field in model.fields:
@@ -3234,6 +3236,10 @@ class Parser(ABC, Generic[ParserConfigT, SchemaFeaturesT]):
                     root_type_model = reference.source
                     root_type_field = root_type_model.fields[0]
 
+                    if root_type_model.path in circular_root_model_paths:
+                        # A circular root model cannot be fully inlined; keep it named.
+                        continue
+
                     # These runtime rules are owned by the referenced root model;
                     # replacing it with the raw type would discard its validator.
                     runtime_validation = (
@@ -3389,6 +3395,26 @@ class Parser(ABC, Generic[ParserConfigT, SchemaFeaturesT]):
                     if not generation_index.has_data_type_references(root_type_model.reference):
                         unused_models.append(root_type_model)
 
+    def __set_circular_root_model_paths(self, module_models: ModuleModels) -> None:
+        """Cache live root-model paths in a circular component for the retry path."""
+        root_models = {
+            model.path: model
+            for _, models in module_models
+            for model in models
+            if isinstance(model, self.data_model_root_type)
+        }
+        graph = {
+            (path,): {
+                (reference_path,)
+                for reference_path in self.generation_store.index.reference_classes_for_model_including_dict_keys(model)
+                if reference_path in root_models
+            }
+            for path, model in root_models.items()
+        }
+        self._circular_root_model_paths = frozenset(
+            path for component in find_circular_sccs(graph) for (path,) in component
+        )
+
     def __set_default_enum_member(
         self,
         models: list[DataModel],
@@ -5158,7 +5184,16 @@ class Parser(ABC, Generic[ParserConfigT, SchemaFeaturesT]):
         """Apply defaults and model transforms before final type adjustments."""
         self.__set_reference_default_value_to_field(models, can_retain_cache=can_retain_cache)
         self.__reuse_model(models, require_update_action_models)
-        self.__collapse_root_models(models, unused_models, imports, scoped_model_resolver, model_path_to_module_name)
+        try:
+            self.__collapse_root_models(
+                models,
+                unused_models,
+                imports,
+                scoped_model_resolver,
+                model_path_to_module_name,
+            )
+        except RecursionError as exc:
+            raise _CollapseRootModelsRecursionError from exc
         self.__set_default_enum_member(models, can_retain_cache=can_retain_cache)
         self.__sort_models(models, imports, use_deferred_annotations=use_deferred_annotations)
         self.__change_field_name(models, can_retain_cache=can_retain_cache)
@@ -5675,6 +5710,9 @@ class Parser(ABC, Generic[ParserConfigT, SchemaFeaturesT]):
         module_to_import: dict[ModulePath, Imports] = {}
         contexts: list[ModuleContext] = []
 
+        if self.collapse_root_models and getattr(self, "_preserve_circular_root_models", False):
+            self.__set_circular_root_model_paths(module_models)
+
         for module_, models in module_models:
             ctx = self._process_single_module(
                 module_,

{datamodel_code_generator-0.75.0 → datamodel_code_generator-0.75.1}/src/datamodel_code_generator/parser/generation.py

@@ -104,6 +104,20 @@ def set_model_base_classes(
         generation_store.set_base_classes(model, base_classes)
 
 
+def _detach_data_type_tree(root: DataType) -> None:
+    """Sever one data-type tree iteratively so cleanup cannot hit recursion limits."""
+    stack = [root]
+    while stack:
+        data_type = stack.pop()
+        stack.extend(data_type.data_types)
+        data_type.data_types.clear()
+        if dict_key := data_type.dict_key:
+            stack.append(dict_key)
+            data_type.dict_key = None
+        data_type.parent = None
+        data_type.reference = None
+
+
 @dataclass(frozen=True, slots=True)
 class ModelFact:
     """A parsed model and the stable facts derived from its reference."""
@@ -475,6 +489,27 @@ class GenerationIndex:
         self._reference_classes_cache[model_id] = reference_classes
         return reference_classes
 
+    def reference_classes_for_model_including_dict_keys(self, model: DataModel) -> frozenset[str]:
+        """Return every referenced path for fallback-only dependency analysis."""
+        facts = self._facts()
+        model_id = self._store.model_id(model)
+        if model_id is None:
+            reference_classes = frozenset(model.reference_classes).union(
+                data_type.reference.path
+                for field in model.fields
+                for data_type in field.data_type.all_data_types
+                if data_type.reference is not None
+            )
+        else:
+            reference_classes = frozenset(
+                reference.path
+                for data_type_id in facts.data_types_by_model.get(model_id, ())
+                if (reference := facts.data_type_facts[data_type_id].reference) is not None
+            )
+        if len(additional_properties_references := model._additional_properties_reference_classes):  # noqa: SLF001
+            return reference_classes.union(additional_properties_references)
+        return reference_classes
+
     def owner_model_for_data_type(self, data_type: DataType) -> DataModel | None:
         """Return the tracked model that owns ``data_type`` if known."""
         facts = self._facts()
@@ -587,14 +622,10 @@ class GenerationStore:  # noqa: PLR0904
         """
         for model in self.models:
             for model_field in model.fields:
-                for data_type in list(model_field.data_type.all_data_types):
-                    data_type.parent = None
-                    data_type.reference = None
+                _detach_data_type_tree(model_field.data_type)
                 model_field.parent = None
             for base_class in model.base_classes:
-                for data_type in list(base_class.all_data_types):
-                    data_type.parent = None
-                    data_type.reference = None
+                _detach_data_type_tree(base_class)
         for reference in references:
             reference.children.clear()
             reference.source = None

datamodel_code_generator-0.75.1/tests/data/expected/main/jsonschema/collapse_root_models_dict_key_self_reference.py

@@ -0,0 +1,25 @@
+# generated by datamodel-codegen:
+#   filename:  collapse_root_models_dict_key_self_reference.json
+
+from __future__ import annotations
+
+from typing import Any, Union
+
+from pydantic import BaseModel, RootModel
+
+
+class JsonValue(RootModel[Union[str, list["JsonValue"]]]):
+    root: Union[str, list["JsonValue"]]
+
+
+class KeyMap(RootModel[dict["KeyMap", str]]):
+    root: dict["KeyMap", str]
+
+
+class Model(BaseModel):
+    value: JsonValue | None = None
+    keys: KeyMap | None = None
+    missing: Any | None = None
+
+
+JsonValue.model_rebuild()

datamodel_code_generator-0.75.1/tests/data/expected/main/jsonschema/collapse_root_models_dict_key_self_reference_legacy.py

@@ -0,0 +1,10 @@
+# generated by datamodel-codegen:
+#   filename:  collapse_root_models_dict_key_self_reference_legacy.json
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Model(BaseModel):
+    keys: dict[, str | dict[, str]] | None = None

datamodel_code_generator-0.75.1/tests/data/expected/main/jsonschema/collapse_root_models_parse_warning.py

@@ -0,0 +1,23 @@
+# generated by datamodel-codegen:
+#   filename:  collapse_root_models_parse_warning.json
+
+from __future__ import annotations
+
+from typing import Any, Union
+
+from pydantic import BaseModel, RootModel
+
+
+class JsonValue(RootModel[Union[str, list["JsonValue"]]]):
+    root: Union[str, list["JsonValue"]]
+
+
+class BooleanSchema(RootModel[Any]):
+    root: Any
+
+
+class Model(BaseModel):
+    value: JsonValue | None = None
+
+
+JsonValue.model_rebuild()

datamodel_code_generator-0.75.1/tests/data/expected/main/jsonschema/jsonschema_collapse_root_models_self_reference.py

@@ -0,0 +1,23 @@
+# generated by datamodel-codegen:
+#   filename:  collapse_root_models_self_reference.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from typing import Union
+
+from pydantic import BaseModel, RootModel
+
+
+class JsonValue(
+    RootModel[Union[str, float, bool, list["JsonValue"], dict[str, "JsonValue"]]]
+):
+    root: Union[str, float, bool, list["JsonValue"], dict[str, "JsonValue"]]
+
+
+class Model(BaseModel):
+    data: JsonValue
+    wrapped: int | JsonValue | None = None
+
+
+JsonValue.model_rebuild()

datamodel_code_generator-0.75.1/tests/data/expected/main/jsonschema/jsonschema_collapse_root_models_shared_reference.py

@@ -0,0 +1,13 @@
+# generated by datamodel-codegen:
+#   filename:  collapse_root_models_shared_reference.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Model(BaseModel):
+    a: str | bool | int | bool | None = None
+    b: bool | None = None
+    c: int | bool | None = None

datamodel_code_generator-0.75.1/tests/data/expected/main/jsonschema/jsonschema_collapse_root_models_transitive_reference_cycle.py

@@ -0,0 +1,16 @@
+# generated by datamodel-codegen:
+#   filename:  collapse_root_models_transitive_reference_cycle.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Plain(BaseModel):
+    x: int | None = None
+
+
+class Model(BaseModel):
+    a: str | Plain | None = None
+    b: float | None = None

datamodel_code_generator-0.75.1/tests/data/expected/main/openapi/collapse_root_models_recursive_invalid_dotted_stdout.py

@@ -0,0 +1,24 @@
+# generated by datamodel-codegen:
+#   filename:  collapse_root_models_recursive_invalid_dotted.yaml
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+from pydantic import BaseModel, RootModel
+
+
+class Value(RootModel[Optional[Union[str, list["Value"], dict[str, "Value"]]]]):
+    root: Optional[Union[str, list["Value"], dict[str, "Value"]]] = None
+
+
+class Field1(BaseModel):
+    pass
+
+
+class SaveRequest(BaseModel):
+    trifecta: Field1 | None = None
+    value: Value | None = None
+
+
+Value.model_rebuild()

datamodel_code_generator-0.75.1/tests/data/jsonschema/collapse_root_models_dict_key_self_reference.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "value": {"$ref": "#/$defs/JsonValue"},
+    "keys": {"$ref": "#/$defs/KeyMap"},
+    "missing": {"$ref": "#/$defs/Missing"}
+  },
+  "$defs": {
+    "JsonValue": {
+      "anyOf": [
+        {"type": "string"},
+        {"type": "array", "items": {"$ref": "#/$defs/JsonValue"}}
+      ]
+    },
+    "KeyMap": {
+      "type": "object",
+      "propertyNames": {"$ref": "#/$defs/KeyMap"},
+      "additionalProperties": {"type": "string"}
+    }
+  }
+}

datamodel_code_generator-0.75.1/tests/data/jsonschema/collapse_root_models_dict_key_self_reference_legacy.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "keys": {"$ref": "#/$defs/KeyMap"}
+  },
+  "$defs": {
+    "KeyMap": {
+      "type": "object",
+      "propertyNames": {"$ref": "#/$defs/KeyMap"},
+      "additionalProperties": {"type": "string"}
+    }
+  }
+}

datamodel_code_generator-0.75.1/tests/data/jsonschema/collapse_root_models_parse_warning.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "properties": {
+    "value": {"$ref": "#/definitions/JsonValue"}
+  },
+  "definitions": {
+    "JsonValue": {
+      "anyOf": [
+        {"type": "string"},
+        {"type": "array", "items": {"$ref": "#/definitions/JsonValue"}}
+      ]
+    },
+    "BooleanSchema": true
+  }
+}

datamodel_code_generator-0.75.1/tests/data/jsonschema/collapse_root_models_self_reference.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "data": {
+      "$ref": "#/$defs/JsonValue"
+    },
+    "wrapped": {
+      "$ref": "#/$defs/Wrapper"
+    }
+  },
+  "required": ["data"],
+  "$defs": {
+    "JsonValue": {
+      "anyOf": [
+        { "type": "string" },
+        { "type": "number" },
+        { "type": "boolean" },
+        {
+          "type": "array",
+          "items": { "$ref": "#/$defs/JsonValue" }
+        },
+        {
+          "type": "object",
+          "additionalProperties": { "$ref": "#/$defs/JsonValue" }
+        }
+      ]
+    },
+    "Wrapper": {
+      "anyOf": [
+        { "type": "integer" },
+        { "$ref": "#/$defs/JsonValue" }
+      ]
+    }
+  }
+}