datamodel-code-generator 0.28.4__py3-none-any.whl → 0.29.0__py3-none-any.whl

datamodel_code_generator/__init__.py

@@ -280,7 +280,7 @@ 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,
@@ -475,13 +475,14 @@ 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,
+        encoding=encoding,
         **kwargs,
     )
 

datamodel_code_generator/__main__.py

@@ -329,7 +329,7 @@ class Config(BaseModel):
             setattr(self, field_name, getattr(parsed_args, field_name))
 
 
-def _get_pyproject_toml_config(source: Path) -> dict[str, Any] | None:
+def _get_pyproject_toml_config(source: Path) -> dict[str, Any]:
     """Find and return the [tool.datamodel-codgen] section of the closest
     pyproject.toml if it exists.
     """
@@ -339,14 +339,20 @@ def _get_pyproject_toml_config(source: Path) -> dict[str, Any] | None:
         if (current_path / "pyproject.toml").is_file():
             pyproject_toml = load_toml(current_path / "pyproject.toml")
             if "datamodel-codegen" in pyproject_toml.get("tool", {}):
-                return pyproject_toml["tool"]["datamodel-codegen"]
+                pyproject_config = pyproject_toml["tool"]["datamodel-codegen"]
+                # Convert options from kebap- to snake-case
+                pyproject_config = {k.replace("-", "_"): v for k, v in pyproject_config.items()}
+                # Replace US-american spelling if present (ignore if british spelling is present)
+                if "capitalize_enum_members" in pyproject_config and "capitalise_enum_members" not in pyproject_config:
+                    pyproject_config["capitalise_enum_members"] = pyproject_config.pop("capitalize_enum_members")
+                return pyproject_config
 
         if (current_path / ".git").exists():
             # Stop early if we see a git repository root.
-            return None
+            return {}
 
         current_path = current_path.parent
-    return None
+    return {}
 
 
 def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912, PLR0915
@@ -367,13 +373,9 @@ def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912,
         sys.exit(0)
 
     pyproject_config = _get_pyproject_toml_config(Path.cwd())
-    if pyproject_config is not None:
-        pyproject_toml = {k.replace("-", "_"): v for k, v in pyproject_config.items()}
-    else:
-        pyproject_toml = {}
 
     try:
-        config = Config.parse_obj(pyproject_toml)
+        config = Config.parse_obj(pyproject_config)
         config.merge_args(namespace)
     except Error as e:
         print(e.message, file=sys.stderr)  # noqa: T201
@@ -516,7 +518,7 @@ 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,

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/template/pydantic_v2/BaseModel.jinja2

@@ -1,3 +1,11 @@
+{% if base_class != "BaseModel" and "," not in base_class and not fields and not config -%}
+
+{# 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 -%}
@@ -37,3 +45,5 @@ class {{ class_name }}({{ base_class }}):{% if comment is defined %}  # {{ comme
     {{ method }}
 {%- endfor -%}
 {%- endfor -%}
+
+{%- endif %}

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,7 +7,7 @@ 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
@@ -370,7 +370,7 @@ 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,
@@ -387,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
@@ -482,7 +483,7 @@ 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
 
@@ -666,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:]
@@ -727,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
@@ -778,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
@@ -800,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)
@@ -945,10 +949,14 @@ class Parser(ABC):
                             model_field.constraints = ConstraintsBase.merge_constraints(
                                 root_type_field.constraints, model_field.constraints
                             )
-                        if isinstance(
-                            root_type_field,
-                            pydantic_model.DataModelField,
-                        ) and not model_field.extras.get("discriminator"):
+                        if (
+                            isinstance(
+                                root_type_field,
+                                pydantic_model.DataModelField,
+                            )
+                            and not model_field.extras.get("discriminator")
+                            and not any(t.is_list for t in model_field.data_type.data_types)
+                        ):
                             discriminator = root_type_field.extras.get("discriminator")
                             if discriminator:
                                 model_field.extras["discriminator"] = discriminator
@@ -1102,6 +1110,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
@@ -1126,7 +1152,7 @@ class Parser(ABC):
                 else:
                     r.append(item)
 
-            r = r[:-2] + [f"{r[-2]}.{r[-1]}"]
+            r = [*r[:-2], f"{r[-2]}.{r[-1]}"]
             return tuple(r)
 
         results = {process(k): v for k, v in results.items()}
@@ -1162,6 +1188,24 @@ class Parser(ABC):
                 class_name=True,
             ).name
 
+    def __alias_shadowed_imports(  # noqa: PLR6301
+        self,
+        models: list[DataModel],
+        all_model_field_names: set[str],
+    ) -> None:
+        for model in models:
+            for model_field in model.fields:
+                if model_field.data_type.type in all_model_field_names:
+                    alias = model_field.data_type.type + "_aliased"
+                    model_field.data_type.type = alias
+                    if model_field.data_type.import_:  # pragma: no cover
+                        model_field.data_type.import_ = Import(
+                            from_=model_field.data_type.import_.from_,
+                            import_=model_field.data_type.import_.import_,
+                            alias=alias,
+                            reference_path=model_field.data_type.import_.reference_path,
+                        )
+
     def parse(  # noqa: PLR0912, PLR0914, PLR0915
         self,
         with_import: bool | None = True,  # noqa: FBT001, FBT002
@@ -1256,6 +1300,7 @@ class Parser(ABC):
             all_module_fields = {field.name for model in models for field in model.fields if field.name is not None}
             scoped_model_resolver = ModelResolver(exclude_names=all_module_fields)
 
+            self.__alias_shadowed_imports(models, all_module_fields)
             self.__override_required_field(models)
             self.__replace_unique_list_to_set(models)
             self.__change_from_import(models, imports, scoped_model_resolver, init)
@@ -1265,6 +1310,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)
 
@@ -1328,7 +1374,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

@@ -147,7 +147,7 @@ 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,
@@ -221,7 +221,7 @@ 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,
@@ -453,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

@@ -416,7 +416,7 @@ 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,
@@ -490,7 +490,7 @@ 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,
@@ -695,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
@@ -737,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)
 
@@ -756,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,
@@ -849,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)
@@ -935,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:
@@ -972,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)
@@ -1185,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)
@@ -1264,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)
@@ -1386,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

@@ -209,7 +209,7 @@ 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,
@@ -283,7 +283,7 @@ 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,
@@ -488,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.4.dist-info → datamodel_code_generator-0.29.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.28.4
+Version: 0.29.0
 Summary: Datamodel Code Generator
 Project-URL: Homepage, https://github.com/koxudaxi/datamodel-code-generator
 Project-URL: Source, https://github.com/koxudaxi/datamodel-code-generator
@@ -21,7 +21,7 @@ Requires-Python: >=3.9
 Requires-Dist: argcomplete<4,>=2.10.1
 Requires-Dist: black>=19.10b0
 Requires-Dist: genson<2,>=1.2.1
-Requires-Dist: inflect<6,>=4.1
+Requires-Dist: inflect<8,>=4.1
 Requires-Dist: isort<7,>=4.3.21
 Requires-Dist: jinja2<4,>=2.10.1
 Requires-Dist: packaging

{datamodel_code_generator-0.28.4.dist-info → datamodel_code_generator-0.29.0.dist-info}/RECORD

@@ -1,33 +1,33 @@
-datamodel_code_generator/__init__.py,sha256=MRt95aGlb7T2fEVUQkLdlAFUKmdQbmr2TliEfLInS2E,20330
-datamodel_code_generator/__main__.py,sha256=xd4V0fpYpgdMDTb0QB1EFeOOblkbkk2v-wXs4Sv9K2o,22138
+datamodel_code_generator/__init__.py,sha256=UlQ_-1Gvin3ODyoli29GCYwUw0iYF8AeflKooYxusL8,20354
+datamodel_code_generator/__main__.py,sha256=Jd_WEPtOWj38WitNuNAGGJjMChKTW6aZkSXz0LOd94w,22507
 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
@@ -44,16 +44,16 @@ datamodel_code_generator/model/template/pydantic/BaseModel.jinja2,sha256=sYZa-47
 datamodel_code_generator/model/template/pydantic/BaseModel_root.jinja2,sha256=WDdTXYNTrkIw-B4OvPVxOaETTknLs0zdNuq_iDQ2Bcw,1000
 datamodel_code_generator/model/template/pydantic/Config.jinja2,sha256=Ik028qdqQhDfEP207TCbwVv2b5Do1-nRNDPKzBHKzwM,135
 datamodel_code_generator/model/template/pydantic/dataclass.jinja2,sha256=hM4OZTVhtOokqlPNSdh5drhBXfQLPvbyO88jipSPr5Y,629
-datamodel_code_generator/model/template/pydantic_v2/BaseModel.jinja2,sha256=XdSCvA0hSdjkMtI9CA3M-2xBgieCOV-sWIfQvJPnJ4I,1119
+datamodel_code_generator/model/template/pydantic_v2/BaseModel.jinja2,sha256=i1Wg9W20c4UGUkGJUf2rjuRNO52zLbktndfYupgJA78,1442
 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=hLHTxTJqA5Ffu9VYFoeKb2TbWZRewpXr8FO2rFBi7s8,59464
-datamodel_code_generator/parser/graphql.py,sha256=tiD1XYRuQvrcJRnHUBRzWUgV_V00tbABcn_jy_E2DVo,22530
-datamodel_code_generator/parser/jsonschema.py,sha256=PzOjbhB6RT0UGDG37lbwhhebbPnK4yVcv1_C-D2FqSo,69272
-datamodel_code_generator/parser/openapi.py,sha256=6lCR9xfMrgLaP-wsby4bB0_fYkkgMXV2N-aRnPkKdoE,27117
-datamodel_code_generator-0.28.4.dist-info/METADATA,sha256=L3e4L3XI47-qWfwRMATKbmY38RYCQBXd3tSI45w6V0c,25189
-datamodel_code_generator-0.28.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-datamodel_code_generator-0.28.4.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
-datamodel_code_generator-0.28.4.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.28.4.dist-info/RECORD,,
+datamodel_code_generator/parser/base.py,sha256=O6KN8fbODI0ED9clVRQmxdtnliSTP6IBlqJXEzDzuIQ,61740
+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.29.0.dist-info/METADATA,sha256=x-MFb_RFCzqFGvaBJENYUN0mYe2Pz6MKoynwHUActmk,25189
+datamodel_code_generator-0.29.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+datamodel_code_generator-0.29.0.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
+datamodel_code_generator-0.29.0.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
+datamodel_code_generator-0.29.0.dist-info/RECORD,,