datamodel-code-generator 0.31.2__py3-none-any.whl → 0.33.0__py3-none-any.whl

datamodel_code_generator/__init__.py

@@ -20,6 +20,7 @@ from typing import (
 from urllib.parse import ParseResult
 
 import yaml
+import yaml.parser
 
 import datamodel_code_generator.pydantic_patch  # noqa: F401
 from datamodel_code_generator.format import (
@@ -116,8 +117,8 @@ def chdir(path: Path | None) -> Iterator[None]:
             os.chdir(prev_cwd)
 
 
-def is_openapi(text: str) -> bool:
-    return "openapi" in load_yaml(text)
+def is_openapi(data: dict) -> bool:
+    return "openapi" in data
 
 
 JSON_SCHEMA_URLS: tuple[str, ...] = (
@@ -126,10 +127,7 @@ JSON_SCHEMA_URLS: tuple[str, ...] = (
 )
 
 
-def is_schema(text: str) -> bool:
-    data = load_yaml(text)
-    if not isinstance(data, dict):
-        return False
+def is_schema(data: dict) -> bool:
     schema = data.get("$schema")
     if isinstance(schema, str) and any(schema.startswith(u) for u in JSON_SCHEMA_URLS):  # pragma: no cover
         return True
@@ -144,7 +142,7 @@ def is_schema(text: str) -> bool:
         )
     ):
         return True
-    return bool(isinstance(data.get("properties"), dict))
+    return isinstance(data.get("properties"), dict)
 
 
 class InputFileType(Enum):
@@ -208,8 +206,8 @@ def get_first_file(path: Path) -> Path:  # pragma: no cover
         for child in path.rglob("*"):
             if child.is_file():
                 return child
-    msg = "File not found"
-    raise Error(msg)
+    msg = f"No file found in: {path}"
+    raise FileNotFoundError(msg)
 
 
 def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
@@ -258,6 +256,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     field_include_all_keys: bool = False,
     field_extra_keys_without_x_prefix: set[str] | None = None,
     openapi_scopes: list[OpenAPIScope] | None = None,
+    include_path_parameters: bool = False,
     graphql_scopes: list[GraphQLScope] | None = None,  # noqa: ARG001
     wrap_string_literal: bool | None = None,
     use_title_as_name: bool = False,
@@ -311,15 +310,21 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
             input_text_ = (
                 get_first_file(input_).read_text(encoding=encoding) if isinstance(input_, Path) else input_text
             )
+        except FileNotFoundError as exc:
+            msg = "File not found"
+            raise Error(msg) from exc
+
+        try:
             assert isinstance(input_text_, str)
             input_file_type = infer_input_type(input_text_)
+        except Exception as exc:
+            msg = "Invalid file format"
+            raise Error(msg) from exc
+        else:
             print(  # noqa: T201
                 inferred_message.format(input_file_type.value),
                 file=sys.stderr,
             )
-        except Exception as exc:
-            msg = "Invalid file format"
-            raise Error(msg) from exc
 
     kwargs: dict[str, Any] = {}
     if input_file_type == InputFileType.OpenAPI:  # noqa: PLR1702
@@ -327,6 +332,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
 
         parser_class: type[Parser] = OpenAPIParser
         kwargs["openapi_scopes"] = openapi_scopes
+        kwargs["include_path_parameters"] = include_path_parameters
     elif input_file_type == InputFileType.GraphQL:
         from datamodel_code_generator.parser.graphql import GraphQLParser  # noqa: PLC0415
 
@@ -407,7 +413,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
 
     from datamodel_code_generator.model import get_data_model_types  # noqa: PLC0415
 
-    data_model_types = get_data_model_types(output_model_type, target_python_version, output_datetime_class)
+    data_model_types = get_data_model_types(output_model_type, target_python_version)
     source = input_text or input_
     assert not isinstance(source, Mapping)
     parser = parser_class(
@@ -558,11 +564,21 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
 
 
 def infer_input_type(text: str) -> InputFileType:
-    if is_openapi(text):
-        return InputFileType.OpenAPI
-    if is_schema(text):
-        return InputFileType.JsonSchema
-    return InputFileType.Json
+    try:
+        data = load_yaml(text)
+    except yaml.parser.ParserError:
+        return InputFileType.CSV
+    if isinstance(data, dict):
+        if is_openapi(data):
+            return InputFileType.OpenAPI
+        if is_schema(data):
+            return InputFileType.JsonSchema
+        return InputFileType.Json
+    msg = (
+        "Can't infer input file type from the input data. "
+        "Please specify the input file type explicitly with --input-file-type option."
+    )
+    raise Error(msg)
 
 
 inferred_message = (
@@ -573,6 +589,7 @@ inferred_message = (
 __all__ = [
     "MAX_VERSION",
     "MIN_VERSION",
+    "DatetimeClassType",
     "DefaultPutDict",
     "Error",
     "InputFileType",

datamodel_code_generator/__main__.py

@@ -13,7 +13,7 @@ from collections.abc import Sequence  # noqa: TC003  # pydantic needs it
 from enum import IntEnum
 from io import TextIOBase
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast
 from urllib.parse import ParseResult, urlparse
 
 import argcomplete
@@ -136,48 +136,6 @@ class Config(BaseModel):
         msg = f"This protocol doesn't support only http/https. --input={value}"
         raise Error(msg)  # pragma: no cover
 
-    @model_validator()
-    def validate_original_field_name_delimiter(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
-        if values.get("original_field_name_delimiter") is not None and not values.get("snake_case_field"):
-            msg = "`--original-field-name-delimiter` can not be used without `--snake-case-field`."
-            raise Error(msg)
-        return values
-
-    @model_validator()
-    def validate_custom_file_header(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
-        if values.get("custom_file_header") and values.get("custom_file_header_path"):
-            msg = "`--custom_file_header_path` can not be used with `--custom_file_header`."
-            raise Error(msg)  # pragma: no cover
-        return values
-
-    @model_validator()
-    def validate_keyword_only(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
-        output_model_type: DataModelType = values.get("output_model_type")  # pyright: ignore[reportAssignmentType]
-        python_target: PythonVersion = values.get("target_python_version")  # pyright: ignore[reportAssignmentType]
-        if (
-            values.get("keyword_only")
-            and output_model_type == DataModelType.DataclassesDataclass
-            and not python_target.has_kw_only_dataclass
-        ):
-            msg = f"`--keyword-only` requires `--target-python-version` {PythonVersion.PY_310.value} or higher."
-            raise Error(msg)
-        return values
-
-    @model_validator()
-    def validate_output_datetime_class(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
-        datetime_class_type: DatetimeClassType | None = values.get("output_datetime_class")
-        if (
-            datetime_class_type
-            and datetime_class_type is not DatetimeClassType.Datetime
-            and values.get("output_model_type") == DataModelType.DataclassesDataclass
-        ):
-            msg = (
-                '`--output-datetime-class` only allows "datetime" for '
-                f"`--output-model-type` {DataModelType.DataclassesDataclass.value}"
-            )
-            raise Error(msg)
-        return values
-
     # Pydantic 1.5.1 doesn't support each_item=True correctly
     @field_validator("http_headers", mode="before")
     def validate_http_headers(cls, value: Any) -> list[tuple[str, str]] | None:  # noqa: N805
@@ -225,18 +183,104 @@ class Config(BaseModel):
             values["custom_formatters"] = custom_formatters.split(",")
         return values
 
+    __validate_output_datetime_class_err: ClassVar[str] = (
+        '`--output-datetime-class` only allows "datetime" for '
+        f"`--output-model-type` {DataModelType.DataclassesDataclass.value}"
+    )
+
+    __validate_original_field_name_delimiter_err: ClassVar[str] = (
+        "`--original-field-name-delimiter` can not be used without `--snake-case-field`."
+    )
+
+    __validate_custom_file_header_err: ClassVar[str] = (
+        "`--custom_file_header_path` can not be used with `--custom_file_header`."
+    )
+    __validate_keyword_only_err: ClassVar[str] = (
+        f"`--keyword-only` requires `--target-python-version` {PythonVersion.PY_310.value} or higher."
+    )
+
     if PYDANTIC_V2:
 
         @model_validator()  # pyright: ignore[reportArgumentType]
-        def validate_root(self: Self) -> Self:
+        def validate_output_datetime_class(self: Self) -> Self:  # pyright: ignore[reportRedeclaration]
+            datetime_class_type: DatetimeClassType | None = self.output_datetime_class
+            if (
+                datetime_class_type
+                and datetime_class_type is not DatetimeClassType.Datetime
+                and self.output_model_type == DataModelType.DataclassesDataclass
+            ):
+                raise Error(self.__validate_output_datetime_class_err)
+            return self
+
+        @model_validator()  # pyright: ignore[reportArgumentType]
+        def validate_original_field_name_delimiter(self: Self) -> Self:  # pyright: ignore[reportRedeclaration]
+            if self.original_field_name_delimiter is not None and not self.snake_case_field:
+                raise Error(self.__validate_original_field_name_delimiter_err)
+            return self
+
+        @model_validator()  # pyright: ignore[reportArgumentType]
+        def validate_custom_file_header(self: Self) -> Self:  # pyright: ignore[reportRedeclaration]
+            if self.custom_file_header and self.custom_file_header_path:
+                raise Error(self.__validate_custom_file_header_err)
+            return self
+
+        @model_validator()  # pyright: ignore[reportArgumentType]
+        def validate_keyword_only(self: Self) -> Self:  # pyright: ignore[reportRedeclaration]
+            output_model_type: DataModelType = self.output_model_type
+            python_target: PythonVersion = self.target_python_version
+            if (
+                self.keyword_only
+                and output_model_type == DataModelType.DataclassesDataclass
+                and not python_target.has_kw_only_dataclass
+            ):
+                raise Error(self.__validate_keyword_only_err)
+            return self
+
+        @model_validator()  # pyright: ignore[reportArgumentType]
+        def validate_root(self: Self) -> Self:  # pyright: ignore[reportRedeclaration]
             if self.use_annotated:
                 self.field_constraints = True
             return self
 
     else:
 
-        @model_validator()
-        def validate_root(cls, values: Any) -> Any:  # noqa: N805
+        @model_validator()  # pyright: ignore[reportArgumentType]
+        def validate_output_datetime_class(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
+            datetime_class_type: DatetimeClassType | None = values.get("output_datetime_class")
+            if (
+                datetime_class_type
+                and datetime_class_type is not DatetimeClassType.Datetime
+                and values.get("output_model_type") == DataModelType.DataclassesDataclass
+            ):
+                raise Error(cls.__validate_output_datetime_class_err)
+            return values
+
+        @model_validator()  # pyright: ignore[reportArgumentType]
+        def validate_original_field_name_delimiter(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
+            if values.get("original_field_name_delimiter") is not None and not values.get("snake_case_field"):
+                raise Error(cls.__validate_original_field_name_delimiter_err)
+            return values
+
+        @model_validator()  # pyright: ignore[reportArgumentType]
+        def validate_custom_file_header(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
+            if values.get("custom_file_header") and values.get("custom_file_header_path"):
+                raise Error(cls.__validate_custom_file_header_err)
+            return values
+
+        @model_validator()  # pyright: ignore[reportArgumentType]
+        def validate_keyword_only(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
+            output_model_type: DataModelType = cast("DataModelType", values.get("output_model_type"))
+            python_target: PythonVersion = cast("PythonVersion", values.get("target_python_version"))
+            if (
+                values.get("keyword_only")
+                and output_model_type == DataModelType.DataclassesDataclass
+                and not python_target.has_kw_only_dataclass
+            ):
+                raise Error(cls.__validate_keyword_only_err)
+            return values
+
+        @model_validator()  # pyright: ignore[reportArgumentType]
+        def validate_root(cls, values: dict[str, Any]) -> dict[str, Any]:  # noqa: N805
             if values.get("use_annotated"):
                 values["field_constraints"] = True
             return values
@@ -287,6 +331,7 @@ class Config(BaseModel):
     field_include_all_keys: bool = False
     field_extra_keys_without_x_prefix: Optional[set[str]] = None  # noqa: UP045
     openapi_scopes: Optional[list[OpenAPIScope]] = [OpenAPIScope.Schemas]  # noqa: UP045
+    include_path_parameters: bool = False
     wrap_string_literal: Optional[bool] = None  # noqa: UP045
     use_title_as_name: bool = False
     use_operation_id_as_name: bool = False
@@ -500,6 +545,7 @@ def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912,
             field_include_all_keys=config.field_include_all_keys,
             field_extra_keys_without_x_prefix=config.field_extra_keys_without_x_prefix,
             openapi_scopes=config.openapi_scopes,
+            include_path_parameters=config.include_path_parameters,
             wrap_string_literal=config.wrap_string_literal,
             use_title_as_name=config.use_title_as_name,
             use_operation_id_as_name=config.use_operation_id_as_name,

datamodel_code_generator/arguments.py

@@ -437,7 +437,11 @@ template_options.add_argument(
 )
 template_options.add_argument(
     "--extra-template-data",
-    help="Extra template data",
+    help="Extra template data for output models. Input is supposed to be a json/yaml file. "
+    "For OpenAPI and Jsonschema the keys are the spec path of the object, or the name of the object if you want to "
+    "apply the template data to multiple objects with the same name. "
+    "If you are using another input file type (e.g. GraphQL), the key is the name of the object. "
+    "The value is a dictionary of the template data to add.",
     type=FileType("rt"),
 )
 template_options.add_argument(
@@ -500,6 +504,12 @@ openapi_options.add_argument(
     action="store_true",
     default=None,
 )
+openapi_options.add_argument(
+    "--include-path-parameters",
+    help="Include path parameters in generated parameter models in addition to query parameters (Only OpenAPI)",
+    action="store_true",
+    default=None,
+)
 openapi_options.add_argument(
     "--validation",
     help="Deprecated: Enable validation (Only OpenAPI). this option is deprecated. it will be removed in future "

datamodel_code_generator/model/__init__.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import sys
 from typing import TYPE_CHECKING, Callable, NamedTuple
 
-from datamodel_code_generator import DatetimeClassType, PythonVersion
+from datamodel_code_generator import PythonVersion
 
 from .base import ConstraintsBase, DataModel, DataModelFieldBase
 
@@ -13,7 +13,6 @@ if TYPE_CHECKING:
     from datamodel_code_generator import DataModelType
     from datamodel_code_generator.types import DataTypeManager as DataTypeManagerABC
 
-DEFAULT_TARGET_DATETIME_CLASS = DatetimeClassType.Datetime
 DEFAULT_TARGET_PYTHON_VERSION = PythonVersion(f"{sys.version_info.major}.{sys.version_info.minor}")
 
 
@@ -29,15 +28,12 @@ class DataModelSet(NamedTuple):
 def get_data_model_types(
     data_model_type: DataModelType,
     target_python_version: PythonVersion = DEFAULT_TARGET_PYTHON_VERSION,
-    target_datetime_class: DatetimeClassType | None = None,
 ) -> DataModelSet:
     from datamodel_code_generator import DataModelType  # noqa: PLC0415
 
     from . import dataclass, msgspec, pydantic, pydantic_v2, rootmodel, typed_dict  # noqa: PLC0415
     from .types import DataTypeManager  # noqa: PLC0415
 
-    if target_datetime_class is None:
-        target_datetime_class = DEFAULT_TARGET_DATETIME_CLASS
     if data_model_type == DataModelType.PydanticBaseModel:
         return DataModelSet(
             data_model=pydantic.BaseModel,

datamodel_code_generator/model/base.py

@@ -298,11 +298,18 @@ class DataModel(TemplateBase, Nullable, ABC):
 
         self.reference.source = self
 
-        self.extra_template_data = (
+        if extra_template_data is not None:
             # The supplied defaultdict will either create a new entry,
             # or already contain a predefined entry for this type
-            extra_template_data[self.name] if extra_template_data is not None else defaultdict(dict)
-        )
+            self.extra_template_data = extra_template_data[self.reference.path]
+
+            # We use the full object reference path as dictionary key, but
+            # we still support `name` as key because it was used for
+            # `--extra-template-data` input file and we don't want to break the
+            # existing behavior.
+            self.extra_template_data.update(extra_template_data[self.name])
+        else:
+            self.extra_template_data = defaultdict(dict)
 
         self.fields = self._validate_fields(fields) if fields else []
 

datamodel_code_generator/model/msgspec.py

@@ -288,7 +288,7 @@ class DataTypeManager(_DataTypeManager):
         use_non_positive_negative_number_constrained_types: bool = False,  # noqa: FBT001, FBT002
         use_union_operator: bool = False,  # noqa: FBT001, FBT002
         use_pendulum: bool = False,  # noqa: FBT001, FBT002
-        target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        target_datetime_class: DatetimeClassType | None = None,
         treat_dot_as_module: bool = False,  # noqa: FBT001, FBT002
     ) -> None:
         super().__init__(

datamodel_code_generator/model/pydantic/types.py

@@ -62,7 +62,6 @@ def type_map_factory(
     strict_types: Sequence[StrictTypes],
     pattern_key: str,
     use_pendulum: bool,  # noqa: FBT001
-    target_datetime_class: DatetimeClassType,  # noqa: ARG001
 ) -> dict[Types, DataType]:
     data_type_int = data_type(type="int")
     data_type_float = data_type(type="float")
@@ -141,7 +140,7 @@ number_kwargs: set[str] = {
 
 string_kwargs: set[str] = {"minItems", "maxItems", "minLength", "maxLength", "pattern"}
 
-byes_kwargs: set[str] = {"minLength", "maxLength"}
+bytes_kwargs: set[str] = {"minLength", "maxLength"}
 
 escape_characters = str.maketrans({
     "'": r"\'",
@@ -208,14 +207,13 @@ class DataTypeManager(_DataTypeManager):
         data_type: type[DataType],
         strict_types: Sequence[StrictTypes],
         pattern_key: str,
-        target_datetime_class: DatetimeClassType,  # noqa: ARG002
+        target_datetime_class: DatetimeClassType | None,  # noqa: ARG002
     ) -> dict[Types, DataType]:
         return type_map_factory(
             data_type,
             strict_types,
             pattern_key,
             self.use_pendulum,
-            self.target_datetime_class,
         )
 
     def transform_kwargs(self, kwargs: dict[str, Any], filter_: set[str]) -> dict[str, str]:
@@ -296,7 +294,7 @@ class DataTypeManager(_DataTypeManager):
         return self.type_map[types]
 
     def get_data_bytes_type(self, types: Types, **kwargs: Any) -> DataType:
-        data_type_kwargs: dict[str, Any] = self.transform_kwargs(kwargs, byes_kwargs)
+        data_type_kwargs: dict[str, Any] = self.transform_kwargs(kwargs, bytes_kwargs)
         strict = StrictTypes.bytes in self.strict_types
         if data_type_kwargs and not strict:
             return self.data_type.from_import(IMPORT_CONBYTES, kwargs=data_type_kwargs)

datamodel_code_generator/model/pydantic_v2/types.py

@@ -45,6 +45,6 @@ class DataTypeManager(_DataTypeManager):
         }
         if target_datetime_class == DatetimeClassType.Awaredatetime:
             result[Types.date_time] = data_type.from_import(IMPORT_AWARE_DATETIME)
-        if target_datetime_class == DatetimeClassType.Naivedatetime:
+        elif target_datetime_class == DatetimeClassType.Naivedatetime:
             result[Types.date_time] = data_type.from_import(IMPORT_NAIVE_DATETIME)
         return result

datamodel_code_generator/model/template/Union.jinja2

@@ -1,5 +1,5 @@
 {%- if description %}
-# {{ description }}
+# {{ description | replace('\n', '\n# ') }}
 {%- endif %}
 {%- if fields|length > 1 %}
 {{ class_name }}: TypeAlias = Union[

datamodel_code_generator/model/types.py

@@ -67,7 +67,7 @@ class DataTypeManager(_DataTypeManager):
         use_non_positive_negative_number_constrained_types: bool = False,  # noqa: FBT001, FBT002
         use_union_operator: bool = False,  # noqa: FBT001, FBT002
         use_pendulum: bool = False,  # noqa: FBT001, FBT002
-        target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        target_datetime_class: DatetimeClassType | None = None,
         treat_dot_as_module: bool = False,  # noqa: FBT001, FBT002
     ) -> None:
         super().__init__(

datamodel_code_generator/parser/base.py

@@ -376,7 +376,7 @@ class Parser(ABC):
         treat_dot_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: dict[str, Any] | None = None,
-        target_datetime_class: DatetimeClassType | None = DatetimeClassType.Datetime,
+        target_datetime_class: DatetimeClassType | None = None,
         keyword_only: bool = False,
         frozen_dataclasses: bool = False,
         no_alias: bool = False,
@@ -389,6 +389,7 @@ class Parser(ABC):
             python_version=target_python_version,
             use_standard_collections=use_standard_collections,
             use_generic_container_types=use_generic_container_types,
+            use_non_positive_negative_number_constrained_types=use_non_positive_negative_number_constrained_types,
             strict_types=strict_types,
             use_union_operator=use_union_operator,
             use_pendulum=use_pendulum,
@@ -934,6 +935,8 @@ class Parser(ABC):
                 for data_type in model_field.data_type.all_data_types:
                     reference = data_type.reference
                     if not reference or not isinstance(reference.source, self.data_model_root_type):
+                        # If the data type is not a reference, we can't collapse it.
+                        # If it's a reference to a root model type, we don't do anything.
                         continue
 
                     # Use root-type as model_field type
@@ -948,6 +951,10 @@ class Parser(ABC):
                     ):
                         continue  # pragma: no cover
 
+                    if root_type_field.data_type.reference:
+                        # If the root type field is a reference, we aren't able to collapse it yet.
+                        continue
+
                     # set copied data_type
                     copied_data_type = root_type_field.data_type.copy()
                     if isinstance(data_type.parent, self.data_model_field_type):

datamodel_code_generator/parser/graphql.py

@@ -308,6 +308,7 @@ class GraphQLParser(Parser):
             required=False,
             alias="__typename",
             use_one_literal_as_default=True,
+            use_default_kwarg=self.use_default_kwarg,
             has_default=True,
         )
 

datamodel_code_generator/parser/jsonschema.py

@@ -211,6 +211,33 @@ class JsonSchemaObject(BaseModel):
             return value.replace("#", "#/")
         return value
 
+    @field_validator("required", mode="before")
+    def validate_required(cls, value: Any) -> Any:  # noqa: N805
+        if value is None:
+            return []
+        if isinstance(value, list):  # noqa: PLR1702
+            # Filter to only include valid strings, excluding invalid objects
+            required_fields: list[str] = []
+            for item in value:
+                if isinstance(item, str):
+                    required_fields.append(item)
+
+                # In some cases, the required field can include "anyOf", "oneOf", or "allOf" as a dict (#2297)
+                elif isinstance(item, dict):
+                    for key, val in item.items():
+                        if isinstance(val, list):
+                            # If 'anyOf' or "oneOf" is present, we won't include it in required fields
+                            if key in {"anyOf", "oneOf"}:
+                                continue
+
+                            if key == "allOf":
+                                # If 'allOf' is present, we include them as required fields
+                                required_fields.extend(sub_item for sub_item in val if isinstance(sub_item, str))
+
+            value = required_fields
+
+        return value
+
     items: Optional[Union[list[JsonSchemaObject], JsonSchemaObject, bool]] = None  # noqa: UP007, UP045
     uniqueItems: Optional[bool] = None  # noqa: N815, UP045
     type: Optional[Union[str, list[str]]] = None  # noqa: UP007, UP045
@@ -431,13 +458,14 @@ class JsonSchemaParser(Parser):
         treat_dot_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: dict[str, Any] | None = None,
-        target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        target_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,
     ) -> None:
+        target_datetime_class = target_datetime_class or DatetimeClassType.Awaredatetime
         super().__init__(
             source=source,
             data_model_type=data_model_type,
@@ -626,13 +654,13 @@ class JsonSchemaParser(Parser):
         reference = self.model_resolver.add_ref(ref)
         return self.data_type(reference=reference)
 
-    def set_additional_properties(self, name: str, obj: JsonSchemaObject) -> None:
+    def set_additional_properties(self, path: str, obj: JsonSchemaObject) -> None:
         if isinstance(obj.additionalProperties, bool):
-            self.extra_template_data[name]["additionalProperties"] = obj.additionalProperties
+            self.extra_template_data[path]["additionalProperties"] = obj.additionalProperties
 
-    def set_title(self, name: str, obj: JsonSchemaObject) -> None:
+    def set_title(self, path: str, obj: JsonSchemaObject) -> None:
         if obj.title:
-            self.extra_template_data[name]["title"] = obj.title
+            self.extra_template_data[path]["title"] = obj.title
 
     def _deep_merge(self, dict1: dict[Any, Any], dict2: dict[Any, Any]) -> dict[Any, Any]:
         result = dict1.copy()
@@ -754,7 +782,7 @@ class JsonSchemaParser(Parser):
         if self.use_title_as_name and obj.title:  # pragma: no cover
             name = obj.title
         reference = self.model_resolver.add(path, name, class_name=True, loaded=True)
-        self.set_additional_properties(reference.name, obj)
+        self.set_additional_properties(reference.path, obj)
 
         data_model_type = self._create_data_model(
             reference=reference,
@@ -965,7 +993,7 @@ class JsonSchemaParser(Parser):
             loaded=True,
         )
         class_name = reference.name
-        self.set_title(class_name, obj)
+        self.set_title(reference.path, obj)
         fields = self.parse_object_fields(
             obj, path, get_module_name(class_name, None, treat_dot_as_module=self.treat_dot_as_module)
         )
@@ -994,7 +1022,7 @@ class JsonSchemaParser(Parser):
             )
             data_model_type_class = self.data_model_root_type
 
-        self.set_additional_properties(class_name, obj)
+        self.set_additional_properties(reference.path, obj)
 
         data_model_type = self._create_data_model(
             model_type=data_model_type_class,
@@ -1277,8 +1305,8 @@ class JsonSchemaParser(Parser):
             name = obj.title
         if not reference:
             reference = self.model_resolver.add(path, name, loaded=True, class_name=True)
-        self.set_title(name, obj)
-        self.set_additional_properties(name, obj)
+        self.set_title(reference.path, obj)
+        self.set_additional_properties(reference.path, obj)
         data_model_root_type = self.data_model_root_type(
             reference=reference,
             fields=[
@@ -1376,6 +1404,7 @@ class JsonSchemaParser(Parser):
                 custom_template_dir=self.custom_template_dir,
                 type_=_get_type(obj.type, obj.format) if self.use_subclass_enum and isinstance(obj.type, str) else None,
                 default=obj.default if obj.has_default else UNDEFINED,
+                treat_dot_as_module=self.treat_dot_as_module,
             )
             self.results.append(enum)
             return self.data_type(reference=reference_)
@@ -1552,7 +1581,7 @@ class JsonSchemaParser(Parser):
         raw: dict[str, Any],
         path: list[str],
     ) -> None:
-        self.parse_obj(name, self.SCHEMA_OBJECT_TYPE.parse_obj(raw), path)
+        self.parse_obj(name, self.SCHEMA_OBJECT_TYPE.model_validate(raw), path)
 
     def parse_obj(
         self,

datamodel_code_generator/parser/openapi.py

@@ -189,6 +189,7 @@ class OpenAPIParser(JsonSchemaParser):
         field_include_all_keys: bool = False,
         field_extra_keys_without_x_prefix: set[str] | None = None,
         openapi_scopes: list[OpenAPIScope] | None = None,
+        include_path_parameters: bool = False,
         wrap_string_literal: bool | None = False,
         use_title_as_name: bool = False,
         use_operation_id_as_name: bool = False,
@@ -214,13 +215,14 @@ class OpenAPIParser(JsonSchemaParser):
         treat_dot_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: dict[str, Any] | None = None,
-        target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        target_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,
     ) -> None:
+        target_datetime_class = target_datetime_class or DatetimeClassType.Awaredatetime
         super().__init__(
             source=source,
             data_model_type=data_model_type,
@@ -299,6 +301,7 @@ class OpenAPIParser(JsonSchemaParser):
             parent_scoped_naming=parent_scoped_naming,
         )
         self.open_api_scopes: list[OpenAPIScope] = openapi_scopes or [OpenAPIScope.Schemas]
+        self.include_path_parameters: bool = include_path_parameters
 
     def get_ref_model(self, ref: str) -> dict[str, Any]:
         ref_file, ref_path = self.model_resolver.resolve_ref(ref).split("#", 1)
@@ -351,13 +354,17 @@ class OpenAPIParser(JsonSchemaParser):
         name: str,
         request_body: RequestBodyObject,
         path: list[str],
-    ) -> None:
+    ) -> dict[str, DataType]:
+        data_types: dict[str, DataType] = {}
         for (
             media_type,
             media_obj,
         ) in request_body.content.items():
             if isinstance(media_obj.schema_, JsonSchemaObject):
-                self.parse_schema(name, media_obj.schema_, [*path, media_type])
+                data_types[media_type] = self.parse_schema(name, media_obj.schema_, [*path, media_type])
+            elif media_obj.schema_ is not None:
+                data_types[media_type] = self.get_ref_data_type(media_obj.schema_.ref)
+        return data_types
 
     def parse_responses(
         self,
@@ -414,15 +421,24 @@ class OpenAPIParser(JsonSchemaParser):
         name: str,
         parameters: list[ReferenceObject | ParameterObject],
         path: list[str],
-    ) -> None:
+    ) -> DataType | None:
         fields: list[DataModelFieldBase] = []
         exclude_field_names: set[str] = set()
         reference = self.model_resolver.add(path, name, class_name=True, unique=True)
         for parameter_ in parameters:
             parameter = self.resolve_object(parameter_, ParameterObject)
             parameter_name = parameter.name
-            if not parameter_name or parameter.in_ != ParameterLocation.query:
+            if (
+                not parameter_name
+                or parameter.in_ not in {ParameterLocation.query, ParameterLocation.path}
+                or (parameter.in_ == ParameterLocation.path and not self.include_path_parameters)
+            ):
                 continue
+
+            if any(field.original_name == parameter_name for field in fields):
+                msg = f"Parameter name '{parameter_name}' is used more than once."
+                raise Exception(msg)  # noqa: TRY002
+
             field_name, alias = self.model_resolver.get_valid_field_name_and_alias(
                 field_name=parameter_name, excludes=exclude_field_names
             )
@@ -500,6 +516,9 @@ class OpenAPIParser(JsonSchemaParser):
                     treat_dot_as_module=self.treat_dot_as_module,
                 )
             )
+            return self.data_type(reference=reference)
+
+        return None
 
     def parse_operation(
         self,
@@ -518,7 +537,9 @@ class OpenAPIParser(JsonSchemaParser):
             path_name = operation.operationId
             method = ""
         self.parse_all_parameters(
-            self._get_model_name(path_name, method, suffix="ParametersQuery"),
+            self._get_model_name(
+                path_name, method, suffix="Parameters" if self.include_path_parameters else "ParametersQuery"
+            ),
             operation.parameters,
             [*path, "parameters"],
         )

datamodel_code_generator/types.py

@@ -602,7 +602,7 @@ class DataTypeManager(ABC):
         )
         self.use_union_operator: bool = use_union_operator
         self.use_pendulum: bool = use_pendulum
-        self.target_datetime_class: DatetimeClassType = target_datetime_class or DatetimeClassType.Datetime
+        self.target_datetime_class: DatetimeClassType | None = target_datetime_class
         self.treat_dot_as_module: bool = treat_dot_as_module
 
         if TYPE_CHECKING:

datamodel_code_generator/util.py

@@ -1,38 +1,33 @@
 from __future__ import annotations
 
 import copy
-from typing import TYPE_CHECKING, Any, Callable, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Literal, TypeVar, overload
 
 import pydantic
 from packaging import version
 from pydantic import BaseModel as _BaseModel
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 PYDANTIC_VERSION = version.parse(pydantic.VERSION if isinstance(pydantic.VERSION, str) else str(pydantic.VERSION))
 
 PYDANTIC_V2: bool = version.parse("2.0b3") <= PYDANTIC_VERSION
 
-if TYPE_CHECKING:
-    from pathlib import Path
-    from typing import Literal
-
+try:
+    from yaml import CSafeLoader as SafeLoader
+except ImportError:  # pragma: no cover
     from yaml import SafeLoader
 
-    def load_toml(path: Path) -> dict[str, Any]: ...
+try:
+    from tomllib import load as load_tomllib  # type: ignore[ignoreMissingImports]
+except ImportError:
+    from tomli import load as load_tomllib  # type: ignore[ignoreMissingImports]
 
-else:
-    try:
-        from yaml import CSafeLoader as SafeLoader
-    except ImportError:  # pragma: no cover
-        from yaml import SafeLoader
-
-    try:
-        from tomllib import load as load_tomllib
-    except ImportError:
-        from tomli import load as load_tomllib
 
-    def load_toml(path: Path) -> dict[str, Any]:
-        with path.open("rb") as f:
-            return load_tomllib(f)
+def load_toml(path: Path) -> dict[str, Any]:
+    with path.open("rb") as f:
+        return load_tomllib(f)
 
 
 SafeLoaderTemp = copy.deepcopy(SafeLoader)
@@ -44,16 +39,70 @@ SafeLoaderTemp.add_constructor(
 SafeLoader = SafeLoaderTemp
 
 Model = TypeVar("Model", bound=_BaseModel)
+T = TypeVar("T")
+
+
+@overload
+def model_validator(
+    mode: Literal["before"],
+) -> (
+    Callable[[Callable[[type[Model], T], T]], Callable[[type[Model], T], T]]
+    | Callable[[Callable[[Model, T], T]], Callable[[Model, T], T]]
+): ...
 
 
+@overload
 def model_validator(
+    mode: Literal["after"],
+) -> (
+    Callable[[Callable[[type[Model], T], T]], Callable[[type[Model], T], T]]
+    | Callable[[Callable[[Model, T], T]], Callable[[Model, T], T]]
+    | Callable[[Callable[[Model], Model]], Callable[[Model], Model]]
+): ...
+
+
+@overload
+def model_validator() -> (
+    Callable[[Callable[[type[Model], T], T]], Callable[[type[Model], T], T]]
+    | Callable[[Callable[[Model, T], T]], Callable[[Model, T], T]]
+    | Callable[[Callable[[Model], Model]], Callable[[Model], Model]]
+): ...
+
+
+def model_validator(  # pyright: ignore[reportInconsistentOverload]
     mode: Literal["before", "after"] = "after",
-) -> Callable[[Callable[[Model, Any], Any]], Callable[[Model, Any], Any]]:
-    def inner(method: Callable[[Model, Any], Any]) -> Callable[[Model, Any], Any]:
+) -> (
+    Callable[[Callable[[type[Model], T], T]], Callable[[type[Model], T], T]]
+    | Callable[[Callable[[Model, T], T]], Callable[[Model, T], T]]
+    | Callable[[Callable[[Model], Model]], Callable[[Model], Model]]
+):
+    """
+    Decorator for model validators in Pydantic models.
+
+    Uses `model_validator` in Pydantic v2 and `root_validator` in Pydantic v1.
+
+    We support only `before` mode because `after` mode needs different validator
+    implementation for v1 and v2.
+    """
+
+    @overload
+    def inner(method: Callable[[type[Model], T], T]) -> Callable[[type[Model], T], T]: ...
+
+    @overload
+    def inner(method: Callable[[Model, T], T]) -> Callable[[Model, T], T]: ...
+
+    @overload
+    def inner(method: Callable[[Model], Model]) -> Callable[[Model], Model]: ...
+
+    def inner(
+        method: Callable[[type[Model], T], T] | Callable[[Model, T], T] | Callable[[Model], Model],
+    ) -> Callable[[type[Model], T], T] | Callable[[Model, T], T] | Callable[[Model], Model]:
         if PYDANTIC_V2:
             from pydantic import model_validator as model_validator_v2  # noqa: PLC0415
 
-            return model_validator_v2(mode=mode)(method)  # pyright: ignore[reportReturnType]
+            if method == "before":
+                return model_validator_v2(mode=mode)(classmethod(method))  # type: ignore[reportReturnType]
+            return model_validator_v2(mode=mode)(method)  # type: ignore[reportReturnType]
         from pydantic import root_validator  # noqa: PLC0415
 
         return root_validator(method, pre=mode == "before")  # pyright: ignore[reportCallIssue]

{datamodel_code_generator-0.31.2.dist-info → datamodel_code_generator-0.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.31.2
+Version: 0.33.0
 Summary: Datamodel Code Generator
 Project-URL: Homepage, https://github.com/koxudaxi/datamodel-code-generator
 Project-URL: Source, https://github.com/koxudaxi/datamodel-code-generator
@@ -543,7 +543,12 @@ Template customization:
                         Custom template directory
   --encoding ENCODING   The encoding of input and output (default: utf-8)
   --extra-template-data EXTRA_TEMPLATE_DATA
-                        Extra template data
+                        Extra template data for output models. Input is supposed to be a
+                        json/yaml file. For OpenAPI and Jsonschema the keys are the spec
+                        path of the object, or the name of the object if you want to apply
+                        the template data to multiple objects with the same name. If you are
+                        using another input file type (e.g. GraphQL), the key is the name of
+                        the object. The value is a dictionary of the template data to add.
   --use-double-quotes   Model generated with double quotes. Single quotes or your black
                         config skip_string_normalization value will be used without this
                         option.
@@ -552,6 +557,9 @@ Template customization:
                         option (require black 20.8b0 or later)
 
 OpenAPI-only options:
+  --include-path-parameters
+                        Include path parameters in generated parameter models in addition to
+                        query parameters (Only OpenAPI)
   --openapi-scopes {schemas,paths,tags,parameters} [{schemas,paths,tags,parameters} ...]
                         Scopes of OpenAPI model generation (default: schemas)
   --strict-nullable     Treat default field as a non-nullable field (Only OpenAPI)

{datamodel_code_generator-0.31.2.dist-info → datamodel_code_generator-0.33.0.dist-info}/RECORD

@@ -1,42 +1,42 @@
-datamodel_code_generator/__init__.py,sha256=TO6OUS0RCHi22nEZ7IeGKbqZHEC1XjciEG3PkLIkMvY,20698
-datamodel_code_generator/__main__.py,sha256=Z9g_NGrnxV63MRuqtUUpPW48felXmVxwGBtWWkgNlj4,22803
-datamodel_code_generator/arguments.py,sha256=3GrwOmcqOpBIuZgkg0_3AFO1iKH9Mj0MryQ4PqJmThY,17147
+datamodel_code_generator/__init__.py,sha256=y2SP5bJH_RsykmqaXt0MfxS1uqyMLqLvVb6fYLMYswY,21243
+datamodel_code_generator/__main__.py,sha256=kmT3ith19I5Mia9VX7z4W66e8g1SznxOU4pL6aK5m2I,25449
+datamodel_code_generator/arguments.py,sha256=In_PyAU_jB6NGtkuP-3fTra0BEpFWocTG_ososRVPrM,17778
 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=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=ZQ3Xy4Fs_I8M01tk1ps0EhWJM9vR-n7umPkz5NmHTjw,15050
+datamodel_code_generator/types.py,sha256=Ofr3QpcJ1E-7ZqJkAglW55zx3YpapN6MapUWoynVkiU,21860
+datamodel_code_generator/util.py,sha256=mi5jwvMNjzIS_EuL4jikcO3WPViBK_oQRAw99db0T48,4465
+datamodel_code_generator/model/__init__.py,sha256=qbldMWjMiDhOphB6n75k3v42SLU17OlCuJQeTPOvgts,3356
+datamodel_code_generator/model/base.py,sha256=KaotBuXbid4KMYglaxDBd5rJKaFwI2WoForNKrb57sc,15431
 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
+datamodel_code_generator/model/msgspec.py,sha256=gTb9H9Dc13nXOYJDYPGO889Y5A4zBKKJOdpzrXz09JU,11830
 datamodel_code_generator/model/rootmodel.py,sha256=pY8G2SPjkafzfJ1L9P5sNdp8qe45UclpUYN86guRB3M,202
 datamodel_code_generator/model/scalar.py,sha256=xfONEK30eYJ2mSL9PK9zXqEG5-xApYMI_gmKOn5qhK4,2664
 datamodel_code_generator/model/typed_dict.py,sha256=FJi_fEZWuFe3nvidfl-jqr9PMRFTvfusoEFQkx1BqHI,4685
-datamodel_code_generator/model/types.py,sha256=ZyEwi76EBI5RS5JfoNUoRHmjOAZDup8oNFvQQDizfwQ,3502
+datamodel_code_generator/model/types.py,sha256=kGnQ7SpjyovXYKwCCIPmAi3gr1HOCqiu7C9k-PnMuo0,3487
 datamodel_code_generator/model/union.py,sha256=zwq1ayGFW3KbI4SxPCcdZcrM7X4Px25IdujDedtwgOw,1929
 datamodel_code_generator/model/pydantic/__init__.py,sha256=ggJNv7_6Vv-BgY50O-0Pa6IHGavkxGAjSa9lLEmFOnE,1149
 datamodel_code_generator/model/pydantic/base_model.py,sha256=0ZsoQfjhhRTMlvsThGEsXJgYMubjrakkuOHUt5-f6HY,12492
 datamodel_code_generator/model/pydantic/custom_root_type.py,sha256=VJpEAmGFe3TzMKrR5YvR7PJ3pfGHcYytO1zhQrWyoWg,299
 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/types.py,sha256=NAtbr61vwrjPQ4BQWHanWwL8U-di4kbJS6O5VIaOpNk,13263
 datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=YHfOs8prPBsrQmYm0kJATSyU0wafQTqKNd24e2-KGJE,1344
 datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=ztDpXrifLVGABElvAgg-h5rulgQHxDG40DQ_Nr91JHg,8723
 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
-datamodel_code_generator/model/pydantic_v2/types.py,sha256=apEuIhCBa15WdwGA0R9cqjpiH8mTLgAgu02CjcU4Css,2064
+datamodel_code_generator/model/pydantic_v2/types.py,sha256=ZEWQ9CiUX-f7bMytzih67Kk_PffizVy54KV-adjUr8Y,2066
 datamodel_code_generator/model/template/Enum.jinja2,sha256=k9lB8iQUsB94bPi8e3xJEd0AGk2ciWL-pSZuGY5kNPQ,378
 datamodel_code_generator/model/template/Scalar.jinja2,sha256=Ss22-mYG3Vez-pbqmW2zFzwxGVhXkbQcAVTMV7POpg8,104
 datamodel_code_generator/model/template/TypedDict.jinja2,sha256=J_Pe_CiuvTOb-EUCExXPaeTEFzn2keyrKB0wglZ8HgA,135
 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/Union.jinja2,sha256=Sx_aqvNPOr75YmbVDfgfzZiBo71DWjzqu7kz-6j8JMY,282
 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
@@ -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=4B4UeEjCfl_IdRak_qi5Wx8sUx5bX8Xt-Z0CmfsWsks,62940
-datamodel_code_generator/parser/graphql.py,sha256=TNLxy-0wWJSpCm6HK5fKooZdaJodcwQqVr0J29ao3J8,23330
-datamodel_code_generator/parser/jsonschema.py,sha256=oFSZOyLL3K0tneH09t2lNKdWcbmR_r5OjCyWKPq2Jxc,71114
-datamodel_code_generator/parser/openapi.py,sha256=kI4kqVBG96rdAVb8z0l4gF6QpcylgVoGjlK_-KToZRg,27607
-datamodel_code_generator-0.31.2.dist-info/METADATA,sha256=v3R32Y4sivpjW4M-a1qvq2ug4sz2Vpb9BSdHA5pLMAM,25577
-datamodel_code_generator-0.31.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-datamodel_code_generator-0.31.2.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
-datamodel_code_generator-0.31.2.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.31.2.dist-info/RECORD,,
+datamodel_code_generator/parser/base.py,sha256=YqhgQMSsrsAuVIMiGUNwJ4vMtW8up8pMI55sFepqa28,63402
+datamodel_code_generator/parser/graphql.py,sha256=x5Jge8xZiaup9jMhX6jVKncme_D5FmSoEWmXIKtguVo,23384
+datamodel_code_generator/parser/jsonschema.py,sha256=inLczqOz1Tl8tC-qR1hiS2SDmVWtppWnp0U44MWnLgI,72514
+datamodel_code_generator/parser/openapi.py,sha256=puBXUaq4zXDl7wj-VsZmmmt_D672RfS6qY9WID0VRPw,28603
+datamodel_code_generator-0.33.0.dist-info/METADATA,sha256=lb9MUWpEd8NRvuijqRabotA8GjYjvyCCEudEcSIe-rA,26256
+datamodel_code_generator-0.33.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+datamodel_code_generator-0.33.0.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
+datamodel_code_generator-0.33.0.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
+datamodel_code_generator-0.33.0.dist-info/RECORD,,