datamodel-code-generator 0.32.0__tar.gz → 0.34.0__tar.gz

{datamodel_code_generator-0.32.0 → datamodel_code_generator-0.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.32.0
+Version: 0.34.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
@@ -313,12 +313,6 @@ class Apis(BaseModel):
       <p>Astral</p>
     </a>
   </td>
-  <td valign="top" align="center">
-    <a href="https://github.com/DataDog">
-      <img src="https://avatars.githubusercontent.com/u/365230?s=200&v=4" alt="Datadog, Inc. Logo" style="width: 100px;">
-      <p>Datadog, Inc.</p>
-    </a>
-  </td>
   </tr>
 </table>
 
@@ -426,6 +420,8 @@ Options:
 Typing customization:
   --base-class BASE_CLASS
                         Base Class (default: pydantic.BaseModel)
+  --disable-future-imports
+                        Disable __future__ imports
   --enum-field-as-literal {all,one}
                         Parse enum field as literal. all: all enum field type are Literal.
                         one: field type is Literal when an enum has only one possible value
@@ -543,7 +539,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 → datamodel_code_generator-0.34.0}/README.md

@@ -263,12 +263,6 @@ class Apis(BaseModel):
       <p>Astral</p>
     </a>
   </td>
-  <td valign="top" align="center">
-    <a href="https://github.com/DataDog">
-      <img src="https://avatars.githubusercontent.com/u/365230?s=200&v=4" alt="Datadog, Inc. Logo" style="width: 100px;">
-      <p>Datadog, Inc.</p>
-    </a>
-  </td>
   </tr>
 </table>
 
@@ -376,6 +370,8 @@ Options:
 Typing customization:
   --base-class BASE_CLASS
                         Base Class (default: pydantic.BaseModel)
+  --disable-future-imports
+                        Disable __future__ imports
   --enum-field-as-literal {all,one}
                         Parse enum field as literal. all: all enum field type are Literal.
                         one: field type is Literal when an enum has only one possible value
@@ -493,7 +489,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 → datamodel_code_generator-0.34.0}/src/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
@@ -291,6 +289,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     no_alias: bool = False,
     formatters: list[Formatter] = DEFAULT_FORMATTERS,
     parent_scoped_naming: bool = False,
+    disable_future_imports: bool = False,
 ) -> None:
     remote_text_cache: DefaultPutDict[str, str] = DefaultPutDict()
     if isinstance(input_, str):
@@ -312,15 +311,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 +414,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(
@@ -495,7 +500,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     )
 
     with chdir(output):
-        results = parser.parse()
+        results = parser.parse(disable_future_imports=disable_future_imports)
     if not input_filename:  # pragma: no cover
         if isinstance(input_, str):
             input_filename = "<stdin>"
@@ -560,11 +565,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 +590,7 @@ inferred_message = (
 __all__ = [
     "MAX_VERSION",
     "MIN_VERSION",
+    "DatetimeClassType",
     "DefaultPutDict",
     "Error",
     "InputFileType",

{datamodel_code_generator-0.32.0 → datamodel_code_generator-0.34.0}/src/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
@@ -318,6 +362,7 @@ class Config(BaseModel):
     no_alias: bool = False
     formatters: list[Formatter] = DEFAULT_FORMATTERS
     parent_scoped_naming: bool = False
+    disable_future_imports: bool = False
 
     def merge_args(self, args: Namespace) -> None:
         set_args = {f: getattr(args, f) for f in self.get_fields() if getattr(args, f) is not None}
@@ -533,6 +578,7 @@ def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912,
             no_alias=config.no_alias,
             formatters=config.formatters,
             parent_scoped_naming=config.parent_scoped_naming,
+            disable_future_imports=config.disable_future_imports,
         )
     except InvalidClassNameError as e:
         print(f"{e} You have to set `--class-name` option", file=sys.stderr)  # noqa: T201

{datamodel_code_generator-0.32.0 → datamodel_code_generator-0.34.0}/src/datamodel_code_generator/arguments.py

@@ -305,6 +305,12 @@ typing_options.add_argument(
     action="store_true",
     default=None,
 )
+typing_options.add_argument(
+    "--disable-future-imports",
+    help="Disable __future__ imports",
+    action="store_true",
+    default=None,
+)
 
 # ======================================================================================
 # Customization options for generated model fields
@@ -437,7 +443,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-0.32.0 → datamodel_code_generator-0.34.0}/src/datamodel_code_generator/format.py

@@ -178,7 +178,7 @@ class CodeFormatter:
         import_ = import_module(custom_formatter_import)
 
         if not hasattr(import_, "CodeFormatter"):
-            msg = f"Custom formatter module `{import_.__name__}` must contains object with name Formatter"
+            msg = f"Custom formatter module `{import_.__name__}` must contains object with name CodeFormatter"
             raise NameError(msg)
 
         formatter_class = import_.__getattribute__("CodeFormatter")  # noqa: PLC2801

{datamodel_code_generator-0.32.0 → datamodel_code_generator-0.34.0}/src/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-0.32.0 → datamodel_code_generator-0.34.0}/src/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-0.32.0 → datamodel_code_generator-0.34.0}/src/datamodel_code_generator/model/dataclass.py

@@ -87,6 +87,16 @@ class DataModelField(DataModelFieldBase):
     }
     constraints: Optional[Constraints] = None  # noqa: UP045
 
+    def process_const(self) -> None:
+        if "const" not in self.extras:
+            return
+        self.const = True
+        self.nullable = False
+        const = self.extras["const"]
+        self.data_type = self.data_type.__class__(literals=[const])
+        if not self.default:
+            self.default = const
+
     @property
     def imports(self) -> tuple[Import, ...]:
         field = self.field

{datamodel_code_generator-0.32.0 → datamodel_code_generator-0.34.0}/src/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-0.32.0 → datamodel_code_generator-0.34.0}/src/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-0.32.0 → datamodel_code_generator-0.34.0}/src/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-0.32.0 → datamodel_code_generator-0.34.0}/src/datamodel_code_generator/model/typed_dict.py

@@ -114,6 +114,16 @@ class TypedDict(DataModel):
 class DataModelField(DataModelFieldBase):
     DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_NOT_REQUIRED,)
 
+    def process_const(self) -> None:
+        if "const" not in self.extras:
+            return
+        self.const = True
+        self.nullable = False
+        const = self.extras["const"]
+        self.data_type = self.data_type.__class__(literals=[const])
+        if not self.default:
+            self.default = const
+
     @property
     def key(self) -> str:
         return (self.original_name or self.name or "").translate(  # pragma: no cover

{datamodel_code_generator-0.32.0 → datamodel_code_generator-0.34.0}/src/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-0.32.0 → datamodel_code_generator-0.34.0}/src/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):
@@ -1240,10 +1246,11 @@ class Parser(ABC):
         with_import: bool | None = True,  # noqa: FBT001, FBT002
         format_: bool | None = True,  # noqa: FBT001, FBT002
         settings_path: Path | None = None,
+        disable_future_imports: bool = False,  # noqa: FBT001, FBT002
     ) -> str | dict[tuple[str, ...], Result]:
         self.parse_raw()
 
-        if with_import:
+        if with_import and not disable_future_imports:
             self.imports.append(IMPORT_ANNOTATIONS)
 
         if format_: