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

datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -1,11 +1,11 @@
+from __future__ import annotations
+
 import re
 from enum import Enum
-from pathlib import Path
 from typing import (
+    TYPE_CHECKING,
     Any,
     ClassVar,
-    DefaultDict,
-    Dict,
     List,
     NamedTuple,
     Optional,
@@ -26,130 +26,133 @@ from datamodel_code_generator.model.pydantic.base_model import (
     DataModelField as DataModelFieldV1,
 )
 from datamodel_code_generator.model.pydantic_v2.imports import IMPORT_CONFIG_DICT
-from datamodel_code_generator.reference import Reference
 from datamodel_code_generator.util import field_validator, model_validator
 
+if TYPE_CHECKING:
+    from collections import defaultdict
+    from pathlib import Path
+
+    from datamodel_code_generator.reference import Reference
+
 
 class UnionMode(Enum):
-    smart = 'smart'
-    left_to_right = 'left_to_right'
+    smart = "smart"
+    left_to_right = "left_to_right"
 
 
 class Constraints(_Constraints):
     # To override existing pattern alias
-    regex: Optional[str] = Field(None, alias='regex')
-    pattern: Optional[str] = Field(None, alias='pattern')
+    regex: Optional[str] = Field(None, alias="regex")  # noqa: UP045
+    pattern: Optional[str] = Field(None, alias="pattern")  # noqa: UP045
 
-    @model_validator(mode='before')
-    def validate_min_max_items(cls, values: Any) -> Dict[str, Any]:
+    @model_validator(mode="before")
+    def validate_min_max_items(cls, values: Any) -> dict[str, Any]:  # noqa: N805
         if not isinstance(values, dict):  # pragma: no cover
             return values
-        min_items = values.pop('minItems', None)
+        min_items = values.pop("minItems", None)
         if min_items is not None:
-            values['minLength'] = min_items
-        max_items = values.pop('maxItems', None)
+            values["minLength"] = min_items
+        max_items = values.pop("maxItems", None)
         if max_items is not None:
-            values['maxLength'] = max_items
+            values["maxLength"] = max_items
         return values
 
 
 class DataModelField(DataModelFieldV1):
-    _EXCLUDE_FIELD_KEYS: ClassVar[Set[str]] = {
-        'alias',
-        'default',
-        'gt',
-        'ge',
-        'lt',
-        'le',
-        'multiple_of',
-        'min_length',
-        'max_length',
-        'pattern',
+    _EXCLUDE_FIELD_KEYS: ClassVar[Set[str]] = {  # noqa: UP006
+        "alias",
+        "default",
+        "gt",
+        "ge",
+        "lt",
+        "le",
+        "multiple_of",
+        "min_length",
+        "max_length",
+        "pattern",
     }
-    _DEFAULT_FIELD_KEYS: ClassVar[Set[str]] = {
-        'default',
-        'default_factory',
-        'alias',
-        'alias_priority',
-        'validation_alias',
-        'serialization_alias',
-        'title',
-        'description',
-        'examples',
-        'exclude',
-        'discriminator',
-        'json_schema_extra',
-        'frozen',
-        'validate_default',
-        'repr',
-        'init_var',
-        'kw_only',
-        'pattern',
-        'strict',
-        'gt',
-        'ge',
-        'lt',
-        'le',
-        'multiple_of',
-        'allow_inf_nan',
-        'max_digits',
-        'decimal_places',
-        'min_length',
-        'max_length',
-        'union_mode',
+    _DEFAULT_FIELD_KEYS: ClassVar[Set[str]] = {  # noqa: UP006
+        "default",
+        "default_factory",
+        "alias",
+        "alias_priority",
+        "validation_alias",
+        "serialization_alias",
+        "title",
+        "description",
+        "examples",
+        "exclude",
+        "discriminator",
+        "json_schema_extra",
+        "frozen",
+        "validate_default",
+        "repr",
+        "init_var",
+        "kw_only",
+        "pattern",
+        "strict",
+        "gt",
+        "ge",
+        "lt",
+        "le",
+        "multiple_of",
+        "allow_inf_nan",
+        "max_digits",
+        "decimal_places",
+        "min_length",
+        "max_length",
+        "union_mode",
     }
-    constraints: Optional[Constraints] = None  # pyright: ignore [reportIncompatibleVariableOverride]
-    _PARSE_METHOD: ClassVar[str] = 'model_validate'
+    constraints: Optional[Constraints] = None  # pyright: ignore[reportIncompatibleVariableOverride]  # noqa: UP045
+    _PARSE_METHOD: ClassVar[str] = "model_validate"
     can_have_extra_keys: ClassVar[bool] = False
 
-    @field_validator('extras')
-    def validate_extras(cls, values: Any) -> Dict[str, Any]:
+    @field_validator("extras")
+    def validate_extras(cls, values: Any) -> dict[str, Any]:  # noqa: N805
         if not isinstance(values, dict):  # pragma: no cover
             return values
-        if 'examples' in values:
+        if "examples" in values:
             return values
 
-        if 'example' in values:
-            values['examples'] = [values.pop('example')]
+        if "example" in values:
+            values["examples"] = [values.pop("example")]
         return values
 
     def process_const(self) -> None:
-        if 'const' not in self.extras:
-            return None
+        if "const" not in self.extras:
+            return
         self.const = True
         self.nullable = False
-        const = self.extras['const']
+        const = self.extras["const"]
         self.data_type = self.data_type.__class__(literals=[const])
         if not self.default:
             self.default = const
 
-    def _process_data_in_str(self, data: Dict[str, Any]) -> None:
+    def _process_data_in_str(self, data: dict[str, Any]) -> None:
         if self.const:
             # const is removed in pydantic 2.0
-            data.pop('const')
+            data.pop("const")
 
         # unique_items is not supported in pydantic 2.0
-        data.pop('unique_items', None)
+        data.pop("unique_items", None)
 
-        if 'union_mode' in data:
+        if "union_mode" in data:
             if self.data_type.is_union:
-                data['union_mode'] = data.pop('union_mode').value
+                data["union_mode"] = data.pop("union_mode").value
             else:
-                data.pop('union_mode')
+                data.pop("union_mode")
 
         # **extra is not supported in pydantic 2.0
-        json_schema_extra = {
-            k: v for k, v in data.items() if k not in self._DEFAULT_FIELD_KEYS
-        }
+        json_schema_extra = {k: v for k, v in data.items() if k not in self._DEFAULT_FIELD_KEYS}
         if json_schema_extra:
-            data['json_schema_extra'] = json_schema_extra
-            for key in json_schema_extra.keys():
+            data["json_schema_extra"] = json_schema_extra
+            for key in json_schema_extra:
                 data.pop(key)
 
-    def _process_annotated_field_arguments(
+    def _process_annotated_field_arguments(  # noqa: PLR6301
         self,
-        field_arguments: List[str],
-    ) -> List[str]:
+        field_arguments: list[str],
+    ) -> list[str]:
         return field_arguments
 
 
@@ -160,27 +163,27 @@ class ConfigAttribute(NamedTuple):
 
 
 class BaseModel(BaseModelBase):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'pydantic_v2/BaseModel.jinja2'
-    BASE_CLASS: ClassVar[str] = 'pydantic.BaseModel'
-    CONFIG_ATTRIBUTES: ClassVar[List[ConfigAttribute]] = [
-        ConfigAttribute('allow_population_by_field_name', 'populate_by_name', False),
-        ConfigAttribute('populate_by_name', 'populate_by_name', False),
-        ConfigAttribute('allow_mutation', 'frozen', True),
-        ConfigAttribute('frozen', 'frozen', False),
+    TEMPLATE_FILE_PATH: ClassVar[str] = "pydantic_v2/BaseModel.jinja2"
+    BASE_CLASS: ClassVar[str] = "pydantic.BaseModel"
+    CONFIG_ATTRIBUTES: ClassVar[List[ConfigAttribute]] = [  # noqa: UP006
+        ConfigAttribute("allow_population_by_field_name", "populate_by_name", False),  # noqa: FBT003
+        ConfigAttribute("populate_by_name", "populate_by_name", False),  # noqa: FBT003
+        ConfigAttribute("allow_mutation", "frozen", True),  # noqa: FBT003
+        ConfigAttribute("frozen", "frozen", False),  # noqa: FBT003
     ]
 
-    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, Any]] = 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, Any] | None = None,
+        path: Path | None = None,
+        description: str | None = None,
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
@@ -199,49 +202,45 @@ class BaseModel(BaseModelBase):
             nullable=nullable,
             keyword_only=keyword_only,
         )
-        config_parameters: Dict[str, Any] = {}
+        config_parameters: dict[str, Any] = {}
 
         extra = self._get_config_extra()
         if extra:
-            config_parameters['extra'] = extra
+            config_parameters["extra"] = extra
 
         for from_, to, invert in self.CONFIG_ATTRIBUTES:
             if from_ in self.extra_template_data:
                 config_parameters[to] = (
-                    not self.extra_template_data[from_]
-                    if invert
-                    else self.extra_template_data[from_]
+                    not self.extra_template_data[from_] if invert else self.extra_template_data[from_]
                 )
         for data_type in self.all_data_types:
             if data_type.is_custom_type:  # pragma: no cover
-                config_parameters['arbitrary_types_allowed'] = True
+                config_parameters["arbitrary_types_allowed"] = True
                 break
 
         for field in self.fields:
             # Check if a regex pattern uses lookarounds.
             # Depending on the generation configuration, the pattern may end up in two different places.
-            pattern = (
-                isinstance(field.constraints, Constraints) and field.constraints.pattern
-            ) or (field.data_type.kwargs or {}).get('pattern')
-            if pattern and re.search(r'\(\?<?[=!]', pattern):
-                config_parameters['regex_engine'] = '"python-re"'
+            pattern = (isinstance(field.constraints, Constraints) and field.constraints.pattern) or (
+                field.data_type.kwargs or {}
+            ).get("pattern")
+            if pattern and re.search(r"\(\?<?[=!]", pattern):
+                config_parameters["regex_engine"] = '"python-re"'
                 break
 
-        if isinstance(self.extra_template_data.get('config'), dict):
-            for key, value in self.extra_template_data['config'].items():
-                config_parameters[key] = value
+        if isinstance(self.extra_template_data.get("config"), dict):
+            for key, value in self.extra_template_data["config"].items():
+                config_parameters[key] = value  # noqa: PERF403
 
         if config_parameters:
-            from datamodel_code_generator.model.pydantic_v2 import ConfigDict
+            from datamodel_code_generator.model.pydantic_v2 import ConfigDict  # noqa: PLC0415
 
-            self.extra_template_data['config'] = ConfigDict.parse_obj(config_parameters)  # pyright: ignore [reportArgumentType]
+            self.extra_template_data["config"] = ConfigDict.parse_obj(config_parameters)  # pyright: ignore[reportArgumentType]
             self._additional_imports.append(IMPORT_CONFIG_DICT)
 
-    def _get_config_extra(self) -> Optional[Literal["'allow'", "'forbid'"]]:
-        additionalProperties = self.extra_template_data.get('additionalProperties')
-        allow_extra_fields = self.extra_template_data.get('allow_extra_fields')
-        if additionalProperties is not None or allow_extra_fields:
-            return (
-                "'allow'" if additionalProperties or allow_extra_fields else "'forbid'"
-            )
+    def _get_config_extra(self) -> Literal["'allow'", "'forbid'"] | None:
+        additional_properties = self.extra_template_data.get("additionalProperties")
+        allow_extra_fields = self.extra_template_data.get("allow_extra_fields")
+        if additional_properties is not None or allow_extra_fields:
+            return "'allow'" if additional_properties or allow_extra_fields else "'forbid'"
         return None

datamodel_code_generator/model/pydantic_v2/imports.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from datamodel_code_generator.imports import Import
 
-IMPORT_CONFIG_DICT = Import.from_full_path('pydantic.ConfigDict')
-IMPORT_AWARE_DATETIME = Import.from_full_path('pydantic.AwareDatetime')
-IMPORT_NAIVE_DATETIME = Import.from_full_path('pydantic.NaiveDatetime')
+IMPORT_CONFIG_DICT = Import.from_full_path("pydantic.ConfigDict")
+IMPORT_AWARE_DATETIME = Import.from_full_path("pydantic.AwareDatetime")
+IMPORT_NAIVE_DATETIME = Import.from_full_path("pydantic.NaiveDatetime")

datamodel_code_generator/model/pydantic_v2/root_model.py

@@ -1,13 +1,13 @@
 from __future__ import annotations
 
-from typing import Any, ClassVar, Literal, Optional
+from typing import Any, ClassVar, Literal
 
 from datamodel_code_generator.model.pydantic_v2.base_model import BaseModel
 
 
 class RootModel(BaseModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'pydantic_v2/RootModel.jinja2'
-    BASE_CLASS: ClassVar[str] = 'pydantic.RootModel'
+    TEMPLATE_FILE_PATH: ClassVar[str] = "pydantic_v2/RootModel.jinja2"
+    BASE_CLASS: ClassVar[str] = "pydantic.RootModel"
 
     def __init__(
         self,
@@ -15,11 +15,11 @@ class RootModel(BaseModel):
     ) -> None:
         # Remove custom_base_class for Pydantic V2 models; behaviour is different from Pydantic V1 as it will not
         # be treated as a root model. custom_base_class cannot both implement BaseModel and RootModel!
-        if 'custom_base_class' in kwargs:
-            kwargs.pop('custom_base_class')
+        if "custom_base_class" in kwargs:
+            kwargs.pop("custom_base_class")
 
         super().__init__(**kwargs)
 
-    def _get_config_extra(self) -> Optional[Literal["'allow'", "'forbid'"]]:
+    def _get_config_extra(self) -> Literal["'allow'", "'forbid'"] | None:  # noqa: PLR6301
         # PydanticV2 RootModels cannot have extra fields
         return None

datamodel_code_generator/model/pydantic_v2/types.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import ClassVar, Dict, Optional, Sequence, Type
+from typing import ClassVar, Sequence
 
 from datamodel_code_generator.format import DatetimeClassType
 from datamodel_code_generator.model.pydantic import DataTypeManager as _DataTypeManager
@@ -13,15 +13,15 @@ from datamodel_code_generator.types import DataType, StrictTypes, Types
 
 
 class DataTypeManager(_DataTypeManager):
-    PATTERN_KEY: ClassVar[str] = 'pattern'
+    PATTERN_KEY: ClassVar[str] = "pattern"
 
     def type_map_factory(
         self,
-        data_type: Type[DataType],
+        data_type: type[DataType],
         strict_types: Sequence[StrictTypes],
         pattern_key: str,
-        target_datetime_class: Optional[DatetimeClassType] = None,
-    ) -> Dict[Types, DataType]:
+        target_datetime_class: DatetimeClassType | None = None,
+    ) -> dict[Types, DataType]:
         result = {
             **super().type_map_factory(
                 data_type,
@@ -34,8 +34,9 @@ class DataTypeManager(_DataTypeManager):
                 strict=StrictTypes.str in strict_types,
                 # https://github.com/horejsek/python-fastjsonschema/blob/61c6997a8348b8df9b22e029ca2ba35ef441fbb8/fastjsonschema/draft04.py#L31
                 kwargs={
-                    pattern_key: r"r'^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]{0,61}[A-Za-z0-9])$'",
-                    **({'strict': True} if StrictTypes.str in strict_types else {}),
+                    pattern_key: r"r'^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])\.)*"
+                    r"([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]{0,61}[A-Za-z0-9])$'",
+                    **({"strict": True} if StrictTypes.str in strict_types else {}),
                 },
             ),
         }

datamodel_code_generator/model/rootmodel.py

@@ -6,4 +6,4 @@ from datamodel_code_generator.model import DataModel
 
 
 class RootModel(DataModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'root.jinja2'
+    TEMPLATE_FILE_PATH: ClassVar[str] = "root.jinja2"

datamodel_code_generator/model/scalar.py

@@ -1,53 +1,56 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from pathlib import Path
-from typing import Any, ClassVar, DefaultDict, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, ClassVar, Tuple
 
 from datamodel_code_generator.imports import IMPORT_TYPE_ALIAS, Import
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model.base import UNDEFINED
-from datamodel_code_generator.reference import Reference
 
-_INT: str = 'int'
-_FLOAT: str = 'float'
-_BOOLEAN: str = 'bool'
-_STR: str = 'str'
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from datamodel_code_generator.reference import Reference
+
+_INT: str = "int"
+_FLOAT: str = "float"
+_BOOLEAN: str = "bool"
+_STR: str = "str"
 
 # default graphql scalar types
 DEFAULT_GRAPHQL_SCALAR_TYPE = _STR
 
-DEFAULT_GRAPHQL_SCALAR_TYPES: Dict[str, str] = {
-    'Boolean': _BOOLEAN,
-    'String': _STR,
-    'ID': _STR,
-    'Int': _INT,
-    'Float': _FLOAT,
+DEFAULT_GRAPHQL_SCALAR_TYPES: dict[str, str] = {
+    "Boolean": _BOOLEAN,
+    "String": _STR,
+    "ID": _STR,
+    "Int": _INT,
+    "Float": _FLOAT,
 }
 
 
 class DataTypeScalar(DataModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'Scalar.jinja2'
-    BASE_CLASS: ClassVar[str] = ''
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_TYPE_ALIAS,)
+    TEMPLATE_FILE_PATH: ClassVar[str] = "Scalar.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = (IMPORT_TYPE_ALIAS,)  # noqa: UP006
 
-    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:
         extra_template_data = extra_template_data or defaultdict(dict)
 
         scalar_name = reference.name
@@ -56,12 +59,10 @@ class DataTypeScalar(DataModel):
 
         # py_type
         py_type = extra_template_data[scalar_name].get(
-            'py_type',
-            DEFAULT_GRAPHQL_SCALAR_TYPES.get(
-                reference.name, DEFAULT_GRAPHQL_SCALAR_TYPE
-            ),
+            "py_type",
+            DEFAULT_GRAPHQL_SCALAR_TYPES.get(reference.name, DEFAULT_GRAPHQL_SCALAR_TYPE),
         )
-        extra_template_data[scalar_name]['py_type'] = py_type
+        extra_template_data[scalar_name]["py_type"] = py_type
 
         super().__init__(
             reference=reference,