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

datamodel_code_generator/format.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from enum import Enum
 from importlib import import_module
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Sequence
 from warnings import warn
 
 import black
@@ -18,28 +18,28 @@ except ImportError:  # pragma: no cover
 
 
 class DatetimeClassType(Enum):
-    Datetime = 'datetime'
-    Awaredatetime = 'AwareDatetime'
-    Naivedatetime = 'NaiveDatetime'
+    Datetime = "datetime"
+    Awaredatetime = "AwareDatetime"
+    Naivedatetime = "NaiveDatetime"
 
 
 class PythonVersion(Enum):
-    PY_36 = '3.6'
-    PY_37 = '3.7'
-    PY_38 = '3.8'
-    PY_39 = '3.9'
-    PY_310 = '3.10'
-    PY_311 = '3.11'
-    PY_312 = '3.12'
-    PY_313 = '3.13'
+    PY_36 = "3.6"
+    PY_37 = "3.7"
+    PY_38 = "3.8"
+    PY_39 = "3.9"
+    PY_310 = "3.10"
+    PY_311 = "3.11"
+    PY_312 = "3.12"
+    PY_313 = "3.13"
 
     @cached_property
     def _is_py_38_or_later(self) -> bool:  # pragma: no cover
-        return self.value not in {self.PY_36.value, self.PY_37.value}  # type: ignore
+        return self.value not in {self.PY_36.value, self.PY_37.value}
 
     @cached_property
     def _is_py_39_or_later(self) -> bool:  # pragma: no cover
-        return self.value not in {self.PY_36.value, self.PY_37.value, self.PY_38.value}  # type: ignore
+        return self.value not in {self.PY_36.value, self.PY_37.value, self.PY_38.value}
 
     @cached_property
     def _is_py_310_or_later(self) -> bool:  # pragma: no cover
@@ -48,7 +48,7 @@ class PythonVersion(Enum):
             self.PY_37.value,
             self.PY_38.value,
             self.PY_39.value,
-        }  # type: ignore
+        }
 
     @cached_property
     def _is_py_311_or_later(self) -> bool:  # pragma: no cover
@@ -58,7 +58,7 @@ class PythonVersion(Enum):
             self.PY_38.value,
             self.PY_39.value,
             self.PY_310.value,
-        }  # type: ignore
+        }
 
     @property
     def has_literal_type(self) -> bool:
@@ -89,12 +89,12 @@ if TYPE_CHECKING:
 
     class _TargetVersion(Enum): ...
 
-    BLACK_PYTHON_VERSION: Dict[PythonVersion, _TargetVersion]
+    BLACK_PYTHON_VERSION: dict[PythonVersion, _TargetVersion]
 else:
-    BLACK_PYTHON_VERSION: Dict[PythonVersion, black.TargetVersion] = {
-        v: getattr(black.TargetVersion, f'PY{v.name.split("_")[-1]}')
+    BLACK_PYTHON_VERSION: dict[PythonVersion, black.TargetVersion] = {
+        v: getattr(black.TargetVersion, f"PY{v.name.split('_')[-1]}")
         for v in PythonVersion
-        if hasattr(black.TargetVersion, f'PY{v.name.split("_")[-1]}')
+        if hasattr(black.TargetVersion, f"PY{v.name.split('_')[-1]}")
     }
 
 
@@ -104,132 +104,111 @@ def is_supported_in_black(python_version: PythonVersion) -> bool:  # pragma: no
 
 def black_find_project_root(sources: Sequence[Path]) -> Path:
     if TYPE_CHECKING:
-        from typing import Iterable, Tuple, Union
+        from typing import Iterable  # noqa: PLC0415
 
         def _find_project_root(
-            srcs: Union[Sequence[str], Iterable[str]],
-        ) -> Union[Tuple[Path, str], Path]: ...
+            srcs: Sequence[str] | Iterable[str],
+        ) -> tuple[Path, str] | Path: ...
 
     else:
-        from black import find_project_root as _find_project_root
+        from black import find_project_root as _find_project_root  # noqa: PLC0415
     project_root = _find_project_root(tuple(str(s) for s in sources))
     if isinstance(project_root, tuple):
         return project_root[0]
-    else:  # pragma: no cover
-        return project_root
+    # pragma: no cover
+    return project_root
 
 
 class CodeFormatter:
-    def __init__(
+    def __init__(  # noqa: PLR0912, PLR0913, PLR0917
         self,
         python_version: PythonVersion,
-        settings_path: Optional[Path] = None,
-        wrap_string_literal: Optional[bool] = None,
-        skip_string_normalization: bool = True,
-        known_third_party: Optional[List[str]] = None,
-        custom_formatters: Optional[List[str]] = None,
-        custom_formatters_kwargs: Optional[Dict[str, Any]] = None,
+        settings_path: Path | None = None,
+        wrap_string_literal: bool | None = None,  # noqa: FBT001
+        skip_string_normalization: bool = True,  # noqa: FBT001, FBT002
+        known_third_party: list[str] | None = None,
+        custom_formatters: list[str] | None = None,
+        custom_formatters_kwargs: dict[str, Any] | None = None,
     ) -> None:
         if not settings_path:
-            settings_path = Path().resolve()
+            settings_path = Path.cwd()
 
         root = black_find_project_root((settings_path,))
-        path = root / 'pyproject.toml'
+        path = root / "pyproject.toml"
         if path.is_file():
             pyproject_toml = load_toml(path)
-            config = pyproject_toml.get('tool', {}).get('black', {})
+            config = pyproject_toml.get("tool", {}).get("black", {})
         else:
             config = {}
 
-        black_kwargs: Dict[str, Any] = {}
+        black_kwargs: dict[str, Any] = {}
         if wrap_string_literal is not None:
             experimental_string_processing = wrap_string_literal
+        elif black.__version__ < "24.1.0":
+            experimental_string_processing = config.get("experimental-string-processing")
         else:
-            if black.__version__ < '24.1.0':  # type: ignore
-                experimental_string_processing = config.get(
-                    'experimental-string-processing'
-                )
-            else:
-                experimental_string_processing = config.get(
-                    'preview', False
-                ) and (  # pragma: no cover
-                    config.get('unstable', False)
-                    or 'string_processing' in config.get('enable-unstable-feature', [])
-                )
+            experimental_string_processing = config.get("preview", False) and (  # pragma: no cover
+                config.get("unstable", False) or "string_processing" in config.get("enable-unstable-feature", [])
+            )
 
         if experimental_string_processing is not None:  # pragma: no cover
-            if black.__version__.startswith('19.'):  # type: ignore
+            if black.__version__.startswith("19."):
                 warn(
-                    f"black doesn't support `experimental-string-processing` option"  # type: ignore
-                    f' for wrapping string literal in {black.__version__}'
-                )
-            elif black.__version__ < '24.1.0':  # type: ignore
-                black_kwargs['experimental_string_processing'] = (
-                    experimental_string_processing
+                    f"black doesn't support `experimental-string-processing` option"
+                    f" for wrapping string literal in {black.__version__}",
+                    stacklevel=2,
                 )
+            elif black.__version__ < "24.1.0":
+                black_kwargs["experimental_string_processing"] = experimental_string_processing
             elif experimental_string_processing:
-                black_kwargs['preview'] = True
-                black_kwargs['unstable'] = config.get('unstable', False)
-                black_kwargs['enabled_features'] = {
-                    black.mode.Preview.string_processing
-                }
+                black_kwargs["preview"] = True
+                black_kwargs["unstable"] = config.get("unstable", False)
+                black_kwargs["enabled_features"] = {black.mode.Preview.string_processing}
 
         if TYPE_CHECKING:
             self.black_mode: black.FileMode
         else:
             self.black_mode = black.FileMode(
                 target_versions={BLACK_PYTHON_VERSION[python_version]},
-                line_length=config.get('line-length', black.DEFAULT_LINE_LENGTH),
-                string_normalization=not skip_string_normalization
-                or not config.get('skip-string-normalization', True),
+                line_length=config.get("line-length", black.DEFAULT_LINE_LENGTH),
+                string_normalization=not skip_string_normalization or not config.get("skip-string-normalization", True),
                 **black_kwargs,
             )
 
         self.settings_path: str = str(settings_path)
 
-        self.isort_config_kwargs: Dict[str, Any] = {}
+        self.isort_config_kwargs: dict[str, Any] = {}
         if known_third_party:
-            self.isort_config_kwargs['known_third_party'] = known_third_party
+            self.isort_config_kwargs["known_third_party"] = known_third_party
 
-        if isort.__version__.startswith('4.'):
+        if isort.__version__.startswith("4."):
             self.isort_config = None
         else:
-            self.isort_config = isort.Config(
-                settings_path=self.settings_path, **self.isort_config_kwargs
-            )
+            self.isort_config = isort.Config(settings_path=self.settings_path, **self.isort_config_kwargs)
 
         self.custom_formatters_kwargs = custom_formatters_kwargs or {}
         self.custom_formatters = self._check_custom_formatters(custom_formatters)
 
-    def _load_custom_formatter(
-        self, custom_formatter_import: str
-    ) -> CustomCodeFormatter:
+    def _load_custom_formatter(self, custom_formatter_import: str) -> CustomCodeFormatter:
         import_ = import_module(custom_formatter_import)
 
-        if not hasattr(import_, 'CodeFormatter'):
-            raise NameError(
-                f'Custom formatter module `{import_.__name__}` must contains object with name Formatter'
-            )
+        if not hasattr(import_, "CodeFormatter"):
+            msg = f"Custom formatter module `{import_.__name__}` must contains object with name Formatter"
+            raise NameError(msg)
 
-        formatter_class = import_.__getattribute__('CodeFormatter')
+        formatter_class = import_.__getattribute__("CodeFormatter")  # noqa: PLC2801
 
         if not issubclass(formatter_class, CustomCodeFormatter):
-            raise TypeError(
-                f'The custom module {custom_formatter_import} must inherit from `datamodel-code-generator`'
-            )
+            msg = f"The custom module {custom_formatter_import} must inherit from `datamodel-code-generator`"
+            raise TypeError(msg)
 
         return formatter_class(formatter_kwargs=self.custom_formatters_kwargs)
 
-    def _check_custom_formatters(
-        self, custom_formatters: Optional[List[str]]
-    ) -> List[CustomCodeFormatter]:
+    def _check_custom_formatters(self, custom_formatters: list[str] | None) -> list[CustomCodeFormatter]:
         if custom_formatters is None:
             return []
 
-        return [
-            self._load_custom_formatter(custom_formatter_import)
-            for custom_formatter_import in custom_formatters
-        ]
+        return [self._load_custom_formatter(custom_formatter_import) for custom_formatter_import in custom_formatters]
 
     def format_code(
         self,
@@ -253,24 +232,23 @@ class CodeFormatter:
 
         def apply_isort(self, code: str) -> str: ...
 
-    else:
-        if isort.__version__.startswith('4.'):
+    elif isort.__version__.startswith("4."):
 
-            def apply_isort(self, code: str) -> str:
-                return isort.SortImports(
-                    file_contents=code,
-                    settings_path=self.settings_path,
-                    **self.isort_config_kwargs,
-                ).output
+        def apply_isort(self, code: str) -> str:
+            return isort.SortImports(
+                file_contents=code,
+                settings_path=self.settings_path,
+                **self.isort_config_kwargs,
+            ).output
 
-        else:
+    else:
 
-            def apply_isort(self, code: str) -> str:
-                return isort.code(code, config=self.isort_config)
+        def apply_isort(self, code: str) -> str:
+            return isort.code(code, config=self.isort_config)
 
 
 class CustomCodeFormatter:
-    def __init__(self, formatter_kwargs: Dict[str, Any]) -> None:
+    def __init__(self, formatter_kwargs: dict[str, Any]) -> None:
         self.formatter_kwargs = formatter_kwargs
 
     def apply(self, code: str) -> str:

datamodel_code_generator/http.py

@@ -1,30 +1,29 @@
 from __future__ import annotations
 
-from typing import Optional, Sequence, Tuple
+from typing import Sequence
 
 try:
     import httpx
-except ImportError:  # pragma: no cover
-    raise Exception(
-        "Please run `$pip install 'datamodel-code-generator[http]`' to resolve URL Reference"
-    )
+except ImportError as exc:  # pragma: no cover
+    msg = "Please run `$pip install 'datamodel-code-generator[http]`' to resolve URL Reference"
+    raise Exception(msg) from exc  # noqa: TRY002
 
 
 def get_body(
     url: str,
-    headers: Optional[Sequence[Tuple[str, str]]] = None,
-    ignore_tls: bool = False,
-    query_parameters: Optional[Sequence[Tuple[str, str]]] = None,
+    headers: Sequence[tuple[str, str]] | None = None,
+    ignore_tls: bool = False,  # noqa: FBT001, FBT002
+    query_parameters: Sequence[tuple[str, str]] | None = None,
 ) -> str:
     return httpx.get(
         url,
         headers=headers,
         verify=not ignore_tls,
         follow_redirects=True,
-        params=query_parameters,  # pyright: ignore [reportArgumentType]
+        params=query_parameters,  # pyright: ignore[reportArgumentType]
         # TODO: Improve params type
     ).text
 
 
-def join_url(url: str, ref: str = '.') -> str:
+def join_url(url: str, ref: str = ".") -> str:
     return str(httpx.URL(url).join(ref))

datamodel_code_generator/imports.py

@@ -2,86 +2,79 @@ from __future__ import annotations
 
 from collections import defaultdict
 from functools import lru_cache
-from typing import DefaultDict, Dict, Iterable, List, Optional, Set, Tuple, Union
+from itertools import starmap
+from typing import DefaultDict, Iterable, Optional, Set
 
 from datamodel_code_generator.util import BaseModel
 
 
 class Import(BaseModel):
-    from_: Optional[str] = None
+    from_: Optional[str] = None  # noqa: UP045
     import_: str
-    alias: Optional[str] = None
-    reference_path: Optional[str] = None
+    alias: Optional[str] = None  # noqa: UP045
+    reference_path: Optional[str] = None  # noqa: UP045
 
     @classmethod
     @lru_cache
     def from_full_path(cls, class_path: str) -> Import:
-        split_class_path: List[str] = class_path.split('.')
-        return Import(
-            from_='.'.join(split_class_path[:-1]) or None, import_=split_class_path[-1]
-        )
+        split_class_path: list[str] = class_path.split(".")
+        return Import(from_=".".join(split_class_path[:-1]) or None, import_=split_class_path[-1])
 
 
 class Imports(DefaultDict[Optional[str], Set[str]]):
     def __str__(self) -> str:
         return self.dump()
 
-    def __init__(self, use_exact: bool = False) -> None:
+    def __init__(self, use_exact: bool = False) -> None:  # noqa: FBT001, FBT002
         super().__init__(set)
-        self.alias: DefaultDict[Optional[str], Dict[str, str]] = defaultdict(dict)
-        self.counter: Dict[Tuple[Optional[str], str], int] = defaultdict(int)
-        self.reference_paths: Dict[str, Import] = {}
+        self.alias: defaultdict[str | None, dict[str, str]] = defaultdict(dict)
+        self.counter: dict[tuple[str | None, str], int] = defaultdict(int)
+        self.reference_paths: dict[str, Import] = {}
         self.use_exact: bool = use_exact
 
-    def _set_alias(self, from_: Optional[str], imports: Set[str]) -> List[str]:
+    def _set_alias(self, from_: str | None, imports: set[str]) -> list[str]:
         return [
-            f'{i} as {self.alias[from_][i]}'
-            if i in self.alias[from_] and i != self.alias[from_][i]
-            else i
+            f"{i} as {self.alias[from_][i]}" if i in self.alias[from_] and i != self.alias[from_][i] else i
             for i in sorted(imports)
         ]
 
-    def create_line(self, from_: Optional[str], imports: Set[str]) -> str:
+    def create_line(self, from_: str | None, imports: set[str]) -> str:
         if from_:
-            return f'from {from_} import {", ".join(self._set_alias(from_, imports))}'
-        return '\n'.join(f'import {i}' for i in self._set_alias(from_, imports))
+            return f"from {from_} import {', '.join(self._set_alias(from_, imports))}"
+        return "\n".join(f"import {i}" for i in self._set_alias(from_, imports))
 
     def dump(self) -> str:
-        return '\n'.join(
-            self.create_line(from_, imports) for from_, imports in self.items()
-        )
+        return "\n".join(starmap(self.create_line, self.items()))
 
-    def append(self, imports: Union[Import, Iterable[Import], None]) -> None:
+    def append(self, imports: Import | Iterable[Import] | None) -> None:
         if imports:
             if isinstance(imports, Import):
                 imports = [imports]
             for import_ in imports:
                 if import_.reference_path:
                     self.reference_paths[import_.reference_path] = import_
-                if '.' in import_.import_:
+                if "." in import_.import_:
                     self[None].add(import_.import_)
-                    self.counter[(None, import_.import_)] += 1
+                    self.counter[None, import_.import_] += 1
                 else:
                     self[import_.from_].add(import_.import_)
-                    self.counter[(import_.from_, import_.import_)] += 1
+                    self.counter[import_.from_, import_.import_] += 1
                     if import_.alias:
                         self.alias[import_.from_][import_.import_] = import_.alias
 
-    def remove(self, imports: Union[Import, Iterable[Import]]) -> None:
+    def remove(self, imports: Import | Iterable[Import]) -> None:
         if isinstance(imports, Import):  # pragma: no cover
             imports = [imports]
         for import_ in imports:
-            if '.' in import_.import_:  # pragma: no cover
-                self.counter[(None, import_.import_)] -= 1
-                if self.counter[(None, import_.import_)] == 0:  # pragma: no cover
+            if "." in import_.import_:  # pragma: no cover
+                self.counter[None, import_.import_] -= 1
+                if self.counter[None, import_.import_] == 0:  # pragma: no cover
                     self[None].remove(import_.import_)
                     if not self[None]:
                         del self[None]
             else:
-                self.counter[(import_.from_, import_.import_)] -= 1  # pragma: no cover
-                if (
-                    self.counter[(import_.from_, import_.import_)] == 0
-                ):  # pragma: no cover
+                self.counter[import_.from_, import_.import_] -= 1  # pragma: no cover
+                if self.counter[import_.from_, import_.import_] == 0:  # pragma: no cover
                     self[import_.from_].remove(import_.import_)
                     if not self[import_.from_]:
                         del self[import_.from_]
@@ -95,33 +88,33 @@ class Imports(DefaultDict[Optional[str], Set[str]]):
             self.remove(self.reference_paths[reference_path])
 
 
-IMPORT_ANNOTATED = Import.from_full_path('typing.Annotated')
-IMPORT_ANNOTATED_BACKPORT = Import.from_full_path('typing_extensions.Annotated')
-IMPORT_ANY = Import.from_full_path('typing.Any')
-IMPORT_LIST = Import.from_full_path('typing.List')
-IMPORT_SET = Import.from_full_path('typing.Set')
-IMPORT_UNION = Import.from_full_path('typing.Union')
-IMPORT_OPTIONAL = Import.from_full_path('typing.Optional')
-IMPORT_LITERAL = Import.from_full_path('typing.Literal')
-IMPORT_TYPE_ALIAS = Import.from_full_path('typing.TypeAlias')
-IMPORT_LITERAL_BACKPORT = Import.from_full_path('typing_extensions.Literal')
-IMPORT_SEQUENCE = Import.from_full_path('typing.Sequence')
-IMPORT_FROZEN_SET = Import.from_full_path('typing.FrozenSet')
-IMPORT_MAPPING = Import.from_full_path('typing.Mapping')
-IMPORT_ABC_SEQUENCE = Import.from_full_path('collections.abc.Sequence')
-IMPORT_ABC_SET = Import.from_full_path('collections.abc.Set')
-IMPORT_ABC_MAPPING = Import.from_full_path('collections.abc.Mapping')
-IMPORT_ENUM = Import.from_full_path('enum.Enum')
-IMPORT_ANNOTATIONS = Import.from_full_path('__future__.annotations')
-IMPORT_DICT = Import.from_full_path('typing.Dict')
-IMPORT_DECIMAL = Import.from_full_path('decimal.Decimal')
-IMPORT_DATE = Import.from_full_path('datetime.date')
-IMPORT_DATETIME = Import.from_full_path('datetime.datetime')
-IMPORT_TIMEDELTA = Import.from_full_path('datetime.timedelta')
-IMPORT_PATH = Import.from_full_path('pathlib.Path')
-IMPORT_TIME = Import.from_full_path('datetime.time')
-IMPORT_UUID = Import.from_full_path('uuid.UUID')
-IMPORT_PENDULUM_DATE = Import.from_full_path('pendulum.Date')
-IMPORT_PENDULUM_DATETIME = Import.from_full_path('pendulum.DateTime')
-IMPORT_PENDULUM_DURATION = Import.from_full_path('pendulum.Duration')
-IMPORT_PENDULUM_TIME = Import.from_full_path('pendulum.Time')
+IMPORT_ANNOTATED = Import.from_full_path("typing.Annotated")
+IMPORT_ANNOTATED_BACKPORT = Import.from_full_path("typing_extensions.Annotated")
+IMPORT_ANY = Import.from_full_path("typing.Any")
+IMPORT_LIST = Import.from_full_path("typing.List")
+IMPORT_SET = Import.from_full_path("typing.Set")
+IMPORT_UNION = Import.from_full_path("typing.Union")
+IMPORT_OPTIONAL = Import.from_full_path("typing.Optional")
+IMPORT_LITERAL = Import.from_full_path("typing.Literal")
+IMPORT_TYPE_ALIAS = Import.from_full_path("typing.TypeAlias")
+IMPORT_LITERAL_BACKPORT = Import.from_full_path("typing_extensions.Literal")
+IMPORT_SEQUENCE = Import.from_full_path("typing.Sequence")
+IMPORT_FROZEN_SET = Import.from_full_path("typing.FrozenSet")
+IMPORT_MAPPING = Import.from_full_path("typing.Mapping")
+IMPORT_ABC_SEQUENCE = Import.from_full_path("collections.abc.Sequence")
+IMPORT_ABC_SET = Import.from_full_path("collections.abc.Set")
+IMPORT_ABC_MAPPING = Import.from_full_path("collections.abc.Mapping")
+IMPORT_ENUM = Import.from_full_path("enum.Enum")
+IMPORT_ANNOTATIONS = Import.from_full_path("__future__.annotations")
+IMPORT_DICT = Import.from_full_path("typing.Dict")
+IMPORT_DECIMAL = Import.from_full_path("decimal.Decimal")
+IMPORT_DATE = Import.from_full_path("datetime.date")
+IMPORT_DATETIME = Import.from_full_path("datetime.datetime")
+IMPORT_TIMEDELTA = Import.from_full_path("datetime.timedelta")
+IMPORT_PATH = Import.from_full_path("pathlib.Path")
+IMPORT_TIME = Import.from_full_path("datetime.time")
+IMPORT_UUID = Import.from_full_path("uuid.UUID")
+IMPORT_PENDULUM_DATE = Import.from_full_path("pendulum.Date")
+IMPORT_PENDULUM_DATETIME = Import.from_full_path("pendulum.DateTime")
+IMPORT_PENDULUM_DURATION = Import.from_full_path("pendulum.Duration")
+IMPORT_PENDULUM_TIME = Import.from_full_path("pendulum.Time")

datamodel_code_generator/model/__init__.py

@@ -1,38 +1,38 @@
 from __future__ import annotations
 
 import sys
-from typing import TYPE_CHECKING, Callable, Iterable, List, NamedTuple, Optional, Type
+from typing import TYPE_CHECKING, Callable, Iterable, 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 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 +44,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 +52,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 +60,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 if target_python_version.has_typed_dict else typed_dict.TypedDictBackport),
             root_model=rootmodel.RootModel,
             field_model=(
                 typed_dict.DataModelField
@@ -76,18 +72,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"]