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

datamodel_code_generator/model/typed_dict.py

@@ -1,39 +1,35 @@
+from __future__ import annotations
+
 import keyword
-from pathlib import Path
-from typing import (
-    Any,
-    ClassVar,
-    DefaultDict,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Tuple,
-)
+from typing import TYPE_CHECKING, Any, ClassVar
 
-from datamodel_code_generator.imports import 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_NOT_REQUIRED,
     IMPORT_NOT_REQUIRED_BACKPORT,
     IMPORT_TYPED_DICT,
-    IMPORT_TYPED_DICT_BACKPORT,
 )
-from datamodel_code_generator.reference import Reference
 from datamodel_code_generator.types import NOT_REQUIRED_PREFIX
 
-escape_characters = str.maketrans(
-    {
-        '\\': r'\\',
-        "'": r'\'',
-        '\b': r'\b',
-        '\f': r'\f',
-        '\n': r'\n',
-        '\r': r'\r',
-        '\t': r'\t',
-    }
-)
+if TYPE_CHECKING:
+    from collections import defaultdict
+    from collections.abc import Iterator
+    from pathlib import Path
+
+    from datamodel_code_generator.reference import Reference
+
+from datamodel_code_generator.imports import Import  # noqa: TC001
+
+escape_characters = str.maketrans({
+    "\\": r"\\",
+    "'": r"\'",
+    "\b": r"\b",
+    "\f": r"\f",
+    "\n": r"\n",
+    "\r": r"\r",
+    "\t": r"\t",
+})
 
 
 def _is_valid_field_name(field: DataModelFieldBase) -> bool:
@@ -44,23 +40,23 @@ def _is_valid_field_name(field: DataModelFieldBase) -> bool:
 
 
 class TypedDict(DataModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'TypedDict.jinja2'
-    BASE_CLASS: ClassVar[str] = 'typing.TypedDict'
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_TYPED_DICT,)
+    TEMPLATE_FILE_PATH: ClassVar[str] = "TypedDict.jinja2"
+    BASE_CLASS: ClassVar[str] = "typing.TypedDict"
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_TYPED_DICT,)
 
-    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,
@@ -99,8 +95,8 @@ class TypedDict(DataModel):
 
         yield from self.fields
 
-    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,
@@ -111,20 +107,14 @@ class TypedDict(DataModel):
             all_fields=self.all_fields,
             **self.extra_template_data,
         )
-        return response
-
-
-class TypedDictBackport(TypedDict):
-    BASE_CLASS: ClassVar[str] = 'typing_extensions.TypedDict'
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_TYPED_DICT_BACKPORT,)
 
 
 class DataModelField(DataModelFieldBase):
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_NOT_REQUIRED,)
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_NOT_REQUIRED,)
 
     @property
     def key(self) -> str:
-        return (self.original_name or self.name or '').translate(  # pragma: no cover
+        return (self.original_name or self.name or "").translate(  # pragma: no cover
             escape_characters
         )
 
@@ -132,7 +122,7 @@ class DataModelField(DataModelFieldBase):
     def type_hint(self) -> str:
         type_hint = super().type_hint
         if self._not_required:
-            return f'{NOT_REQUIRED_PREFIX}{type_hint}]'
+            return f"{NOT_REQUIRED_PREFIX}{type_hint}]"
         return type_hint
 
     @property
@@ -144,7 +134,7 @@ class DataModelField(DataModelFieldBase):
         return not self._not_required
 
     @property
-    def imports(self) -> Tuple[Import, ...]:
+    def imports(self) -> tuple[Import, ...]:
         return (
             *super().imports,
             *(self.DEFAULT_IMPORTS if self._not_required else ()),
@@ -152,4 +142,4 @@ class DataModelField(DataModelFieldBase):
 
 
 class DataModelFieldBackport(DataModelField):
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_NOT_REQUIRED_BACKPORT,)
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_NOT_REQUIRED_BACKPORT,)

datamodel_code_generator/model/types.py

@@ -1,6 +1,8 @@
-from typing import Any, Dict, Optional, Sequence, Type
+from __future__ import annotations
 
-from datamodel_code_generator import DatetimeClassType, PythonVersion
+from typing import TYPE_CHECKING, Any
+
+from datamodel_code_generator import DatetimeClassType, PythonVersion, PythonVersionMin
 from datamodel_code_generator.imports import (
     IMPORT_ANY,
     IMPORT_DECIMAL,
@@ -9,11 +11,14 @@ from datamodel_code_generator.imports import (
 from datamodel_code_generator.types import DataType, StrictTypes, Types
 from datamodel_code_generator.types import DataTypeManager as _DataTypeManager
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
-def type_map_factory(data_type: Type[DataType]) -> Dict[Types, DataType]:
-    data_type_int = data_type(type='int')
-    data_type_float = data_type(type='float')
-    data_type_str = data_type(type='str')
+def type_map_factory(data_type: type[DataType]) -> dict[Types, DataType]:
+    data_type_int = data_type(type="int")
+    data_type_float = data_type(type="float")
+    data_type_str = data_type(type="str")
     return {
         # TODO: Should we support a special type such UUID?
         Types.integer: data_type_int,
@@ -26,7 +31,7 @@ def type_map_factory(data_type: Type[DataType]) -> Dict[Types, DataType]:
         Types.time: data_type_str,
         Types.string: data_type_str,
         Types.byte: data_type_str,  # base64 encoded string
-        Types.binary: data_type(type='bytes'),
+        Types.binary: data_type(type="bytes"),
         Types.date: data_type_str,
         Types.date_time: data_type_str,
         Types.timedelta: data_type.from_import(IMPORT_TIMEDELTA),
@@ -44,26 +49,26 @@ def type_map_factory(data_type: Type[DataType]) -> Dict[Types, DataType]:
         Types.ipv6: data_type_str,
         Types.ipv4_network: data_type_str,
         Types.ipv6_network: data_type_str,
-        Types.boolean: data_type(type='bool'),
+        Types.boolean: data_type(type="bool"),
         Types.object: data_type.from_import(IMPORT_ANY, is_dict=True),
-        Types.null: data_type(type='None'),
+        Types.null: data_type(type="None"),
         Types.array: data_type.from_import(IMPORT_ANY, is_list=True),
         Types.any: data_type.from_import(IMPORT_ANY),
     }
 
 
 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,
@@ -75,7 +80,7 @@ class DataTypeManager(_DataTypeManager):
             target_datetime_class,
         )
 
-        self.type_map: Dict[Types, DataType] = type_map_factory(self.data_type)
+        self.type_map: dict[Types, DataType] = type_map_factory(self.data_type)
 
     def get_data_type(
         self,

datamodel_code_generator/model/union.py

@@ -1,39 +1,43 @@
 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
 
 from datamodel_code_generator.imports import IMPORT_TYPE_ALIAS, IMPORT_UNION, Import
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.base import UNDEFINED
-from datamodel_code_generator.reference import Reference
+
+if TYPE_CHECKING:
+    from collections import defaultdict
+    from pathlib import Path
+
+    from datamodel_code_generator.reference import Reference
 
 
 class DataTypeUnion(DataModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'Union.jinja2'
-    BASE_CLASS: ClassVar[str] = ''
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (
+    TEMPLATE_FILE_PATH: ClassVar[str] = "Union.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (
         IMPORT_TYPE_ALIAS,
         IMPORT_UNION,
     )
 
-    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=fields,

datamodel_code_generator/parser/__init__.py

@@ -1,33 +1,37 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Callable, Dict, Optional, TypeVar
+from typing import Callable, TypeVar
 
-TK = TypeVar('TK')
-TV = TypeVar('TV')
+TK = TypeVar("TK")
+TV = TypeVar("TV")
 
 
 class LiteralType(Enum):
-    All = 'all'
-    One = 'one'
+    All = "all"
+    One = "one"
 
 
-class DefaultPutDict(Dict[TK, TV]):
+class DefaultPutDict(dict[TK, TV]):
     def get_or_put(
         self,
         key: TK,
-        default: Optional[TV] = None,
-        default_factory: Optional[Callable[[TK], TV]] = None,
+        default: TV | None = None,
+        default_factory: Callable[[TK], TV] | None = None,
     ) -> TV:
         if key in self:
             return self[key]
-        elif default:  # pragma: no cover
+        if default:  # pragma: no cover
             value = self[key] = default
             return value
-        elif default_factory:
+        if default_factory:
             value = self[key] = default_factory(key)
             return value
-        raise ValueError('Not found default and default_factory')  # pragma: no cover
+        msg = "Not found default and default_factory"
+        raise ValueError(msg)  # pragma: no cover
 
 
-__all__ = ['LiteralType']
+__all__ = [
+    "DefaultPutDict",
+    "LiteralType",
+]