Backtestspydanticrun-20261005-183002#13661

Issue #13661 Merged fix PR #13668 Run 5 Oct 2026 · run-20261005-183002 pydantic/pydantic

Runtime by_name/by_alias arguments dropped by model_validator(mode="wrap")

Better

Our patch was judged better than the merged fix.

In this judgment, Patch B = our agent, Patch A = the merged fix.

The two Rust changes are functionally identical. Both add `by_alias`/`by_name` fields to `InternalValidator`, capture them from `extra` in `new`, and forward them in both `validate` and `validate_assignment` instead of hardcoding `None`. That fixes the root cause: the wrap handler built a fresh `Extra` that dropped the runtime flags. The only Rust difference is where the new struct fields sit, which does not matter. So correctness and scope are tied, and tests decide it.

Patch A adds one relevant test, covering a model wrap validator and a field wrap validator on `model_validate`. Its second test, on strict/extra/from_attributes/context, exercises settings that were already forwarded before this change. It would likely pass without the fix, so it adds little evidence.

Patch B tests more of the changed code:
- A pydantic-core-level parametrized test of `no_info_wrap_validator_function` that isolates the fix at the layer where it lives.
- A model wrap validator via both `validate_python` and `validate_json`, matching the issue's `TypeAdapter` reproduction.
- A field wrap validator.
- The `validate_assignment` path, which the patch also changes.
- An `Iterable` (generator) case that exercises `InternalValidator` through the generator path in `generator.rs`.

B's tests also check for the specific missing-field error in each direction. Overall they map directly onto each code path the fix touches and would fail before the change. B is the better-verified patch.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

11m 58s

Wall-clock time in the container

Full test suite

No new failures

12,374 passed · 500 skipped · 12,874 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

120vs 89 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

The handler passed to a wrap-mode model validator appears to silently drop the passed-in by_name/by_alias arguments from the top-level validate_python methods.

Example Code

from typing import Self
from pydantic import BaseModel, TypeAdapter, ValidatorFunctionWrapHandler, model_validator

CFG = {"alias_generator": lambda s: s.replace("_", "-"), "validate_by_name": True}

class Plain(BaseModel):
    model_config = CFG
    build_depends: list[str] = []

class Wrapped(BaseModel):
    model_config = CFG
    build_depends: list[str] = []

    @model_validator(mode="wrap")
    @classmethod
    def _noop(cls, data, handler: ValidatorFunctionWrapHandler) -> Self:
        return handler(data)

data = {"build_depends": ["x"]}  # field name, not the alias
print(TypeAdapter(Plain).validate_python(data, by_alias=True, by_name=False))    # build_depends=[]    correct
print(TypeAdapter(Wrapped).validate_python(data, by_alias=True, by_name=False))  # build_depends=['x'] wrong

Python, Pydantic & OS Version

pydantic version: 2.13.4
        pydantic-core version: 2.46.4
          pydantic-core build: profile=release pgo=false
               python version: 3.14.6 (main, Jun 23 2026, 15:18:23) [Clang 22.1.3 ]
                     platform: Linux-6.18.33.2-microsoft-standard-WSL2-x86_64-with-glibc2.39
             related packages: typing_extensions-4.16.0
                       commit: unknown

The two patches

Our patch+116 −4
pydantic-core/src/validators/generator.rsindex 7529248d..702825c4 100644@@ -234,6 +234,8 @@ pub struct InternalValidator {     hide_input_in_errors: bool,     validation_error_cause: bool,     cache_str: jiter::StringCacheMode,+    by_alias: Option<bool>,+    by_name: Option<bool>, }  impl fmt::Debug for InternalValidator {@@ -268,6 +270,8 @@ impl InternalValidator {             hide_input_in_errors,             validation_error_cause,             cache_str: extra.cache_str,+            by_alias: extra.by_alias,+            by_name: extra.by_name,         }     } @@ -286,8 +290,8 @@ impl InternalValidator {             from_attributes: self.from_attributes,             context: self.context.as_ref().map(|data| data.bind(py)),             cache_str: self.cache_str,-            by_alias: None,-            by_name: None,+            by_alias: self.by_alias,+            by_name: self.by_name,         };         let mut state = ValidationState::new(             extra,@@ -329,8 +333,8 @@ impl InternalValidator {             from_attributes: self.from_attributes,             context: self.context.as_ref().map(|data| data.bind(py)),             cache_str: self.cache_str,-            by_alias: None,-            by_name: None,+            by_alias: self.by_alias,+            by_name: self.by_name,         };         let mut state = ValidationState::new(             extra,pydantic-core/tests/validators/test_function.pyindex 32613812..f9c99617 100644@@ -185,6 +185,36 @@ def test_function_wrap_no_info():     assert v.validate_python('input value') == 'input value Changed'  +@pytest.mark.parametrize(+    'by_alias,by_name,input_value,valid',+    [+        (True, False, {'my_alias': 1}, True),+        (True, False, {'my_field': 1}, False),+        (False, True, {'my_field': 1}, True),+        (False, True, {'my_alias': 1}, False),+    ],+)+def test_function_wrap_propagates_by_alias_by_name(by_alias, by_name, input_value, valid):+    def f(input_value, validator):+        return validator(input_value)++    v = SchemaValidator(+        core_schema.no_info_wrap_validator_function(+            f,+            core_schema.typed_dict_schema(+                {'my_field': core_schema.typed_dict_field(core_schema.int_schema(), validation_alias='my_alias')}+            ),+        ),+        config=CoreConfig(validate_by_name=True),+    )++    if valid:+        assert v.validate_python(input_value, by_alias=by_alias, by_name=by_name) == {'my_field': 1}+    else:+        with pytest.raises(ValidationError, match='Field required'):+            v.validate_python(input_value, by_alias=by_alias, by_name=by_name)++ def test_function_wrap_repr():     def f(input_value, validator, info):         assert repr(validator) == str(validator)tests/test_aliases.pyindex c26efb28..9616b2ec 100644@@ -1,3 +1,5 @@+import json+from collections.abc import Iterable from contextlib import AbstractContextManager from contextlib import nullcontext as does_not_raise from inspect import signature@@ -15,8 +17,12 @@ from pydantic import (     ConfigDict,     Field,     PydanticUserError,+    TypeAdapter,     ValidationError,+    ValidatorFunctionWrapHandler,     computed_field,+    field_validator,+    model_validator, )  @@ -876,6 +882,78 @@ def test_user_error_on_validation_methods() -> None:         Model.model_validate_strings("{'my_alias': 1}", by_alias=False, by_name=False)  +def _wrap_noop(value: Any, handler: ValidatorFunctionWrapHandler) -> Any:+    return handler(value)+++class _AliasedInner(BaseModel):+    model_config = ConfigDict(validate_by_name=True)++    my_field: int = Field(alias='my_alias')+++class _WrappedInner(_AliasedInner):+    _wrap = model_validator(mode='wrap')(_wrap_noop)+++@pytest.mark.parametrize('validate_fn', ['validate_python', 'validate_json'])+def test_runtime_by_alias_by_name_with_wrap_model_validator(validate_fn: str) -> None:+    """https://github.com/pydantic/pydantic/issues/13661"""+    ta = TypeAdapter(_WrappedInner)+    validate = getattr(ta, validate_fn)++    def dump(data: dict[str, int]) -> Any:+        return data if validate_fn == 'validate_python' else json.dumps(data)++    with pytest.raises(ValidationError, match='my_alias'):+        validate(dump({'my_field': 1}), by_alias=True, by_name=False)+    assert validate(dump({'my_alias': 1}), by_alias=True, by_name=False).my_field == 1++    with pytest.raises(ValidationError, match='my_field'):+        validate(dump({'my_alias': 1}), by_alias=False, by_name=True)+    assert validate(dump({'my_field': 1}), by_alias=False, by_name=True).my_field == 1+++def test_runtime_by_alias_by_name_with_wrap_field_validator() -> None:+    class Outer(BaseModel):+        inner: _AliasedInner++        _wrap = field_validator('inner', mode='wrap')(_wrap_noop)++    with pytest.raises(ValidationError, match='my_alias'):+        Outer.model_validate({'inner': {'my_field': 1}}, by_alias=True, by_name=False)+    with pytest.raises(ValidationError, match='my_field'):+        Outer.model_validate({'inner': {'my_alias': 1}}, by_alias=False, by_name=True)+    assert Outer.model_validate({'inner': {'my_field': 1}}, by_alias=False, by_name=True).inner.my_field == 1+++def test_runtime_by_alias_by_name_with_wrap_validator_on_assignment() -> None:+    class Outer(BaseModel):+        model_config = ConfigDict(validate_assignment=True)++        inner: _AliasedInner++        _wrap = model_validator(mode='wrap')(_wrap_noop)++    outer = Outer(inner={'my_alias': 1})+    with pytest.raises(ValidationError, match='my_alias'):+        Outer.__pydantic_validator__.validate_assignment(outer, 'inner', {'my_field': 2}, by_alias=True, by_name=False)+    with pytest.raises(ValidationError, match='my_field'):+        Outer.__pydantic_validator__.validate_assignment(outer, 'inner', {'my_alias': 2}, by_alias=False, by_name=True)+    Outer.__pydantic_validator__.validate_assignment(outer, 'inner', {'my_field': 3}, by_alias=False, by_name=True)+    assert outer.inner.my_field == 3+++def test_runtime_by_alias_by_name_with_iterable() -> None:+    ta = TypeAdapter(Iterable[_AliasedInner])++    with pytest.raises(ValidationError, match='my_alias'):+        list(ta.validate_python([{'my_field': 1}], by_alias=True, by_name=False))+    with pytest.raises(ValidationError, match='my_field'):+        list(ta.validate_python([{'my_alias': 1}], by_alias=False, by_name=True))+    assert [m.my_field for m in ta.validate_python([{'my_field': 1}], by_alias=False, by_name=True)] == [1]++ @pytest.mark.parametrize(     'config,runtime,expected',     [ 
Merged fix · PR #13668+85 −4
pydantic-core/src/validators/generator.rsindex 7529248d3..a83527dfe 100644@@ -225,6 +225,8 @@ pub struct InternalValidator {     extra_behavior: Option<ExtraBehavior>,     from_attributes: Option<bool>,     context: Option<Py<PyAny>>,+    by_alias: Option<bool>,+    by_name: Option<bool>,     field_name: Option<Py<PyString>>,     self_instance: Option<Py<PyAny>>,     recursion_guard: RecursionState,@@ -259,6 +261,8 @@ impl InternalValidator {             extra_behavior: extra.extra_behavior,             from_attributes: extra.from_attributes,             context: extra.context.map(|d| d.clone().unbind()),+            by_alias: extra.by_alias,+            by_name: extra.by_name,             field_name: state.field_name().map(|d| d.clone().unbind()),             self_instance: state.self_instance.map(|d| d.clone().unbind()),             recursion_guard: state.recursion_guard.clone(),@@ -286,8 +290,8 @@ impl InternalValidator {             from_attributes: self.from_attributes,             context: self.context.as_ref().map(|data| data.bind(py)),             cache_str: self.cache_str,-            by_alias: None,-            by_name: None,+            by_alias: self.by_alias,+            by_name: self.by_name,         };         let mut state = ValidationState::new(             extra,@@ -329,8 +333,8 @@ impl InternalValidator {             from_attributes: self.from_attributes,             context: self.context.as_ref().map(|data| data.bind(py)),             cache_str: self.cache_str,-            by_alias: None,-            by_name: None,+            by_alias: self.by_alias,+            by_name: self.by_name,         };         let mut state = ValidationState::new(             extra,tests/test_validators.pyindex 0a5bc5f04..7e9f47137 100644@@ -3177,3 +3177,80 @@ def test_model_validate_json_default_value_validator_with_validation_info() -> N     f2 = Foo.model_validate_json('{"field1": 1}', context='context')      assert f1.field == f2.field == 2+++def test_wrap_validator_forwards_by_alias_by_name() -> None:+    """https://github.com/pydantic/pydantic/issues/13661"""++    class Inner(BaseModel):+        model_config = ConfigDict(validate_by_name=True)++        build_depends: list[str] = Field(default=[], alias='build-depends')++        @model_validator(mode='wrap')+        @classmethod+        def _wrap(cls, data: Any, handler: ValidatorFunctionWrapHandler) -> Any:+            return handler(data)++    class Outer(BaseModel):+        inner: Inner++        @field_validator('inner', mode='wrap')+        @classmethod+        def _wrap(cls, v: Any, handler: ValidatorFunctionWrapHandler) -> Any:+            return handler(v)++    by_name = {'build_depends': ['x']}+    by_alias = {'build-depends': ['x']}++    assert Inner.model_validate(by_name, by_alias=True, by_name=False).build_depends == []+    assert Inner.model_validate(by_alias, by_alias=True, by_name=False).build_depends == ['x']+    assert Inner.model_validate(by_name, by_alias=False, by_name=True).build_depends == ['x']+    assert Inner.model_validate(by_alias, by_alias=False, by_name=True).build_depends == []++    assert Outer.model_validate({'inner': by_name}, by_alias=True, by_name=False).inner.build_depends == []+    assert Outer.model_validate({'inner': by_alias}, by_alias=False, by_name=True).inner.build_depends == []+++def test_wrap_validator_forwards_runtime_settings() -> None:+    class Inner(BaseModel):+        a: int++        @model_validator(mode='wrap')+        @classmethod+        def _wrap(cls, data: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo) -> Any:+            assert info.context == 'ctx'+            return handler(data)++        @field_validator('a', mode='wrap')+        @classmethod+        def _wrap_a(cls, v: Any, handler: ValidatorFunctionWrapHandler, info: ValidationInfo) -> Any:+            assert info.context == 'ctx'+            return handler(v)++    class Outer(BaseModel):+        inner: Inner++        @field_validator('inner', mode='wrap')+        @classmethod+        def _wrap(cls, v: Any, handler: ValidatorFunctionWrapHandler) -> Any:+            return handler(v)++    # strict:+    assert Outer.model_validate({'inner': {'a': '1'}}, context='ctx').inner.a == 1+    with pytest.raises(ValidationError, match='Input should be a valid integer'):+        Outer.model_validate({'inner': {'a': '1'}}, strict=True, context='ctx')++    # extra:+    m = Outer.model_validate({'inner': {'a': 1, 'b': 2}}, extra='allow', context='ctx')+    assert m.inner.model_extra == {'b': 2}+    with pytest.raises(ValidationError, match='Extra inputs are not permitted'):+        Outer.model_validate({'inner': {'a': 1, 'b': 2}}, extra='forbid', context='ctx')++    # from_attributes:+    class InnerObj:+        a = 1++    with pytest.raises(ValidationError, match='Input should be a valid dictionary'):+        Outer.model_validate({'inner': InnerObj()}, context='ctx')+    assert Outer.model_validate({'inner': InnerObj()}, from_attributes=True, context='ctx').inner.a == 1