datamodel-code-generator 0.32.0__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
@@ -312,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
@@ -409,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(
@@ -560,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 = (
@@ -575,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

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(

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")
@@ -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]:

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/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,
@@ -935,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
@@ -949,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/jsonschema.py

@@ -458,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,
@@ -653,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()
@@ -781,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,
@@ -992,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)
         )
@@ -1021,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,
@@ -1304,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=[

datamodel_code_generator/parser/openapi.py

@@ -215,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,

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.32.0.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.32.0
+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.

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

@@ -1,36 +1,36 @@
-datamodel_code_generator/__init__.py,sha256=5WIAPB0SYL-VFLIfC8OKl9euih2S6IfZ6otV7ZWCXKY,20809
-datamodel_code_generator/__main__.py,sha256=RtiTFNKB-UAL54ywMB8mSllkYhE9h-GZOe_h9ztmOM8,22913
-datamodel_code_generator/arguments.py,sha256=JdU1DvV4wMFdmaqqYiTQ2eafLyK2LhztwjTiwekEwIg,17368
+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=pI6LTvjT3ddiIYylR2MZ1Hq3Wem3pie6gedpGxyzyF4,13358
+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
@@ -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=nYL7JjmsfsZHIPgIr5Mp4Gzy2BC2-EAm-ZFrMZMR6yw,63055
+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=Y5jZtjZmg6ewo3J44RUSLq01sqA0ugW5eezK9b90Qtk,72412
-datamodel_code_generator/parser/openapi.py,sha256=nVZoO4BvVbh_jVCtzjcXZAuVMrlQUQo4ZbBqZC-JBB0,28529
-datamodel_code_generator-0.32.0.dist-info/METADATA,sha256=xryfSH-rOwdjyJX2HPeFzkDLcG-D5yiWU5jpY5F8A1Y,25754
-datamodel_code_generator-0.32.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-datamodel_code_generator-0.32.0.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
-datamodel_code_generator-0.32.0.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.32.0.dist-info/RECORD,,
+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,,