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

datamodel_code_generator/model/template/TypeStatement.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 -%}
+
+type {{ 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 %}

datamodel_code_generator/model/template/TypedDict.jinja2

@@ -0,0 +1,5 @@
+{%- if is_functional_syntax %}
+{% include 'TypedDictFunction.jinja2' %}
+{%- else %}
+{% include 'TypedDictClass.jinja2' %}
+{%- endif %}

datamodel_code_generator/model/template/TypedDictClass.jinja2

@@ -0,0 +1,25 @@
+class {{ class_name }}({{ base_class }}):
+{%- if description %}
+    """
+    {{ description | indent(4) }}
+    """
+{%- endif %}
+{%- if not fields and not description %}
+    pass
+{%- endif %}
+{%- for field in fields %}
+    {{ field.name }}: {{ field.type_hint }}
+    {%- 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/TypedDictFunction.jinja2

@@ -0,0 +1,24 @@
+{%- if description %}
+"""
+{{ description | indent(4) }}
+"""
+{%- endif %}
+{{ class_name }} = TypedDict('{{ class_name }}', {
+{%- for field in all_fields %}
+    '{{ field.key }}': {{ field.type_hint }},
+    {%- 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/UnionTypeAliasAnnotation.jinja2

@@ -0,0 +1,10 @@
+{%- if description %}
+# {{ description | replace('\n', '\n# ') }}
+{%- endif %}
+{%- if fields|length > 1 %}
+{{ class_name }}: TypeAlias = Union[
+{%- for field in fields %}
+        '{{ field.name }}',
+{%- endfor %}
+    ]{% else %}
+{{ class_name }}: TypeAlias = {{ fields[0].name }}{% endif %}

datamodel_code_generator/model/template/UnionTypeAliasType.jinja2

@@ -0,0 +1,10 @@
+{%- if description %}
+# {{ description | replace('\n', '\n# ') }}
+{%- endif %}
+{%- if fields|length > 1 %}
+{{ class_name }} = TypeAliasType("{{ class_name }}", Union[
+{%- for field in fields %}
+    '{{ field.name }}',
+{%- endfor %}
+]){% else %}
+{{ class_name }} = TypeAliasType("{{ class_name }}", {{ fields[0].name }}){% endif %}

datamodel_code_generator/model/template/UnionTypeStatement.jinja2

@@ -0,0 +1,10 @@
+{%- if description %}
+# {{ description | replace('\n', '\n# ') }}
+{%- endif %}
+{%- if fields|length > 1 %}
+type {{ class_name }} = Union[
+{%- for field in fields %}
+    '{{ field.name }}',
+{%- endfor %}
+]{% else %}
+type {{ class_name }} = {{ fields[0].name }}{% endif %}

datamodel_code_generator/model/template/dataclass.jinja2

@@ -0,0 +1,50 @@
+{% for decorator in decorators -%}
+{{ decorator }}
+{% endfor -%}
+{%- set args = [] %}
+{%- for k, v in (dataclass_arguments or {}).items() %}
+    {%- if v is not none and v is not false %}
+        {%- set _ = args.append(k ~ '=' ~ (v|pprint)) %}
+    {%- endif %}
+{%- endfor %}
+{%- if args %}
+@dataclass({{ args | join(', ') }})
+{%- else %}
+@dataclass
+{%- endif %}
+{%- if base_class %}
+class {{ class_name }}({{ base_class }}):
+{%- else %}
+class {{ class_name }}:
+{%- endif %}
+{%- if description %}
+    """
+    {{ description | indent(4) }}
+    """
+{%- endif %}
+{%- if not fields and not description %}
+    pass
+{%- endif %}
+{%- for field in fields -%}
+    {%- if field.field %}
+    {{ field.name }}: {{ field.type_hint }} = {{ field.field }}
+    {%- else %}
+    {{ field.name }}: {{ field.type_hint }}
+    {%- if not (field.required or (field.represented_default == 'None' and field.strip_default_none))
+            %} = {{ field.represented_default }}
+    {%- endif -%}
+    {%- endif %}
+    {%- 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/msgspec.jinja2

@@ -0,0 +1,55 @@
+{% for decorator in decorators -%}
+{{ decorator }}
+{% endfor -%}
+{%- if base_class %}
+class {{ class_name }}({{ base_class }}{%- for key, value in (base_class_kwargs|default({})).items() -%}
+, {{ key }}={{ value }}
+{%- endfor -%}):
+{%- else %}
+class {{ class_name }}:
+{%- endif %}
+{%- if description %}
+    """
+    {{ description | indent(4) }}
+    """
+{%- endif %}
+{%- set ns = namespace(has_rendered_field=false) -%}
+{%- for field in fields -%}
+    {%- if field.extras.get('is_classvar') %}
+    {#- Skip fields with is_classvar=True - they are managed by msgspec tag_field -#}
+    {%- elif not field.annotated and field.field %}
+    {%- set ns.has_rendered_field = true %}
+    {{ field.name }}: {{ field.type_hint }} = {{ field.field }}
+    {%- else %}
+    {%- set ns.has_rendered_field = true %}
+    {%- if field.annotated and not field.field %}
+    {{ field.name }}: {{ field.annotated }}
+    {%- elif field.annotated and field.field %}
+    {{ field.name }}: {{ field.annotated }} = {{ field.field }}
+    {%- else %}
+    {{ field.name }}: {{ field.type_hint }}
+    {%- endif %}
+    {%- if not field.field and (not field.required or field.data_type.is_optional or field.nullable)
+            %} = {{ field.represented_default }}
+    {%- endif -%}
+    {%- endif %}
+
+
+
+    {%- if not field.extras.get('is_classvar') and field.docstring %}
+    """
+    {{ field.docstring | indent(4) }}
+    """
+{%- if field.use_inline_field_description and not loop.last %}
+
+{% endif %}
+    {%- elif not field.extras.get('is_classvar') and field.inline_field_docstring %}
+    {{ field.inline_field_docstring }}
+{%- if not loop.last %}
+
+{% endif %}
+    {%- endif %}
+{%- endfor -%}
+{%- if not ns.has_rendered_field and not description %}
+    pass
+{%- endif -%}

datamodel_code_generator/model/template/pydantic/BaseModel.jinja2

@@ -1,13 +1,13 @@
 {% for decorator in decorators -%}
 {{ decorator }}
 {% endfor -%}
-class {{ class_name }}({{ base_class }}):
+class {{ class_name }}({{ base_class }}):{% if comment is defined %}  # {{ comment }}{% endif %}
 {%- if description %}
     """
-    {{ description }}
+    {{ description | indent(4) }}
     """
 {%- endif %}
-{%- if not fields %}
+{%- if not fields and not description %}
     pass
 {%- endif %}
 {%- if config %}
@@ -24,10 +24,23 @@ class {{ class_name }}({{ base_class }}):
     {%- else %}
     {{ field.name }}: {{ field.type_hint }}
     {%- endif %}
-    {%- if not (field.required or (field.represented_default == 'None' and field.strip_default_none))
+    {%- if not field.has_default_factory_in_field and not (field.required or (field.represented_default == 'None' and field.strip_default_none))
             %} = {{ field.represented_default }}
     {%- endif -%}
     {%- endif %}
+    {%- 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 %}
 {%- for method in methods -%}
     {{ method }}
 {%- endfor -%}

datamodel_code_generator/model/template/pydantic/BaseModel_root.jinja2

@@ -1,10 +1,10 @@
 {% for decorator in decorators -%}
 {{ decorator }}
 {% endfor -%}
-class {{ class_name }}({{ base_class }}):
+class {{ class_name }}({{ base_class }}):{% if comment is defined %}  # {{ comment }}{% endif %}
 {%- if description %}
     """
-    {{ description }}
+    {{ description | indent(4) }}
     """
 {%- endif %}
 {%- if config %}
@@ -12,7 +12,7 @@ class {{ class_name }}({{ base_class }}):
 {% include 'Config.jinja2' %}
 {%- endfilter %}
 {%- endif %}
-{%- if not fields %}
+{%- if not fields and not description %}
     pass
 {%- else %}
     {%- set field = fields[0] %}
@@ -24,8 +24,16 @@ class {{ class_name }}({{ base_class }}):
     {%- else %}
     __root__: {{ field.type_hint }}
     {%- endif %}
-    {%- if not (field.required or (field.represented_default == 'None' and field.strip_default_none))
+    {%- if not field.has_default_factory_in_field and not (field.required or (field.represented_default == 'None' and field.strip_default_none))
             %} = {{ field.represented_default }}
     {%- endif -%}
     {%- endif %}
+    {%- if field.docstring %}
+    """
+    {{ field.docstring | indent(4) }}
+    """
+    {%- elif field.inline_field_docstring %}
+    {{ field.inline_field_docstring }}
+
+    {%- endif %}
 {%- endif %}

datamodel_code_generator/model/template/pydantic/Config.jinja2

@@ -1,4 +1,4 @@
 class Config:
 {%- for field_name, value in config.dict(exclude_unset=True).items() %}
     {{ field_name }} = {{ value }}
-{%- endfor %}
+{%- endfor %}

datamodel_code_generator/model/template/pydantic/dataclass.jinja2

@@ -9,7 +9,7 @@ class {{ class_name }}:
 {%- endif %}
 {%- if description %}
     """
-    {{ description }}
+    {{ description | indent(4) }}
     """
 {%- endif %}
 {%- if not fields %}
@@ -21,4 +21,17 @@ class {{ class_name }}:
     {%- else %}
     {{ field.name }}: {{ field.type_hint }}
     {%- endif %}
-{%- endfor -%}
+    {%- 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/pydantic_v2/BaseModel.jinja2

@@ -0,0 +1,57 @@
+{% if base_class != "BaseModel" and "," not in base_class and not fields and not config and not description -%}
+
+{# if this is just going to be `class Foo(Bar): pass`, then might as well just make Foo
+an alias for Bar: every pydantic model class consumes considerable memory. #}
+{{ class_name }} = {{ base_class }}
+
+{% else -%}
+
+{% for decorator in decorators -%}
+{{ decorator }}
+{% endfor -%}
+class {{ class_name }}({{ base_class }}):{% if comment is defined %}  # {{ comment }}{% endif %}
+{%- if description %}
+    """
+    {{ description | indent(4) }}
+    """
+{%- endif %}
+{%- if not fields and not description %}
+    pass
+{%- endif %}
+{%- if config %}
+{%- filter indent(4) %}
+{% include 'ConfigDict.jinja2' %}
+{%- endfilter %}
+{%- endif %}
+{%- for field in fields %}
+    {%- if not field.annotated and field.field %}
+    {{ field.name }}: {{ field.type_hint }} = {{ field.field }}
+    {%- else %}
+    {%- if field.annotated %}
+    {{ field.name }}: {{ field.annotated }}
+    {%- else %}
+    {{ field.name }}: {{ field.type_hint }}
+    {%- endif %}
+    {%- if not field.has_default_factory_in_field and (not (field.required or (field.represented_default == 'None' and field.strip_default_none)) or field.data_type.is_optional)
+            %} = {{ field.represented_default }}
+    {%- endif -%}
+    {%- endif %}
+    {%- 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 %}
+{%- for method in methods -%}
+    {{ method }}
+{%- endfor -%}
+{%- endfor -%}
+
+{%- endif %}

datamodel_code_generator/model/template/pydantic_v2/ConfigDict.jinja2

@@ -0,0 +1,5 @@
+model_config = ConfigDict(
+{%- for field_name, value in config.dict(exclude_unset=True).items() %}
+    {{ field_name }}={{ value }},
+{%- endfor %}
+)

datamodel_code_generator/model/template/pydantic_v2/RootModel.jinja2

@@ -0,0 +1,48 @@
+{%- macro get_type_hint(_fields) -%}
+{%- if _fields -%}
+{#There will only ever be a single field for RootModel#}
+{{- _fields[0].type_hint}}
+{%- endif -%}
+{%- endmacro -%}
+
+
+{% for decorator in decorators -%}
+{{ decorator }}
+{% endfor -%}
+
+class {{ class_name }}({{ base_class }}{%- if fields -%}[{{get_type_hint(fields)}}]{%- endif -%}):{% if comment is defined %}  # {{ comment }}{% endif %}
+{%- if description %}
+    """
+    {{ description | indent(4) }}
+    """
+{%- endif %}
+{%- if config %}
+{%- filter indent(4) %}
+{% include 'ConfigDict.jinja2' %}
+{%- endfilter %}
+{%- endif %}
+{%- if not fields and not description %}
+    pass
+{%- else %}
+    {%- set field = fields[0] %}
+    {%- if not field.annotated and field.field %}
+    root: {{ field.type_hint }} = {{ field.field }}
+    {%- else %}
+    {%- if field.annotated %}
+    root: {{ field.annotated }}
+    {%- else %}
+    root: {{ field.type_hint }}
+    {%- endif %}
+    {%- if not field.has_default_factory_in_field and not (field.required or (field.represented_default == 'None' and field.strip_default_none))
+            %} = {{ field.represented_default }}
+    {%- endif -%}
+    {%- endif %}
+    {%- if field.docstring %}
+    """
+    {{ field.docstring | indent(4) }}
+    """
+    {%- elif field.inline_field_docstring %}
+    {{ field.inline_field_docstring }}
+
+    {%- endif %}
+{%- endif %}

datamodel_code_generator/model/type_alias.py

@@ -0,0 +1,70 @@
+"""Type alias model generators.
+
+Provides classes for generating type aliases using different Python syntax:
+TypeAlias annotation, TypeAliasType, and type statement (Python 3.12+).
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from datamodel_code_generator.imports import (
+    IMPORT_ANNOTATED,
+    IMPORT_TYPE_ALIAS,
+    IMPORT_TYPE_ALIAS_BACKPORT,
+    IMPORT_TYPE_ALIAS_TYPE,
+    Import,
+)
+from datamodel_code_generator.model import DataModel
+from datamodel_code_generator.types import chain_as_tuple
+
+
+class TypeAliasBase(DataModel):
+    """Base class for all type alias implementations."""
+
+    IS_ALIAS: bool = True
+
+    @property
+    def imports(self) -> tuple[Import, ...]:
+        """Get imports including Annotated if needed."""
+        imports = super().imports
+        if self.fields and (self.fields[0].annotated or self.fields[0].field):
+            imports = chain_as_tuple(imports, (IMPORT_ANNOTATED,))
+
+        return imports
+
+
+class TypeAlias(TypeAliasBase):
+    """TypeAlias annotation for Python 3.10+ (Name: TypeAlias = type)."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "TypeAliasAnnotation.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_TYPE_ALIAS,)
+
+
+class TypeAliasBackport(TypeAliasBase):
+    """TypeAlias annotation for Python 3.9 (Name: TypeAlias = type) using typing_extensions."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "TypeAliasAnnotation.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_TYPE_ALIAS_BACKPORT,)
+
+
+class TypeAliasTypeBackport(TypeAliasBase):
+    """TypeAliasType for Python 3.9-3.11 (Name = TypeAliasType("Name", type))."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "TypeAliasType.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_TYPE_ALIAS_TYPE,)
+
+
+class TypeStatement(TypeAliasBase):
+    """Type statement for Python 3.12+ (type Name = type).
+
+    Note: Python 3.12+ type statements use deferred evaluation,
+    so forward references don't need to be quoted.
+    """
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "TypeStatement.jinja2"
+    BASE_CLASS: ClassVar[str] = ""
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = ()

datamodel_code_generator/model/typed_dict.py

@@ -0,0 +1,161 @@
+"""TypedDict model generator.
+
+Generates Python TypedDict classes for use with type checkers.
+"""
+
+from __future__ import annotations
+
+import keyword
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from datamodel_code_generator.model import DataModel, DataModelFieldBase
+from datamodel_code_generator.model.base import UNDEFINED
+from datamodel_code_generator.model.imports import (
+    IMPORT_NOT_REQUIRED,
+    IMPORT_NOT_REQUIRED_BACKPORT,
+    IMPORT_TYPED_DICT,
+)
+from datamodel_code_generator.types import NOT_REQUIRED_PREFIX
+
+if TYPE_CHECKING:
+    from collections import defaultdict
+    from collections.abc import Iterator
+    from pathlib import Path
+
+    from datamodel_code_generator.imports import Import
+    from datamodel_code_generator.reference import Reference
+
+
+escape_characters = str.maketrans({
+    "\\": r"\\",
+    "'": r"\'",
+    "\b": r"\b",
+    "\f": r"\f",
+    "\n": r"\n",
+    "\r": r"\r",
+    "\t": r"\t",
+})
+
+
+def _is_valid_field_name(field: DataModelFieldBase) -> bool:
+    name = field.original_name or field.name
+    if name is None:  # pragma: no cover
+        return False
+    return name.isidentifier() and not keyword.iskeyword(name)
+
+
+class TypedDict(DataModel):
+    """DataModel implementation for Python TypedDict."""
+
+    TEMPLATE_FILE_PATH: ClassVar[str] = "TypedDict.jinja2"
+    BASE_CLASS: ClassVar[str] = "typing.TypedDict"
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_TYPED_DICT,)
+
+    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 TypedDict model."""
+        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,
+        )
+
+    @property
+    def is_functional_syntax(self) -> bool:
+        """Check if TypedDict requires functional syntax."""
+        return any(not _is_valid_field_name(f) for f in self.fields)
+
+    @property
+    def all_fields(self) -> Iterator[DataModelFieldBase]:
+        """Iterate over all fields including inherited ones."""
+        yield from self.iter_all_fields()
+
+    def render(self, *, class_name: str | None = None) -> str:
+        """Render TypedDict class with appropriate syntax."""
+        return self._render(
+            class_name=class_name or self.class_name,
+            fields=self.fields,
+            decorators=self.decorators,
+            base_class=self.base_class,
+            methods=self.methods,
+            description=self.description,
+            is_functional_syntax=self.is_functional_syntax,
+            all_fields=self.all_fields,
+            **self.extra_template_data,
+        )
+
+
+class DataModelField(DataModelFieldBase):
+    """Field implementation for TypedDict models."""
+
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_NOT_REQUIRED,)
+
+    def process_const(self) -> None:
+        """Process const field constraint using literal type."""
+        self._process_const_as_literal()
+
+    @property
+    def key(self) -> str:
+        """Get escaped field key for TypedDict."""
+        return (self.original_name or self.name or "").translate(  # pragma: no cover
+            escape_characters
+        )
+
+    @property
+    def type_hint(self) -> str:
+        """Get type hint with NotRequired wrapper if needed."""
+        type_hint = super().type_hint
+        if self._not_required:
+            return f"{NOT_REQUIRED_PREFIX}{type_hint}]"
+        return type_hint
+
+    @property
+    def _not_required(self) -> bool:
+        """Check if field should be marked as NotRequired."""
+        return not self.required and isinstance(self.parent, TypedDict)
+
+    @property
+    def fall_back_to_nullable(self) -> bool:
+        """Check if field should fall back to nullable."""
+        return not self._not_required
+
+    @property
+    def imports(self) -> tuple[Import, ...]:
+        """Get imports including NotRequired if needed."""
+        return (
+            *super().imports,
+            *(self.DEFAULT_IMPORTS if self._not_required else ()),
+        )
+
+
+class DataModelFieldBackport(DataModelField):
+    """Field implementation for TypedDict models using typing_extensions."""
+
+    DEFAULT_IMPORTS: ClassVar[tuple[Import, ...]] = (IMPORT_NOT_REQUIRED_BACKPORT,)