datamodel-code-generator 0.30.1__py3-none-any.whl → 0.31.0__py3-none-any.whl

datamodel_code_generator/__init__.py

@@ -233,6 +233,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     enable_version_header: bool = False,
     allow_population_by_field_name: bool = False,
     allow_extra_fields: bool = False,
+    extra_fields: str | None = None,
     apply_default_values_for_required_fields: bool = False,
     force_optional_for_required_fields: bool = False,
     class_name: str | None = None,
@@ -285,6 +286,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     union_mode: UnionMode | None = None,
     output_datetime_class: DatetimeClassType | None = None,
     keyword_only: bool = False,
+    frozen_dataclasses: bool = False,
     no_alias: bool = False,
     formatters: list[Formatter] = DEFAULT_FORMATTERS,
     parent_scoped_naming: bool = False,
@@ -427,6 +429,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
         aliases=aliases,
         allow_population_by_field_name=allow_population_by_field_name,
         allow_extra_fields=allow_extra_fields,
+        extra_fields=extra_fields,
         apply_default_values_for_required_fields=apply_default_values_for_required_fields,
         force_optional_for_required_fields=force_optional_for_required_fields,
         class_name=class_name,
@@ -481,6 +484,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
         default_field_extras=default_field_extras,
         target_datetime_class=output_datetime_class,
         keyword_only=keyword_only,
+        frozen_dataclasses=frozen_dataclasses,
         no_alias=no_alias,
         formatters=formatters,
         encoding=encoding,

datamodel_code_generator/__main__.py

@@ -261,6 +261,7 @@ class Config(BaseModel):
     enable_version_header: bool = False
     allow_population_by_field_name: bool = False
     allow_extra_fields: bool = False
+    extra_fields: Optional[str] = None  # noqa: UP045
     use_default: bool = False
     force_optional: bool = False
     class_name: Optional[str] = None  # noqa: UP045
@@ -312,6 +313,7 @@ class Config(BaseModel):
     union_mode: Optional[UnionMode] = None  # noqa: UP045
     output_datetime_class: Optional[DatetimeClassType] = None  # noqa: UP045
     keyword_only: bool = False
+    frozen_dataclasses: bool = False
     no_alias: bool = False
     formatters: list[Formatter] = DEFAULT_FORMATTERS
     parent_scoped_naming: bool = False
@@ -474,6 +476,7 @@ def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912,
             enable_version_header=config.enable_version_header,
             allow_population_by_field_name=config.allow_population_by_field_name,
             allow_extra_fields=config.allow_extra_fields,
+            extra_fields=config.extra_fields,
             apply_default_values_for_required_fields=config.use_default,
             force_optional_for_required_fields=config.force_optional,
             class_name=config.class_name,
@@ -524,6 +527,7 @@ def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912,
             union_mode=config.union_mode,
             output_datetime_class=config.output_datetime_class,
             keyword_only=config.keyword_only,
+            frozen_dataclasses=config.frozen_dataclasses,
             no_alias=config.no_alias,
             formatters=config.formatters,
             parent_scoped_naming=config.parent_scoped_naming,

datamodel_code_generator/arguments.py

@@ -43,6 +43,7 @@ base_options = arg_parser.add_argument_group("Options")
 typing_options = arg_parser.add_argument_group("Typing customization")
 field_options = arg_parser.add_argument_group("Field customization")
 model_options = arg_parser.add_argument_group("Model customization")
+extra_fields_model_options = model_options.add_mutually_exclusive_group()
 template_options = arg_parser.add_argument_group("Template customization")
 openapi_options = arg_parser.add_argument_group("OpenAPI-only options")
 general_options = arg_parser.add_argument_group("General options")
@@ -94,9 +95,10 @@ base_options.add_argument(
 # ======================================================================================
 # Customization options for generated models
 # ======================================================================================
-model_options.add_argument(
+extra_fields_model_options.add_argument(
     "--allow-extra-fields",
-    help="Allow passing extra fields, if this flag is not passed, extra fields are forbidden.",
+    help="Deprecated: Allow passing extra fields, if this flag is not passed, extra fields are forbidden. "
+    "This flag is deprecated. Use `--extra-fields=allow` instead.",
     action="store_true",
     default=None,
 )
@@ -141,6 +143,12 @@ model_options.add_argument(
     action="store_true",
     default=None,
 )
+extra_fields_model_options.add_argument(
+    "--extra-fields",
+    help="Set the generated models to allow, forbid, or ignore extra fields.",
+    choices=["allow", "ignore", "forbid"],
+    default=None,
+)
 model_options.add_argument(
     "--keep-model-order",
     help="Keep generated models' order",
@@ -153,6 +161,12 @@ model_options.add_argument(
     action="store_true",
     default=None,
 )
+model_options.add_argument(
+    "--frozen-dataclasses",
+    help="Generate frozen dataclasses (dataclass(frozen=True)). Only applies to dataclass output.",
+    action="store_true",
+    default=None,
+)
 model_options.add_argument(
     "--reuse-model",
     help="Reuse models on the field when a module has the model with the same content",

datamodel_code_generator/format.py

@@ -222,7 +222,7 @@ class CodeFormatter:
         )
 
     def apply_ruff_lint(self, code: str) -> str:
-        result = subprocess.run(  # noqa: S603
+        result = subprocess.run(
             ("ruff", "check", "--fix", "-"),
             input=code.encode(self.encoding),
             capture_output=True,
@@ -231,7 +231,7 @@ class CodeFormatter:
         return result.stdout.decode(self.encoding)
 
     def apply_ruff_formatter(self, code: str) -> str:
-        result = subprocess.run(  # noqa: S603
+        result = subprocess.run(
             ("ruff", "format", "-"),
             input=code.encode(self.encoding),
             capture_output=True,

datamodel_code_generator/model/base.py

@@ -275,9 +275,11 @@ class DataModel(TemplateBase, Nullable, ABC):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        frozen: bool = False,
         treat_dot_as_module: bool = False,
     ) -> None:
         self.keyword_only = keyword_only
+        self.frozen = frozen
         if not self.TEMPLATE_FILE_PATH:
             msg = "TEMPLATE_FILE_PATH is undefined"
             raise Exception(msg)  # noqa: TRY002
@@ -434,5 +436,6 @@ class DataModel(TemplateBase, Nullable, ABC):
             methods=self.methods,
             description=self.description,
             keyword_only=self.keyword_only,
+            frozen=self.frozen,
             **self.extra_template_data,
         )

datamodel_code_generator/model/dataclass.py

@@ -53,6 +53,7 @@ class DataClass(DataModel):
         default: Any = UNDEFINED,
         nullable: bool = False,
         keyword_only: bool = False,
+        frozen: bool = False,
         treat_dot_as_module: bool = False,
     ) -> None:
         super().__init__(
@@ -69,6 +70,7 @@ class DataClass(DataModel):
             default=default,
             nullable=nullable,
             keyword_only=keyword_only,
+            frozen=frozen,
             treat_dot_as_module=treat_dot_as_module,
         )
 

datamodel_code_generator/model/pydantic/__init__.py

@@ -22,6 +22,7 @@ class Config(_BaseModel):
     title: Optional[str] = None  # noqa: UP045
     allow_population_by_field_name: Optional[bool] = None  # noqa: UP045
     allow_extra_fields: Optional[bool] = None  # noqa: UP045
+    extra_fields: Optional[str] = None  # noqa: UP045
     allow_mutation: Optional[bool] = None  # noqa: UP045
     arbitrary_types_allowed: Optional[bool] = None  # noqa: UP045
     orm_mode: Optional[bool] = None  # noqa: UP045

datamodel_code_generator/model/pydantic/base_model.py

@@ -286,12 +286,20 @@ class BaseModel(BaseModelBase):
 
         additional_properties = self.extra_template_data.get("additionalProperties")
         allow_extra_fields = self.extra_template_data.get("allow_extra_fields")
-        if additional_properties is not None or allow_extra_fields:
-            config_parameters["extra"] = (
-                "Extra.allow" if additional_properties or allow_extra_fields else "Extra.forbid"
-            )
+        extra_fields = self.extra_template_data.get("extra_fields")
+
+        if allow_extra_fields or extra_fields or additional_properties is not None:
             self._additional_imports.append(IMPORT_EXTRA)
 
+        if allow_extra_fields:
+            config_parameters["extra"] = "Extra.allow"
+        elif extra_fields:
+            config_parameters["extra"] = f"Extra.{extra_fields}"
+        elif additional_properties is True:
+            config_parameters["extra"] = "Extra.allow"
+        elif additional_properties is False:
+            config_parameters["extra"] = "Extra.forbid"
+
         for config_attribute in "allow_population_by_field_name", "allow_mutation":
             if config_attribute in self.extra_template_data:
                 config_parameters[config_attribute] = self.extra_template_data[config_attribute]

datamodel_code_generator/model/pydantic_v2/__init__.py

@@ -21,12 +21,14 @@ class ConfigDict(_BaseModel):
     title: Optional[str] = None  # noqa: UP045
     populate_by_name: Optional[bool] = None  # noqa: UP045
     allow_extra_fields: Optional[bool] = None  # noqa: UP045
+    extra_fields: Optional[str] = None  # noqa: UP045
     from_attributes: Optional[bool] = None  # noqa: UP045
     frozen: Optional[bool] = None  # noqa: UP045
     arbitrary_types_allowed: Optional[bool] = None  # noqa: UP045
     protected_namespaces: Optional[tuple[str, ...]] = None  # noqa: UP045
     regex_engine: Optional[str] = None  # noqa: UP045
     use_enum_values: Optional[bool] = None  # noqa: UP045
+    coerce_numbers_to_str: Optional[bool] = None  # noqa: UP045
 
 
 __all__ = [

datamodel_code_generator/model/template/dataclass.jinja2

@@ -1,7 +1,14 @@
 {% for decorator in decorators -%}
 {{ decorator }}
 {% endfor -%}
-@dataclass{%- if keyword_only -%}(kw_only=True){%- endif %}
+@dataclass
+{%- if keyword_only or frozen -%}
+(
+{%- if keyword_only -%}kw_only=True{%- endif -%}
+{%- if keyword_only and frozen -%}, {% endif -%}
+{%- if frozen -%}frozen=True{%- endif -%}
+)
+{%- endif %}
 {%- if base_class %}
 class {{ class_name }}({{ base_class }}):
 {%- else %}

datamodel_code_generator/parser/base.py

@@ -326,6 +326,7 @@ class Parser(ABC):
         allow_population_by_field_name: bool = False,
         apply_default_values_for_required_fields: bool = False,
         allow_extra_fields: bool = False,
+        extra_fields: str | None = None,
         force_optional_for_required_fields: bool = False,
         class_name: str | None = None,
         use_standard_collections: bool = False,
@@ -377,11 +378,13 @@ class Parser(ABC):
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType | None = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        frozen_dataclasses: bool = False,
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
     ) -> None:
         self.keyword_only = keyword_only
+        self.frozen_dataclasses = frozen_dataclasses
         self.data_type_manager: DataTypeManager = data_type_manager_type(
             python_version=target_python_version,
             use_standard_collections=use_standard_collections,
@@ -450,6 +453,9 @@ class Parser(ABC):
         if allow_extra_fields:
             self.extra_template_data[ALL_MODEL]["allow_extra_fields"] = True
 
+        if extra_fields:
+            self.extra_template_data[ALL_MODEL]["extra_fields"] = extra_fields
+
         if enable_faux_immutability:
             self.extra_template_data[ALL_MODEL]["allow_mutation"] = False
 
@@ -770,19 +776,31 @@ class Parser(ABC):
                                     continue
                             type_names.append(name)
 
-                    # Check the main discriminator model path
-                    if mapping:
-                        check_paths(discriminator_model, mapping)  # pyright: ignore[reportArgumentType]
+                    # First try to get the discriminator value from the const field
+                    for discriminator_field in discriminator_model.fields:
+                        if field_name not in {discriminator_field.original_name, discriminator_field.name}:
+                            continue
+                        if discriminator_field.extras.get("const"):
+                            type_names = [discriminator_field.extras["const"]]
+                            break
+
+                    # If no const value found, try to get it from the mapping
+                    if not type_names:
+                        # Check the main discriminator model path
+                        if mapping:
+                            check_paths(discriminator_model, mapping)  # pyright: ignore[reportArgumentType]
+
+                            # Check the base_classes if they exist
+                            if len(type_names) == 0:
+                                for base_class in discriminator_model.base_classes:
+                                    check_paths(base_class.reference, mapping)  # pyright: ignore[reportArgumentType]
+                        else:
+                            type_names = [discriminator_model.path.split("/")[-1]]
 
-                        # Check the base_classes if they exist
-                        if len(type_names) == 0:
-                            for base_class in discriminator_model.base_classes:
-                                check_paths(base_class.reference, mapping)  # pyright: ignore[reportArgumentType]
-                    else:
-                        type_names = [discriminator_model.path.split("/")[-1]]
                     if not type_names:  # pragma: no cover
                         msg = f"Discriminator type is not found. {data_type.reference.path}"
                         raise RuntimeError(msg)
+
                     has_one_literal = False
                     for discriminator_field in discriminator_model.fields:
                         if field_name not in {discriminator_field.original_name, discriminator_field.name}:
@@ -1121,7 +1139,7 @@ class Parser(ABC):
         if self.data_model_type != pydantic_model_v2.BaseModel:
             return
         for model in models:
-            if model.base_class == "Enum":
+            if "Enum" in model.base_class:
                 continue
 
             for field in model.fields:
@@ -1202,7 +1220,10 @@ class Parser(ABC):
     ) -> None:
         for model in models:
             for model_field in model.fields:
-                if model_field.data_type.type in all_model_field_names:
+                if (
+                    model_field.data_type.type in all_model_field_names
+                    and model_field.data_type.type == model_field.name
+                ):
                     alias = model_field.data_type.type + "_aliased"
                     model_field.data_type.type = alias
                     if model_field.data_type.import_:  # pragma: no cover

datamodel_code_generator/parser/graphql.py

@@ -17,6 +17,7 @@ from datamodel_code_generator import (
 )
 from datamodel_code_generator.model import DataModel, DataModelFieldBase
 from datamodel_code_generator.model import pydantic as pydantic_model
+from datamodel_code_generator.model.dataclass import DataClass
 from datamodel_code_generator.model.enum import Enum
 from datamodel_code_generator.model.scalar import DataTypeScalar
 from datamodel_code_generator.model.union import DataTypeUnion
@@ -101,6 +102,7 @@ class GraphQLParser(Parser):
         allow_population_by_field_name: bool = False,
         apply_default_values_for_required_fields: bool = False,
         allow_extra_fields: bool = False,
+        extra_fields: str | None = None,
         force_optional_for_required_fields: bool = False,
         class_name: str | None = None,
         use_standard_collections: bool = False,
@@ -152,6 +154,7 @@ class GraphQLParser(Parser):
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        frozen_dataclasses: bool = False,
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
@@ -175,6 +178,7 @@ class GraphQLParser(Parser):
             aliases=aliases,
             allow_population_by_field_name=allow_population_by_field_name,
             allow_extra_fields=allow_extra_fields,
+            extra_fields=extra_fields,
             apply_default_values_for_required_fields=apply_default_values_for_required_fields,
             force_optional_for_required_fields=force_optional_for_required_fields,
             class_name=class_name,
@@ -227,6 +231,7 @@ class GraphQLParser(Parser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            frozen_dataclasses=frozen_dataclasses,
             no_alias=no_alias,
             formatters=formatters,
             parent_scoped_naming=parent_scoped_naming,
@@ -283,6 +288,13 @@ class GraphQLParser(Parser):
 
                 self.support_graphql_types[resolved_type].append(type_)
 
+    def _create_data_model(self, model_type: type[DataModel] | None = None, **kwargs: Any) -> DataModel:
+        """Create data model instance with conditional frozen parameter for DataClass."""
+        data_model_class = model_type or self.data_model_type
+        if issubclass(data_model_class, DataClass):
+            kwargs["frozen"] = self.frozen_dataclasses
+        return data_model_class(**kwargs)
+
     def _typename_field(self, name: str) -> DataModelFieldBase:
         return self.data_model_field_type(
             name="typename__",
@@ -445,7 +457,7 @@ class GraphQLParser(Parser):
         if hasattr(obj, "interfaces"):  # pragma: no cover
             base_classes = [self.references[i.name] for i in obj.interfaces]  # pyright: ignore[reportAttributeAccessIssue]
 
-        data_model_type = self.data_model_type(
+        data_model_type = self._create_data_model(
             reference=self.references[obj.name],
             fields=fields,
             base_classes=base_classes,

datamodel_code_generator/parser/jsonschema.py

@@ -6,7 +6,7 @@ from contextlib import contextmanager
 from functools import cached_property, lru_cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Union
-from urllib.parse import ParseResult
+from urllib.parse import ParseResult, unquote
 from warnings import warn
 
 from pydantic import (
@@ -23,6 +23,7 @@ from datamodel_code_generator.format import DEFAULT_FORMATTERS, Formatter, Pytho
 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
+from datamodel_code_generator.model.dataclass import DataClass
 from datamodel_code_generator.model.enum import Enum
 from datamodel_code_generator.parser import DefaultPutDict, LiteralType
 from datamodel_code_generator.parser.base import (
@@ -58,16 +59,26 @@ if TYPE_CHECKING:
     from collections.abc import Generator, Iterable, Iterator, Mapping, Sequence
 
 
+def unescape_json_pointer_segment(segment: str) -> str:
+    # Unescape ~1, ~0, and percent-encoding
+    return unquote(segment.replace("~1", "/").replace("~0", "~"))
+
+
 def get_model_by_path(schema: dict[str, Any] | list[Any], keys: list[str] | list[int]) -> dict[Any, Any]:
     model: dict[Any, Any] | list[Any]
     if not keys:
         model = schema
-    elif len(keys) == 1:
-        model = schema.get(str(keys[0]), {}) if isinstance(schema, dict) else schema[int(keys[0])]
-    elif isinstance(schema, dict):
-        model = get_model_by_path(schema[str(keys[0])], keys[1:])
     else:
-        model = get_model_by_path(schema[int(keys[0])], keys[1:])
+        # Unescape the key if it's a string (JSON pointer segment)
+        key = keys[0]
+        if isinstance(key, str):
+            key = unescape_json_pointer_segment(key)
+        if len(keys) == 1:
+            model = schema.get(str(key), {}) if isinstance(schema, dict) else schema[int(key)]
+        elif isinstance(schema, dict):
+            model = get_model_by_path(schema[str(key)], keys[1:])
+        else:
+            model = get_model_by_path(schema[int(key)], keys[1:])
     if isinstance(model, dict):
         return model
     msg = f"Does not support json pointer to array. schema={schema}, key={keys}"
@@ -370,6 +381,7 @@ class JsonSchemaParser(Parser):
         allow_population_by_field_name: bool = False,
         apply_default_values_for_required_fields: bool = False,
         allow_extra_fields: bool = False,
+        extra_fields: str | None = None,
         force_optional_for_required_fields: bool = False,
         class_name: str | None = None,
         use_standard_collections: bool = False,
@@ -421,6 +433,7 @@ class JsonSchemaParser(Parser):
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        frozen_dataclasses: bool = False,
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
@@ -444,6 +457,7 @@ class JsonSchemaParser(Parser):
             aliases=aliases,
             allow_population_by_field_name=allow_population_by_field_name,
             allow_extra_fields=allow_extra_fields,
+            extra_fields=extra_fields,
             apply_default_values_for_required_fields=apply_default_values_for_required_fields,
             force_optional_for_required_fields=force_optional_for_required_fields,
             class_name=class_name,
@@ -496,6 +510,7 @@ class JsonSchemaParser(Parser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            frozen_dataclasses=frozen_dataclasses,
             no_alias=no_alias,
             formatters=formatters,
             parent_scoped_naming=parent_scoped_naming,
@@ -627,7 +642,7 @@ class JsonSchemaParser(Parser):
                     result[key] = self._deep_merge(result[key], value)
                     continue
                 if isinstance(result[key], list) and isinstance(value, list):
-                    result[key] += value
+                    result[key] = result[key] + value  # noqa: PLR6104
                     continue
             result[key] = value
         return result
@@ -686,6 +701,13 @@ class JsonSchemaParser(Parser):
     def parse_one_of(self, name: str, obj: JsonSchemaObject, path: list[str]) -> list[DataType]:
         return self.parse_combined_schema(name, obj, path, "oneOf")
 
+    def _create_data_model(self, model_type: type[DataModel] | None = None, **kwargs: Any) -> DataModel:
+        """Create data model instance with conditional frozen parameter for DataClass."""
+        data_model_class = model_type or self.data_model_type
+        if issubclass(data_model_class, DataClass):
+            kwargs["frozen"] = self.frozen_dataclasses
+        return data_model_class(**kwargs)
+
     def _parse_object_common_part(  # noqa: PLR0913, PLR0917
         self,
         name: str,
@@ -733,7 +755,8 @@ class JsonSchemaParser(Parser):
             name = obj.title
         reference = self.model_resolver.add(path, name, class_name=True, loaded=True)
         self.set_additional_properties(reference.name, obj)
-        data_model_type = self.data_model_type(
+
+        data_model_type = self._create_data_model(
             reference=reference,
             fields=fields,
             base_classes=base_classes,
@@ -874,7 +897,7 @@ class JsonSchemaParser(Parser):
         exclude_field_names: set[str] = set()
         for original_field_name, field in properties.items():
             field_name, alias = self.model_resolver.get_valid_field_name_and_alias(
-                original_field_name, exclude_field_names
+                original_field_name, excludes=exclude_field_names
             )
             modular_name = f"{module_name}.{field_name}" if module_name else field_name
 
@@ -972,7 +995,9 @@ class JsonSchemaParser(Parser):
             data_model_type_class = self.data_model_root_type
 
         self.set_additional_properties(class_name, obj)
-        data_model_type = data_model_type_class(
+
+        data_model_type = self._create_data_model(
+            model_type=data_model_type_class,
             reference=reference,
             fields=fields,
             custom_base_class=obj.custom_base_path or self.base_class,

datamodel_code_generator/parser/openapi.py

@@ -42,6 +42,7 @@ if TYPE_CHECKING:
     from pathlib import Path
     from urllib.parse import ParseResult
 
+
 RE_APPLICATION_JSON_PATTERN: Pattern[str] = re.compile(r"^application/.*json$")
 
 OPERATION_NAMES: list[str] = [
@@ -161,6 +162,7 @@ class OpenAPIParser(JsonSchemaParser):
         aliases: Mapping[str, str] | None = None,
         allow_population_by_field_name: bool = False,
         allow_extra_fields: bool = False,
+        extra_fields: str | None = None,
         apply_default_values_for_required_fields: bool = False,
         force_optional_for_required_fields: bool = False,
         class_name: str | None = None,
@@ -214,6 +216,7 @@ class OpenAPIParser(JsonSchemaParser):
         default_field_extras: dict[str, Any] | None = None,
         target_datetime_class: DatetimeClassType = DatetimeClassType.Datetime,
         keyword_only: bool = False,
+        frozen_dataclasses: bool = False,
         no_alias: bool = False,
         formatters: list[Formatter] = DEFAULT_FORMATTERS,
         parent_scoped_naming: bool = False,
@@ -237,6 +240,7 @@ class OpenAPIParser(JsonSchemaParser):
             aliases=aliases,
             allow_population_by_field_name=allow_population_by_field_name,
             allow_extra_fields=allow_extra_fields,
+            extra_fields=extra_fields,
             apply_default_values_for_required_fields=apply_default_values_for_required_fields,
             force_optional_for_required_fields=force_optional_for_required_fields,
             class_name=class_name,
@@ -289,6 +293,7 @@ class OpenAPIParser(JsonSchemaParser):
             default_field_extras=default_field_extras,
             target_datetime_class=target_datetime_class,
             keyword_only=keyword_only,
+            frozen_dataclasses=frozen_dataclasses,
             no_alias=no_alias,
             formatters=formatters,
             parent_scoped_naming=parent_scoped_naming,
@@ -483,8 +488,10 @@ class OpenAPIParser(JsonSchemaParser):
                 )
 
         if OpenAPIScope.Parameters in self.open_api_scopes and fields:
+            # Using _create_data_model from parent class JsonSchemaParser
+            # This method automatically adds frozen=True for DataClass types
             self.results.append(
-                self.data_model_type(
+                self._create_data_model(
                     fields=fields,
                     reference=reference,
                     custom_base_class=self.base_class,

datamodel_code_generator/types.py

@@ -6,13 +6,27 @@ from enum import Enum, auto
 from functools import lru_cache
 from itertools import chain
 from re import Pattern
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, Protocol, TypeVar, Union, runtime_checkable
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Optional,
+    Protocol,
+    TypeVar,
+    Union,
+    runtime_checkable,
+)
 
 import pydantic
 from packaging import version
 from pydantic import StrictBool, StrictInt, StrictStr, create_model
 
-from datamodel_code_generator.format import DatetimeClassType, PythonVersion, PythonVersionMin
+from datamodel_code_generator.format import (
+    DatetimeClassType,
+    PythonVersion,
+    PythonVersionMin,
+)
 from datamodel_code_generator.imports import (
     IMPORT_ABC_MAPPING,
     IMPORT_ABC_SEQUENCE,
@@ -167,53 +181,57 @@ 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: PLR0911, PLR0912
+def _remove_none_from_union(type_: str, *, use_union_operator: bool) -> str:  # noqa: PLR0912
     if use_union_operator:
         if " | " not in type_:
             return type_
+        separator = "|"
+        inner_text = type_
+    else:
+        if not type_.startswith(UNION_PREFIX):
+            return type_
+        separator = ","
+        inner_text = type_[len(UNION_PREFIX) : -1]
 
-        # 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_text = type_[len(UNION_PREFIX) : -1]
     parts = []
     inner_count = 0
     current_part = ""
 
+    # With this variable we count any non-escaped round bracket, whenever we are inside a
+    # constraint string expression. Once found a part starting with `constr(`, we increment
+    # this counter for each non-escaped opening round bracket and decrement it for each
+    # non-escaped closing round bracket.
+    in_constr = 0
+
     # Parse union parts carefully to handle nested structures
     for char in inner_text:
         current_part += char
-        if char == "[":
+        if char == "[" and in_constr == 0:
             inner_count += 1
-        elif char == "]":
+        elif char == "]" and in_constr == 0:
             inner_count -= 1
-        elif char == "," and inner_count == 0:
+        elif char == "(":
+            if current_part.strip().startswith("constr(") and current_part[-2] != "\\":
+                # non-escaped opening round bracket found inside constraint string expression
+                in_constr += 1
+        elif char == ")":
+            if in_constr > 0 and current_part[-2] != "\\":
+                # non-escaped closing round bracket found inside constraint string expression
+                in_constr -= 1
+        elif char == separator and inner_count == 0 and in_constr == 0:
             part = current_part[:-1].strip()
             if part != NONE:
                 # Process nested unions recursively
-                if part.startswith(UNION_PREFIX):
+                # only UNION_PREFIX might be nested but not union_operator
+                if not use_union_operator and 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):
+        # only UNION_PREFIX might be nested but not union_operator
+        if not use_union_operator and part.startswith(UNION_PREFIX):
             part = _remove_none_from_union(part, use_union_operator=False)
         parts.append(part)
 
@@ -222,6 +240,9 @@ def _remove_none_from_union(type_: str, *, use_union_operator: bool) -> str:  #
     if len(parts) == 1:
         return parts[0]
 
+    if use_union_operator:
+        return UNION_OPERATOR_DELIMITER.join(parts)
+
     return f"{UNION_PREFIX}{UNION_DELIMITER.join(parts)}]"
 
 

{datamodel_code_generator-0.30.1.dist-info → datamodel_code_generator-0.31.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.30.1
+Version: 0.31.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
@@ -489,8 +489,9 @@ Field customization:
                         Use schema description to populate field docstring
 
 Model customization:
-  --allow-extra-fields  Allow passing extra fields, if this flag is not passed, extra fields
-                        are forbidden.
+  --allow-extra-fields  Deprecated: Allow passing extra fields, if this flag is not passed,
+                        extra fields are forbidden. This flag is deprecated. Use `--extra-
+                        fields=allow` instead.
   --allow-population-by-field-name
                         Allow population by field name
   --class-name CLASS_NAME
@@ -505,6 +506,10 @@ Model customization:
                         Enable faux immutability
   --enable-version-header
                         Enable package version on file headers
+  --extra-fields {allow,ignore,forbid}
+                        Set the generated models to allow, forbid, or ignore extra fields.
+  --frozen-dataclasses  Generate frozen dataclasses (dataclass(frozen=True)). Only applies
+                        to dataclass output.
   --keep-model-order    Keep generated models'' order
   --keyword-only        Defined models as keyword only (for example
                         dataclass(kw_only=True)).

{datamodel_code_generator-0.30.1.dist-info → datamodel_code_generator-0.31.0.dist-info}/RECORD

@@ -1,17 +1,17 @@
-datamodel_code_generator/__init__.py,sha256=2h8FA8O_x1VGRVlXKJHt3jwuC34MIEnmHwHv-zGuF_I,20445
-datamodel_code_generator/__main__.py,sha256=rF1Se8R0rfqDmJ4_INBdOYlU7G4XIthPCe3ldDwtgQI,22608
-datamodel_code_generator/arguments.py,sha256=xPAnid2-dC_Hj4o1hY9fL13NMJl5wCPphTsCHZ3QeNQ,16637
-datamodel_code_generator/format.py,sha256=zvX0KH1uWwGnTYoVM4KhAuKZn5erjkH5eyi4t3leirw,8962
+datamodel_code_generator/__init__.py,sha256=H6ZnGum3Xw1u1o2e7a6gLjA09Vm2DlXo_Vm8GRrTUlY,20602
+datamodel_code_generator/__main__.py,sha256=Z9g_NGrnxV63MRuqtUUpPW48felXmVxwGBtWWkgNlj4,22803
+datamodel_code_generator/arguments.py,sha256=vGNwaq0B3Lchi30Uh1Lt-MBdkEW2nW2PwDQrmrpLKxA,17210
+datamodel_code_generator/format.py,sha256=ZlnTCAl1H4og685smvCBSzexgpYbZtyYLIrt7lwUNcY,8934
 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=OobfjN5hWaKzv4ECdCPc9Q3ODkoG93B4qaKlzDEcDrY,26748
-datamodel_code_generator/types.py,sha256=fobUZnNTOGpzF4qZMraoLogVkAU7zBdFVG-8SOFoDD4,21163
+datamodel_code_generator/types.py,sha256=1g4RZZ1e5oC4EHaNyyDmsIfF4o1WAjQ2KaLjwc9mYss,21883
 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=Ma28Vx1p5zsFt23BMCs1UNDXuBq_USEhuPUvaeFLkS4,14959
-datamodel_code_generator/model/dataclass.py,sha256=t4NtgVhopTtEDUJCqijJheVlewSt8IJzQhQb8gXspfs,6252
+datamodel_code_generator/model/base.py,sha256=ZQ3Xy4Fs_I8M01tk1ps0EhWJM9vR-n7umPkz5NmHTjw,15050
+datamodel_code_generator/model/dataclass.py,sha256=8Z02XY3S6byNe9Pb46LisE5opQcvpx8FVvPjUrlAacE,6309
 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=qL2DIEwBfpn-vd8p8KEmUViMUce6RgI4Ql-drOmPR7M,11845
@@ -20,13 +20,13 @@ datamodel_code_generator/model/scalar.py,sha256=xfONEK30eYJ2mSL9PK9zXqEG5-xApYMI
 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=qlGTxWYPS3XsHYwrRKjJDHvCixAxpWMEXTPtyAVXb6g,12182
+datamodel_code_generator/model/pydantic/__init__.py,sha256=ggJNv7_6Vv-BgY50O-0Pa6IHGavkxGAjSa9lLEmFOnE,1149
+datamodel_code_generator/model/pydantic/base_model.py,sha256=0ZsoQfjhhRTMlvsThGEsXJgYMubjrakkuOHUt5-f6HY,12492
 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=ttTiDsQ6FV3h4C_NTEhvPUmUpeqxBNQt-DJJFpKZS8s,13356
-datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=xsfYcIUA2S8XzPIsYQSzDuBYZ1XRicfhGLHlQBlZwsg,1226
+datamodel_code_generator/model/pydantic_v2/__init__.py,sha256=YHfOs8prPBsrQmYm0kJATSyU0wafQTqKNd24e2-KGJE,1344
 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
@@ -37,7 +37,7 @@ datamodel_code_generator/model/template/TypedDict.jinja2,sha256=J_Pe_CiuvTOb-EUC
 datamodel_code_generator/model/template/TypedDictClass.jinja2,sha256=URwp5__WyR8G21Hoyc17aMzoast-NppXnXe19VFi5wQ,377
 datamodel_code_generator/model/template/TypedDictFunction.jinja2,sha256=KjSij5_w4ow4a12SR3orYOndmXGkIvJBBUN735bQ6G0,321
 datamodel_code_generator/model/template/Union.jinja2,sha256=sq7o--2ESUSfIL4kCfgnr5ZXPFa_VeioqbATTY-N-5I,258
-datamodel_code_generator/model/template/dataclass.jinja2,sha256=wRSy2g11Dr1GN9YUl13OZt2xg37bQyFwKn2wEsQIndE,865
+datamodel_code_generator/model/template/dataclass.jinja2,sha256=c3gs1ZwDEwLpmZ2PpOEWjHjfdl6kPP64xm18mt9lZMk,1007
 datamodel_code_generator/model/template/msgspec.jinja2,sha256=qMuFOH6SFFh558wImdI6uIjG4Mtam3J_ox8Hmgqkv0g,1174
 datamodel_code_generator/model/template/root.jinja2,sha256=3OTtibxLcGA-FMdR0QDCJUJQgf_kRW0OafeCTPFSFFo,162
 datamodel_code_generator/model/template/pydantic/BaseModel.jinja2,sha256=sYZa-47YAXqZrd5cYKVnPrsbDvLkHEJOUd7M0nAosP8,1084
@@ -48,12 +48,12 @@ datamodel_code_generator/model/template/pydantic_v2/BaseModel.jinja2,sha256=i1Wg
 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=h2YD0aRtGiW3jBBbJ-bx3YjBb9NTF1TBj51JxZnZcxQ,61947
-datamodel_code_generator/parser/graphql.py,sha256=scotG-q8zTS40i5rP9HfhriSVhXVnxEKtuBoXvbzECg,22684
-datamodel_code_generator/parser/jsonschema.py,sha256=bwXNvXjG8tiUPCNZsEXbo2TlCYJVKIzeYWEKfvlPzo8,70011
-datamodel_code_generator/parser/openapi.py,sha256=3IWF40DK0a710rVqXCod7Hi3Fh9u7neD4YR_kn_6VD4,27279
-datamodel_code_generator-0.30.1.dist-info/METADATA,sha256=9YcS5FD4-A9Dk96eQsagXfsuPAQs0qidE_szFAPChKs,25294
-datamodel_code_generator-0.30.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-datamodel_code_generator-0.30.1.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
-datamodel_code_generator-0.30.1.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
-datamodel_code_generator-0.30.1.dist-info/RECORD,,
+datamodel_code_generator/parser/base.py,sha256=4B4UeEjCfl_IdRak_qi5Wx8sUx5bX8Xt-Z0CmfsWsks,62940
+datamodel_code_generator/parser/graphql.py,sha256=TNLxy-0wWJSpCm6HK5fKooZdaJodcwQqVr0J29ao3J8,23330
+datamodel_code_generator/parser/jsonschema.py,sha256=oFSZOyLL3K0tneH09t2lNKdWcbmR_r5OjCyWKPq2Jxc,71114
+datamodel_code_generator/parser/openapi.py,sha256=kI4kqVBG96rdAVb8z0l4gF6QpcylgVoGjlK_-KToZRg,27607
+datamodel_code_generator-0.31.0.dist-info/METADATA,sha256=4pJIEOpNG7M2YhWpZi8OjNBSD0KO6UFIelQNRjIkSg0,25658
+datamodel_code_generator-0.31.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+datamodel_code_generator-0.31.0.dist-info/entry_points.txt,sha256=cJVcHiEViQMANaoM5C1xR5hzmyCqH6hHHMpV8W00in8,77
+datamodel_code_generator-0.31.0.dist-info/licenses/LICENSE,sha256=K54Lwc6_jduycsy8oFFjQEeSSuEiqvVIjCGIXOMnuTQ,1068
+datamodel_code_generator-0.31.0.dist-info/RECORD,,