Refactor pydantic v2 config generation

Author: koxudaxi

src/datamodel_code_generator/model/msgspec.py

@@ -9,8 +9,6 @@
 from math import isfinite
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypeVar
 
-from pydantic import Field
-
 from datamodel_code_generator.imports import IMPORT_UNION, Import
 from datamodel_code_generator.model import DataModel, DataModelFieldBase, _rebuild_model_with_datamodel_namespace
 from datamodel_code_generator.model.base import UNDEFINED, BaseClassDataType, _nested_model_default_factory
@@ -23,7 +21,7 @@
     IMPORT_MSGSPEC_UNSETTYPE,
 )
 from datamodel_code_generator.model.pydantic_base import (
-    Constraints as _Constraints,
+    PatternConstraints as _Constraints,
 )
 from datamodel_code_generator.model.type_alias import TypeAliasBase
 from datamodel_code_generator.model.types import DataTypeManager as _DataTypeManager
@@ -206,10 +204,6 @@ def create_base_class_model(
 class Constraints(_Constraints):
     """Constraint model for msgspec fields."""
 
-    # To override existing pattern alias
-    regex: Optional[str] = Field(None, alias="regex")  # noqa: UP045
-    pattern: Optional[str] = Field(None, alias="pattern")  # noqa: UP045
-
 
 @lru_cache
 def get_neither_required_nor_nullable_type(type_: str, use_union_operator: bool) -> str:  # noqa: FBT001

src/datamodel_code_generator/model/pydantic_base.py

@@ -52,6 +52,11 @@ class Constraints(ConstraintsBase):
     regex: Optional[str] = Field(None, alias="pattern")  # noqa: UP045
 
 
+class PatternConstraints(Constraints):  # noqa: D101
+    regex: Optional[str] = Field(None, alias="regex")  # noqa: UP045
+    pattern: Optional[str] = Field(None, alias="pattern")  # noqa: UP045
+
+
 class DataModelField(DataModelFieldBase):
     """Field implementation for Pydantic models."""
 

src/datamodel_code_generator/model/pydantic_v2/__init__.py

@@ -6,12 +6,11 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, Optional  # noqa: UP035
-
-from pydantic import BaseModel as _BaseModel
+from typing import TYPE_CHECKING
 
 from datamodel_code_generator.enums import UnionMode
 
+from ._config import ConfigDict as ConfigDict
 from .base_model import BaseModel, DataModelField
 from .root_model import RootModel
 from .root_model_type_alias import RootModelTypeAlias
@@ -26,31 +25,6 @@ def dump_resolve_reference_action(class_names: Iterable[str]) -> str:
     return "\n".join(f"{class_name}.model_rebuild()" for class_name in class_names)
 
 
-class ConfigDict(_BaseModel):
-    """Pydantic v2 model_config options."""
-
-    extra: Optional[str] = None  # noqa: UP045
-    title: Optional[str] = None  # noqa: UP045
-    populate_by_name: Optional[bool] = None  # noqa: UP045  # deprecated in v2.11+
-    validate_by_name: Optional[bool] = None  # noqa: UP045  # v2.11+
-    validate_by_alias: Optional[bool] = None  # noqa: UP045  # v2.11+
-    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
-    use_attribute_docstrings: Optional[bool] = None  # noqa: UP045
-    json_schema_extra: Optional[Dict[str, Any]] = None  # noqa: UP006, UP045
-
-    def dict(self, **kwargs: Any) -> dict[str, Any]:  # type: ignore[override]
-        """Return dict for templates."""
-        return self.model_dump(**kwargs)
-
-
 __all__ = [
     "BaseModel",
     "DataModelField",

src/datamodel_code_generator/model/pydantic_v2/_config.py

@@ -0,0 +1,116 @@
+"""Shared Pydantic v2 ConfigDict generation helpers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, NamedTuple, Optional  # noqa: UP035
+
+from pydantic import BaseModel as _BaseModel
+
+from datamodel_code_generator.enums import TargetPydanticVersion
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from datamodel_code_generator.types import DataType
+
+
+class ConfigAttribute(NamedTuple):
+    """Configuration attribute mapping for ConfigDict conversion."""
+
+    from_: str
+    to: str
+    invert: bool
+
+
+def get_config_extra(extra_template_data: dict[str, Any]) -> str | None:
+    """Get extra field configuration for ConfigDict."""
+    additional_properties = extra_template_data.get("additionalProperties")
+    unevaluated_properties = extra_template_data.get("unevaluatedProperties")
+    allow_extra_fields = extra_template_data.get("allow_extra_fields")
+    extra_fields = extra_template_data.get("extra_fields")
+
+    config_extra = None
+    if allow_extra_fields or extra_fields == "allow":
+        config_extra = "'allow'"
+    elif extra_fields == "forbid":
+        config_extra = "'forbid'"
+    elif extra_fields == "ignore":
+        config_extra = "'ignore'"
+    elif additional_properties is True:
+        config_extra = "'allow'"
+    elif additional_properties is False:
+        config_extra = "'forbid'"
+    elif unevaluated_properties is True:
+        config_extra = "'allow'"
+    elif unevaluated_properties is False:
+        config_extra = "'forbid'"
+    return config_extra
+
+
+def get_config_attributes(
+    extra_template_data: dict[str, Any],
+    *,
+    config_attributes_v2: list[ConfigAttribute],
+    config_attributes_v2_11: list[ConfigAttribute],
+) -> list[ConfigAttribute]:
+    """Get config attributes based on target Pydantic version."""
+    target_version = extra_template_data.get("target_pydantic_version")
+    if target_version == TargetPydanticVersion.V2_11:
+        return config_attributes_v2_11
+    return config_attributes_v2
+
+
+def build_base_config_parameters(
+    *,
+    extra_template_data: dict[str, Any],
+    all_data_types: Iterable[DataType],
+    config_attributes_v2: list[ConfigAttribute],
+    config_attributes_v2_11: list[ConfigAttribute],
+) -> dict[str, Any]:
+    """Build shared ConfigDict parameters for Pydantic v2 models."""
+    config_parameters: dict[str, Any] = {}
+
+    extra = get_config_extra(extra_template_data)
+    if extra:
+        config_parameters["extra"] = extra
+
+    config_attributes = get_config_attributes(
+        extra_template_data,
+        config_attributes_v2=config_attributes_v2,
+        config_attributes_v2_11=config_attributes_v2_11,
+    )
+    for from_, to, invert in config_attributes:
+        if from_ in extra_template_data:
+            config_parameters[to] = not extra_template_data[from_] if invert else extra_template_data[from_]
+
+    for data_type in all_data_types:
+        if data_type.is_custom_type:  # pragma: no cover
+            config_parameters["arbitrary_types_allowed"] = True
+            break
+
+    return config_parameters
+
+
+class ConfigDict(_BaseModel):
+    """Pydantic v2 model_config options."""
+
+    extra: Optional[str] = None  # noqa: UP045
+    title: Optional[str] = None  # noqa: UP045
+    populate_by_name: Optional[bool] = None  # noqa: UP045  # deprecated in v2.11+
+    validate_by_name: Optional[bool] = None  # noqa: UP045  # v2.11+
+    validate_by_alias: Optional[bool] = None  # noqa: UP045  # v2.11+
+    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
+    use_attribute_docstrings: Optional[bool] = None  # noqa: UP045
+    json_schema_extra: Optional[Dict[str, Any]] = None  # noqa: UP006, UP045
+
+    def dict(self, **kwargs: Any) -> dict[str, Any]:  # type: ignore[override]
+        """Return dict for templates."""
+        return self.model_dump(**kwargs)

src/datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -8,12 +8,11 @@
 
 import re
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, ClassVar, Literal, NamedTuple, Optional
+from typing import TYPE_CHECKING, Any, ClassVar, Optional
 
-from pydantic import Field, ValidationError, field_validator, model_validator
+from pydantic import ValidationError, field_validator, model_validator
 
 from datamodel_code_generator import Error
-from datamodel_code_generator.enums import TargetPydanticVersion
 from datamodel_code_generator.imports import IMPORT_ANY, IMPORT_DICT, Import
 from datamodel_code_generator.model import _rebuild_model_with_datamodel_namespace
 from datamodel_code_generator.model.base import (
@@ -23,14 +22,17 @@
     DataModelFieldBase,
 )
 from datamodel_code_generator.model.imports import IMPORT_CLASSVAR
+from datamodel_code_generator.model.pydantic_base import BaseModelBase
 from datamodel_code_generator.model.pydantic_base import (
-    BaseModelBase,
+    DataModelField as _PydanticBaseDataModelField,
 )
 from datamodel_code_generator.model.pydantic_base import (
-    Constraints as _Constraints,
+    PatternConstraints as _Constraints,
 )
-from datamodel_code_generator.model.pydantic_base import (
-    DataModelField as _PydanticBaseDataModelField,
+from datamodel_code_generator.model.pydantic_v2._config import (
+    ConfigAttribute,
+    ConfigDict,
+    build_base_config_parameters,
 )
 from datamodel_code_generator.model.pydantic_v2.imports import (
     IMPORT_ALIAS_CHOICES,
@@ -68,10 +70,6 @@ def __repr__(self) -> str:
 class Constraints(_Constraints):
     """Pydantic v2 field constraints with pattern support."""
 
-    # To override existing pattern alias
-    regex: Optional[str] = Field(None, alias="regex")  # noqa: UP045
-    pattern: Optional[str] = Field(None, alias="pattern")  # noqa: UP045
-
     @model_validator(mode="before")  # ty: ignore
     def validate_min_max_items(cls, values: Any) -> dict[str, Any]:  # noqa: N805
         """Validate and convert minItems/maxItems to minLength/maxLength."""
@@ -273,14 +271,6 @@ def imports(self) -> tuple[Import, ...]:
         return base_imports
 
 
-class ConfigAttribute(NamedTuple):
-    """Configuration attribute mapping for ConfigDict conversion."""
-
-    from_: str
-    to: str
-    invert: bool
-
-
 class BaseModel(BaseModelBase):
     """Pydantic v2 BaseModel with ConfigDict and pattern-based regex_engine support."""
 
@@ -356,30 +346,19 @@ def __init__(  # noqa: PLR0913
             keyword_only=keyword_only,
             treat_dot_as_module=treat_dot_as_module,
         )
-        config_parameters: dict[str, Any] = {}
-
-        extra = self._get_config_extra()
-        if extra:
-            config_parameters["extra"] = extra
-
-        # Select CONFIG_ATTRIBUTES based on target_pydantic_version
-        config_attributes = self._get_config_attributes()
-        for from_, to, invert in config_attributes:
-            if from_ in self.extra_template_data:
-                config_parameters[to] = (
-                    not self.extra_template_data[from_] if invert else self.extra_template_data[from_]
-                )
-        for data_type in self.all_data_types:
-            if data_type.is_custom_type:  # pragma: no cover
-                config_parameters["arbitrary_types_allowed"] = True
-                break
+        config_parameters = build_base_config_parameters(
+            extra_template_data=self.extra_template_data,
+            all_data_types=self.all_data_types,
+            config_attributes_v2=self._CONFIG_ATTRIBUTES_V2,
+            config_attributes_v2_11=self._CONFIG_ATTRIBUTES_V2_11,
+        )
 
         if self._has_lookaround_pattern():
             config_parameters["regex_engine"] = '"python-re"'
 
         if isinstance(self.extra_template_data.get("config"), dict):
             for key, value in self.extra_template_data["config"].items():
-                config_parameters[key] = value  # noqa: PERF403
+                config_parameters[key] = value
 
         # Handle json_schema_extra from schema extensions (x-* fields)
         model_extras = self.extra_template_data.get("model_extras")
@@ -388,47 +367,11 @@ def __init__(  # noqa: PLR0913
             config_parameters["json_schema_extra"] = {**existing, **model_extras}
 
         if config_parameters:
-            from datamodel_code_generator.model.pydantic_v2 import ConfigDict  # noqa: PLC0415
-
             self.extra_template_data["config"] = ConfigDict.model_validate(config_parameters)  # ty: ignore
             self._additional_imports.append(IMPORT_CONFIG_DICT)
 
         self._process_validators()
 
-    def _get_config_extra(self) -> Literal["'allow'", "'forbid'", "'ignore'"] | None:
-        additional_properties = self.extra_template_data.get("additionalProperties")
-        unevaluated_properties = self.extra_template_data.get("unevaluatedProperties")
-        allow_extra_fields = self.extra_template_data.get("allow_extra_fields")
-        extra_fields = self.extra_template_data.get("extra_fields")
-
-        config_extra = None
-        if allow_extra_fields or extra_fields == "allow":
-            config_extra = "'allow'"
-        elif extra_fields == "forbid":
-            config_extra = "'forbid'"
-        elif extra_fields == "ignore":
-            config_extra = "'ignore'"
-        elif additional_properties is True:
-            config_extra = "'allow'"
-        elif additional_properties is False:
-            config_extra = "'forbid'"
-        elif unevaluated_properties is True:
-            config_extra = "'allow'"
-        elif unevaluated_properties is False:
-            config_extra = "'forbid'"
-        return config_extra
-
-    def _get_config_attributes(self) -> list[ConfigAttribute]:
-        """Get config attributes based on target Pydantic version.
-
-        If target_pydantic_version is V2_11, use validate_by_name.
-        Otherwise (V2 or not specified), use populate_by_name for compatibility.
-        """
-        target_version = self.extra_template_data.get("target_pydantic_version")
-        if target_version == TargetPydanticVersion.V2_11:
-            return self._CONFIG_ATTRIBUTES_V2_11
-        return self._CONFIG_ATTRIBUTES_V2
-
     def _has_lookaround_pattern(self) -> bool:
         """Check if any field has a regex pattern with lookaround assertions."""
         lookaround_regex = re.compile(r"\(\?<?[=!]")