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

datamodel_code_generator/model/msgspec.py

@@ -1,22 +1,11 @@
+from __future__ import annotations
+
 from functools import wraps
-from pathlib import Path
-from typing import (
-    Any,
-    ClassVar,
-    DefaultDict,
-    Dict,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-)
+from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar
 
 from pydantic import Field
 
-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,
@@ -38,7 +27,6 @@ from datamodel_code_generator.model.pydantic.base_model import (
 from datamodel_code_generator.model.rootmodel import RootModel as _RootModel
 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,
@@ -47,36 +35,40 @@ from datamodel_code_generator.types import (
     get_optional_type,
 )
 
+if TYPE_CHECKING:
+    from collections import defaultdict
+    from collections.abc import Sequence
+    from pathlib import Path
+
+    from datamodel_code_generator.reference import Reference
+
 
 def _has_field_assignment(field: DataModelFieldBase) -> bool:
-    return not (
-        field.required
-        or (field.represented_default == 'None' and field.strip_default_none)
-    )
+    return not (field.required or (field.represented_default == "None" and field.strip_default_none))
 
 
-DataModelFieldBaseT = TypeVar('DataModelFieldBaseT', bound=DataModelFieldBase)
+DataModelFieldBaseT = TypeVar("DataModelFieldBaseT", bound=DataModelFieldBase)
 
 
-def import_extender(cls: Type[DataModelFieldBaseT]) -> Type[DataModelFieldBaseT]:
-    original_imports: property = getattr(cls, 'imports', None)  # type: ignore
+def import_extender(cls: type[DataModelFieldBaseT]) -> type[DataModelFieldBaseT]:
+    original_imports: property = cls.imports
 
-    @wraps(original_imports.fget)  # type: ignore
-    def new_imports(self: DataModelFieldBaseT) -> Tuple[Import, ...]:
+    @wraps(original_imports.fget)  # pyright: ignore[reportArgumentType]
+    def new_imports(self: DataModelFieldBaseT) -> tuple[Import, ...]:
         extra_imports = []
         field = self.field
         # TODO: Improve field detection
-        if field and field.startswith('field('):
+        if field and field.startswith("field("):
             extra_imports.append(IMPORT_MSGSPEC_FIELD)
-        if self.field and 'lambda: convert' in self.field:
+        if self.field and "lambda: convert" in self.field:
             extra_imports.append(IMPORT_MSGSPEC_CONVERT)
         if self.annotated:
             extra_imports.append(IMPORT_MSGSPEC_META)
-        if self.extras.get('is_classvar'):
+        if self.extras.get("is_classvar"):
             extra_imports.append(IMPORT_CLASSVAR)
-        return chain_as_tuple(original_imports.fget(self), extra_imports)  # type: ignore
+        return chain_as_tuple(original_imports.fget(self), extra_imports)  # pyright: ignore[reportOptionalCall]
 
-    setattr(cls, 'imports', property(new_imports))
+    cls.imports = property(new_imports)  # pyright: ignore[reportAttributeAccessIssue]
     return cls
 
 
@@ -85,30 +77,30 @@ class RootModel(_RootModel):
 
 
 class Struct(DataModel):
-    TEMPLATE_FILE_PATH: ClassVar[str] = 'msgspec.jinja2'
-    BASE_CLASS: ClassVar[str] = 'msgspec.Struct'
-    DEFAULT_IMPORTS: ClassVar[Tuple[Import, ...]] = ()
+    TEMPLATE_FILE_PATH: ClassVar[str] = "msgspec.jinja2"
+    BASE_CLASS: ClassVar[str] = "msgspec.Struct"
+    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:
         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,
@@ -121,45 +113,45 @@ class Struct(DataModel):
             nullable=nullable,
             keyword_only=keyword_only,
         )
-        self.extra_template_data.setdefault('base_class_kwargs', {})
+        self.extra_template_data.setdefault("base_class_kwargs", {})
         if self.keyword_only:
-            self.add_base_class_kwarg('kw_only', 'True')
+            self.add_base_class_kwarg("kw_only", "True")
 
-    def add_base_class_kwarg(self, name: str, value):
-        self.extra_template_data['base_class_kwargs'][name] = value
+    def add_base_class_kwarg(self, name: str, value: str) -> None:
+        self.extra_template_data["base_class_kwargs"][name] = value
 
 
 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
 
 
 @import_extender
 class DataModelField(DataModelFieldBase):
-    _FIELD_KEYS: ClassVar[Set[str]] = {
-        'default',
-        'default_factory',
+    _FIELD_KEYS: ClassVar[set[str]] = {
+        "default",
+        "default_factory",
     }
-    _META_FIELD_KEYS: ClassVar[Set[str]] = {
-        'title',
-        'description',
-        'gt',
-        'ge',
-        'lt',
-        'le',
-        'multiple_of',
+    _META_FIELD_KEYS: ClassVar[set[str]] = {
+        "title",
+        "description",
+        "gt",
+        "ge",
+        "lt",
+        "le",
+        "multiple_of",
         # 'min_items', # not supported by msgspec
         # 'max_items', # not supported by msgspec
-        'min_length',
-        'max_length',
-        'pattern',
-        'examples',
+        "min_length",
+        "max_length",
+        "pattern",
+        "examples",
         # 'unique_items', # not supported by msgspec
     }
-    _PARSE_METHOD = 'convert'
-    _COMPARE_EXPRESSIONS: ClassVar[Set[str]] = {'gt', 'ge', 'lt', 'le', 'multiple_of'}
-    constraints: Optional[Constraints] = None
+    _PARSE_METHOD = "convert"
+    _COMPARE_EXPRESSIONS: ClassVar[set[str]] = {"gt", "ge", "lt", "le", "multiple_of"}
+    constraints: Optional[Constraints] = None  # noqa: UP045
 
     def self_reference(self) -> bool:  # pragma: no cover
         return isinstance(self.parent, Struct) and self.parent.reference.path in {
@@ -167,87 +159,72 @@ class DataModelField(DataModelFieldBase):
         }
 
     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']
-        if self.data_type.type == 'str' and isinstance(
-            const, str
-        ):  # pragma: no cover # Literal supports only str
+        const = self.extras["const"]
+        if self.data_type.type == "str" and isinstance(const, str):  # pragma: no cover # Literal supports only str
             self.data_type = self.data_type.__class__(literals=[const])
 
     def _get_strict_field_constraint_value(self, constraint: str, value: Any) -> Any:
         if value is None or constraint not in self._COMPARE_EXPRESSIONS:
             return value
 
-        if any(
-            data_type.type == 'float' for data_type in self.data_type.all_data_types
-        ):
+        if any(data_type.type == "float" for data_type in self.data_type.all_data_types):
             return float(value)
         return int(value)
 
     @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.alias:
-            data['name'] = self.alias
+            data["name"] = self.alias
 
         if self.default != UNDEFINED and self.default is not None:
-            data['default'] = self.default
+            data["default"] = self.default
         elif not self.required:
-            data['default'] = None
+            data["default"] = None
 
         if self.required:
             data = {
                 k: v
                 for k, v in data.items()
                 if k
-                not in (
-                    'default',
-                    'default_factory',
-                )
+                not in {
+                    "default",
+                    "default_factory",
+                }
             }
-        elif self.default and 'default_factory' not in data:
+        elif self.default and "default_factory" not in data:
             default_factory = self._get_default_as_struct_model()
             if default_factory is not None:
-                data.pop('default')
-                data['default_factory'] = default_factory
+                data.pop("default")
+                data["default_factory"] = default_factory
 
         if not data:
-            return ''
+            return ""
 
-        if len(data) == 1 and 'default' in data:
-            return repr(data['default'])
+        if len(data) == 1 and "default" in data:
+            return repr(data["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)})"
 
     @property
-    def annotated(self) -> Optional[str]:
+    def annotated(self) -> str | None:
         if not self.use_annotated:  # pragma: no cover
             return None
 
-        data: Dict[str, Any] = {
-            k: v for k, v in self.extras.items() if k in self._META_FIELD_KEYS
-        }
-        if (
-            self.constraints is not None
-            and not self.self_reference()
-            and not self.data_type.strict
-        ):
+        data: dict[str, Any] = {k: v for k, v in self.extras.items() if k in self._META_FIELD_KEYS}
+        if self.constraints is not None and not self.self_reference() and not self.data_type.strict:
             data = {
                 **data,
                 **{
@@ -257,59 +234,60 @@ class DataModelField(DataModelFieldBase):
                 },
             }
 
-        meta_arguments = sorted(
-            f'{k}={repr(v)}' for k, v in data.items() if v is not None
-        )
+        meta_arguments = sorted(f"{k}={v!r}" for k, v in data.items() if v is not None)
         if not meta_arguments:
             return None
 
-        meta = f'Meta({", ".join(meta_arguments)})'
+        meta = f"Meta({', '.join(meta_arguments)})"
 
-        if not self.required and not self.extras.get('is_classvar'):
+        if not self.required and not self.extras.get("is_classvar"):
             type_hint = self.data_type.type_hint
-            annotated_type = f'Annotated[{type_hint}, {meta}]'
+            annotated_type = f"Annotated[{type_hint}, {meta}]"
             return get_optional_type(annotated_type, self.data_type.use_union_operator)
 
-        annotated_type = f'Annotated[{self.type_hint}, {meta}]'
-        if self.extras.get('is_classvar'):
-            annotated_type = f'ClassVar[{annotated_type}]'
+        annotated_type = f"Annotated[{self.type_hint}, {meta}]"
+        if self.extras.get("is_classvar"):
+            annotated_type = f"ClassVar[{annotated_type}]"
 
         return annotated_type
 
-    def _get_default_as_struct_model(self) -> Optional[str]:
+    def _get_default_as_struct_model(self) -> str | None:
         for data_type in self.data_type.data_types or (self.data_type,):
             # TODO: Check nested data_types
             if data_type.is_dict or self.data_type.is_union:
                 # TODO: Parse Union and dict model for default
                 continue  # pragma: no cover
-            elif data_type.is_list and len(data_type.data_types) == 1:
-                data_type = data_type.data_types[0]
+            if data_type.is_list and len(data_type.data_types) == 1:
+                data_type_child = data_type.data_types[0]
                 if (  # pragma: no cover
-                    data_type.reference
-                    and (
-                        isinstance(data_type.reference.source, Struct)
-                        or isinstance(data_type.reference.source, RootModel)
-                    )
+                    data_type_child.reference
+                    and (isinstance(data_type_child.reference.source, (Struct, RootModel)))
                     and isinstance(self.default, list)
                 ):
-                    return f'lambda: {self._PARSE_METHOD}({repr(self.default)},  type=list[{data_type.alias or data_type.reference.source.class_name}])'
+                    return (
+                        f"lambda: {self._PARSE_METHOD}({self.default!r},  "
+                        f"type=list[{data_type_child.alias or data_type_child.reference.source.class_name}])"
+                    )
             elif data_type.reference and isinstance(data_type.reference.source, Struct):
-                return f'lambda: {self._PARSE_METHOD}({repr(self.default)},  type={data_type.alias or data_type.reference.source.class_name})'
+                return (
+                    f"lambda: {self._PARSE_METHOD}({self.default!r},  "
+                    f"type={data_type.alias or data_type.reference.source.class_name})"
+                )
         return None
 
 
 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,
@@ -332,7 +310,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/pydantic/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterable, Optional
+from typing import TYPE_CHECKING, Optional
 
 from pydantic import BaseModel as _BaseModel
 
@@ -9,39 +9,29 @@ from .custom_root_type import CustomRootType
 from .dataclass import DataClass
 from .types import DataTypeManager
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
 
 def dump_resolve_reference_action(class_names: Iterable[str]) -> str:
-    return '\n'.join(
-        f'{class_name}.update_forward_refs()' for class_name in class_names
-    )
+    return "\n".join(f"{class_name}.update_forward_refs()" for class_name in class_names)
 
 
 class Config(_BaseModel):
-    extra: Optional[str] = None
-    title: Optional[str] = None
-    allow_population_by_field_name: Optional[bool] = None
-    allow_extra_fields: Optional[bool] = None
-    allow_mutation: Optional[bool] = None
-    arbitrary_types_allowed: Optional[bool] = None
-    orm_mode: Optional[bool] = None
-
-
-# def get_validator_template() -> Template:
-#     template_file_path: Path = Path('pydantic') / 'one_of_validator.jinja2'
-#     loader = FileSystemLoader(str(TEMPLATE_DIR / template_file_path.parent))
-#     environment: Environment = Environment(loader=loader, autoescape=True)
-#     return environment.get_template(template_file_path.name)
-#
-#
-# VALIDATOR_TEMPLATE: Template = get_validator_template()
+    extra: Optional[str] = None  # noqa: UP045
+    title: Optional[str] = None  # noqa: UP045
+    allow_population_by_field_name: Optional[bool] = None  # noqa: UP045
+    allow_extra_fields: Optional[bool] = None  # noqa: UP045
+    allow_mutation: Optional[bool] = None  # noqa: UP045
+    arbitrary_types_allowed: Optional[bool] = None  # noqa: UP045
+    orm_mode: Optional[bool] = None  # noqa: UP045
 
 
 __all__ = [
-    'BaseModel',
-    'DataModelField',
-    'CustomRootType',
-    'DataClass',
-    'dump_resolve_reference_action',
-    'DataTypeManager',
-    # 'VALIDATOR_TEMPLATE',
+    "BaseModel",
+    "CustomRootType",
+    "DataClass",
+    "DataModelField",
+    "DataTypeManager",
+    "dump_resolve_reference_action",
 ]