datamodel-code-generator 0.30.0__py3-none-any.whl → 0.30.2__py3-none-any.whl

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/__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/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/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/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/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/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/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/parser/base.py

@@ -88,6 +88,8 @@ def to_hashable(item: Any) -> Any:
         return frozenset(to_hashable(i) for i in item)
     if isinstance(item, BaseModel):
         return to_hashable(item.dict())
+    if item is None:
+        return ""
     return item
 
 
@@ -375,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,
@@ -768,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}:
@@ -1119,6 +1135,9 @@ class Parser(ABC):
         if self.data_model_type != pydantic_model_v2.BaseModel:
             return
         for model in models:
+            if model.base_class == "Enum":
+                continue
+
             for field in model.fields:
                 filed_name = field.name
                 filed_name_resolver = ModelResolver(snake_case_field=self.snake_case_field, remove_suffix_number=True)
@@ -1197,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/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/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/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/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.0.dist-info → datamodel_code_generator-0.30.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.30.0
+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.0.dist-info → datamodel_code_generator-0.30.2.dist-info}/RECORD

@@ -1,17 +1,17 @@
-datamodel_code_generator/__init__.py,sha256=2h8FA8O_x1VGRVlXKJHt3jwuC34MIEnmHwHv-zGuF_I,20445
-datamodel_code_generator/__main__.py,sha256=rF1Se8R0rfqDmJ4_INBdOYlU7G4XIthPCe3ldDwtgQI,22608
-datamodel_code_generator/arguments.py,sha256=xPAnid2-dC_Hj4o1hY9fL13NMJl5wCPphTsCHZ3QeNQ,16637
-datamodel_code_generator/format.py,sha256=zvX0KH1uWwGnTYoVM4KhAuKZn5erjkH5eyi4t3leirw,8962
+datamodel_code_generator/__init__.py,sha256=h0yxjBBK7_RJdAqUVimMfSqsq0tXqH_nzcNZRgL3Yrs,20530
+datamodel_code_generator/__main__.py,sha256=Sl3ch890tr6J8voedlz8nyCq2QYLZDtibFa3o2SfQ_k,22703
+datamodel_code_generator/arguments.py,sha256=T8iPrqTq9MJLJyi4PHB3_JQC2PgfLpYNmXpDFZWsXAs,16838
+datamodel_code_generator/format.py,sha256=ZlnTCAl1H4og685smvCBSzexgpYbZtyYLIrt7lwUNcY,8934
 datamodel_code_generator/http.py,sha256=LE94GC7I9D8lWIg_YAGWedfy0XNxOXTmiYKuNMTwouo,887
 datamodel_code_generator/imports.py,sha256=Nq83WbEGCegntg3WX4VbKfzAIs84alZ7IrYyNPrlUbc,5517
 datamodel_code_generator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datamodel_code_generator/pydantic_patch.py,sha256=co1IUDvZqQ-xEZ3C9gbV-BVm2Cin1vfyZNr2Dr0LdHY,718
 datamodel_code_generator/reference.py,sha256=OobfjN5hWaKzv4ECdCPc9Q3ODkoG93B4qaKlzDEcDrY,26748
-datamodel_code_generator/types.py,sha256=fobUZnNTOGpzF4qZMraoLogVkAU7zBdFVG-8SOFoDD4,21163
+datamodel_code_generator/types.py,sha256=1g4RZZ1e5oC4EHaNyyDmsIfF4o1WAjQ2KaLjwc9mYss,21883
 datamodel_code_generator/util.py,sha256=mZW8-6CbFe6T4IY5OM9Av6cH-0VknQGe2eIKjTM6Jzo,2729
 datamodel_code_generator/model/__init__.py,sha256=pJlJ1juQ-Gv17ZKXy6OAfJSSoOAmYQ7QCbdneu1BENU,3594
-datamodel_code_generator/model/base.py,sha256=Ma28Vx1p5zsFt23BMCs1UNDXuBq_USEhuPUvaeFLkS4,14959
-datamodel_code_generator/model/dataclass.py,sha256=t4NtgVhopTtEDUJCqijJheVlewSt8IJzQhQb8gXspfs,6252
+datamodel_code_generator/model/base.py,sha256=ZQ3Xy4Fs_I8M01tk1ps0EhWJM9vR-n7umPkz5NmHTjw,15050
+datamodel_code_generator/model/dataclass.py,sha256=8Z02XY3S6byNe9Pb46LisE5opQcvpx8FVvPjUrlAacE,6309
 datamodel_code_generator/model/enum.py,sha256=yriQslY1hag_Qk-Xv3vl_LkPnbmMZ3iRTAGiiyMN0Io,4003
 datamodel_code_generator/model/imports.py,sha256=PTc09UzIBSsa5yAPoieb6hCGIohU2T1Y7igNy_pYarg,820
 datamodel_code_generator/model/msgspec.py,sha256=qL2DIEwBfpn-vd8p8KEmUViMUce6RgI4Ql-drOmPR7M,11845
@@ -26,7 +26,7 @@ datamodel_code_generator/model/pydantic/custom_root_type.py,sha256=VJpEAmGFe3TzM
 datamodel_code_generator/model/pydantic/dataclass.py,sha256=jgjkqQk71CQP4RbTcPGSEOQDNqjTQnzFavvl5LjWTBw,455
 datamodel_code_generator/model/pydantic/imports.py,sha256=nWPiLgDeYNPHcAs8M-gaUUZg1daQRHdBPpjYuX3b5u4,2225
 datamodel_code_generator/model/pydantic/types.py,sha256=ttTiDsQ6FV3h4C_NTEhvPUmUpeqxBNQt-DJJFpKZS8s,13356
-datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=xsfYcIUA2S8XzPIsYQSzDuBYZ1XRicfhGLHlQBlZwsg,1226
+datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=6liTgL3VeH4ohYXkRoiCSafEc0nHxgbnYO3Rl2iQDx8,1290
 datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=J_DxR6Auw0L-zHn0F5l9K8XtSmfEvDT26Bj-VZxihiE,8353
 datamodel_code_generator/model/pydantic_v2/imports.py,sha256=K3XD2kF9YCKmo5_7b2ipV5bGUrjz0avS-SiyDMVIpF0,299
 datamodel_code_generator/model/pydantic_v2/root_model.py,sha256=H4rwtg56N65-I3QHlPvlNhDcSPV0m56KSAgfGmxYXAQ,888
@@ -37,7 +37,7 @@ datamodel_code_generator/model/template/TypedDict.jinja2,sha256=J_Pe_CiuvTOb-EUC
 datamodel_code_generator/model/template/TypedDictClass.jinja2,sha256=URwp5__WyR8G21Hoyc17aMzoast-NppXnXe19VFi5wQ,377
 datamodel_code_generator/model/template/TypedDictFunction.jinja2,sha256=KjSij5_w4ow4a12SR3orYOndmXGkIvJBBUN735bQ6G0,321
 datamodel_code_generator/model/template/Union.jinja2,sha256=sq7o--2ESUSfIL4kCfgnr5ZXPFa_VeioqbATTY-N-5I,258
-datamodel_code_generator/model/template/dataclass.jinja2,sha256=wRSy2g11Dr1GN9YUl13OZt2xg37bQyFwKn2wEsQIndE,865
+datamodel_code_generator/model/template/dataclass.jinja2,sha256=c3gs1ZwDEwLpmZ2PpOEWjHjfdl6kPP64xm18mt9lZMk,1007
 datamodel_code_generator/model/template/msgspec.jinja2,sha256=qMuFOH6SFFh558wImdI6uIjG4Mtam3J_ox8Hmgqkv0g,1174
 datamodel_code_generator/model/template/root.jinja2,sha256=3OTtibxLcGA-FMdR0QDCJUJQgf_kRW0OafeCTPFSFFo,162
 datamodel_code_generator/model/template/pydantic/BaseModel.jinja2,sha256=sYZa-47YAXqZrd5cYKVnPrsbDvLkHEJOUd7M0nAosP8,1084
@@ -48,12 +48,12 @@ datamodel_code_generator/model/template/pydantic_v2/BaseModel.jinja2,sha256=i1Wg
 datamodel_code_generator/model/template/pydantic_v2/ConfigDict.jinja2,sha256=xHvBYrh__32O1xRCSl6_u5zbyYIjB8a5k8fZiTo0spY,149
 datamodel_code_generator/model/template/pydantic_v2/RootModel.jinja2,sha256=XQBlML7Hm5hN6_AExENNvVc_yxNWijcIfTTbbmegCpE,1223
 datamodel_code_generator/parser/__init__.py,sha256=3XtFcDPocaetfjmWFqj_CubqNCDipb7vXZHsYKdJXXU,851
-datamodel_code_generator/parser/base.py,sha256=iI57e61U2YgG9K8vuBjw72dM034bgsBrfOFL1zG7Y-w,61839
-datamodel_code_generator/parser/graphql.py,sha256=scotG-q8zTS40i5rP9HfhriSVhXVnxEKtuBoXvbzECg,22684
-datamodel_code_generator/parser/jsonschema.py,sha256=bwXNvXjG8tiUPCNZsEXbo2TlCYJVKIzeYWEKfvlPzo8,70011
-datamodel_code_generator/parser/openapi.py,sha256=3IWF40DK0a710rVqXCod7Hi3Fh9u7neD4YR_kn_6VD4,27279
-datamodel_code_generator-0.30.0.dist-info/METADATA,sha256=u9lGxU2--PWj6uTxDi6AA-Dvyw06mhn2KQy_j4ewbds,25294
-datamodel_code_generator-0.30.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-datamodel_code_generator-0.30.0.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
-datamodel_code_generator-0.30.0.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.30.0.dist-info/RECORD,,
+datamodel_code_generator/parser/base.py,sha256=2rNtyo9Gcu4lSihbQKtawL6W7KD4keM2CR1KHgnrNso,62794
+datamodel_code_generator/parser/graphql.py,sha256=w4rnPXxQWGluG9dKlfv9XG1sv8T7HJOq9wySd-EsfDs,23250
+datamodel_code_generator/parser/jsonschema.py,sha256=cjxYs2vQ2aka5YpqagDkNhyhvBwNXz7YOrdsJz7bVeQ,71034
+datamodel_code_generator/parser/openapi.py,sha256=oY_qOngrxr4fHk9b6YUNI2IQCWkUeAJ9-CvTCTym8WM,27527
+datamodel_code_generator-0.30.2.dist-info/METADATA,sha256=AXlPlc6b1QyG1ylx4pUj6NZqLI-P59K3QZw4e2vSjlY,25430
+datamodel_code_generator-0.30.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+datamodel_code_generator-0.30.2.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
+datamodel_code_generator-0.30.2.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
+datamodel_code_generator-0.30.2.dist-info/RECORD,,