datamodel-code-generator 0.11.12__py3-none-any.whl → 0.45.0__py3-none-any.whl

datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -0,0 +1,268 @@
+"""Pydantic v2 BaseModel implementation.
+
+Provides Constraints, DataModelField, and BaseModel for Pydantic v2
+with support for Field() constraints and ConfigDict.
+"""
+
+from __future__ import annotations
+
+import re
+from enum import Enum
+from typing import TYPE_CHECKING, Any, ClassVar, NamedTuple, Optional
+
+from pydantic import Field
+from typing_extensions import Literal
+
+from datamodel_code_generator.model.base import UNDEFINED, DataModelFieldBase
+from datamodel_code_generator.model.pydantic.base_model import (
+    BaseModelBase,
+)
+from datamodel_code_generator.model.pydantic.base_model import (
+    Constraints as _Constraints,
+)
+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.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):
+    """Union discriminator mode for Pydantic v2."""
+
+    smart = "smart"
+    left_to_right = "left_to_right"
+
+
+class Constraints(_Constraints):
+    """Pydantic v2 field constraints with pattern support."""
+
+    # To override existing pattern alias
+    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]:  # noqa: N805
+        """Validate and convert minItems/maxItems to minLength/maxLength."""
+        if not isinstance(values, dict):  # pragma: no cover
+            return values
+        min_items = values.pop("minItems", None)
+        if min_items is not None:
+            values["minLength"] = min_items
+        max_items = values.pop("maxItems", None)
+        if max_items is not None:
+            values["maxLength"] = max_items
+        return values
+
+
+class DataModelField(DataModelFieldV1):
+    """Pydantic v2 field with Field() constraints and json_schema_extra support."""
+
+    _EXCLUDE_FIELD_KEYS: ClassVar[set[str]] = {
+        "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",
+    }
+    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]:  # noqa: N805
+        """Validate and convert example to examples list."""
+        if not isinstance(values, dict):  # pragma: no cover
+            return values
+        if "examples" in values:
+            return values
+
+        if "example" in values:
+            values["examples"] = [values.pop("example")]
+        return values
+
+    def process_const(self) -> None:
+        """Process const field constraint using literal type."""
+        self._process_const_as_literal()
+
+    def _process_data_in_str(self, data: dict[str, Any]) -> None:
+        if self.const:
+            # const is removed in pydantic 2.0
+            data.pop("const")
+
+        # unique_items is not supported in pydantic 2.0
+        data.pop("unique_items", None)
+
+        if self.use_frozen_field and self.read_only:
+            data["frozen"] = True
+
+        if "union_mode" in data:
+            if self.data_type.is_union:
+                data["union_mode"] = data.pop("union_mode").value
+            else:
+                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}
+        if json_schema_extra:
+            data["json_schema_extra"] = json_schema_extra
+            for key in json_schema_extra:
+                data.pop(key)
+
+    def _process_annotated_field_arguments(  # noqa: PLR6301
+        self,
+        field_arguments: list[str],
+    ) -> list[str]:
+        return field_arguments
+
+
+class ConfigAttribute(NamedTuple):
+    """Configuration attribute mapping for ConfigDict conversion."""
+
+    from_: str
+    to: str
+    invert: bool
+
+
+class BaseModel(BaseModelBase):
+    """Pydantic v2 BaseModel with ConfigDict and pattern-based regex_engine support."""
+
+    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),  # 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
+        ConfigAttribute("use_attribute_docstrings", "use_attribute_docstrings", False),  # noqa: FBT003
+    ]
+
+    def __init__(  # noqa: PLR0913
+        self,
+        *,
+        reference: Reference,
+        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,
+        treat_dot_as_module: bool = False,
+    ) -> None:
+        """Initialize BaseModel with ConfigDict generation from template data."""
+        super().__init__(
+            reference=reference,
+            fields=fields,
+            decorators=decorators,
+            base_classes=base_classes,
+            custom_base_class=custom_base_class,
+            custom_template_dir=custom_template_dir,
+            extra_template_data=extra_template_data,
+            path=path,
+            description=description,
+            default=default,
+            nullable=nullable,
+            keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
+        )
+        config_parameters: dict[str, Any] = {}
+
+        extra = self._get_config_extra()
+        if 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_]
+                )
+        for data_type in self.all_data_types:
+            if data_type.is_custom_type:  # pragma: no cover
+                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"'
+                break
+
+        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  # noqa: PLC0415
+
+            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) -> Literal["'allow'", "'forbid'", "'ignore'"] | None:
+        additional_properties = self.extra_template_data.get("additionalProperties")
+        allow_extra_fields = self.extra_template_data.get("allow_extra_fields")
+        extra_fields = self.extra_template_data.get("extra_fields")
+
+        config_extra = None
+        if allow_extra_fields or extra_fields == "allow":
+            config_extra = "'allow'"
+        elif extra_fields == "forbid":
+            config_extra = "'forbid'"
+        elif extra_fields == "ignore":
+            config_extra = "'ignore'"
+        elif additional_properties is True:
+            config_extra = "'allow'"
+        elif additional_properties is False:
+            config_extra = "'forbid'"
+        return config_extra

datamodel_code_generator/model/pydantic_v2/imports.py

@@ -0,0 +1,15 @@
+"""Import definitions for Pydantic v2 types.
+
+Provides pre-defined Import objects for Pydantic v2 types (ConfigDict, AwareDatetime, etc.).
+"""
+
+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_BASE64STR = Import.from_full_path("pydantic.Base64Str")
+# IMPORT_BASE64STR: Used for OpenAPI strings with format "byte" (base64 encoded characters).
+IMPORT_SERIALIZE_AS_ANY = Import.from_full_path("pydantic.SerializeAsAny")

datamodel_code_generator/model/pydantic_v2/root_model.py

@@ -0,0 +1,35 @@
+"""Pydantic v2 RootModel implementation.
+
+Generates models inheriting from pydantic.RootModel for wrapping single types.
+"""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar, Literal
+
+from datamodel_code_generator.model.pydantic_v2.base_model import BaseModel
+
+
+class RootModel(BaseModel):
+    """DataModel for Pydantic v2 RootModel."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "pydantic_v2/RootModel.jinja2"
+    BASE_CLASS: ClassVar[str] = "pydantic.RootModel"
+
+    def __init__(
+        self,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize RootModel and remove custom_base_class if present.
+
+        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")
+
+        super().__init__(**kwargs)
+
+    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

@@ -0,0 +1,143 @@
+"""Pydantic v2 type manager.
+
+Maps schema types to Pydantic v2 specific types with AwareDatetime, NaiveDatetime, etc.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+
+from datamodel_code_generator.format import DatetimeClassType
+from datamodel_code_generator.model.pydantic import DataTypeManager as _DataTypeManager
+from datamodel_code_generator.model.pydantic.imports import IMPORT_CONSTR
+from datamodel_code_generator.model.pydantic_v2.imports import (
+    IMPORT_AWARE_DATETIME,
+    IMPORT_BASE64STR,
+    IMPORT_NAIVE_DATETIME,
+    IMPORT_SERIALIZE_AS_ANY,
+)
+from datamodel_code_generator.types import (
+    DataType,
+    PythonVersion,
+    PythonVersionMin,
+    StrictTypes,
+    Types,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
+
+    from datamodel_code_generator.imports import Import
+
+
+class PydanticV2DataType(DataType):
+    """Pydantic v2-specific DataType with SerializeAsAny support."""
+
+    def _should_wrap_with_serialize_as_any(self) -> bool:
+        if not self.use_serialize_as_any:
+            return False
+
+        assert self.reference is not None
+
+        from datamodel_code_generator.model.base import DataModel  # noqa: PLC0415
+
+        return any(isinstance(child, DataModel) and child.fields for child in self.reference.children)
+
+    def _get_wrapped_reference_type_hint(self, type_: str) -> str:
+        if self._should_wrap_with_serialize_as_any():
+            return f"SerializeAsAny[{type_}]"
+
+        return type_
+
+    @property
+    def imports(self) -> Iterator[Import]:
+        """Yield imports including SerializeAsAny when needed."""
+        yield from super().imports
+
+        if "SerializeAsAny" in self.type_hint:
+            yield IMPORT_SERIALIZE_AS_ANY
+
+
+class DataTypeManager(_DataTypeManager):
+    """Type manager for Pydantic v2 with pattern key support."""
+
+    PATTERN_KEY: ClassVar[str] = "pattern"
+
+    def __init__(  # noqa: PLR0913, PLR0917
+        self,
+        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_decimal_for_multiple_of: bool = False,  # noqa: FBT001, FBT002
+        use_union_operator: bool = False,  # noqa: FBT001, FBT002
+        use_pendulum: bool = False,  # noqa: FBT001, FBT002
+        target_datetime_class: DatetimeClassType | None = None,
+        treat_dot_as_module: bool = False,  # noqa: FBT001, FBT002
+        use_serialize_as_any: bool = False,  # noqa: FBT001, FBT002
+    ) -> None:
+        """Initialize with pydantic v2-specific DataType."""
+        super().__init__(
+            python_version=python_version,
+            use_standard_collections=use_standard_collections,
+            use_generic_container_types=use_generic_container_types,
+            strict_types=strict_types,
+            use_non_positive_negative_number_constrained_types=use_non_positive_negative_number_constrained_types,
+            use_decimal_for_multiple_of=use_decimal_for_multiple_of,
+            use_union_operator=use_union_operator,
+            use_pendulum=use_pendulum,
+            target_datetime_class=target_datetime_class,
+            treat_dot_as_module=treat_dot_as_module,
+            use_serialize_as_any=use_serialize_as_any,
+        )
+
+        # Override the data_type with our pydantic v2 version
+        from pydantic import create_model  # noqa: PLC0415
+
+        self.data_type: type[DataType] = create_model(
+            "PydanticV2ContextDataType",
+            python_version=(PythonVersion, python_version),
+            use_standard_collections=(bool, use_standard_collections),
+            use_generic_container=(bool, use_generic_container_types),
+            use_union_operator=(bool, use_union_operator),
+            treat_dot_as_module=(bool, treat_dot_as_module),
+            use_serialize_as_any=(bool, use_serialize_as_any),
+            __base__=PydanticV2DataType,
+        )
+
+    def type_map_factory(
+        self,
+        data_type: type[DataType],
+        strict_types: Sequence[StrictTypes],
+        pattern_key: str,
+        target_datetime_class: DatetimeClassType | None = None,
+    ) -> dict[Types, DataType]:
+        """Create type mapping with Pydantic v2 specific types and datetime classes."""
+        result = {
+            **super().type_map_factory(
+                data_type,
+                strict_types,
+                pattern_key,
+                target_datetime_class or DatetimeClassType.Datetime,
+            ),
+            Types.hostname: self.data_type.from_import(
+                IMPORT_CONSTR,
+                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])\.)*"
+                    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 {}),
+                },
+            ),
+            Types.byte: self.data_type.from_import(
+                IMPORT_BASE64STR,
+                strict=StrictTypes.str in strict_types,
+            ),
+        }
+        if target_datetime_class == DatetimeClassType.Awaredatetime:
+            result[Types.date_time] = data_type.from_import(IMPORT_AWARE_DATETIME)
+        elif target_datetime_class == DatetimeClassType.Naivedatetime:
+            result[Types.date_time] = data_type.from_import(IMPORT_NAIVE_DATETIME)
+        return result

datamodel_code_generator/model/scalar.py

@@ -0,0 +1,124 @@
+"""Scalar type model generator.
+
+Generates type aliases for GraphQL scalar types.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from datamodel_code_generator.imports import (
+    IMPORT_TYPE_ALIAS,
+    IMPORT_TYPE_ALIAS_BACKPORT,
+    IMPORT_TYPE_ALIAS_TYPE,
+    Import,
+)
+from datamodel_code_generator.model import DataModel, DataModelFieldBase
+from datamodel_code_generator.model.base import UNDEFINED
+
+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,
+}
+
+
+class _DataTypeScalarBase(DataModel):
+    """Base class for GraphQL scalar types with shared __init__ logic."""
+
+    def __init__(  # noqa: PLR0913
+        self,
+        *,
+        reference: Reference,
+        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,
+        treat_dot_as_module: bool = False,
+    ) -> None:
+        """Initialize GraphQL scalar type with Python type mapping."""
+        extra_template_data = extra_template_data or defaultdict(dict)
+
+        scalar_name = reference.name
+        if scalar_name not in extra_template_data:
+            extra_template_data[scalar_name] = defaultdict(dict)
+
+        # py_type
+        py_type = extra_template_data[scalar_name].get(
+            "py_type",
+            DEFAULT_GRAPHQL_SCALAR_TYPES.get(reference.name, DEFAULT_GRAPHQL_SCALAR_TYPE),
+        )
+        extra_template_data[scalar_name]["py_type"] = py_type
+
+        super().__init__(
+            reference=reference,
+            fields=fields,
+            decorators=decorators,
+            base_classes=base_classes,
+            custom_base_class=custom_base_class,
+            custom_template_dir=custom_template_dir,
+            extra_template_data=extra_template_data,
+            methods=methods,
+            path=path,
+            description=description,
+            default=default,
+            nullable=nullable,
+            keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
+        )
+
+
+class DataTypeScalar(_DataTypeScalarBase):
+    """GraphQL scalar using TypeAlias annotation for Python 3.10+ (Name: TypeAlias = type)."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "ScalarTypeAliasAnnotation.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_TYPE_ALIAS,)
+
+
+class DataTypeScalarBackport(_DataTypeScalarBase):
+    """GraphQL scalar using TypeAlias annotation for Python 3.9 (Name: TypeAlias = type)."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "ScalarTypeAliasAnnotation.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_TYPE_ALIAS_BACKPORT,)
+
+
+class DataTypeScalarTypeBackport(_DataTypeScalarBase):
+    """GraphQL scalar using TypeAliasType for Python 3.9-3.11 (Name = TypeAliasType("Name", type))."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "ScalarTypeAliasType.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_TYPE_ALIAS_TYPE,)
+
+
+class DataTypeScalarTypeStatement(_DataTypeScalarBase):
+    """GraphQL scalar using type statement for Python 3.12+ (type Name = type)."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "ScalarTypeStatement.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = ()

datamodel_code_generator/model/template/Enum.jinja2

@@ -1,12 +1,25 @@
 {% for decorator in decorators -%}
 {{ decorator }}
 {% endfor -%}
-class {{ class_name }}(Enum):
+class {{ class_name }}({{ base_class }}):
 {%- if description %}
     """
-    {{ description }}
+    {{ description | indent(4) }}
     """
 {%- endif %}
 {%- for field in fields %}
     {{ field.name }} = {{ field.default }}
+    {%- if field.docstring %}
+    """
+    {{ field.docstring | indent(4) }}
+    """
+{%- if field.use_inline_field_description and not loop.last %}
+
+{% endif %}
+    {%- elif field.inline_field_docstring %}
+    {{ field.inline_field_docstring }}
+{%- if not loop.last %}
+
+{% endif %}
+    {%- endif %}
 {%- endfor -%}

datamodel_code_generator/model/template/ScalarTypeAliasAnnotation.jinja2

@@ -0,0 +1,6 @@
+{{ class_name }}: TypeAlias = {{ py_type }}
+{%- if description %}
+"""
+{{ description }}
+"""
+{%- endif %}

datamodel_code_generator/model/template/ScalarTypeAliasType.jinja2

@@ -0,0 +1,6 @@
+{{ class_name }} = TypeAliasType("{{ class_name }}", {{ py_type }})
+{%- if description %}
+"""
+{{ description }}
+"""
+{%- endif %}

datamodel_code_generator/model/template/ScalarTypeStatement.jinja2

@@ -0,0 +1,6 @@
+type {{ class_name }} = {{ py_type }}
+{%- if description %}
+"""
+{{ description }}
+"""
+{%- endif %}

datamodel_code_generator/model/template/TypeAliasAnnotation.jinja2

@@ -0,0 +1,20 @@
+{%- macro get_type_annotation(_field) -%}
+{%- if _field.annotated -%}
+{{ _field.annotated }}
+{%- elif _field.field -%}
+Annotated[{{ _field.type_hint }}, {{ _field.field }}]
+{%- else -%}
+{{ _field.type_hint }}
+{%- endif -%}
+{%- endmacro -%}
+
+{{ class_name }}: TypeAlias = {{ get_type_annotation(fields[0]) }}{% if comment is defined %}  # {{ comment }}{% endif %}
+{%- if description %}
+"""
+{{ description | indent(0) }}
+"""
+{%- elif fields and fields[0].docstring %}
+"""
+{{ fields[0].docstring | indent(0) }}
+"""
+{%- endif %}

datamodel_code_generator/model/template/TypeAliasType.jinja2

@@ -0,0 +1,20 @@
+{%- macro get_type_annotation(_field) -%}
+{%- if _field.annotated -%}
+{{ _field.annotated }}
+{%- elif _field.field -%}
+Annotated[{{ _field.type_hint }}, {{ _field.field }}]
+{%- else -%}
+{{ _field.type_hint }}
+{%- endif -%}
+{%- endmacro -%}
+
+{{ class_name }} = TypeAliasType("{{ class_name }}", {{ get_type_annotation(fields[0]) }}){% if comment is defined %}  # {{ comment }}{% endif %}
+{%- if description %}
+"""
+{{ description | indent(0) }}
+"""
+{%- elif fields and fields[0].docstring %}
+"""
+{{ fields[0].docstring | indent(0) }}
+"""
+{%- endif %}