datamodel-code-generator 0.60.1__tar.gz → 0.60.2__tar.gz

{datamodel_code_generator-0.60.1 → datamodel_code_generator-0.60.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datamodel-code-generator
-Version: 0.60.1
+Version: 0.60.2
 Summary: Datamodel Code Generator
 Project-URL: Homepage, https://github.com/koxudaxi/datamodel-code-generator
 Project-URL: Source, https://github.com/koxudaxi/datamodel-code-generator

{datamodel_code_generator-0.60.1 → datamodel_code_generator-0.60.2}/src/datamodel_code_generator/model/base.py

@@ -129,6 +129,20 @@ def comment_safe(value: str | None) -> str | None:
     return value.replace("\r\n", "\n").replace("\r", "\n")
 
 
+def inline_comment_safe(value: str | None) -> str | None:
+    """Make a value safe for a generated inline Python comment."""
+    if value is None:
+        return None
+    safe_value = comment_safe(value) or ""
+    return safe_value.replace("\v", "\n").replace("\f", "\n").replace("\n", "\n# ")
+
+
+def _safe_extra_template_data(extra_template_data: dict[str, Any]) -> dict[str, Any]:
+    if not isinstance(comment := extra_template_data.get("comment"), str):
+        return extra_template_data
+    return {**extra_template_data, "comment": inline_comment_safe(comment)}
+
+
 class _RenderedDataModelField:
     """Proxy a field with a pre-rendered docstring for built-in templates."""
 
@@ -990,6 +1004,10 @@ class DataModel(TemplateBase, Nullable, ABC):  # noqa: PLR0904
     def render(self, *, class_name: str | None = None) -> str:
         """Render the model to a string using the template."""
         use_custom_template = self.template_file_path.is_absolute()
+        if use_custom_template:
+            extra_template_data = self.extra_template_data
+        else:
+            extra_template_data = _safe_extra_template_data(self.extra_template_data)
         return self._render(
             class_name=class_name or self.class_name,
             fields=self.fields if use_custom_template else self.rendered_fields,
@@ -1001,7 +1019,7 @@ class DataModel(TemplateBase, Nullable, ABC):  # noqa: PLR0904
             else self.rendered_description,
             dataclass_arguments=self.dataclass_arguments,
             path=self.path,
-            **self.extra_template_data,
+            **extra_template_data,
         )
 
     @property

{datamodel_code_generator-0.60.1 → datamodel_code_generator-0.60.2}/src/datamodel_code_generator/model/pydantic_v2/base_model.py

@@ -10,7 +10,7 @@ import re
 from collections import defaultdict
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, NamedTuple, Optional
 
-from pydantic import Field, field_validator, model_validator
+from pydantic import Field, ValidationError, field_validator, model_validator
 
 from datamodel_code_generator.imports import IMPORT_ANY, Import
 from datamodel_code_generator.model import _rebuild_model_with_datamodel_namespace
@@ -40,6 +40,7 @@ from datamodel_code_generator.model.pydantic_v2.imports import (
 )
 from datamodel_code_generator.reference import ModelResolver
 from datamodel_code_generator.types import chain_as_tuple
+from datamodel_code_generator.validators import format_validation_error, normalize_validators
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -404,10 +405,19 @@ class BaseModel(BaseModelBase):
 
     def _process_validators(self) -> None:
         """Process validator definitions and prepare them for template rendering."""
+        self.extra_template_data.pop("prepared_validators", None)
         validators = self.extra_template_data.get("validators")
         if not validators:
             return
 
+        try:
+            validators = normalize_validators(validators)
+        except ValidationError as e:
+            from datamodel_code_generator import Error  # noqa: PLC0415
+
+            msg = f"Invalid validators configuration: {format_validation_error(e)}"
+            raise Error(msg) from e
+
         prepared_validators: list[dict[str, Any]] = []
         scoped_resolver = ModelResolver(custom_class_name_generator=lambda name: name)
         for validator in validators:
@@ -420,12 +430,12 @@ class BaseModel(BaseModelBase):
             function_name = function_path.rsplit(".", 1)[-1]
             mode = validator.get("mode", "after")
 
-            fields_str = ", ".join(f"'{f}'" for f in fields)
+            fields_str = ", ".join(repr(f) for f in fields)
 
             base_method_name = f"{function_name}_validator"
             method_name = scoped_resolver.add([base_method_name], base_method_name, unique=True, class_name=True).name
 
-            mode_str = f"mode='{mode}'"
+            mode_str = f"mode={mode!r}"
 
             prepared_validators.append({
                 "fields_str": fields_str,

{datamodel_code_generator-0.60.1 → datamodel_code_generator-0.60.2}/src/datamodel_code_generator/parser/jsonschema.py

@@ -77,6 +77,7 @@ from datamodel_code_generator.types import (
     extract_qualified_names,
     get_subscript_args,
     get_type_base_name,
+    is_python_type_annotation,
 )
 from datamodel_code_generator.util import BaseModel
 
@@ -613,6 +614,17 @@ DEFAULT_FIELD_KEYS: set[str] = {
     "xml",
 }
 
+ALLOWED_DEFAULT_FACTORIES: frozenset[str] = frozenset({"dict", "list", "set"})
+
+
+def _validate_default_factory(default_factory: Any) -> str:
+    if isinstance(default_factory, str) and default_factory in ALLOWED_DEFAULT_FACTORIES:
+        return default_factory
+    allowed_values = ", ".join(sorted(ALLOWED_DEFAULT_FACTORIES))
+    msg = f"default_factory must be one of: {allowed_values}"
+    raise Error(msg)
+
+
 DEFAULT_MODEL_EXTRA_KEYS: set[str] = {
     "contentEncoding",
     "contentMediaType",
@@ -809,6 +821,8 @@ class JsonSchemaParser(Parser["JSONSchemaParserConfig", "JsonSchemaFeatures"]):
             }
         if self.default_field_extras:
             extras.update(self.default_field_extras)
+        if (default_factory := extras.get("default_factory", UNDEFINED)) is not UNDEFINED:
+            extras["default_factory"] = _validate_default_factory(default_factory)
         return extras
 
     @cached_property
@@ -1939,7 +1953,7 @@ class JsonSchemaParser(Parser["JSONSchemaParserConfig", "JsonSchemaFeatures"]):
         if model_extras:
             self.extra_template_data[path]["model_extras"] = model_extras
 
-    def _get_python_type_flags(self, obj: JsonSchemaObject) -> dict[str, bool]:  # noqa: PLR6301
+    def _get_python_type_flags(self, obj: JsonSchemaObject) -> dict[str, bool]:
         """Get container type flags from x-python-type extension.
 
         Returns a dict with flags like is_set, is_frozen_set, is_mapping, is_sequence
@@ -1948,8 +1962,7 @@ class JsonSchemaParser(Parser["JSONSchemaParserConfig", "JsonSchemaFeatures"]):
         Note: This is an instance method (not static) due to the snooper_to_methods
         class decorator which does not preserve staticmethod descriptors.
         """
-        x_python_type = obj.extras.get("x-python-type")
-        if not x_python_type or not isinstance(x_python_type, str):
+        if (x_python_type := self._get_x_python_type(obj)) is None:
             return {}
 
         type_to_flag: dict[str, dict[str, bool]] = {
@@ -2010,6 +2023,16 @@ class JsonSchemaParser(Parser["JSONSchemaParserConfig", "JsonSchemaFeatures"]):
             pattern = r"(?<![.\w])([A-Za-z_]\w*)"
             return re.findall(pattern, type_str)
 
+    def _get_x_python_type(self, obj: JsonSchemaObject) -> str | None:  # noqa: PLR6301
+        """Return a validated x-python-type value."""
+        x_python_type = obj.extras.get("x-python-type")
+        if not x_python_type or not isinstance(x_python_type, str):
+            return None
+        if is_python_type_annotation(x_python_type):
+            return x_python_type
+        msg = "x-python-type must be a valid Python type annotation"
+        raise Error(msg)
+
     @staticmethod
     @lru_cache(maxsize=256)
     def _resolve_type_import_dynamic(type_name: str) -> Import | None:
@@ -2054,8 +2077,7 @@ class JsonSchemaParser(Parser["JSONSchemaParserConfig", "JsonSchemaFeatures"]):
 
     def _get_python_type_override(self, obj: JsonSchemaObject) -> DataType | None:
         """Get DataType from x-python-type if it's incompatible with schema type."""
-        x_python_type = obj.extras.get("x-python-type")
-        if not x_python_type or not isinstance(x_python_type, str):
+        if (x_python_type := self._get_x_python_type(obj)) is None:
             return None
 
         schema_type = obj.type if isinstance(obj.type, str) else None

{datamodel_code_generator-0.60.1 → datamodel_code_generator-0.60.2}/src/datamodel_code_generator/types.py

@@ -277,6 +277,49 @@ def extract_qualified_names(type_str: str) -> list[str]:
     return qualified_names
 
 
+@lru_cache(maxsize=1024)
+def is_python_type_annotation(type_str: str) -> bool:
+    """Return whether a string is a Python type annotation expression."""
+    try:
+        tree = ast.parse(type_str, mode="eval")
+    except SyntaxError:
+        return False
+
+    return _is_python_type_annotation_node(tree.body, allow_literal=False)
+
+
+def _is_python_type_annotation_node(node: ast.AST, *, allow_literal: bool) -> bool:
+    match node:
+        case ast.Name():
+            result = True
+        case ast.Attribute(value=value):
+            result = isinstance(value, (ast.Name, ast.Attribute)) and _is_python_type_annotation_node(
+                value,
+                allow_literal=False,
+            )
+        case ast.Subscript(value=value, slice=slice_node):
+            result = _is_python_type_annotation_node(
+                value,
+                allow_literal=False,
+            ) and _is_python_type_annotation_node(slice_node, allow_literal=True)
+        case ast.Tuple(elts=elts) | ast.List(elts=elts):
+            result = all(_is_python_type_annotation_node(elt, allow_literal=True) for elt in elts)
+        case ast.BinOp(left=left, op=ast.BitOr(), right=right):
+            result = _is_python_type_annotation_node(left, allow_literal=False) and _is_python_type_annotation_node(
+                right,
+                allow_literal=False,
+            )
+        case ast.Constant(value=None):
+            result = True
+        case ast.Constant(value=value) if allow_literal:
+            result = value is None or value is Ellipsis or isinstance(value, (str, int, float, bool))
+        case ast.UnaryOp(op=ast.UAdd() | ast.USub(), operand=ast.Constant(value=value)) if allow_literal:
+            result = isinstance(value, (int, float))
+        case _:
+            result = False
+    return result
+
+
 def _remove_none_from_union(type_: str, *, use_union_operator: bool) -> str:  # noqa: PLR0912
     """Remove None from a Union type string, handling nested unions."""
     if use_union_operator:

datamodel_code_generator-0.60.2/src/datamodel_code_generator/validators.py

@@ -0,0 +1,124 @@
+"""Validator definitions for generated Pydantic models.
+
+Provides types for defining custom field validators that can be added to generated models.
+"""
+
+from __future__ import annotations
+
+import keyword
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel, RootModel, ValidationError, field_validator
+
+_MIN_DOTTED_PATH_PARTS = 2
+
+
+class ValidatorMode(str, Enum):
+    """Validator mode for Pydantic v2 field_validator."""
+
+    BEFORE = "before"
+    AFTER = "after"
+    WRAP = "wrap"
+    PLAIN = "plain"
+
+
+def _is_python_identifier(value: str) -> bool:
+    return value.isidentifier() and not keyword.iskeyword(value)
+
+
+def _validate_python_identifier(value: str) -> str:
+    if not _is_python_identifier(value):
+        msg = f"must be a valid Python identifier: {value!r}"
+        raise ValueError(msg)
+    return value
+
+
+def _validate_dotted_python_identifier_path(value: str) -> str:
+    parts = value.split(".")
+    if len(parts) < _MIN_DOTTED_PATH_PARTS or any(not _is_python_identifier(part) for part in parts):
+        msg = f"must be a dotted Python identifier path: {value!r}"
+        raise ValueError(msg)
+    return value
+
+
+def _validator_mode_values() -> set[str]:
+    return {mode.value for mode in ValidatorMode}
+
+
+class ValidatorDefinition(BaseModel):
+    """Definition of a single validator."""
+
+    field: str | None = None
+    fields: list[str] | None = None
+    function: str
+    mode: ValidatorMode = ValidatorMode.AFTER
+
+    @field_validator("field")
+    @classmethod
+    def validate_field(cls, value: str | None) -> str | None:
+        """Validate a single field name."""
+        if value is None:
+            return value
+        return _validate_python_identifier(value)
+
+    @field_validator("fields")
+    @classmethod
+    def validate_fields(cls, value: list[str] | None) -> list[str] | None:
+        """Validate multiple field names."""
+        if value is None:
+            return value
+        for field_name in value:
+            _validate_python_identifier(field_name)
+        return value
+
+    @field_validator("function")
+    @classmethod
+    def validate_function(cls, value: str) -> str:
+        """Validate the imported validator function path."""
+        return _validate_dotted_python_identifier_path(value)
+
+    @field_validator("mode", mode="before")
+    @classmethod
+    def validate_mode(cls, value: Any) -> Any:
+        """Validate the Pydantic field_validator mode."""
+        if isinstance(value, ValidatorMode):
+            return value
+        if isinstance(value, str) and value in _validator_mode_values():
+            return value
+        allowed_values = ", ".join(repr(mode.value) for mode in ValidatorMode)
+        msg = f"must be one of: {allowed_values}"
+        raise ValueError(msg)
+
+
+class ModelValidators(BaseModel):
+    """Validators configuration for a single model."""
+
+    validators: list[ValidatorDefinition]
+
+
+class ValidatorsConfig(RootModel[dict[str, ModelValidators]]):
+    """Root model for validators configuration."""
+
+
+def format_validation_error(error: ValidationError) -> str:
+    """Format the first Pydantic validation error as a concise, stable message."""
+    errors = error.errors()
+    if not errors:
+        return str(error)  # pragma: no cover
+
+    first_error = errors[0]
+    location = ".".join(str(part) for part in first_error.get("loc", ()))
+    context = first_error.get("ctx") or {}
+    context_error = context.get("error")
+    message = str(context_error) if context_error else str(first_error["msg"])
+
+    if location:
+        return f"{location}: {message}"
+    return message
+
+
+def normalize_validators(validators: Any) -> list[dict[str, Any]]:
+    """Validate and normalize raw validators extra template data."""
+    model_validators = ModelValidators.model_validate({"validators": validators})
+    return [validator.model_dump(mode="json", exclude_none=True) for validator in model_validators.validators]

datamodel_code_generator-0.60.2/tests/data/expected/validators/format_validation_error_without_location.txt

@@ -0,0 +1 @@
+plain message

{datamodel_code_generator-0.60.1 → datamodel_code_generator-0.60.2}/tests/main/jsonschema/test_main_jsonschema.py

@@ -3106,6 +3106,56 @@ def test_main_jsonschema_field_extras(output_file: Path) -> None:
     )
 
 
+@pytest.mark.parametrize(
+    "default_factory",
+    [
+        "__import__('builtins').print('DF_EXEC') or str",
+        "lambda: []",
+        "datetime.utcnow",
+        None,
+    ],
+)
+@pytest.mark.parametrize(
+    "output_model",
+    [
+        "pydantic_v2.BaseModel",
+        "pydantic_v2.dataclass",
+        "dataclasses.dataclass",
+        "msgspec.Struct",
+    ],
+)
+def test_main_jsonschema_default_factory_rejects_unsafe_value(
+    default_factory: object,
+    output_model: str,
+    output_file: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Reject unsafe schema-supplied default_factory values."""
+    input_file = output_file.with_suffix(".json")
+    input_file.write_text(
+        json.dumps({
+            "type": "object",
+            "properties": {
+                "payload": {
+                    "type": "string",
+                    "default_factory": default_factory,
+                }
+            },
+        }),
+        encoding="utf-8",
+    )
+    run_main_and_assert(
+        input_path=input_file,
+        output_path=output_file,
+        input_file_type="jsonschema",
+        expected_exit=Exit.ERROR,
+        output_should_not_exist=True,
+        capsys=capsys,
+        expected_stderr_contains="default_factory must be one of: dict, list, set",
+        extra_args=["--output-model-type", output_model],
+    )
+
+
 def test_main_jsonschema_custom_base_path(output_file: Path) -> None:
     """Test custom base path configuration."""
     run_main_and_assert(
@@ -10510,6 +10560,57 @@ def test_main_jsonschema_x_python_import_unused(output_file: Path) -> None:
     )
 
 
+@pytest.mark.parametrize(
+    "x_python_type",
+    [
+        "X[1]; __import__('builtins').print('XPT_EXEC') #",
+        "__import__('builtins').print('XPT_EXEC')",
+        "Callable[[str], __import__('builtins').print('XPT_EXEC')]",
+        "str\nprint('XPT_EXEC')\n#",
+    ],
+)
+@pytest.mark.parametrize(
+    "output_model",
+    [
+        "pydantic_v2.BaseModel",
+        "pydantic_v2.dataclass",
+        "dataclasses.dataclass",
+        "msgspec.Struct",
+        "typing.TypedDict",
+    ],
+)
+def test_x_python_type_rejects_unsafe_value(
+    x_python_type: str,
+    output_model: str,
+    output_file: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Reject unsafe x-python-type values."""
+    input_file = output_file.with_suffix(".json")
+    input_file.write_text(
+        json.dumps({
+            "type": "object",
+            "properties": {
+                "payload": {
+                    "type": "string",
+                    "x-python-type": x_python_type,
+                }
+            },
+        }),
+        encoding="utf-8",
+    )
+    run_main_and_assert(
+        input_path=input_file,
+        output_path=output_file,
+        input_file_type="jsonschema",
+        expected_exit=Exit.ERROR,
+        output_should_not_exist=True,
+        capsys=capsys,
+        expected_stderr_contains="x-python-type must be a valid Python type annotation",
+        extra_args=["--output-model-type", output_model],
+    )
+
+
 def test_x_python_type_callable(output_file: Path) -> None:
     """Test x-python-type with Callable preserves the Callable type."""
     run_main_and_assert(
@@ -10841,6 +10942,194 @@ def test_field_validators_multi_fields(output_file: Path) -> None:
     )
 
 
+def test_extra_template_data_field_validators(output_file: Path, tmp_path: Path) -> None:
+    """Test validators supplied through extra template data."""
+    extra_template_data = tmp_path / "extra_template_data_validators.json"
+    extra_template_data.write_text(
+        json.dumps({
+            "User": {
+                "validators": [
+                    {
+                        "field": "name",
+                        "function": "myapp.validators.validate_name",
+                        "mode": "before",
+                    },
+                    {
+                        "field": "email",
+                        "function": "myapp.validators.validate_email",
+                        "mode": "after",
+                    },
+                ]
+            }
+        })
+    )
+
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "field_validators.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        assert_func=assert_file_content,
+        expected_file="field_validators.py",
+        extra_args=[
+            "--extra-template-data",
+            str(extra_template_data),
+            "--output-model-type",
+            "pydantic_v2.BaseModel",
+            "--disable-timestamp",
+        ],
+        skip_code_validation=True,
+    )
+
+
+@pytest.mark.parametrize("extra_template_data_key", ["User", "#all#"])
+def test_extra_template_data_prepared_validators_ignored(
+    output_file: Path,
+    tmp_path: Path,
+    extra_template_data_key: str,
+) -> None:
+    """Ignore prepared validator data supplied through extra template data."""
+    extra_template_data = tmp_path / "extra_template_data_prepared_validators.json"
+    extra_template_data.write_text(
+        json.dumps({
+            extra_template_data_key: {
+                "prepared_validators": [
+                    {
+                        "fields_str": "'name'); __import__('os').system('touch pwned') #",
+                        "mode_str": "mode='after'",
+                        "method_name": "validate_name_validator",
+                        "function_name": "validate_name",
+                        "mode": "after",
+                    }
+                ]
+            }
+        })
+    )
+
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "field_validators.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        assert_func=assert_file_content,
+        expected_file="field_validators_all_skipped.py",
+        extra_args=[
+            "--extra-template-data",
+            str(extra_template_data),
+            "--output-model-type",
+            "pydantic_v2.BaseModel",
+            "--disable-timestamp",
+        ],
+        skip_code_validation=True,
+    )
+
+
+@pytest.mark.parametrize(
+    ("validator", "expected_message"),
+    [
+        (
+            {
+                "field": "name', __import__('os').system('touch pwned'), 'email",
+                "function": "myapp.validators.validate_name",
+            },
+            (
+                "validators.0.field: must be a valid Python identifier: "
+                "\"name', __import__('os').system('touch pwned'), 'email\""
+            ),
+        ),
+        (
+            {
+                "fields": ["name", "email', __import__('os').system('touch pwned'), 'age"],
+                "function": "myapp.validators.validate_name",
+            },
+            (
+                "validators.0.fields: must be a valid Python identifier: "
+                "\"email', __import__('os').system('touch pwned'), 'age\""
+            ),
+        ),
+        (
+            {
+                "field": "name",
+                "function": "myapp.validators.validate_name;__import__('os').system('touch pwned')",
+            },
+            (
+                "validators.0.function: must be a dotted Python identifier path: "
+                "\"myapp.validators.validate_name;__import__('os').system('touch pwned')\""
+            ),
+        ),
+        (
+            {
+                "field": "name",
+                "function": "myapp.validators.validate_name",
+                "mode": "after', __import__('os').system('touch pwned'), mode='after",
+            },
+            "validators.0.mode: must be one of: 'before', 'after', 'wrap', 'plain'",
+        ),
+    ],
+)
+def test_extra_template_data_field_validators_reject_unsafe_values(
+    output_file: Path,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    validator: dict[str, str | list[str]],
+    expected_message: str,
+) -> None:
+    """Test unsafe extra template data validators fail before code generation."""
+    extra_template_data = tmp_path / "extra_template_data_invalid_validators.json"
+    extra_template_data.write_text(json.dumps({"User": {"validators": [validator]}}))
+
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "field_validators.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        expected_exit=Exit.ERROR,
+        extra_args=[
+            "--extra-template-data",
+            str(extra_template_data),
+            "--output-model-type",
+            "pydantic_v2.BaseModel",
+        ],
+        capsys=capsys,
+        expected_stderr=f"Invalid validators configuration: {expected_message}\n",
+        output_should_not_exist=True,
+    )
+
+
+def test_validators_option_rejects_unsafe_values(
+    output_file: Path,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Test unsafe validators file values fail before code generation."""
+    validators_config = tmp_path / "invalid_validators_config.json"
+    validators_config.write_text(
+        json.dumps({
+            "User": {
+                "validators": [
+                    {
+                        "field": "name', __import__('os').system('touch pwned'), 'email",
+                        "function": "myapp.validators.validate_name",
+                    }
+                ]
+            }
+        })
+    )
+
+    run_main_and_assert(
+        input_path=JSON_SCHEMA_DATA_PATH / "field_validators.json",
+        output_path=output_file,
+        input_file_type="jsonschema",
+        expected_exit=Exit.ERROR,
+        extra_args=[
+            "--validators",
+            str(validators_config),
+            "--output-model-type",
+            "pydantic_v2.BaseModel",
+        ],
+        capsys=capsys,
+        expected_stderr_contains="must be a valid Python identifier",
+        output_should_not_exist=True,
+    )
+
+
 def test_field_validators_wrap_mode(output_file: Path, tmp_path: Path) -> None:
     """Test validators with wrap mode."""
     config_file = tmp_path / "wrap_mode_config.json"