Backtestspydanticrun-20261013-104308#13661

Issue #13661 Merged fix PR #13668 Run 13 Oct 2026 · run-20261013-104308 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 A = our agent, Patch B = the merged fix.

The Rust changes in generator.rs 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`. This fixes the root cause: the wrap-validator handler (and the generator item validator) built a fresh `Extra` that dropped the runtime settings. Field placement differs slightly, which is immaterial, so correctness is a tie.

The difference is in testing.

Patch A's tests cover every path its change touches:
- **Wrap handler, core level:** `validate_python`, `validate_json` and `validate_strings` through a wrap validator, compared directly against an unwrapped validator.
- **Assignment path:** `validate_assignment` through a wrap handler, which exercises the second modified method.
- **Generator path:** the `InternalValidator` used for lazy generator items.
- **Issue repro:** the exact pydantic-level scenario from the issue (alias_generator, `TypeAdapter.validate_python`, `model_validate_json`), comparing Plain vs Wrapped across three by_alias/by_name combinations.

All of these would fail before the fix.

Patch B's tests are narrower:
- **First test:** checks a wrap model validator and a nested wrap field validator with `model_validate`. This would fail before the fix and is relevant.
- **Second test:** covers strict/extra/from_attributes/context forwarding. These were already forwarded before the patch, so it adds no regression value for this issue.
- **Gaps:** nothing covers JSON validation, the `validate_assignment` code path, or the generator path, even though the patch modifies them.

Scope and craft are comparable. Patch A wins on test coverage of the changed behavior.

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

5m 49s

Wall-clock time in the container

Full test suite

No new failures

488 passed · 92 skipped · 580 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

143vs 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+139 −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..e654e0ab 100644@@ -1,4 +1,5 @@ import datetime+import json import platform import re from copy import deepcopy@@ -1047,3 +1048,66 @@ def test_field_name_preserved_wrap_validator() -> None:     v.validate_python({'f': 1})      assert field_names == [('val1', 'f'), ('val2', 'f')]+++def _aliased_typed_dict_schema() -> core_schema.TypedDictSchema:+    return core_schema.typed_dict_schema(+        {+            'field_a': core_schema.typed_dict_field(+                core_schema.int_schema(), validation_alias='FieldA', required=False+            ),+        },+        config=CoreConfig(validate_by_name=True, validate_by_alias=True),+    )+++@pytest.mark.parametrize(+    'by_alias,by_name,expected',+    [+        (True, False, [{}, {'field_a': 2}]),+        (False, True, [{'field_a': 1}, {}]),+        (True, True, [{'field_a': 1}, {'field_a': 2}]),+    ],+)+def test_wrap_validator_handler_respects_runtime_by_alias_by_name(by_alias, by_name, expected) -> None:+    """https://github.com/pydantic/pydantic/issues/13661"""++    def f(input_value, handler):+        return handler(input_value)++    plain = SchemaValidator(_aliased_typed_dict_schema())+    wrapped = SchemaValidator(core_schema.no_info_wrap_validator_function(f, _aliased_typed_dict_schema()))++    inputs = [{'field_a': 1}, {'FieldA': 2}]+    for v in (plain, wrapped):+        assert [v.validate_python(i, by_alias=by_alias, by_name=by_name) for i in inputs] == expected+        assert [v.validate_json(json.dumps(i), by_alias=by_alias, by_name=by_name) for i in inputs] == expected+        assert [+            v.validate_strings({k: str(val) for k, val in i.items()}, by_alias=by_alias, by_name=by_name)+            for i in inputs+        ] == expected+++@pytest.mark.parametrize(+    'by_alias,by_name,expected',+    [+        (True, False, {}),+        (False, True, {'field_a': 1}),+    ],+)+def test_wrap_validator_assignment_handler_respects_runtime_by_alias_by_name(by_alias, by_name, expected) -> None:+    """https://github.com/pydantic/pydantic/issues/13661"""++    def f(input_value, handler):+        return handler(input_value)++    v = SchemaValidator(+        core_schema.no_info_wrap_validator_function(+            f,+            core_schema.model_fields_schema({'sub': core_schema.model_field(_aliased_typed_dict_schema())}),+        )+    )++    model_dict, _, _ = v.validate_python({'sub': {}})+    new_dict, _, _ = v.validate_assignment(model_dict, 'sub', {'field_a': 1}, by_alias=by_alias, by_name=by_name)+    assert new_dict == {'sub': expected}pydantic-core/tests/validators/test_generator.pyindex 411b2202..70ebbff7 100644@@ -197,3 +197,24 @@ def test_generator_too_short():             'ctx': {'field_type': 'Generator', 'min_length': 4, 'actual_length': 3},         }     ]+++@pytest.mark.parametrize(+    'by_alias,by_name,expected',+    [+        (True, False, [{}, {'field_a': 2}]),+        (False, True, [{'field_a': 1}, {}]),+    ],+)+def test_generator_items_respect_runtime_by_alias_by_name(by_alias, by_name, expected) -> None:+    """https://github.com/pydantic/pydantic/issues/13661"""+    v = SchemaValidator(+        cs.generator_schema(+            items_schema=cs.typed_dict_schema(+                {'field_a': cs.typed_dict_field(cs.int_schema(), validation_alias='FieldA', required=False)},+                config=CoreConfig(validate_by_name=True, validate_by_alias=True),+            )+        )+    )+    gen = v.validate_python([{'field_a': 1}, {'FieldA': 2}], by_alias=by_alias, by_name=by_name)+    assert list(gen) == expectedtests/test_aliases.pyindex c26efb28..00670a0b 100644@@ -15,8 +15,11 @@ from pydantic import (     ConfigDict,     Field,     PydanticUserError,+    TypeAdapter,     ValidationError,+    ValidatorFunctionWrapHandler,     computed_field,+    model_validator, )  @@ -904,3 +907,46 @@ def test_serialization_alias_settings(config: bool | None, runtime: bool | None,      model = Model(my_field=1)     assert model.model_dump(by_alias=runtime) == expected+++@pytest.mark.parametrize(+    'by_alias,by_name,expected',+    [+        (True, False, {'from_name': [], 'from_alias': ['y']}),+        (False, True, {'from_name': ['x'], 'from_alias': []}),+        (True, True, {'from_name': ['x'], 'from_alias': ['y']}),+    ],+)+def test_runtime_by_alias_by_name_with_wrap_model_validator(by_alias: bool, by_name: bool, expected: dict) -> None:+    """https://github.com/pydantic/pydantic/issues/13661"""+    config = ConfigDict(alias_generator=lambda s: s.replace('_', '-'), validate_by_name=True)++    class Plain(BaseModel):+        model_config = config+        build_depends: list[str] = []++    class Wrapped(BaseModel):+        model_config = config+        build_depends: list[str] = []++        @model_validator(mode='wrap')+        @classmethod+        def _noop(cls, data: Any, handler: ValidatorFunctionWrapHandler) -> 'Wrapped':+            return handler(data)++    from_name = {'build_depends': ['x']}+    from_alias = {'build-depends': ['y']}+    for cls in (Plain, Wrapped):+        ta = TypeAdapter(cls)+        assert ta.validate_python(from_name, by_alias=by_alias, by_name=by_name).build_depends == expected['from_name']+        assert (+            ta.validate_python(from_alias, by_alias=by_alias, by_name=by_name).build_depends == expected['from_alias']+        )+        assert (+            cls.model_validate_json('{"build_depends": ["x"]}', by_alias=by_alias, by_name=by_name).build_depends+            == expected['from_name']+        )+        assert (+            cls.model_validate_json('{"build-depends": ["y"]}', by_alias=by_alias, by_name=by_name).build_depends+            == expected['from_alias']+        ) 
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