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

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

@@ -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 → datamodel_code_generator-0.33.0}/README.md

@@ -493,7 +493,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.33.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
@@ -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-0.32.0 → datamodel_code_generator-0.33.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

{datamodel_code_generator-0.32.0 → datamodel_code_generator-0.33.0}/src/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-0.32.0 → datamodel_code_generator-0.33.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.33.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.33.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.33.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.33.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.33.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.33.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):

{datamodel_code_generator-0.32.0 → datamodel_code_generator-0.33.0}/src/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-0.32.0 → datamodel_code_generator-0.33.0}/src/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-0.32.0 → datamodel_code_generator-0.33.0}/src/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: