datamodel-code-generator 0.30.1__tar.gz → 0.30.2__tar.gz

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.30.1
+Version: 0.30.2
 Summary: Datamodel Code Generator
 Project-URL: Homepage, https://github.com/koxudaxi/datamodel-code-generator
 Project-URL: Source, https://github.com/koxudaxi/datamodel-code-generator
@@ -505,6 +505,8 @@ Model customization:
                         Enable faux immutability
   --enable-version-header
                         Enable package version on file headers
+  --frozen-dataclasses  Generate frozen dataclasses (dataclass(frozen=True)). Only applies
+                        to dataclass output.
   --keep-model-order    Keep generated models'' order
   --keyword-only        Defined models as keyword only (for example
                         dataclass(kw_only=True)).

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/README.md

@@ -455,6 +455,8 @@ Model customization:
                         Enable faux immutability
   --enable-version-header
                         Enable package version on file headers
+  --frozen-dataclasses  Generate frozen dataclasses (dataclass(frozen=True)). Only applies
+                        to dataclass output.
   --keep-model-order    Keep generated models'' order
   --keyword-only        Defined models as keyword only (for example
                         dataclass(kw_only=True)).

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/__init__.py

@@ -285,6 +285,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     union_mode: UnionMode | None = None,
     output_datetime_class: DatetimeClassType | None = None,
     keyword_only: bool = False,
+    frozen_dataclasses: bool = False,
     no_alias: bool = False,
     formatters: list[Formatter] = DEFAULT_FORMATTERS,
     parent_scoped_naming: bool = False,
@@ -481,6 +482,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
         default_field_extras=default_field_extras,
         target_datetime_class=output_datetime_class,
         keyword_only=keyword_only,
+        frozen_dataclasses=frozen_dataclasses,
         no_alias=no_alias,
         formatters=formatters,
         encoding=encoding,

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/__main__.py

@@ -312,6 +312,7 @@ class Config(BaseModel):
     union_mode: Optional[UnionMode] = None  # noqa: UP045
     output_datetime_class: Optional[DatetimeClassType] = None  # noqa: UP045
     keyword_only: bool = False
+    frozen_dataclasses: bool = False
     no_alias: bool = False
     formatters: list[Formatter] = DEFAULT_FORMATTERS
     parent_scoped_naming: bool = False
@@ -524,6 +525,7 @@ def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912,
             union_mode=config.union_mode,
             output_datetime_class=config.output_datetime_class,
             keyword_only=config.keyword_only,
+            frozen_dataclasses=config.frozen_dataclasses,
             no_alias=config.no_alias,
             formatters=config.formatters,
             parent_scoped_naming=config.parent_scoped_naming,

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/arguments.py

@@ -153,6 +153,12 @@ model_options.add_argument(
     action="store_true",
     default=None,
 )
+model_options.add_argument(
+    "--frozen-dataclasses",
+    help="Generate frozen dataclasses (dataclass(frozen=True)). Only applies to dataclass output.",
+    action="store_true",
+    default=None,
+)
 model_options.add_argument(
     "--reuse-model",
     help="Reuse models on the field when a module has the model with the same content",

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/format.py

@@ -222,7 +222,7 @@ class CodeFormatter:
         )
 
     def apply_ruff_lint(self, code: str) -> str:
-        result = subprocess.run(  # noqa: S603
+        result = subprocess.run(
             ("ruff", "check", "--fix", "-"),
             input=code.encode(self.encoding),
             capture_output=True,
@@ -231,7 +231,7 @@ class CodeFormatter:
         return result.stdout.decode(self.encoding)
 
     def apply_ruff_formatter(self, code: str) -> str:
-        result = subprocess.run(  # noqa: S603
+        result = subprocess.run(
             ("ruff", "format", "-"),
             input=code.encode(self.encoding),
             capture_output=True,

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/model/base.py

@@ -275,9 +275,11 @@ class DataModel(TemplateBase, Nullable, ABC):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        frozen: bool = False,
         treat_dot_as_module: bool = False,
     ) -> None:
         self.keyword_only = keyword_only
+        self.frozen = frozen
         if not self.TEMPLATE_FILE_PATH:
             msg = "TEMPLATE_FILE_PATH is undefined"
             raise Exception(msg)  # noqa: TRY002
@@ -434,5 +436,6 @@ class DataModel(TemplateBase, Nullable, ABC):
             methods=self.methods,
             description=self.description,
             keyword_only=self.keyword_only,
+            frozen=self.frozen,
             **self.extra_template_data,
         )

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/model/dataclass.py

@@ -53,6 +53,7 @@ class DataClass(DataModel):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        frozen: bool = False,
         treat_dot_as_module: bool = False,
     ) -> None:
         super().__init__(
@@ -69,6 +70,7 @@ class DataClass(DataModel):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            frozen=frozen,
             treat_dot_as_module=treat_dot_as_module,
         )
 

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/model/pydantic_v2/__init__.py

@@ -27,6 +27,7 @@ class ConfigDict(_BaseModel):
     protected_namespaces: Optional[tuple[str, ...]] = None  # noqa: UP045
     regex_engine: Optional[str] = None  # noqa: UP045
     use_enum_values: Optional[bool] = None  # noqa: UP045
+    coerce_numbers_to_str: Optional[bool] = None  # noqa: UP045
 
 
 __all__ = [

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/model/template/dataclass.jinja2

@@ -1,7 +1,14 @@
 {% for decorator in decorators -%}
 {{ decorator }}
 {% endfor -%}
-@dataclass{%- if keyword_only -%}(kw_only=True){%- endif %}
+@dataclass
+{%- if keyword_only or frozen -%}
+(
+{%- if keyword_only -%}kw_only=True{%- endif -%}
+{%- if keyword_only and frozen -%}, {% endif -%}
+{%- if frozen -%}frozen=True{%- endif -%}
+)
+{%- endif %}
 {%- if base_class %}
 class {{ class_name }}({{ base_class }}):
 {%- else %}

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/parser/base.py

@@ -377,11 +377,13 @@ class Parser(ABC):
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType | None = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        frozen_dataclasses: bool = False,
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
     ) -> None:
         self.keyword_only = keyword_only
+        self.frozen_dataclasses = frozen_dataclasses
         self.data_type_manager: DataTypeManager = data_type_manager_type(
             python_version=target_python_version,
             use_standard_collections=use_standard_collections,
@@ -770,19 +772,31 @@ class Parser(ABC):
                                     continue
                             type_names.append(name)
 
-                    # Check the main discriminator model path
-                    if mapping:
-                        check_paths(discriminator_model, mapping)  # pyright: ignore[reportArgumentType]
+                    # First try to get the discriminator value from the const field
+                    for discriminator_field in discriminator_model.fields:
+                        if field_name not in {discriminator_field.original_name, discriminator_field.name}:
+                            continue
+                        if discriminator_field.extras.get("const"):
+                            type_names = [discriminator_field.extras["const"]]
+                            break
+
+                    # If no const value found, try to get it from the mapping
+                    if not type_names:
+                        # Check the main discriminator model path
+                        if mapping:
+                            check_paths(discriminator_model, mapping)  # pyright: ignore[reportArgumentType]
+
+                            # Check the base_classes if they exist
+                            if len(type_names) == 0:
+                                for base_class in discriminator_model.base_classes:
+                                    check_paths(base_class.reference, mapping)  # pyright: ignore[reportArgumentType]
+                        else:
+                            type_names = [discriminator_model.path.split("/")[-1]]
 
-                        # Check the base_classes if they exist
-                        if len(type_names) == 0:
-                            for base_class in discriminator_model.base_classes:
-                                check_paths(base_class.reference, mapping)  # pyright: ignore[reportArgumentType]
-                    else:
-                        type_names = [discriminator_model.path.split("/")[-1]]
                     if not type_names:  # pragma: no cover
                         msg = f"Discriminator type is not found. {data_type.reference.path}"
                         raise RuntimeError(msg)
+
                     has_one_literal = False
                     for discriminator_field in discriminator_model.fields:
                         if field_name not in {discriminator_field.original_name, discriminator_field.name}:
@@ -1202,7 +1216,10 @@ class Parser(ABC):
     ) -> None:
         for model in models:
             for model_field in model.fields:
-                if model_field.data_type.type in all_model_field_names:
+                if (
+                    model_field.data_type.type in all_model_field_names
+                    and model_field.data_type.type == model_field.name
+                ):
                     alias = model_field.data_type.type + "_aliased"
                     model_field.data_type.type = alias
                     if model_field.data_type.import_:  # pragma: no cover

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/parser/graphql.py

@@ -17,6 +17,7 @@ from datamodel_code_generator import (
 )
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model import pydantic as pydantic_model
+from datamodel_code_generator.model.dataclass import DataClass
 from datamodel_code_generator.model.enum import Enum
 from datamodel_code_generator.model.scalar import DataTypeScalar
 from datamodel_code_generator.model.union import DataTypeUnion
@@ -152,6 +153,7 @@ class GraphQLParser(Parser):
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        frozen_dataclasses: bool = False,
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
@@ -227,6 +229,7 @@ class GraphQLParser(Parser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            frozen_dataclasses=frozen_dataclasses,
             no_alias=no_alias,
             formatters=formatters,
             parent_scoped_naming=parent_scoped_naming,
@@ -283,6 +286,13 @@ class GraphQLParser(Parser):
 
                 self.support_graphql_types[resolved_type].append(type_)
 
+    def _create_data_model(self, model_type: type[DataModel] | None = None, **kwargs: Any) -> DataModel:
+        """Create data model instance with conditional frozen parameter for DataClass."""
+        data_model_class = model_type or self.data_model_type
+        if issubclass(data_model_class, DataClass):
+            kwargs["frozen"] = self.frozen_dataclasses
+        return data_model_class(**kwargs)
+
     def _typename_field(self, name: str) -> DataModelFieldBase:
         return self.data_model_field_type(
             name="typename__",
@@ -445,7 +455,7 @@ class GraphQLParser(Parser):
         if hasattr(obj, "interfaces"):  # pragma: no cover
             base_classes = [self.references[i.name] for i in obj.interfaces]  # pyright: ignore[reportAttributeAccessIssue]
 
-        data_model_type = self.data_model_type(
+        data_model_type = self._create_data_model(
             reference=self.references[obj.name],
             fields=fields,
             base_classes=base_classes,

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/parser/jsonschema.py

@@ -6,7 +6,7 @@ from contextlib import contextmanager
 from functools import cached_property, lru_cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Union
-from urllib.parse import ParseResult
+from urllib.parse import ParseResult, unquote
 from warnings import warn
 
 from pydantic import (
@@ -23,6 +23,7 @@ from datamodel_code_generator.format import DEFAULT_FORMATTERS, Formatter, Pytho
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model import pydantic as pydantic_model
 from datamodel_code_generator.model.base import UNDEFINED, get_module_name
+from datamodel_code_generator.model.dataclass import DataClass
 from datamodel_code_generator.model.enum import Enum
 from datamodel_code_generator.parser import DefaultPutDict, LiteralType
 from datamodel_code_generator.parser.base import (
@@ -58,16 +59,26 @@ if TYPE_CHECKING:
     from collections.abc import Generator, Iterable, Iterator, Mapping, Sequence
 
 
+def unescape_json_pointer_segment(segment: str) -> str:
+    # Unescape ~1, ~0, and percent-encoding
+    return unquote(segment.replace("~1", "/").replace("~0", "~"))
+
+
 def get_model_by_path(schema: dict[str, Any] | list[Any], keys: list[str] | list[int]) -> dict[Any, Any]:
     model: dict[Any, Any] | list[Any]
     if not keys:
         model = schema
-    elif len(keys) == 1:
-        model = schema.get(str(keys[0]), {}) if isinstance(schema, dict) else schema[int(keys[0])]
-    elif isinstance(schema, dict):
-        model = get_model_by_path(schema[str(keys[0])], keys[1:])
     else:
-        model = get_model_by_path(schema[int(keys[0])], keys[1:])
+        # Unescape the key if it's a string (JSON pointer segment)
+        key = keys[0]
+        if isinstance(key, str):
+            key = unescape_json_pointer_segment(key)
+        if len(keys) == 1:
+            model = schema.get(str(key), {}) if isinstance(schema, dict) else schema[int(key)]
+        elif isinstance(schema, dict):
+            model = get_model_by_path(schema[str(key)], keys[1:])
+        else:
+            model = get_model_by_path(schema[int(key)], keys[1:])
     if isinstance(model, dict):
         return model
     msg = f"Does not support json pointer to array. schema={schema}, key={keys}"
@@ -421,6 +432,7 @@ class JsonSchemaParser(Parser):
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        frozen_dataclasses: bool = False,
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
@@ -496,6 +508,7 @@ class JsonSchemaParser(Parser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            frozen_dataclasses=frozen_dataclasses,
             no_alias=no_alias,
             formatters=formatters,
             parent_scoped_naming=parent_scoped_naming,
@@ -627,7 +640,7 @@ class JsonSchemaParser(Parser):
                     result[key] = self._deep_merge(result[key], value)
                     continue
                 if isinstance(result[key], list) and isinstance(value, list):
-                    result[key] += value
+                    result[key] = result[key] + value  # noqa: PLR6104
                     continue
             result[key] = value
         return result
@@ -686,6 +699,13 @@ class JsonSchemaParser(Parser):
     def parse_one_of(self, name: str, obj: JsonSchemaObject, path: list[str]) -> list[DataType]:
         return self.parse_combined_schema(name, obj, path, "oneOf")
 
+    def _create_data_model(self, model_type: type[DataModel] | None = None, **kwargs: Any) -> DataModel:
+        """Create data model instance with conditional frozen parameter for DataClass."""
+        data_model_class = model_type or self.data_model_type
+        if issubclass(data_model_class, DataClass):
+            kwargs["frozen"] = self.frozen_dataclasses
+        return data_model_class(**kwargs)
+
     def _parse_object_common_part(  # noqa: PLR0913, PLR0917
         self,
         name: str,
@@ -733,7 +753,8 @@ class JsonSchemaParser(Parser):
             name = obj.title
         reference = self.model_resolver.add(path, name, class_name=True, loaded=True)
         self.set_additional_properties(reference.name, obj)
-        data_model_type = self.data_model_type(
+
+        data_model_type = self._create_data_model(
             reference=reference,
             fields=fields,
             base_classes=base_classes,
@@ -874,7 +895,7 @@ class JsonSchemaParser(Parser):
         exclude_field_names: set[str] = set()
         for original_field_name, field in properties.items():
             field_name, alias = self.model_resolver.get_valid_field_name_and_alias(
-                original_field_name, exclude_field_names
+                original_field_name, excludes=exclude_field_names
             )
             modular_name = f"{module_name}.{field_name}" if module_name else field_name
 
@@ -972,7 +993,9 @@ class JsonSchemaParser(Parser):
             data_model_type_class = self.data_model_root_type
 
         self.set_additional_properties(class_name, obj)
-        data_model_type = data_model_type_class(
+
+        data_model_type = self._create_data_model(
+            model_type=data_model_type_class,
             reference=reference,
             fields=fields,
             custom_base_class=obj.custom_base_path or self.base_class,

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/parser/openapi.py

@@ -42,6 +42,7 @@ if TYPE_CHECKING:
     from pathlib import Path
     from urllib.parse import ParseResult
 
+
 RE_APPLICATION_JSON_PATTERN: Pattern[str] = re.compile(r"^application/.*json$")
 
 OPERATION_NAMES: list[str] = [
@@ -214,6 +215,7 @@ class OpenAPIParser(JsonSchemaParser):
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        frozen_dataclasses: bool = False,
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
@@ -289,6 +291,7 @@ class OpenAPIParser(JsonSchemaParser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            frozen_dataclasses=frozen_dataclasses,
             no_alias=no_alias,
             formatters=formatters,
             parent_scoped_naming=parent_scoped_naming,
@@ -483,8 +486,10 @@ class OpenAPIParser(JsonSchemaParser):
                 )
 
         if OpenAPIScope.Parameters in self.open_api_scopes and fields:
+            # Using _create_data_model from parent class JsonSchemaParser
+            # This method automatically adds frozen=True for DataClass types
             self.results.append(
-                self.data_model_type(
+                self._create_data_model(
                     fields=fields,
                     reference=reference,
                     custom_base_class=self.base_class,

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/src/datamodel_code_generator/types.py

@@ -6,13 +6,27 @@ from enum import Enum, auto
 from functools import lru_cache
 from itertools import chain
 from re import Pattern
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Protocol, TypeVar, Union, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Optional,
+    Protocol,
+    TypeVar,
+    Union,
+    runtime_checkable,
+)
 
 import pydantic
 from packaging import version
 from pydantic import StrictBool, StrictInt, StrictStr, create_model
 
-from datamodel_code_generator.format import DatetimeClassType, PythonVersion, PythonVersionMin
+from datamodel_code_generator.format import (
+    DatetimeClassType,
+    PythonVersion,
+    PythonVersionMin,
+)
 from datamodel_code_generator.imports import (
     IMPORT_ABC_MAPPING,
     IMPORT_ABC_SEQUENCE,
@@ -167,53 +181,57 @@ def _remove_none_from_type(type_: str, split_pattern: Pattern[str], delimiter: s
     return types
 
 
-def _remove_none_from_union(type_: str, *, use_union_operator: bool) -> str:  # noqa: PLR0911, PLR0912
+def _remove_none_from_union(type_: str, *, use_union_operator: bool) -> str:  # noqa: PLR0912
     if use_union_operator:
         if " | " not in type_:
             return type_
+        separator = "|"
+        inner_text = type_
+    else:
+        if not type_.startswith(UNION_PREFIX):
+            return type_
+        separator = ","
+        inner_text = type_[len(UNION_PREFIX) : -1]
 
-        # Process each part of the union
-        parts = UNION_OPERATOR_PATTERN.split(type_)
-        processed_parts = []
-        for part in parts:
-            if part == NONE:
-                continue
-
-            # Check if this part contains a nested union
-            processed_part = _remove_none_from_union(part, use_union_operator=True) if " | " in part else part
-            processed_parts.append(processed_part)
-
-        if not processed_parts:
-            return NONE
-
-        return UNION_OPERATOR_DELIMITER.join(processed_parts)
-    if not type_.startswith(UNION_PREFIX):
-        return type_
-
-    inner_text = type_[len(UNION_PREFIX) : -1]
     parts = []
     inner_count = 0
     current_part = ""
 
+    # With this variable we count any non-escaped round bracket, whenever we are inside a
+    # constraint string expression. Once found a part starting with `constr(`, we increment
+    # this counter for each non-escaped opening round bracket and decrement it for each
+    # non-escaped closing round bracket.
+    in_constr = 0
+
     # Parse union parts carefully to handle nested structures
     for char in inner_text:
         current_part += char
-        if char == "[":
+        if char == "[" and in_constr == 0:
             inner_count += 1
-        elif char == "]":
+        elif char == "]" and in_constr == 0:
             inner_count -= 1
-        elif char == "," and inner_count == 0:
+        elif char == "(":
+            if current_part.strip().startswith("constr(") and current_part[-2] != "\\":
+                # non-escaped opening round bracket found inside constraint string expression
+                in_constr += 1
+        elif char == ")":
+            if in_constr > 0 and current_part[-2] != "\\":
+                # non-escaped closing round bracket found inside constraint string expression
+                in_constr -= 1
+        elif char == separator and inner_count == 0 and in_constr == 0:
             part = current_part[:-1].strip()
             if part != NONE:
                 # Process nested unions recursively
-                if part.startswith(UNION_PREFIX):
+                # only UNION_PREFIX might be nested but not union_operator
+                if not use_union_operator and part.startswith(UNION_PREFIX):
                     part = _remove_none_from_union(part, use_union_operator=False)
                 parts.append(part)
             current_part = ""
 
     part = current_part.strip()
     if current_part and part != NONE:
-        if part.startswith(UNION_PREFIX):
+        # only UNION_PREFIX might be nested but not union_operator
+        if not use_union_operator and part.startswith(UNION_PREFIX):
             part = _remove_none_from_union(part, use_union_operator=False)
         parts.append(part)
 
@@ -222,6 +240,9 @@ def _remove_none_from_union(type_: str, *, use_union_operator: bool) -> str:  #
     if len(parts) == 1:
         return parts[0]
 
+    if use_union_operator:
+        return UNION_OPERATOR_DELIMITER.join(parts)
+
     return f"{UNION_PREFIX}{UNION_DELIMITER.join(parts)}]"
 
 

datamodel_code_generator-0.30.2/tests/data/expected/main/frozen_dataclasses.py

@@ -0,0 +1,15 @@
+# generated by datamodel-codegen:
+#   filename:  simple_frozen_test.json
+#   timestamp: 1985-10-26T08:21:00+00:00
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class User:
+    name: str
+    age: int
+    email: Optional[str] = None

datamodel_code_generator-0.30.2/tests/data/expected/main/frozen_dataclasses_keyword_only.py

@@ -0,0 +1,15 @@
+# generated by datamodel-codegen:
+#   filename:  simple_frozen_test.json
+#   timestamp: 1985-10-26T08:21:00+00:00
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(kw_only=True, frozen=True)
+class User:
+    name: str
+    age: int
+    email: Optional[str] = None

datamodel_code_generator-0.30.2/tests/data/expected/main/jsonschema/discriminator_no_mapping.py

@@ -0,0 +1,21 @@
+# generated by datamodel-codegen:
+#   filename:  discriminator_no_mapping.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from typing import Literal, Union
+
+from pydantic import BaseModel, Field
+
+
+class Cat(BaseModel):
+    pet_type: Literal['cat']
+
+
+class Dog(BaseModel):
+    pet_type: Literal['dog']
+
+
+class Animal(BaseModel):
+    pet: Union[Cat, Dog] = Field(..., discriminator='pet_type', title='Pet')

datamodel_code_generator-0.30.2/tests/data/expected/main/jsonschema/required_and_any_of_required.py

@@ -0,0 +1,25 @@
+# generated by datamodel-codegen:
+#   filename:  required_and_any_of_required.json
+#   timestamp: 2019-07-26T00:00:00+00:00
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+from pydantic import BaseModel
+
+
+class Foo(BaseModel):
+    bar: int
+    baz: int
+    qux: Optional[int] = None
+
+
+class Foo1(BaseModel):
+    bar: int
+    baz: Optional[int] = None
+    qux: int
+
+
+class Model(BaseModel):
+    foo: Union[Foo, Foo1]

{datamodel_code_generator-0.30.1 → datamodel_code_generator-0.30.2}/tests/data/expected/main/openapi/extra_template_data_config_pydantic_v2.py

@@ -12,6 +12,7 @@ from pydantic import AnyUrl, BaseModel, ConfigDict, Field, RootModel
 class Pet(BaseModel):  # 1 2, 1 2, this is just a pet
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
+        coerce_numbers_to_str=True,
     )
     id: int
     name: str