datamodel-code-generator 0.28.3__py3-none-any.whl → 0.28.5__py3-none-any.whl

datamodel_code_generator/__init__.py

@@ -22,7 +22,13 @@ from urllib.parse import ParseResult
 import yaml
 
 import datamodel_code_generator.pydantic_patch  # noqa: F401
-from datamodel_code_generator.format import DatetimeClassType, PythonVersion, PythonVersionMin
+from datamodel_code_generator.format import (
+    DEFAULT_FORMATTERS,
+    DatetimeClassType,
+    Formatter,
+    PythonVersion,
+    PythonVersionMin,
+)
 from datamodel_code_generator.parser import DefaultPutDict, LiteralType
 from datamodel_code_generator.util import SafeLoader
 
@@ -274,12 +280,13 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     custom_formatters_kwargs: dict[str, Any] | None = None,
     use_pendulum: bool = False,
     http_query_parameters: Sequence[tuple[str, str]] | None = None,
-    treat_dots_as_module: bool = False,
+    treat_dot_as_module: bool = False,
     use_exact_imports: bool = False,
     union_mode: UnionMode | None = None,
     output_datetime_class: DatetimeClassType | None = None,
     keyword_only: bool = False,
     no_alias: bool = False,
+    formatters: list[Formatter] = DEFAULT_FORMATTERS,
 ) -> None:
     remote_text_cache: DefaultPutDict[str, str] = DefaultPutDict()
     if isinstance(input_, str):
@@ -468,12 +475,13 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
         custom_formatters_kwargs=custom_formatters_kwargs,
         use_pendulum=use_pendulum,
         http_query_parameters=http_query_parameters,
-        treat_dots_as_module=treat_dots_as_module,
+        treat_dot_as_module=treat_dot_as_module,
         use_exact_imports=use_exact_imports,
         default_field_extras=default_field_extras,
         target_datetime_class=output_datetime_class,
         keyword_only=keyword_only,
         no_alias=no_alias,
+        formatters=formatters,
         **kwargs,
     )
 

datamodel_code_generator/__main__.py

@@ -36,7 +36,9 @@ from datamodel_code_generator import (
 )
 from datamodel_code_generator.arguments import DEFAULT_ENCODING, arg_parser, namespace
 from datamodel_code_generator.format import (
+    DEFAULT_FORMATTERS,
     DatetimeClassType,
+    Formatter,
     PythonVersion,
     PythonVersionMin,
     is_supported_in_black,
@@ -311,6 +313,7 @@ class Config(BaseModel):
     output_datetime_class: Optional[DatetimeClassType] = None  # noqa: UP045
     keyword_only: bool = False
     no_alias: bool = False
+    formatters: list[Formatter] = DEFAULT_FORMATTERS
 
     def merge_args(self, args: Namespace) -> None:
         set_args = {f: getattr(args, f) for f in self.get_fields() if getattr(args, f) is not None}
@@ -513,12 +516,13 @@ def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912,
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=config.use_pendulum,
             http_query_parameters=config.http_query_parameters,
-            treat_dots_as_module=config.treat_dot_as_module,
+            treat_dot_as_module=config.treat_dot_as_module,
             use_exact_imports=config.use_exact_imports,
             union_mode=config.union_mode,
             output_datetime_class=config.output_datetime_class,
             keyword_only=config.keyword_only,
             no_alias=config.no_alias,
+            formatters=config.formatters,
         )
     except InvalidClassNameError as e:
         print(f"{e} You have to set `--class-name` option", file=sys.stderr)  # noqa: T201

datamodel_code_generator/arguments.py

@@ -6,7 +6,7 @@ from operator import attrgetter
 from typing import TYPE_CHECKING
 
 from datamodel_code_generator import DataModelType, InputFileType, OpenAPIScope
-from datamodel_code_generator.format import DatetimeClassType, PythonVersion
+from datamodel_code_generator.format import DatetimeClassType, Formatter, PythonVersion
 from datamodel_code_generator.model.pydantic_v2 import UnionMode
 from datamodel_code_generator.parser import LiteralType
 from datamodel_code_generator.types import StrictTypes
@@ -440,6 +440,13 @@ base_options.add_argument(
     type=str,
     default=None,
 )
+base_options.add_argument(
+    "--formatters",
+    help="Formatters for output (default: [black, isort])",
+    choices=[f.value for f in Formatter],
+    nargs="+",
+    default=None,
+)
 base_options.add_argument(
     "--custom-formatters",
     help="List of modules with custom formatter (delimited list input).",

datamodel_code_generator/format.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import subprocess  # noqa: S404
 from enum import Enum
 from functools import cached_property
 from importlib import import_module
@@ -89,6 +90,16 @@ def black_find_project_root(sources: Sequence[Path]) -> Path:
     return project_root
 
 
+class Formatter(Enum):
+    BLACK = "black"
+    ISORT = "isort"
+    RUFF_CHECK = "ruff-check"
+    RUFF_FORMAT = "ruff-format"
+
+
+DEFAULT_FORMATTERS = [Formatter.BLACK, Formatter.ISORT]
+
+
 class CodeFormatter:
     def __init__(  # noqa: PLR0912, PLR0913, PLR0917
         self,
@@ -99,6 +110,8 @@ class CodeFormatter:
         known_third_party: list[str] | None = None,
         custom_formatters: list[str] | None = None,
         custom_formatters_kwargs: dict[str, Any] | None = None,
+        encoding: str = "utf-8",
+        formatters: list[Formatter] = DEFAULT_FORMATTERS,
     ) -> None:
         if not settings_path:
             settings_path = Path.cwd()
@@ -158,6 +171,8 @@ class CodeFormatter:
 
         self.custom_formatters_kwargs = custom_formatters_kwargs or {}
         self.custom_formatters = self._check_custom_formatters(custom_formatters)
+        self.encoding = encoding
+        self.formatters = formatters
 
     def _load_custom_formatter(self, custom_formatter_import: str) -> CustomCodeFormatter:
         import_ = import_module(custom_formatter_import)
@@ -184,8 +199,16 @@ class CodeFormatter:
         self,
         code: str,
     ) -> str:
-        code = self.apply_isort(code)
-        code = self.apply_black(code)
+        if Formatter.ISORT in self.formatters:
+            code = self.apply_isort(code)
+        if Formatter.BLACK in self.formatters:
+            code = self.apply_black(code)
+
+        if Formatter.RUFF_CHECK in self.formatters:
+            code = self.apply_ruff_lint(code)
+
+        if Formatter.RUFF_FORMAT in self.formatters:
+            code = self.apply_ruff_formatter(code)
 
         for formatter in self.custom_formatters:
             code = formatter.apply(code)
@@ -198,6 +221,24 @@ class CodeFormatter:
             mode=self.black_mode,
         )
 
+    def apply_ruff_lint(self, code: str) -> str:
+        result = subprocess.run(  # noqa: S603
+            ("ruff", "check", "--fix", "-"),
+            input=code.encode(self.encoding),
+            capture_output=True,
+            check=False,
+        )
+        return result.stdout.decode(self.encoding)
+
+    def apply_ruff_formatter(self, code: str) -> str:
+        result = subprocess.run(  # noqa: S603
+            ("ruff", "format", "-"),
+            input=code.encode(self.encoding),
+            capture_output=True,
+            check=False,
+        )
+        return result.stdout.decode(self.encoding)
+
     if TYPE_CHECKING:
 
         def apply_isort(self, code: str) -> str: ...

datamodel_code_generator/model/base.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from copy import deepcopy
@@ -203,18 +204,27 @@ def get_template(template_file_path: Path) -> Template:
     return environment.get_template(template_file_path.name)
 
 
-def get_module_path(name: str, file_path: Path | None) -> list[str]:
+def sanitize_module_name(name: str, *, treat_dot_as_module: bool) -> str:
+    pattern = r"[^0-9a-zA-Z_.]" if treat_dot_as_module else r"[^0-9a-zA-Z_]"
+    sanitized = re.sub(pattern, "_", name)
+    if sanitized and sanitized[0].isdigit():
+        sanitized = f"_{sanitized}"
+    return sanitized
+
+
+def get_module_path(name: str, file_path: Path | None, *, treat_dot_as_module: bool) -> list[str]:
     if file_path:
+        sanitized_stem = sanitize_module_name(file_path.stem, treat_dot_as_module=treat_dot_as_module)
         return [
             *file_path.parts[:-1],
-            file_path.stem,
+            sanitized_stem,
             *name.split(".")[:-1],
         ]
     return name.split(".")[:-1]
 
 
-def get_module_name(name: str, file_path: Path | None) -> str:
-    return ".".join(get_module_path(name, file_path))
+def get_module_name(name: str, file_path: Path | None, *, treat_dot_as_module: bool) -> str:
+    return ".".join(get_module_path(name, file_path, treat_dot_as_module=treat_dot_as_module))
 
 
 class TemplateBase(ABC):
@@ -265,6 +275,7 @@ class DataModel(TemplateBase, Nullable, ABC):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         self.keyword_only = keyword_only
         if not self.TEMPLATE_FILE_PATH:
@@ -313,6 +324,7 @@ class DataModel(TemplateBase, Nullable, ABC):
         self._additional_imports.extend(self.DEFAULT_IMPORTS)
         self.default: Any = default
         self._nullable: bool = nullable
+        self._treat_dot_as_module: bool = treat_dot_as_module
 
     def _validate_fields(self, fields: list[DataModelFieldBase]) -> list[DataModelFieldBase]:
         names: set[str] = set()
@@ -393,11 +405,11 @@ class DataModel(TemplateBase, Nullable, ABC):
 
     @property
     def module_path(self) -> list[str]:
-        return get_module_path(self.name, self.file_path)
+        return get_module_path(self.name, self.file_path, treat_dot_as_module=self._treat_dot_as_module)
 
     @property
     def module_name(self) -> str:
-        return get_module_name(self.name, self.file_path)
+        return get_module_name(self.name, self.file_path, treat_dot_as_module=self._treat_dot_as_module)
 
     @property
     def all_data_types(self) -> Iterator[DataType]:

datamodel_code_generator/model/dataclass.py

@@ -53,6 +53,7 @@ class DataClass(DataModel):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -68,6 +69,7 @@ class DataClass(DataModel):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
         )
 
 
@@ -144,6 +146,7 @@ class DataTypeManager(_DataTypeManager):
         use_union_operator: bool = False,  # noqa: FBT001, FBT002
         use_pendulum: bool = False,  # noqa: FBT001, FBT002
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        treat_dot_as_module: bool = False,  # noqa: FBT001, FBT002
     ) -> None:
         super().__init__(
             python_version,
@@ -154,6 +157,7 @@ class DataTypeManager(_DataTypeManager):
             use_union_operator,
             use_pendulum,
             target_datetime_class,
+            treat_dot_as_module,
         )
 
         datetime_map = (

datamodel_code_generator/model/enum.py

@@ -52,6 +52,7 @@ class Enum(DataModel):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -67,6 +68,7 @@ class Enum(DataModel):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
         )
 
         if not base_classes and type_:
@@ -91,7 +93,7 @@ class Enum(DataModel):
 
         for field in self.fields:
             # Remove surrounding quotes from field default value
-            field_default = (field.default or "").strip("'\"")
+            field_default = str(field.default or "").strip("'\"")
 
             # Compare values after removing quotes
             if field_default == str_value:

datamodel_code_generator/model/msgspec.py

@@ -97,6 +97,7 @@ class Struct(DataModel):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -112,6 +113,7 @@ class Struct(DataModel):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
         )
         self.extra_template_data.setdefault("base_class_kwargs", {})
         if self.keyword_only:
@@ -287,6 +289,7 @@ class DataTypeManager(_DataTypeManager):
         use_union_operator: bool = False,  # noqa: FBT001, FBT002
         use_pendulum: bool = False,  # noqa: FBT001, FBT002
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        treat_dot_as_module: bool = False,  # noqa: FBT001, FBT002
     ) -> None:
         super().__init__(
             python_version,
@@ -297,6 +300,7 @@ class DataTypeManager(_DataTypeManager):
             use_union_operator,
             use_pendulum,
             target_datetime_class,
+            treat_dot_as_module,
         )
 
         datetime_map = (

datamodel_code_generator/model/pydantic/base_model.py

@@ -213,6 +213,7 @@ class BaseModelBase(DataModel, ABC):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         methods: list[str] = [field.method for field in fields if field.method]
 
@@ -230,6 +231,7 @@ class BaseModelBase(DataModel, ABC):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
         )
 
     @cached_property
@@ -263,6 +265,7 @@ class BaseModel(BaseModelBase):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -277,6 +280,7 @@ class BaseModel(BaseModelBase):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
         )
         config_parameters: dict[str, Any] = {}
 

datamodel_code_generator/model/pydantic/types.py

@@ -166,6 +166,7 @@ class DataTypeManager(_DataTypeManager):
         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
     ) -> None:
         super().__init__(
             python_version,
@@ -176,6 +177,7 @@ class DataTypeManager(_DataTypeManager):
             use_union_operator,
             use_pendulum,
             target_datetime_class,
+            treat_dot_as_module,
         )
 
         self.type_map: dict[Types, DataType] = self.type_map_factory(

datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -179,6 +179,7 @@ class BaseModel(BaseModelBase):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -193,6 +194,7 @@ class BaseModel(BaseModelBase):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
         )
         config_parameters: dict[str, Any] = {}
 

datamodel_code_generator/model/scalar.py

@@ -50,6 +50,7 @@ class DataTypeScalar(DataModel):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         extra_template_data = extra_template_data or defaultdict(dict)
 
@@ -78,4 +79,5 @@ class DataTypeScalar(DataModel):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
         )

datamodel_code_generator/model/typed_dict.py

@@ -60,6 +60,7 @@ class TypedDict(DataModel):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -75,6 +76,7 @@ class TypedDict(DataModel):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
         )
 
     @property

datamodel_code_generator/model/types.py

@@ -68,6 +68,7 @@ class DataTypeManager(_DataTypeManager):
         use_union_operator: bool = False,  # noqa: FBT001, FBT002
         use_pendulum: bool = False,  # noqa: FBT001, FBT002
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
+        treat_dot_as_module: bool = False,  # noqa: FBT001, FBT002
     ) -> None:
         super().__init__(
             python_version,
@@ -78,6 +79,7 @@ class DataTypeManager(_DataTypeManager):
             use_union_operator,
             use_pendulum,
             target_datetime_class,
+            treat_dot_as_module,
         )
 
         self.type_map: dict[Types, DataType] = type_map_factory(self.data_type)

datamodel_code_generator/model/union.py

@@ -37,6 +37,7 @@ class DataTypeUnion(DataModel):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        treat_dot_as_module: bool = False,
     ) -> None:
         super().__init__(
             reference=reference,
@@ -52,4 +53,5 @@ class DataTypeUnion(DataModel):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            treat_dot_as_module=treat_dot_as_module,
         )

datamodel_code_generator/parser/base.py

@@ -7,12 +7,19 @@ from abc import ABC, abstractmethod
 from collections import OrderedDict, defaultdict
 from itertools import groupby
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, NamedTuple, Optional, Protocol, TypeVar, runtime_checkable
+from typing import TYPE_CHECKING, Any, Callable, NamedTuple, Optional, Protocol, TypeVar, cast, runtime_checkable
 from urllib.parse import ParseResult
 
 from pydantic import BaseModel
 
-from datamodel_code_generator.format import CodeFormatter, DatetimeClassType, PythonVersion, PythonVersionMin
+from datamodel_code_generator.format import (
+    DEFAULT_FORMATTERS,
+    CodeFormatter,
+    DatetimeClassType,
+    Formatter,
+    PythonVersion,
+    PythonVersionMin,
+)
 from datamodel_code_generator.imports import (
     IMPORT_ANNOTATIONS,
     IMPORT_LITERAL,
@@ -363,12 +370,13 @@ class Parser(ABC):
         custom_formatters_kwargs: dict[str, Any] | None = None,
         use_pendulum: bool = False,
         http_query_parameters: Sequence[tuple[str, str]] | None = None,
-        treat_dots_as_module: bool = False,
+        treat_dot_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType | None = DatetimeClassType.Datetime,
         keyword_only: bool = False,
         no_alias: bool = False,
+        formatters: list[Formatter] = DEFAULT_FORMATTERS,
     ) -> None:
         self.keyword_only = keyword_only
         self.data_type_manager: DataTypeManager = data_type_manager_type(
@@ -379,6 +387,7 @@ class Parser(ABC):
             use_union_operator=use_union_operator,
             use_pendulum=use_pendulum,
             target_datetime_class=target_datetime_class,
+            treat_dot_as_module=treat_dot_as_module,
         )
         self.data_model_type: type[DataModel] = data_model_type
         self.data_model_root_type: type[DataModel] = data_model_root_type
@@ -474,8 +483,9 @@ class Parser(ABC):
         self.known_third_party = known_third_party
         self.custom_formatter = custom_formatters
         self.custom_formatters_kwargs = custom_formatters_kwargs
-        self.treat_dots_as_module = treat_dots_as_module
+        self.treat_dot_as_module = treat_dot_as_module
         self.default_field_extras: dict[str, Any] | None = default_field_extras
+        self.formatters: list[Formatter] = formatters
 
     @property
     def iter_source(self) -> Iterator[Source]:
@@ -657,7 +667,7 @@ class Parser(ABC):
                     if (
                         len(model.module_path) > 1
                         and model.module_path[-1].count(".") > 0
-                        and not self.treat_dots_as_module
+                        and not self.treat_dot_as_module
                     ):
                         rel_path_depth = model.module_path[-1].count(".")
                         from_ = from_[rel_path_depth:]
@@ -718,6 +728,8 @@ class Parser(ABC):
                 property_name = discriminator.get("propertyName")
                 if not property_name:  # pragma: no cover
                     continue
+                field_name, alias = self.model_resolver.get_valid_field_name_and_alias(field_name=property_name)
+                discriminator["propertyName"] = field_name
                 mapping = discriminator.get("mapping", {})
                 for data_type in field.data_type.data_types:
                     if not data_type.reference:  # pragma: no cover
@@ -769,13 +781,13 @@ class Parser(ABC):
                         raise RuntimeError(msg)
                     has_one_literal = False
                     for discriminator_field in discriminator_model.fields:
-                        if (discriminator_field.original_name or discriminator_field.name) != property_name:
+                        if field_name not in {discriminator_field.original_name, discriminator_field.name}:
                             continue
                         literals = discriminator_field.data_type.literals
                         if len(literals) == 1 and literals[0] == (type_names[0] if type_names else None):
                             has_one_literal = True
                             if isinstance(discriminator_model, msgspec_model.Struct):  # pragma: no cover
-                                discriminator_model.add_base_class_kwarg("tag_field", f"'{property_name}'")
+                                discriminator_model.add_base_class_kwarg("tag_field", f"'{field_name}'")
                                 discriminator_model.add_base_class_kwarg("tag", discriminator_field.represented_default)
                                 discriminator_field.extras["is_classvar"] = True
                             # Found the discriminator field, no need to keep looking
@@ -791,9 +803,10 @@ class Parser(ABC):
                     if not has_one_literal:
                         discriminator_model.fields.append(
                             self.data_model_field_type(
-                                name=property_name,
+                                name=field_name,
                                 data_type=self.data_type(literals=type_names),
                                 required=True,
+                                alias=alias,
                             )
                         )
                     has_imported_literal = any(import_ == IMPORT_LITERAL for import_ in imports)
@@ -1093,6 +1106,24 @@ class Parser(ABC):
                 models[i], models[i + 1] = models[i + 1], model
                 changed = True
 
+    def __change_field_name(
+        self,
+        models: list[DataModel],
+    ) -> None:
+        if self.data_model_type != pydantic_model_v2.BaseModel:
+            return
+        for model in models:
+            for field in model.fields:
+                filed_name = field.name
+                filed_name_resolver = ModelResolver(snake_case_field=self.snake_case_field, remove_suffix_number=True)
+                for data_type in field.data_type.all_data_types:
+                    if data_type.reference:
+                        filed_name_resolver.exclude_names.add(data_type.reference.short_name)
+                new_filed_name = filed_name_resolver.add(["field"], cast("str", filed_name)).name
+                if filed_name != new_filed_name:
+                    field.alias = filed_name
+                    field.name = new_filed_name
+
     def __set_one_literal_on_default(self, models: list[DataModel]) -> None:
         if not self.use_one_literal_as_default:
             return
@@ -1173,6 +1204,8 @@ class Parser(ABC):
                 known_third_party=self.known_third_party,
                 custom_formatters=self.custom_formatter,
                 custom_formatters_kwargs=self.custom_formatters_kwargs,
+                encoding=self.encoding,
+                formatters=self.formatters,
             )
         else:
             code_formatter = None
@@ -1254,6 +1287,7 @@ class Parser(ABC):
             self.__collapse_root_models(models, unused_models, imports, scoped_model_resolver)
             self.__set_default_enum_member(models)
             self.__sort_models(models, imports)
+            self.__change_field_name(models)
             self.__apply_discriminator_type(models, imports)
             self.__set_one_literal_on_default(models)
 
@@ -1317,7 +1351,7 @@ class Parser(ABC):
         results = {tuple(i.replace("-", "_") for i in k): v for k, v in results.items()}
         return (
             self.__postprocess_result_modules(results)
-            if self.treat_dots_as_module
+            if self.treat_dot_as_module
             else {
                 tuple((part[: part.rfind(".")].replace(".", "_") + part[part.rfind(".") :]) for part in k): v
                 for k, v in results.items()

datamodel_code_generator/parser/graphql.py

@@ -36,7 +36,7 @@ except ImportError as exc:  # pragma: no cover
     raise Exception(msg) from exc  # noqa: TRY002
 
 
-from datamodel_code_generator.format import DatetimeClassType
+from datamodel_code_generator.format import DEFAULT_FORMATTERS, DatetimeClassType, Formatter
 
 if TYPE_CHECKING:
     from collections import defaultdict
@@ -147,12 +147,13 @@ class GraphQLParser(Parser):
         custom_formatters_kwargs: dict[str, Any] | None = None,
         use_pendulum: bool = False,
         http_query_parameters: Sequence[tuple[str, str]] | None = None,
-        treat_dots_as_module: bool = False,
+        treat_dot_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
         no_alias: bool = False,
+        formatters: list[Formatter] = DEFAULT_FORMATTERS,
     ) -> None:
         super().__init__(
             source=source,
@@ -220,12 +221,13 @@ class GraphQLParser(Parser):
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=use_pendulum,
             http_query_parameters=http_query_parameters,
-            treat_dots_as_module=treat_dots_as_module,
+            treat_dot_as_module=treat_dot_as_module,
             use_exact_imports=use_exact_imports,
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
             no_alias=no_alias,
+            formatters=formatters,
         )
 
         self.data_model_scalar_type = data_model_scalar_type
@@ -451,6 +453,7 @@ class GraphQLParser(Parser):
             path=self.current_source_path,
             description=obj.description,
             keyword_only=self.keyword_only,
+            treat_dot_as_module=self.treat_dot_as_module,
         )
         self.results.append(data_model_type)
 

datamodel_code_generator/parser/jsonschema.py

@@ -19,7 +19,7 @@ from datamodel_code_generator import (
     load_yaml_from_path,
     snooper_to_methods,
 )
-from datamodel_code_generator.format import PythonVersion, PythonVersionMin
+from datamodel_code_generator.format import DEFAULT_FORMATTERS, Formatter, PythonVersion, PythonVersionMin
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model import pydantic as pydantic_model
 from datamodel_code_generator.model.base import UNDEFINED, get_module_name
@@ -416,12 +416,13 @@ class JsonSchemaParser(Parser):
         custom_formatters_kwargs: dict[str, Any] | None = None,
         use_pendulum: bool = False,
         http_query_parameters: Sequence[tuple[str, str]] | None = None,
-        treat_dots_as_module: bool = False,
+        treat_dot_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
         no_alias: bool = False,
+        formatters: list[Formatter] = DEFAULT_FORMATTERS,
     ) -> None:
         super().__init__(
             source=source,
@@ -489,12 +490,13 @@ class JsonSchemaParser(Parser):
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=use_pendulum,
             http_query_parameters=http_query_parameters,
-            treat_dots_as_module=treat_dots_as_module,
+            treat_dot_as_module=treat_dot_as_module,
             use_exact_imports=use_exact_imports,
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
             no_alias=no_alias,
+            formatters=formatters,
         )
 
         self.remote_object_cache: DefaultPutDict[str, dict[str, Any]] = DefaultPutDict()
@@ -693,7 +695,11 @@ class JsonSchemaParser(Parser):
         required: list[str],
     ) -> DataType:
         if obj.properties:
-            fields.extend(self.parse_object_fields(obj, path, get_module_name(name, None)))
+            fields.extend(
+                self.parse_object_fields(
+                    obj, path, get_module_name(name, None, treat_dot_as_module=self.treat_dot_as_module)
+                )
+            )
         # ignore an undetected object
         if ignore_duplicate_model and not fields and len(base_classes) == 1:
             with self.model_resolver.current_base_path_context(self.model_resolver._base_path):  # noqa: SLF001
@@ -735,6 +741,7 @@ class JsonSchemaParser(Parser):
             path=self.current_source_path,
             description=obj.description if self.use_schema_description else None,
             keyword_only=self.keyword_only,
+            treat_dot_as_module=self.treat_dot_as_module,
         )
         self.results.append(data_model_type)
 
@@ -754,7 +761,7 @@ class JsonSchemaParser(Parser):
             if all_of_item.ref:  # $ref
                 base_classes.append(self.model_resolver.add_ref(all_of_item.ref))
             else:
-                module_name = get_module_name(name, None)
+                module_name = get_module_name(name, None, treat_dot_as_module=self.treat_dot_as_module)
                 object_fields = self.parse_object_fields(
                     all_of_item,
                     path,
@@ -847,6 +854,7 @@ class JsonSchemaParser(Parser):
             path=self.current_source_path,
             description=obj.description if self.use_schema_description else None,
             nullable=obj.type_has_null,
+            treat_dot_as_module=self.treat_dot_as_module,
         )
         self.results.append(data_model_root)
         return self.data_type(reference=reference)
@@ -933,7 +941,9 @@ class JsonSchemaParser(Parser):
         )
         class_name = reference.name
         self.set_title(class_name, obj)
-        fields = self.parse_object_fields(obj, path, get_module_name(class_name, None))
+        fields = self.parse_object_fields(
+            obj, path, get_module_name(class_name, None, treat_dot_as_module=self.treat_dot_as_module)
+        )
         if fields or not isinstance(obj.additionalProperties, JsonSchemaObject):
             data_model_type_class = self.data_model_type
         else:
@@ -970,6 +980,7 @@ class JsonSchemaParser(Parser):
             description=obj.description if self.use_schema_description else None,
             nullable=obj.type_has_null,
             keyword_only=self.keyword_only,
+            treat_dot_as_module=self.treat_dot_as_module,
         )
         self.results.append(data_model_type)
         return self.data_type(reference=reference)
@@ -1183,6 +1194,7 @@ class JsonSchemaParser(Parser):
             path=self.current_source_path,
             description=obj.description if self.use_schema_description else None,
             nullable=obj.type_has_null,
+            treat_dot_as_module=self.treat_dot_as_module,
         )
         self.results.append(data_model_root)
         return self.data_type(reference=reference)
@@ -1262,6 +1274,8 @@ class JsonSchemaParser(Parser):
             extra_template_data=self.extra_template_data,
             path=self.current_source_path,
             nullable=obj.type_has_null,
+            treat_dot_as_module=self.treat_dot_as_module,
+            default=obj.default if obj.has_default else UNDEFINED,
         )
         self.results.append(data_model_root_type)
         return self.data_type(reference=reference)
@@ -1384,6 +1398,7 @@ class JsonSchemaParser(Parser):
             path=self.current_source_path,
             default=obj.default if obj.has_default else UNDEFINED,
             nullable=obj.type_has_null,
+            treat_dot_as_module=self.treat_dot_as_module,
         )
         self.results.append(data_model_root_type)
         return self.data_type(reference=reference)

datamodel_code_generator/parser/openapi.py

@@ -18,7 +18,7 @@ from datamodel_code_generator import (
     load_yaml,
     snooper_to_methods,
 )
-from datamodel_code_generator.format import DatetimeClassType
+from datamodel_code_generator.format import DEFAULT_FORMATTERS, DatetimeClassType, Formatter
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model import pydantic as pydantic_model
 from datamodel_code_generator.parser import DefaultPutDict  # noqa: TC001 # needed for type check
@@ -209,12 +209,13 @@ class OpenAPIParser(JsonSchemaParser):
         custom_formatters_kwargs: dict[str, Any] | None = None,
         use_pendulum: bool = False,
         http_query_parameters: Sequence[tuple[str, str]] | None = None,
-        treat_dots_as_module: bool = False,
+        treat_dot_as_module: bool = False,
         use_exact_imports: bool = False,
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
         no_alias: bool = False,
+        formatters: list[Formatter] = DEFAULT_FORMATTERS,
     ) -> None:
         super().__init__(
             source=source,
@@ -282,12 +283,13 @@ class OpenAPIParser(JsonSchemaParser):
             custom_formatters_kwargs=custom_formatters_kwargs,
             use_pendulum=use_pendulum,
             http_query_parameters=http_query_parameters,
-            treat_dots_as_module=treat_dots_as_module,
+            treat_dot_as_module=treat_dot_as_module,
             use_exact_imports=use_exact_imports,
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
             no_alias=no_alias,
+            formatters=formatters,
         )
         self.open_api_scopes: list[OpenAPIScope] = openapi_scopes or [OpenAPIScope.Schemas]
 
@@ -486,6 +488,7 @@ class OpenAPIParser(JsonSchemaParser):
                     custom_base_class=self.base_class,
                     custom_template_dir=self.custom_template_dir,
                     keyword_only=self.keyword_only,
+                    treat_dot_as_module=self.treat_dot_as_module,
                 )
             )
 

datamodel_code_generator/reference.py

@@ -317,6 +317,7 @@ class ModelResolver:  # noqa: PLR0904
         remove_special_field_name_prefix: bool = False,  # noqa: FBT001, FBT002
         capitalise_enum_members: bool = False,  # noqa: FBT001, FBT002
         no_alias: bool = False,  # noqa: FBT001, FBT002
+        remove_suffix_number: bool = False,  # noqa: FBT001, FBT002
     ) -> None:
         self.references: dict[str, Reference] = {}
         self._current_root: Sequence[str] = []
@@ -349,6 +350,7 @@ class ModelResolver:  # noqa: PLR0904
         self.class_name_generator = custom_class_name_generator or self.default_class_name_generator
         self._base_path: Path = base_path or Path.cwd()
         self._current_base_path: Path | None = self._base_path
+        self.remove_suffix_number: bool = remove_suffix_number
 
     @property
     def current_base_path(self) -> Path | None:
@@ -615,7 +617,7 @@ class ModelResolver:  # noqa: PLR0904
 
     def _get_unique_name(self, name: str, camel: bool = False) -> str:  # noqa: FBT001, FBT002
         unique_name: str = name
-        count: int = 1
+        count: int = 0 if self.remove_suffix_number else 1
         reference_names = {r.name for r in self.references.values()} | self.exclude_names
         while unique_name in reference_names:
             if self.duplicate_name_suffix:
@@ -627,7 +629,7 @@ class ModelResolver:  # noqa: PLR0904
             else:
                 name_parts = [name, count]
             delimiter = "" if camel else "_"
-            unique_name = delimiter.join(str(p) for p in name_parts if p)
+            unique_name = delimiter.join(str(p) for p in name_parts if p) if count else name
             count += 1
         return unique_name
 

datamodel_code_generator/types.py

@@ -167,26 +167,67 @@ def _remove_none_from_type(type_: str, split_pattern: Pattern[str], delimiter: s
     return types
 
 
-def _remove_none_from_union(type_: str, use_union_operator: bool) -> str:  # noqa: FBT001
+def _remove_none_from_union(type_: str, *, use_union_operator: bool) -> str:  # noqa: PLR0911, PLR0912
     if use_union_operator:
-        if not re.match(r"^\w+ | ", type_):
+        if " | " not in type_:
             return type_
-        return UNION_OPERATOR_DELIMITER.join(
-            _remove_none_from_type(type_, UNION_OPERATOR_PATTERN, UNION_OPERATOR_DELIMITER)
-        )
 
+        # Process each part of the union
+        parts = UNION_OPERATOR_PATTERN.split(type_)
+        processed_parts = []
+        for part in parts:
+            if part == NONE:
+                continue
+
+            # Check if this part contains a nested union
+            processed_part = _remove_none_from_union(part, use_union_operator=True) if " | " in part else part
+            processed_parts.append(processed_part)
+
+        if not processed_parts:
+            return NONE
+
+        return UNION_OPERATOR_DELIMITER.join(processed_parts)
     if not type_.startswith(UNION_PREFIX):
         return type_
-    inner_types = _remove_none_from_type(type_[len(UNION_PREFIX) :][:-1], UNION_PATTERN, UNION_DELIMITER)
 
-    if len(inner_types) == 1:
-        return inner_types[0]
-    return f"{UNION_PREFIX}{UNION_DELIMITER.join(inner_types)}]"
+    inner_text = type_[len(UNION_PREFIX) : -1]
+    parts = []
+    inner_count = 0
+    current_part = ""
+
+    # Parse union parts carefully to handle nested structures
+    for char in inner_text:
+        current_part += char
+        if char == "[":
+            inner_count += 1
+        elif char == "]":
+            inner_count -= 1
+        elif char == "," and inner_count == 0:
+            part = current_part[:-1].strip()
+            if part != NONE:
+                # Process nested unions recursively
+                if part.startswith(UNION_PREFIX):
+                    part = _remove_none_from_union(part, use_union_operator=False)
+                parts.append(part)
+            current_part = ""
+
+    part = current_part.strip()
+    if current_part and part != NONE:
+        if part.startswith(UNION_PREFIX):
+            part = _remove_none_from_union(part, use_union_operator=False)
+        parts.append(part)
+
+    if not parts:
+        return NONE
+    if len(parts) == 1:
+        return parts[0]
+
+    return f"{UNION_PREFIX}{UNION_DELIMITER.join(parts)}]"
 
 
 @lru_cache
 def get_optional_type(type_: str, use_union_operator: bool) -> str:  # noqa: FBT001
-    type_ = _remove_none_from_union(type_, use_union_operator)
+    type_ = _remove_none_from_union(type_, use_union_operator=use_union_operator)
 
     if not type_ or type_ == NONE:
         return NONE
@@ -249,6 +290,7 @@ class DataType(_BaseModel):
     children: list[Any] = []  # noqa: RUF012
     strict: bool = False
     dict_key: Optional[DataType] = None  # noqa: UP045
+    treat_dot_as_module: bool = False
 
     _exclude_fields: ClassVar[set[str]] = {"parent", "children"}
     _pass_fields: ClassVar[set[str]] = {"parent", "children", "data_types", "reference"}
@@ -402,7 +444,9 @@ class DataType(_BaseModel):
                         self.is_optional = True
                         continue
 
-                    non_optional_data_type_type = _remove_none_from_union(data_type_type, self.use_union_operator)
+                    non_optional_data_type_type = _remove_none_from_union(
+                        data_type_type, use_union_operator=self.use_union_operator
+                    )
 
                     if non_optional_data_type_type != data_type_type:
                         self.is_optional = True
@@ -526,6 +570,7 @@ class DataTypeManager(ABC):
         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
     ) -> None:
         self.python_version = python_version
         self.use_standard_collections: bool = use_standard_collections
@@ -537,6 +582,7 @@ class DataTypeManager(ABC):
         self.use_union_operator: bool = use_union_operator
         self.use_pendulum: bool = use_pendulum
         self.target_datetime_class: DatetimeClassType = target_datetime_class or DatetimeClassType.Datetime
+        self.treat_dot_as_module: bool = treat_dot_as_module
 
         if TYPE_CHECKING:
             self.data_type: type[DataType]
@@ -547,6 +593,7 @@ class DataTypeManager(ABC):
                 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),
                 __base__=DataType,
             )
 

{datamodel_code_generator-0.28.3.dist-info → datamodel_code_generator-0.28.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.28.3
+Version: 0.28.5
 Summary: Datamodel Code Generator
 Project-URL: Homepage, https://github.com/koxudaxi/datamodel-code-generator
 Project-URL: Source, https://github.com/koxudaxi/datamodel-code-generator
@@ -34,12 +34,15 @@ Requires-Dist: httpx>=0.24.1; extra == 'all'
 Requires-Dist: openapi-spec-validator<0.7,>=0.2.8; extra == 'all'
 Requires-Dist: prance>=0.18.2; extra == 'all'
 Requires-Dist: pysnooper<2,>=0.4.1; extra == 'all'
+Requires-Dist: ruff>=0.9.10; extra == 'all'
 Provides-Extra: debug
 Requires-Dist: pysnooper<2,>=0.4.1; extra == 'debug'
 Provides-Extra: graphql
 Requires-Dist: graphql-core>=3.2.3; extra == 'graphql'
 Provides-Extra: http
 Requires-Dist: httpx>=0.24.1; extra == 'http'
+Provides-Extra: ruff
+Requires-Dist: ruff>=0.9.10; extra == 'ruff'
 Provides-Extra: validation
 Requires-Dist: openapi-spec-validator<0.7,>=0.2.8; extra == 'validation'
 Requires-Dist: prance>=0.18.2; extra == 'validation'
@@ -403,6 +406,8 @@ Options:
                         "datetime.date,datetime.datetime"
   --custom-formatters CUSTOM_FORMATTERS
                         List of modules with custom formatter (delimited list input).
+  --formatters {black,isort,ruff-check,ruff-format} [{black,isort,ruff-check,ruff-format} ...]
+                        Formatters for output (default: [black, isort])
   --http-headers HTTP_HEADER [HTTP_HEADER ...]
                         Set headers in HTTP requests to the remote host. (example:
                         "Authorization: Basic dXNlcjpwYXNz")

{datamodel_code_generator-0.28.3.dist-info → datamodel_code_generator-0.28.5.dist-info}/RECORD

@@ -1,33 +1,33 @@
-datamodel_code_generator/__init__.py,sha256=Ta_7GGxfh5nqIEweL-M4WkOF6DNtX7x_v61AKzV13hI,20189
-datamodel_code_generator/__main__.py,sha256=itZbM4fpgEOJ-srnZx5rOJcQlFXpWT171p4kyHUjadQ,22004
-datamodel_code_generator/arguments.py,sha256=SAPrwQYDiHMSi_v8qG9TomkoX2RxPA9WXtro0sd-mK4,16271
-datamodel_code_generator/format.py,sha256=FYAx8yTS9GHPWw_gxkxxSF2mrO4DT2_4Gic45tc4z4o,7667
+datamodel_code_generator/__init__.py,sha256=sguYwixd5tfTNpa0TwfKFiYqEgwunUaVY2Aea7mCavk,20327
+datamodel_code_generator/__main__.py,sha256=LMD988WjkqmzWjHXoNiiEI3KFnrq3kupbyiObDf1HpA,22137
+datamodel_code_generator/arguments.py,sha256=LQyCC7tsDdy7ie7nbQVVW_79usVumX8O5pd99ZZ51ds,16466
+datamodel_code_generator/format.py,sha256=zvX0KH1uWwGnTYoVM4KhAuKZn5erjkH5eyi4t3leirw,8962
 datamodel_code_generator/http.py,sha256=LE94GC7I9D8lWIg_YAGWedfy0XNxOXTmiYKuNMTwouo,887
 datamodel_code_generator/imports.py,sha256=Nq83WbEGCegntg3WX4VbKfzAIs84alZ7IrYyNPrlUbc,5517
 datamodel_code_generator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datamodel_code_generator/pydantic_patch.py,sha256=co1IUDvZqQ-xEZ3C9gbV-BVm2Cin1vfyZNr2Dr0LdHY,718
-datamodel_code_generator/reference.py,sha256=uq9AxjINy0FRlHeD-vAsEGxWnZPnn_4RaiEkAT4C-0g,25835
-datamodel_code_generator/types.py,sha256=sTpL9bsSVUkuYa1Uq6axtp2LPa2mnxMGUN-ZvZJOhh4,19619
+datamodel_code_generator/reference.py,sha256=cnD6gGevRomez1dr16-KBz-GgDN8gCMQZqpwmb16CwA,26021
+datamodel_code_generator/types.py,sha256=fobUZnNTOGpzF4qZMraoLogVkAU7zBdFVG-8SOFoDD4,21163
 datamodel_code_generator/util.py,sha256=mZW8-6CbFe6T4IY5OM9Av6cH-0VknQGe2eIKjTM6Jzo,2729
 datamodel_code_generator/model/__init__.py,sha256=pJlJ1juQ-Gv17ZKXy6OAfJSSoOAmYQ7QCbdneu1BENU,3594
-datamodel_code_generator/model/base.py,sha256=E2qE4jzXkxuzknoztc34mUy17AoBbTMHJQ8ABjWlSZA,14248
-datamodel_code_generator/model/dataclass.py,sha256=O6nwWV6QL6Tu7T6PuxemOBcX84LP6IflNOYKSU6Rztg,6056
-datamodel_code_generator/model/enum.py,sha256=SuUolloDULJ46GiTmCHfhLdofHILGtM4oLBpcItofGM,3904
+datamodel_code_generator/model/base.py,sha256=Ma28Vx1p5zsFt23BMCs1UNDXuBq_USEhuPUvaeFLkS4,14959
+datamodel_code_generator/model/dataclass.py,sha256=t4NtgVhopTtEDUJCqijJheVlewSt8IJzQhQb8gXspfs,6252
+datamodel_code_generator/model/enum.py,sha256=yriQslY1hag_Qk-Xv3vl_LkPnbmMZ3iRTAGiiyMN0Io,4003
 datamodel_code_generator/model/imports.py,sha256=PTc09UzIBSsa5yAPoieb6hCGIohU2T1Y7igNy_pYarg,820
-datamodel_code_generator/model/msgspec.py,sha256=1tz1QDkoumoef_dMBCI-3dMGHgT21_0QioJVXJNAhJg,11649
+datamodel_code_generator/model/msgspec.py,sha256=qL2DIEwBfpn-vd8p8KEmUViMUce6RgI4Ql-drOmPR7M,11845
 datamodel_code_generator/model/rootmodel.py,sha256=pY8G2SPjkafzfJ1L9P5sNdp8qe45UclpUYN86guRB3M,202
-datamodel_code_generator/model/scalar.py,sha256=3HDIklJ9YJ7JROsUMDkhZTRIZq-JHEqSBfYl4ePzT2A,2568
-datamodel_code_generator/model/typed_dict.py,sha256=qa-wjGWpKzN-p6YE6RfUbhzZl6aoceXw8bSubes7XCs,4589
-datamodel_code_generator/model/types.py,sha256=QHqkyBMZgY1vCTRdkI5TCx1z1YqQyfr78oy1UTl-M04,3402
-datamodel_code_generator/model/union.py,sha256=TDOXxXb2kXM3gB88Bi5o9lYc1Sr5EFdKuFlhwxRppU0,1833
+datamodel_code_generator/model/scalar.py,sha256=xfONEK30eYJ2mSL9PK9zXqEG5-xApYMI_gmKOn5qhK4,2664
+datamodel_code_generator/model/typed_dict.py,sha256=FJi_fEZWuFe3nvidfl-jqr9PMRFTvfusoEFQkx1BqHI,4685
+datamodel_code_generator/model/types.py,sha256=ZyEwi76EBI5RS5JfoNUoRHmjOAZDup8oNFvQQDizfwQ,3502
+datamodel_code_generator/model/union.py,sha256=zwq1ayGFW3KbI4SxPCcdZcrM7X4Px25IdujDedtwgOw,1929
 datamodel_code_generator/model/pydantic/__init__.py,sha256=CtyzSriGEYGp1yfHapjD5lrS2vkSNe8AqKSYO-XaRWc,1095
-datamodel_code_generator/model/pydantic/base_model.py,sha256=5LRoU88wWDVnN4TziTs0CBilbkFqflkOtfY-qiCT_so,11990
+datamodel_code_generator/model/pydantic/base_model.py,sha256=qlGTxWYPS3XsHYwrRKjJDHvCixAxpWMEXTPtyAVXb6g,12182
 datamodel_code_generator/model/pydantic/custom_root_type.py,sha256=VJpEAmGFe3TzMKrR5YvR7PJ3pfGHcYytO1zhQrWyoWg,299
 datamodel_code_generator/model/pydantic/dataclass.py,sha256=jgjkqQk71CQP4RbTcPGSEOQDNqjTQnzFavvl5LjWTBw,455
 datamodel_code_generator/model/pydantic/imports.py,sha256=nWPiLgDeYNPHcAs8M-gaUUZg1daQRHdBPpjYuX3b5u4,2225
-datamodel_code_generator/model/pydantic/types.py,sha256=Ok8wA7Hp19N2EjmVxm4AveQRC1t4qoE6EyzNLWUOIcw,13256
+datamodel_code_generator/model/pydantic/types.py,sha256=ttTiDsQ6FV3h4C_NTEhvPUmUpeqxBNQt-DJJFpKZS8s,13356
 datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=xsfYcIUA2S8XzPIsYQSzDuBYZ1XRicfhGLHlQBlZwsg,1226
-datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=hDe6M1tV9eC-gfq-rsRUn0Av8QBhmtB5dKNjV7HTXRk,8257
+datamodel_code_generator/model/pydantic_v2/base_model.py,sha256=J_DxR6Auw0L-zHn0F5l9K8XtSmfEvDT26Bj-VZxihiE,8353
 datamodel_code_generator/model/pydantic_v2/imports.py,sha256=K3XD2kF9YCKmo5_7b2ipV5bGUrjz0avS-SiyDMVIpF0,299
 datamodel_code_generator/model/pydantic_v2/root_model.py,sha256=H4rwtg56N65-I3QHlPvlNhDcSPV0m56KSAgfGmxYXAQ,888
 datamodel_code_generator/model/pydantic_v2/types.py,sha256=apEuIhCBa15WdwGA0R9cqjpiH8mTLgAgu02CjcU4Css,2064
@@ -48,12 +48,12 @@ datamodel_code_generator/model/template/pydantic_v2/BaseModel.jinja2,sha256=XdSC
 datamodel_code_generator/model/template/pydantic_v2/ConfigDict.jinja2,sha256=xHvBYrh__32O1xRCSl6_u5zbyYIjB8a5k8fZiTo0spY,149
 datamodel_code_generator/model/template/pydantic_v2/RootModel.jinja2,sha256=XQBlML7Hm5hN6_AExENNvVc_yxNWijcIfTTbbmegCpE,1223
 datamodel_code_generator/parser/__init__.py,sha256=3XtFcDPocaetfjmWFqj_CubqNCDipb7vXZHsYKdJXXU,851
-datamodel_code_generator/parser/base.py,sha256=cGguXxF7DNRPz4Nq-AmpLKZL5SKBFr-qOGNp_1e7WlY,59208
-datamodel_code_generator/parser/graphql.py,sha256=n3WwlzdDndNKIRZXXVUPImdfJfqreC9AUEb7fB6UwpA,22406
-datamodel_code_generator/parser/jsonschema.py,sha256=5qz5zfX-eWrq9XZCQheTV6-ZzCGG87rvTrbYn6qLars,69148
-datamodel_code_generator/parser/openapi.py,sha256=TPefYZoQ8NosYLuj7htXpTwhBQHIGzvXpmtvt0RZyBk,26993
-datamodel_code_generator-0.28.3.dist-info/METADATA,sha256=qO7n9PYCs-eveoqzt7HTqHake5VxiM39zqCdZY96yYc,24912
-datamodel_code_generator-0.28.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-datamodel_code_generator-0.28.3.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
-datamodel_code_generator-0.28.3.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.28.3.dist-info/RECORD,,
+datamodel_code_generator/parser/base.py,sha256=COceRiOHtaOOS0gvDvKLNboxD4KY0ofJdmSdoyPBfNw,60618
+datamodel_code_generator/parser/graphql.py,sha256=ODbkMp42fYh8kH81KNeAffcFTmJb6_hgMyCsLUmdpMo,22585
+datamodel_code_generator/parser/jsonschema.py,sha256=J5Ec5Vf4LGjCRWPraBmpTkepq-tN0ri5MKB9bUSDdFc,69912
+datamodel_code_generator/parser/openapi.py,sha256=MfHSVfwq7qx_YEOiNel-ABbwISdH-kp87Q09WeNr_5w,27180
+datamodel_code_generator-0.28.5.dist-info/METADATA,sha256=UVX-nQFVHIBUGD1dqfDNsZ4qw4eOyiOsQI8MzkGrKUs,25189
+datamodel_code_generator-0.28.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+datamodel_code_generator-0.28.5.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
+datamodel_code_generator-0.28.5.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
+datamodel_code_generator-0.28.5.dist-info/RECORD,,