datamodel-code-generator 0.27.2__py3-none-any.whl → 0.28.0__py3-none-any.whl

datamodel_code_generator/model/__init__.py

@@ -1,38 +1,40 @@
 from __future__ import annotations
 
 import sys
-from typing import TYPE_CHECKING, Callable, Iterable, List, NamedTuple, Optional, Type
+from typing import TYPE_CHECKING, Callable, NamedTuple
+
+from datamodel_code_generator import DatetimeClassType, PythonVersion
 
-from .. import DatetimeClassType, PythonVersion
-from ..types import DataTypeManager as DataTypeManagerABC
 from .base import ConstraintsBase, DataModel, DataModelFieldBase
 
 if TYPE_CHECKING:
-    from .. import DataModelType
+    from collections.abc import Iterable
+
+    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}'
-)
+DEFAULT_TARGET_PYTHON_VERSION = PythonVersion(f"{sys.version_info.major}.{sys.version_info.minor}")
 
 
 class DataModelSet(NamedTuple):
-    data_model: Type[DataModel]
-    root_model: Type[DataModel]
-    field_model: Type[DataModelFieldBase]
-    data_type_manager: Type[DataTypeManagerABC]
-    dump_resolve_reference_action: Optional[Callable[[Iterable[str]], str]]
-    known_third_party: Optional[List[str]] = None
+    data_model: type[DataModel]
+    root_model: type[DataModel]
+    field_model: type[DataModelFieldBase]
+    data_type_manager: type[DataTypeManagerABC]
+    dump_resolve_reference_action: Callable[[Iterable[str]], str] | None
+    known_third_party: list[str] | None = None
 
 
 def get_data_model_types(
     data_model_type: DataModelType,
     target_python_version: PythonVersion = DEFAULT_TARGET_PYTHON_VERSION,
-    target_datetime_class: Optional[DatetimeClassType] = None,
+    target_datetime_class: DatetimeClassType | None = None,
 ) -> DataModelSet:
-    from .. import DataModelType
-    from . import dataclass, msgspec, pydantic, pydantic_v2, rootmodel, typed_dict
-    from .types import DataTypeManager
+    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
@@ -44,7 +46,7 @@ def get_data_model_types(
             data_type_manager=pydantic.DataTypeManager,
             dump_resolve_reference_action=pydantic.dump_resolve_reference_action,
         )
-    elif data_model_type == DataModelType.PydanticV2BaseModel:
+    if data_model_type == DataModelType.PydanticV2BaseModel:
         return DataModelSet(
             data_model=pydantic_v2.BaseModel,
             root_model=pydantic_v2.RootModel,
@@ -52,7 +54,7 @@ def get_data_model_types(
             data_type_manager=pydantic_v2.DataTypeManager,
             dump_resolve_reference_action=pydantic_v2.dump_resolve_reference_action,
         )
-    elif data_model_type == DataModelType.DataclassesDataclass:
+    if data_model_type == DataModelType.DataclassesDataclass:
         return DataModelSet(
             data_model=dataclass.DataClass,
             root_model=rootmodel.RootModel,
@@ -60,13 +62,9 @@ def get_data_model_types(
             data_type_manager=dataclass.DataTypeManager,
             dump_resolve_reference_action=None,
         )
-    elif data_model_type == DataModelType.TypingTypedDict:
+    if data_model_type == DataModelType.TypingTypedDict:
         return DataModelSet(
-            data_model=(
-                typed_dict.TypedDict
-                if target_python_version.has_typed_dict
-                else typed_dict.TypedDictBackport
-            ),
+            data_model=typed_dict.TypedDict,
             root_model=rootmodel.RootModel,
             field_model=(
                 typed_dict.DataModelField
@@ -76,18 +74,17 @@ def get_data_model_types(
             data_type_manager=DataTypeManager,
             dump_resolve_reference_action=None,
         )
-    elif data_model_type == DataModelType.MsgspecStruct:
+    if data_model_type == DataModelType.MsgspecStruct:
         return DataModelSet(
             data_model=msgspec.Struct,
             root_model=msgspec.RootModel,
             field_model=msgspec.DataModelField,
             data_type_manager=msgspec.DataTypeManager,
             dump_resolve_reference_action=None,
-            known_third_party=['msgspec'],
+            known_third_party=["msgspec"],
         )
-    raise ValueError(
-        f'{data_model_type} is unsupported data model type'
-    )  # pragma: no cover
+    msg = f"{data_model_type} is unsupported data model type"
+    raise ValueError(msg)  # pragma: no cover
 
 
-__all__ = ['ConstraintsBase', 'DataModel', 'DataModelFieldBase']
+__all__ = ["ConstraintsBase", "DataModel", "DataModelFieldBase"]

datamodel_code_generator/model/base.py

@@ -1,23 +1,11 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from copy import deepcopy
-from functools import lru_cache
+from functools import cached_property, lru_cache
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    ClassVar,
-    DefaultDict,
-    Dict,
-    FrozenSet,
-    Iterator,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    TypeVar,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar
 from warnings import warn
 
 from jinja2 import Environment, FileSystemLoader, Template
@@ -25,7 +13,6 @@ from pydantic import Field
 
 from datamodel_code_generator.imports import (
     IMPORT_ANNOTATED,
-    IMPORT_ANNOTATED_BACKPORT,
     IMPORT_OPTIONAL,
     IMPORT_UNION,
     Import,
@@ -40,20 +27,23 @@ from datamodel_code_generator.types import (
     chain_as_tuple,
     get_optional_type,
 )
-from datamodel_code_generator.util import PYDANTIC_V2, ConfigDict, cached_property
+from datamodel_code_generator.util import PYDANTIC_V2, ConfigDict
 
-TEMPLATE_DIR: Path = Path(__file__).parents[0] / 'template'
+if TYPE_CHECKING:
+    from collections.abc import Iterator
 
-ALL_MODEL: str = '#all#'
+TEMPLATE_DIR: Path = Path(__file__).parents[0] / "template"
 
-ConstraintsBaseT = TypeVar('ConstraintsBaseT', bound='ConstraintsBase')
+ALL_MODEL: str = "#all#"
+
+ConstraintsBaseT = TypeVar("ConstraintsBaseT", bound="ConstraintsBase")
 
 
 class ConstraintsBase(_BaseModel):
-    unique_items: Optional[bool] = Field(None, alias='uniqueItems')
-    _exclude_fields: ClassVar[Set[str]] = {'has_constraints'}
+    unique_items: Optional[bool] = Field(None, alias="uniqueItems")  # noqa: UP045
+    _exclude_fields: ClassVar[set[str]] = {"has_constraints"}
     if PYDANTIC_V2:
-        model_config = ConfigDict(  # pyright: ignore [reportAssignmentType]
+        model_config = ConfigDict(  # pyright: ignore[reportAssignmentType]
             arbitrary_types_allowed=True, ignored_types=(cached_property,)
         )
     else:
@@ -67,61 +57,51 @@ class ConstraintsBase(_BaseModel):
         return any(v is not None for v in self.dict().values())
 
     @staticmethod
-    def merge_constraints(
-        a: ConstraintsBaseT, b: ConstraintsBaseT
-    ) -> Optional[ConstraintsBaseT]:
+    def merge_constraints(a: ConstraintsBaseT, b: ConstraintsBaseT) -> ConstraintsBaseT | None:
         constraints_class = None
         if isinstance(a, ConstraintsBase):  # pragma: no cover
-            root_type_field_constraints = {
-                k: v for k, v in a.dict(by_alias=True).items() if v is not None
-            }
+            root_type_field_constraints = {k: v for k, v in a.dict(by_alias=True).items() if v is not None}
             constraints_class = a.__class__
         else:
             root_type_field_constraints = {}  # pragma: no cover
 
         if isinstance(b, ConstraintsBase):  # pragma: no cover
-            model_field_constraints = {
-                k: v for k, v in b.dict(by_alias=True).items() if v is not None
-            }
+            model_field_constraints = {k: v for k, v in b.dict(by_alias=True).items() if v is not None}
             constraints_class = constraints_class or b.__class__
         else:
             model_field_constraints = {}
 
-        if constraints_class is None or not issubclass(
-            constraints_class, ConstraintsBase
-        ):  # pragma: no cover
+        if constraints_class is None or not issubclass(constraints_class, ConstraintsBase):  # pragma: no cover
             return None
 
-        return constraints_class.parse_obj(
-            {
-                **root_type_field_constraints,
-                **model_field_constraints,
-            }
-        )
+        return constraints_class.parse_obj({
+            **root_type_field_constraints,
+            **model_field_constraints,
+        })
 
 
 class DataModelFieldBase(_BaseModel):
-    name: Optional[str] = None
-    default: Optional[Any] = None
+    name: Optional[str] = None  # noqa: UP045
+    default: Optional[Any] = None  # noqa: UP045
     required: bool = False
-    alias: Optional[str] = None
+    alias: Optional[str] = None  # noqa: UP045
     data_type: DataType
     constraints: Any = None
     strip_default_none: bool = False
-    nullable: Optional[bool] = None
-    parent: Optional[Any] = None
-    extras: Dict[str, Any] = {}
+    nullable: Optional[bool] = None  # noqa: UP045
+    parent: Optional[Any] = None  # noqa: UP045
+    extras: dict[str, Any] = {}  # noqa: RUF012
     use_annotated: bool = False
     has_default: bool = False
     use_field_description: bool = False
     const: bool = False
-    original_name: Optional[str] = None
+    original_name: Optional[str] = None  # noqa: UP045
     use_default_kwarg: bool = False
     use_one_literal_as_default: bool = False
-    _exclude_fields: ClassVar[Set[str]] = {'parent'}
-    _pass_fields: ClassVar[Set[str]] = {'parent', 'data_type'}
+    _exclude_fields: ClassVar[set[str]] = {"parent"}
+    _pass_fields: ClassVar[set[str]] = {"parent", "data_type"}
     can_have_extra_keys: ClassVar[bool] = True
-    type_has_null: Optional[bool] = None
+    type_has_null: Optional[bool] = None  # noqa: UP045
 
     if not TYPE_CHECKING:
 
@@ -132,46 +112,39 @@ class DataModelFieldBase(_BaseModel):
             self.process_const()
 
     def process_const(self) -> None:
-        if 'const' not in self.extras:
-            return None
-        self.default = self.extras['const']
+        if "const" not in self.extras:
+            return
+        self.default = self.extras["const"]
         self.const = True
         self.required = False
         self.nullable = False
 
     @property
-    def type_hint(self) -> str:
+    def type_hint(self) -> str:  # noqa: PLR0911
         type_hint = self.data_type.type_hint
 
         if not type_hint:
             return NONE
-        elif self.has_default_factory:
-            return type_hint
-        elif self.data_type.is_optional and self.data_type.type != ANY:
+        if self.has_default_factory or (self.data_type.is_optional and self.data_type.type != ANY):
             return type_hint
-        elif self.nullable is not None:
+        if self.nullable is not None:
             if self.nullable:
                 return get_optional_type(type_hint, self.data_type.use_union_operator)
             return type_hint
-        elif self.required:
+        if self.required:
             if self.type_has_null:
                 return get_optional_type(type_hint, self.data_type.use_union_operator)
             return type_hint
-        elif self.fall_back_to_nullable:
+        if self.fall_back_to_nullable:
             return get_optional_type(type_hint, self.data_type.use_union_operator)
-        else:
-            return type_hint
+        return type_hint
 
     @property
-    def imports(self) -> Tuple[Import, ...]:
+    def imports(self) -> tuple[Import, ...]:
         type_hint = self.type_hint
         has_union = not self.data_type.use_union_operator and UNION_PREFIX in type_hint
-        imports: List[Union[Tuple[Import], Iterator[Import]]] = [
-            iter(
-                i
-                for i in self.data_type.all_imports
-                if not (not has_union and i == IMPORT_UNION)
-            )
+        imports: list[tuple[Import] | Iterator[Import]] = [
+            iter(i for i in self.data_type.all_imports if not (not has_union and i == IMPORT_UNION))
         ]
 
         if self.fall_back_to_nullable:
@@ -179,39 +152,31 @@ class DataModelFieldBase(_BaseModel):
                 self.nullable or (self.nullable is None and not self.required)
             ) and not self.data_type.use_union_operator:
                 imports.append((IMPORT_OPTIONAL,))
-        else:
-            if (
-                self.nullable and not self.data_type.use_union_operator
-            ):  # pragma: no cover
-                imports.append((IMPORT_OPTIONAL,))
+        elif self.nullable and not self.data_type.use_union_operator:  # pragma: no cover
+            imports.append((IMPORT_OPTIONAL,))
         if self.use_annotated and self.annotated:
-            import_annotated = (
-                IMPORT_ANNOTATED
-                if self.data_type.python_version.has_annotated_type
-                else IMPORT_ANNOTATED_BACKPORT
-            )
-            imports.append((import_annotated,))
+            imports.append((IMPORT_ANNOTATED,))
         return chain_as_tuple(*imports)
 
     @property
-    def docstring(self) -> Optional[str]:
+    def docstring(self) -> str | None:
         if self.use_field_description:
-            description = self.extras.get('description', None)
+            description = self.extras.get("description", None)
             if description is not None:
-                return f'{description}'
+                return f"{description}"
         return None
 
     @property
-    def unresolved_types(self) -> FrozenSet[str]:
+    def unresolved_types(self) -> frozenset[str]:
         return self.data_type.unresolved_types
 
     @property
-    def field(self) -> Optional[str]:
+    def field(self) -> str | None:
         """for backwards compatibility"""
         return None
 
     @property
-    def method(self) -> Optional[str]:
+    def method(self) -> str | None:
         return None
 
     @property
@@ -219,12 +184,12 @@ class DataModelFieldBase(_BaseModel):
         return repr(self.default)
 
     @property
-    def annotated(self) -> Optional[str]:
+    def annotated(self) -> str | None:
         return None
 
     @property
     def has_default_factory(self) -> bool:
-        return 'default_factory' in self.extras
+        return "default_factory" in self.extras
 
     @property
     def fall_back_to_nullable(self) -> bool:
@@ -234,22 +199,22 @@ class DataModelFieldBase(_BaseModel):
 @lru_cache
 def get_template(template_file_path: Path) -> Template:
     loader = FileSystemLoader(str(TEMPLATE_DIR / template_file_path.parent))
-    environment: Environment = Environment(loader=loader)
+    environment: Environment = Environment(loader=loader)  # noqa: S701
     return environment.get_template(template_file_path.name)
 
 
-def get_module_path(name: str, file_path: Optional[Path]) -> List[str]:
+def get_module_path(name: str, file_path: Path | None) -> list[str]:
     if file_path:
         return [
             *file_path.parts[:-1],
             file_path.stem,
-            *name.split('.')[:-1],
+            *name.split(".")[:-1],
         ]
-    return name.split('.')[:-1]
+    return name.split(".")[:-1]
 
 
-def get_module_name(name: str, file_path: Optional[Path]) -> str:
-    return '.'.join(get_module_path(name, file_path))
+def get_module_name(name: str, file_path: Path | None) -> str:
+    return ".".join(get_module_path(name, file_path))
 
 
 class TemplateBase(ABC):
@@ -280,43 +245,42 @@ UNDEFINED: Any = object()
 
 
 class DataModel(TemplateBase, Nullable, ABC):
-    TEMPLATE_FILE_PATH: ClassVar[str] = ''
-    BASE_CLASS: ClassVar[str] = ''
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = ()
+    TEMPLATE_FILE_PATH: ClassVar[str] = ""
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = ()
 
-    def __init__(
+    def __init__(  # noqa: PLR0913
         self,
         *,
         reference: Reference,
-        fields: List[DataModelFieldBase],
-        decorators: Optional[List[str]] = None,
-        base_classes: Optional[List[Reference]] = None,
-        custom_base_class: Optional[str] = None,
-        custom_template_dir: Optional[Path] = None,
-        extra_template_data: Optional[DefaultDict[str, Dict[str, Any]]] = None,
-        methods: Optional[List[str]] = None,
-        path: Optional[Path] = None,
-        description: Optional[str] = None,
+        fields: list[DataModelFieldBase],
+        decorators: list[str] | None = None,
+        base_classes: list[Reference] | None = None,
+        custom_base_class: str | None = None,
+        custom_template_dir: Path | None = None,
+        extra_template_data: defaultdict[str, dict[str, Any]] | None = None,
+        methods: list[str] | None = None,
+        path: Path | None = None,
+        description: str | None = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
     ) -> None:
         self.keyword_only = keyword_only
         if not self.TEMPLATE_FILE_PATH:
-            raise Exception('TEMPLATE_FILE_PATH is undefined')
+            msg = "TEMPLATE_FILE_PATH is undefined"
+            raise Exception(msg)  # noqa: TRY002
 
-        self._custom_template_dir: Optional[Path] = custom_template_dir
-        self.decorators: List[str] = decorators or []
-        self._additional_imports: List[Import] = []
+        self._custom_template_dir: Path | None = custom_template_dir
+        self.decorators: list[str] = decorators or []
+        self._additional_imports: list[Import] = []
         self.custom_base_class = custom_base_class
         if base_classes:
-            self.base_classes: List[BaseClassDataType] = [
-                BaseClassDataType(reference=b) for b in base_classes
-            ]
+            self.base_classes: list[BaseClassDataType] = [BaseClassDataType(reference=b) for b in base_classes]
         else:
             self.set_base_class()
 
-        self.file_path: Optional[Path] = path
+        self.file_path: Path | None = path
         self.reference: Reference = reference
 
         self.reference.source = self
@@ -324,9 +288,7 @@ class DataModel(TemplateBase, Nullable, ABC):
         self.extra_template_data = (
             # 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)
+            extra_template_data[self.name] if extra_template_data is not None else defaultdict(dict)
         )
 
         self.fields = self._validate_fields(fields) if fields else []
@@ -342,7 +304,7 @@ class DataModel(TemplateBase, Nullable, ABC):
                 # end up inadvertently sharing state (such as "base_class_kwargs")
                 self.extra_template_data.update(deepcopy(all_model_extra_template_data))
 
-        self.methods: List[str] = methods or []
+        self.methods: list[str] = methods or []
 
         self.description = description
         for field in self.fields:
@@ -352,18 +314,15 @@ class DataModel(TemplateBase, Nullable, ABC):
         self.default: Any = default
         self._nullable: bool = nullable
 
-    def _validate_fields(
-        self, fields: List[DataModelFieldBase]
-    ) -> List[DataModelFieldBase]:
-        names: Set[str] = set()
-        unique_fields: List[DataModelFieldBase] = []
+    def _validate_fields(self, fields: list[DataModelFieldBase]) -> list[DataModelFieldBase]:
+        names: set[str] = set()
+        unique_fields: list[DataModelFieldBase] = []
         for field in fields:
             if field.name:
                 if field.name in names:
-                    warn(f'Field name `{field.name}` is duplicated on {self.name}')
+                    warn(f"Field name `{field.name}` is duplicated on {self.name}", stacklevel=2)
                     continue
-                else:
-                    names.add(field.name)
+                names.add(field.name)
             unique_fields.append(field)
         return unique_fields
 
@@ -371,7 +330,7 @@ class DataModel(TemplateBase, Nullable, ABC):
         base_class = self.custom_base_class or self.BASE_CLASS
         if not base_class:
             self.base_classes = []
-            return None
+            return
         base_class_import = Import.from_full_path(base_class)
         self._additional_imports.append(base_class_import)
         self.base_classes = [BaseClassDataType.from_import(base_class_import)]
@@ -386,14 +345,14 @@ class DataModel(TemplateBase, Nullable, ABC):
         return template_file_path
 
     @property
-    def imports(self) -> Tuple[Import, ...]:
+    def imports(self) -> tuple[Import, ...]:
         return chain_as_tuple(
             (i for f in self.fields for i in f.imports),
             self._additional_imports,
         )
 
     @property
-    def reference_classes(self) -> FrozenSet[str]:
+    def reference_classes(self) -> frozenset[str]:
         return frozenset(
             {r.reference.path for r in self.base_classes if r.reference}
             | {t for f in self.fields for t in f.unresolved_types}
@@ -405,16 +364,16 @@ class DataModel(TemplateBase, Nullable, ABC):
 
     @property
     def duplicate_name(self) -> str:
-        return self.reference.duplicate_name or ''
+        return self.reference.duplicate_name or ""
 
     @property
     def base_class(self) -> str:
-        return ', '.join(b.type_hint for b in self.base_classes)
+        return ", ".join(b.type_hint for b in self.base_classes)
 
     @staticmethod
     def _get_class_name(name: str) -> str:
-        if '.' in name:
-            return name.rsplit('.', 1)[-1]
+        if "." in name:
+            return name.rsplit(".", 1)[-1]
         return name
 
     @property
@@ -423,10 +382,8 @@ class DataModel(TemplateBase, Nullable, ABC):
 
     @class_name.setter
     def class_name(self, class_name: str) -> None:
-        if '.' in self.reference.name:
-            self.reference.name = (
-                f'{self.reference.name.rsplit(".", 1)[0]}.{class_name}'
-            )
+        if "." in self.reference.name:
+            self.reference.name = f"{self.reference.name.rsplit('.', 1)[0]}.{class_name}"
         else:
             self.reference.name = class_name
 
@@ -435,7 +392,7 @@ class DataModel(TemplateBase, Nullable, ABC):
         return self._get_class_name(self.duplicate_name)
 
     @property
-    def module_path(self) -> List[str]:
+    def module_path(self) -> list[str]:
         return get_module_path(self.name, self.file_path)
 
     @property
@@ -456,8 +413,8 @@ class DataModel(TemplateBase, Nullable, ABC):
     def path(self) -> str:
         return self.reference.path
 
-    def render(self, *, class_name: Optional[str] = None) -> str:
-        response = self._render(
+    def render(self, *, class_name: str | None = None) -> str:
+        return self._render(
             class_name=class_name or self.class_name,
             fields=self.fields,
             decorators=self.decorators,
@@ -467,4 +424,3 @@ class DataModel(TemplateBase, Nullable, ABC):
             keyword_only=self.keyword_only,
             **self.extra_template_data,
         )
-        return response