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

datamodel_code_generator/model/dataclass.py

@@ -1,17 +1,8 @@
-from pathlib import Path
-from typing import (
-    Any,
-    ClassVar,
-    DefaultDict,
-    Dict,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-)
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Optional
 
-from datamodel_code_generator import DatetimeClassType, PythonVersion
+from datamodel_code_generator import DatetimeClassType, PythonVersion, PythonVersionMin
 from datamodel_code_generator.imports import (
     IMPORT_DATE,
     IMPORT_DATETIME,
@@ -22,44 +13,50 @@ from datamodel_code_generator.imports import (
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.base import UNDEFINED
 from datamodel_code_generator.model.imports import IMPORT_DATACLASS, IMPORT_FIELD
-from datamodel_code_generator.model.pydantic.base_model import Constraints
 from datamodel_code_generator.model.types import DataTypeManager as _DataTypeManager
 from datamodel_code_generator.model.types import type_map_factory
-from datamodel_code_generator.reference import Reference
 from datamodel_code_generator.types import DataType, StrictTypes, Types, chain_as_tuple
 
+if TYPE_CHECKING:
+    from collections import defaultdict
+    from collections.abc import Sequence
+    from pathlib import Path
+
+    from datamodel_code_generator.reference import Reference
+
+from datamodel_code_generator.model.pydantic.base_model import Constraints  # noqa: TC001
+
 
 def _has_field_assignment(field: DataModelFieldBase) -> bool:
     return bool(field.field) or not (
-        field.required
-        or (field.represented_default == 'None' and field.strip_default_none)
+        field.required or (field.represented_default == "None" and field.strip_default_none)
     )
 
 
 class DataClass(DataModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'dataclass.jinja2'
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_DATACLASS,)
+    TEMPLATE_FILE_PATH: ClassVar[str] = "dataclass.jinja2"
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_DATACLASS,)
 
-    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:
         super().__init__(
             reference=reference,
-            fields=sorted(fields, key=_has_field_assignment, reverse=False),
+            fields=sorted(fields, key=_has_field_assignment),
             decorators=decorators,
             base_classes=base_classes,
             custom_base_class=custom_base_class,
@@ -75,21 +72,21 @@ class DataClass(DataModel):
 
 
 class DataModelField(DataModelFieldBase):
-    _FIELD_KEYS: ClassVar[Set[str]] = {
-        'default_factory',
-        'init',
-        'repr',
-        'hash',
-        'compare',
-        'metadata',
-        'kw_only',
+    _FIELD_KEYS: ClassVar[set[str]] = {
+        "default_factory",
+        "init",
+        "repr",
+        "hash",
+        "compare",
+        "metadata",
+        "kw_only",
     }
-    constraints: Optional[Constraints] = None
+    constraints: Optional[Constraints] = None  # noqa: UP045
 
     @property
-    def imports(self) -> Tuple[Import, ...]:
+    def imports(self) -> tuple[Import, ...]:
         field = self.field
-        if field and field.startswith('field('):
+        if field and field.startswith("field("):
             return chain_as_tuple(super().imports, (IMPORT_FIELD,))
         return super().imports
 
@@ -99,60 +96,55 @@ class DataModelField(DataModelFieldBase):
         }
 
     @property
-    def field(self) -> Optional[str]:
+    def field(self) -> str | None:
         """for backwards compatibility"""
         result = str(self)
-        if result == '':
+        if not result:
             return None
-
         return result
 
     def __str__(self) -> str:
-        data: Dict[str, Any] = {
-            k: v for k, v in self.extras.items() if k in self._FIELD_KEYS
-        }
+        data: dict[str, Any] = {k: v for k, v in self.extras.items() if k in self._FIELD_KEYS}
 
         if self.default != UNDEFINED and self.default is not None:
-            data['default'] = self.default
+            data["default"] = self.default
 
         if self.required:
             data = {
                 k: v
                 for k, v in data.items()
                 if k
-                not in (
-                    'default',
-                    'default_factory',
-                )
+                not in {
+                    "default",
+                    "default_factory",
+                }
             }
 
         if not data:
-            return ''
+            return ""
 
-        if len(data) == 1 and 'default' in data:
-            default = data['default']
+        if len(data) == 1 and "default" in data:
+            default = data["default"]
 
             if isinstance(default, (list, dict)):
-                return f'field(default_factory=lambda :{repr(default)})'
+                return f"field(default_factory=lambda :{default!r})"
             return repr(default)
-        kwargs = [
-            f'{k}={v if k == "default_factory" else repr(v)}' for k, v in data.items()
-        ]
-        return f'field({", ".join(kwargs)})'
+        kwargs = [f"{k}={v if k == 'default_factory' else repr(v)}" for k, v in data.items()]
+        return f"field({', '.join(kwargs)})"
 
 
 class DataTypeManager(_DataTypeManager):
-    def __init__(
+    def __init__(  # noqa: PLR0913, PLR0917
         self,
-        python_version: PythonVersion = PythonVersion.PY_38,
-        use_standard_collections: bool = False,
-        use_generic_container_types: bool = False,
-        strict_types: Optional[Sequence[StrictTypes]] = None,
-        use_non_positive_negative_number_constrained_types: bool = False,
-        use_union_operator: bool = False,
-        use_pendulum: bool = False,
+        python_version: PythonVersion = PythonVersionMin,
+        use_standard_collections: bool = False,  # noqa: FBT001, FBT002
+        use_generic_container_types: bool = False,  # noqa: FBT001, FBT002
+        strict_types: Sequence[StrictTypes] | None = None,
+        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,
-    ):
+    ) -> None:
         super().__init__(
             python_version,
             use_standard_collections,
@@ -175,7 +167,7 @@ class DataTypeManager(_DataTypeManager):
             else {}
         )
 
-        self.type_map: Dict[Types, DataType] = {
+        self.type_map: dict[Types, DataType] = {
             **type_map_factory(self.data_type),
             **datetime_map,
         }

datamodel_code_generator/model/enum.py

@@ -1,20 +1,24 @@
 from __future__ import annotations
 
-from pathlib import Path
-from typing import Any, ClassVar, DefaultDict, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, ClassVar, Optional
 
 from datamodel_code_generator.imports import IMPORT_ANY, IMPORT_ENUM, Import
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.base import UNDEFINED, BaseClassDataType
-from datamodel_code_generator.reference import Reference
 from datamodel_code_generator.types import DataType, Types
 
-_INT: str = 'int'
-_FLOAT: str = 'float'
-_BYTES: str = 'bytes'
-_STR: str = 'str'
+if TYPE_CHECKING:
+    from collections import defaultdict
+    from pathlib import Path
 
-SUBCLASS_BASE_CLASSES: Dict[Types, str] = {
+    from datamodel_code_generator.reference import Reference
+
+_INT: str = "int"
+_FLOAT: str = "float"
+_BYTES: str = "bytes"
+_STR: str = "str"
+
+SUBCLASS_BASE_CLASSES: dict[Types, str] = {
     Types.int32: _INT,
     Types.int64: _INT,
     Types.integer: _INT,
@@ -27,28 +31,28 @@ SUBCLASS_BASE_CLASSES: Dict[Types, str] = {
 
 
 class Enum(DataModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'Enum.jinja2'
-    BASE_CLASS: ClassVar[str] = 'enum.Enum'
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_ENUM,)
+    TEMPLATE_FILE_PATH: ClassVar[str] = "Enum.jinja2"
+    BASE_CLASS: ClassVar[str] = "enum.Enum"
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_ENUM,)
 
-    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,
-        type_: Optional[Types] = 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,
+        type_: Types | None = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
-    ):
+    ) -> None:
         super().__init__(
             reference=reference,
             fields=fields,
@@ -68,7 +72,7 @@ class Enum(DataModel):
         if not base_classes and type_:
             base_class = SUBCLASS_BASE_CLASSES.get(type_)
             if base_class:
-                self.base_classes: List[BaseClassDataType] = [
+                self.base_classes: list[BaseClassDataType] = [
                     BaseClassDataType(type=base_class),
                     *self.base_classes,
                 ]
@@ -80,14 +84,14 @@ class Enum(DataModel):
     def get_member(self, field: DataModelFieldBase) -> Member:
         return Member(self, field)
 
-    def find_member(self, value: Any) -> Optional[Member]:
+    def find_member(self, value: Any) -> Member | None:
         repr_value = repr(value)
         # Remove surrounding quotes from the string representation
-        str_value = str(value).strip('\'"')
+        str_value = str(value).strip("'\"")
 
         for field in self.fields:
             # Remove surrounding quotes from field default value
-            field_default = (field.default or '').strip('\'"')
+            field_default = (field.default or "").strip("'\"")
 
             # Compare values after removing quotes
             if field_default == str_value:
@@ -100,7 +104,7 @@ class Enum(DataModel):
         return None
 
     @property
-    def imports(self) -> Tuple[Import, ...]:
+    def imports(self) -> tuple[Import, ...]:
         return tuple(i for i in super().imports if i != IMPORT_ANY)
 
 
@@ -108,7 +112,7 @@ class Member:
     def __init__(self, enum: Enum, field: DataModelFieldBase) -> None:
         self.enum: Enum = enum
         self.field: DataModelFieldBase = field
-        self.alias: Optional[str] = None
+        self.alias: Optional[str] = None  # noqa: UP045
 
     def __repr__(self) -> str:
-        return f'{self.alias or self.enum.name}.{self.field.name}'
+        return f"{self.alias or self.enum.name}.{self.field.name}"

datamodel_code_generator/model/imports.py

@@ -1,13 +1,15 @@
+from __future__ import annotations
+
 from datamodel_code_generator.imports import Import
 
-IMPORT_DATACLASS = Import.from_full_path('dataclasses.dataclass')
-IMPORT_FIELD = Import.from_full_path('dataclasses.field')
-IMPORT_CLASSVAR = Import.from_full_path('typing.ClassVar')
-IMPORT_TYPED_DICT = Import.from_full_path('typing.TypedDict')
-IMPORT_TYPED_DICT_BACKPORT = Import.from_full_path('typing_extensions.TypedDict')
-IMPORT_NOT_REQUIRED = Import.from_full_path('typing.NotRequired')
-IMPORT_NOT_REQUIRED_BACKPORT = Import.from_full_path('typing_extensions.NotRequired')
-IMPORT_MSGSPEC_STRUCT = Import.from_full_path('msgspec.Struct')
-IMPORT_MSGSPEC_FIELD = Import.from_full_path('msgspec.field')
-IMPORT_MSGSPEC_META = Import.from_full_path('msgspec.Meta')
-IMPORT_MSGSPEC_CONVERT = Import.from_full_path('msgspec.convert')
+IMPORT_DATACLASS = Import.from_full_path("dataclasses.dataclass")
+IMPORT_FIELD = Import.from_full_path("dataclasses.field")
+IMPORT_CLASSVAR = Import.from_full_path("typing.ClassVar")
+IMPORT_TYPED_DICT = Import.from_full_path("typing.TypedDict")
+IMPORT_TYPED_DICT_BACKPORT = Import.from_full_path("typing_extensions.TypedDict")
+IMPORT_NOT_REQUIRED = Import.from_full_path("typing.NotRequired")
+IMPORT_NOT_REQUIRED_BACKPORT = Import.from_full_path("typing_extensions.NotRequired")
+IMPORT_MSGSPEC_STRUCT = Import.from_full_path("msgspec.Struct")
+IMPORT_MSGSPEC_FIELD = Import.from_full_path("msgspec.field")
+IMPORT_MSGSPEC_META = Import.from_full_path("msgspec.Meta")
+IMPORT_MSGSPEC_CONVERT = Import.from_full_path("msgspec.convert")