Backtestspydanticrun-20261013-104308#13601

Issue #13601 Merged fix PR #13702 Run 13 Oct 2026 · run-20261013-104308 pydantic/pydantic

model_dump(exclude=...) is silently ignored in python mode when a wrap model_serializer is gated with when_used="json"

Better

Our patch was judged better than the merged fix.

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

Both patches fix the bug at its root cause in the same way. In `function.rs`, the function serializer used to clear include/exclude unconditionally before delegating to the return or fallback serializer. Both patches now clear it only when the user function actually ran. When `when_used` skips the function, the caller's include/exclude reaches the fallback serializer. Patch A passes the existing `state` straight through. Patch B re-scopes with a clone of the current include/exclude via a new `include_exclude()` accessor. These behave the same, and both cover `to_python`, `json_key` and `serde_serialize`, so correctness is a wash. On craft, Patch B is tidier: it adds the include/exclude value to the match tuple and keeps a single call site. Patch A uses a `used` flag with two near-identical if/else branches, which is more verbose but clear and well commented. Tests are where they differ. Patch B adds one test covering plain and wrap model serializers with `when_used='json'`, checking python-mode exclude/include and JSON-mode output. Patch A adds core-level tests in `pydantic-core` and parametrizes over `json` and `json-unless-none`. It also checks `to_json` and `model_dump_json`, covers the plain-function fallback for `unless-none` and the nullable case, and covers nested models (including `__all__` list exclusion) and field-level wrap serializers. All of these would fail before the fix. That is a more thorough regression suite for the exact scenarios the issue raises, including the identity-handler wrap case from the report, which Patch B's test does not use. Tests outrank craft, so Patch A's stronger and more targeted tests outweigh Patch B's slightly cleaner implementation.

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 54s

Wall-clock time in the container

Full test suite

No new failures

404 passed · 91 skipped · 495 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

175vs 59 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

When a model declares @model_serializer(mode="wrap") with when_used="json" (or "json-unless-none"), the runtime exclude argument passed to model_dump() is silently ignored in python mode. The same call in JSON mode behaves correctly.

Expected: model_dump(exclude={"b"}) omits b regardless of when_used, since the gate concerns which serializer runs and not which fields the caller asked to drop.

Actual: b is present in python mode.

Example Code

from pydantic import BaseModel, SerializerFunctionWrapHandler, model_serializer


class Gated(BaseModel):
    a: int
    b: int

    @model_serializer(mode="wrap", when_used="json")
    def _serialize(self, handler: SerializerFunctionWrapHandler) -> object:
        return handler(self)


class Always(BaseModel):
    a: int
    b: int

    @model_serializer(mode="wrap")
    def _serialize(self, handler: SerializerFunctionWrapHandler) -> object:
        return handler(self)


  # Gated to JSON: python mode ignores exclude.
  print(Gated(a=1, b=2).model_dump(exclude={"b"}))               # {'a': 1, 'b': 2}  <-- expected {'a': 1}
  print(Gated(a=1, b=2).model_dump(mode="json", exclude={"b"}))  # {'a': 1}          <-- correct

  # Identical model without the gate: python mode honours exclude.
  print(Always(a=1, b=2).model_dump(exclude={"b"}))              # {'a': 1}

  Output:

  gated  python: {'a': 1, 'b': 2}
  gated  json  : {'a': 1}
  always python: {'a': 1}

Python, Pydantic & OS Version

pydantic version: 2.13.2
          pydantic-core version: 2.46.2
            pydantic-core build: profile=release pgo=false
                 python version: 3.13.12 (main, Mar 25 2026, 02:48:22) [Clang 22.1.1 ]
                       platform: macOS-26.6-arm64-arm-64bit-Mach-O
               related packages: mypy-2.1.0 typing_extensions-4.15.0

Reproducible in 2.13.3 and 2.13.4 as well.

The two patches

Our patch+155 −20
pydantic-core/src/serializers/type_serializers/function.rsindex 5944310c..340da450 100644@@ -217,17 +217,23 @@ macro_rules! function_type_serializer {                 state: &mut SerializationState<'py>,             ) -> PyResult<Py<PyAny>> {                 let py = value.py();-                let (ret_serializer, v) = match self.call(value, state) {-                    Ok((true, v)) => (&*self.return_serializer, v),-                    Ok((false, v)) => (self.get_fallback_serializer(), v),+                let (ret_serializer, v, used) = match self.call(value, state) {+                    Ok((true, v)) => (&*self.return_serializer, v, true),+                    Ok((false, v)) => (self.get_fallback_serializer(), v, false),                     Err(err) => {                         on_error(py, err, &self.function_name, state)?;                         return infer_to_python(value, state);                     }                 };-                // None for include/exclude here, as filtering should be done-                let state = &mut state.scoped_include_exclude(IncludeExclude::empty());-                ret_serializer.to_python(v.bind(py), state)+                if used {+                    // None for include/exclude here, as filtering should be done by the function+                    let state = &mut state.scoped_include_exclude(IncludeExclude::empty());+                    ret_serializer.to_python(v.bind(py), state)+                } else {+                    // the function was skipped (see `when_used`), so the fallback serializer+                    // must apply the caller's include/exclude+                    ret_serializer.to_python(v.bind(py), state)+                }             }              fn json_key<'a, 'py>(@@ -236,19 +242,24 @@ macro_rules! function_type_serializer {                 state: &mut SerializationState<'py>,             ) -> PyResult<Cow<'a, str>> {                 let py = key.py();-                let (ret_serializer, v) = match self.call(key, state) {-                    Ok((true, v)) => (&*self.return_serializer, v),-                    Ok((false, v)) => (self.get_fallback_serializer(), v),+                let (ret_serializer, v, used) = match self.call(key, state) {+                    Ok((true, v)) => (&*self.return_serializer, v, true),+                    Ok((false, v)) => (self.get_fallback_serializer(), v, false),                     Err(err) => {                         on_error(py, err, &self.function_name, state)?;                         return infer_json_key(key, state);                     }                 };-                // None for include/exclude here, as filtering should be done-                let state = &mut state.scoped_include_exclude(IncludeExclude::empty());-                ret_serializer-                    .json_key(v.bind(py), state)-                    .map(|cow| Cow::Owned(cow.into_owned()))+                let key = if used {+                    // None for include/exclude here, as filtering should be done by the function+                    let state = &mut state.scoped_include_exclude(IncludeExclude::empty());+                    ret_serializer.json_key(v.bind(py), state)?.into_owned()+                } else {+                    // the function was skipped (see `when_used`), so the fallback serializer+                    // must apply the caller's include/exclude+                    ret_serializer.json_key(v.bind(py), state)?.into_owned()+                };+                Ok(Cow::Owned(key))             }              fn serde_serialize<'py, S: serde::ser::Serializer>(@@ -258,17 +269,23 @@ macro_rules! function_type_serializer {                 state: &mut SerializationState<'py>,             ) -> Result<S::Ok, S::Error> {                 let py = value.py();-                let (ret_serializer, v) = match self.call(value, state) {-                    Ok((true, v)) => (&*self.return_serializer, v),-                    Ok((false, v)) => (self.get_fallback_serializer(), v),+                let (ret_serializer, v, used) = match self.call(value, state) {+                    Ok((true, v)) => (&*self.return_serializer, v, true),+                    Ok((false, v)) => (self.get_fallback_serializer(), v, false),                     Err(err) => {                         on_error(py, err, &self.function_name, state).map_err(py_err_se_err)?;                         return infer_serialize(value, serializer, state);                     }                 };-                // None for include/exclude here, as filtering should be done-                let mut state = state.scoped_include_exclude(IncludeExclude::empty());-                ret_serializer.serde_serialize(v.bind(py), serializer, &mut state)+                if used {+                    // None for include/exclude here, as filtering should be done by the function+                    let mut state = state.scoped_include_exclude(IncludeExclude::empty());+                    ret_serializer.serde_serialize(v.bind(py), serializer, &mut state)+                } else {+                    // the function was skipped (see `when_used`), so the fallback serializer+                    // must apply the caller's include/exclude+                    ret_serializer.serde_serialize(v.bind(py), serializer, state)+                }             }              fn get_name(&self) -> &str {pydantic-core/tests/serializers/test_functions.pyindex b6bd900e..87091e9b 100644@@ -304,6 +304,46 @@ def test_function_only_json():     assert s.to_json(4) == b'8'  +@pytest.mark.parametrize('when_used', ['json', 'json-unless-none'])+def test_wrap_function_when_used_json_include_exclude(when_used):+    """When the wrap function is skipped by `when_used`, runtime include/exclude must still apply."""++    def wrap(value, handler):+        return handler(value)++    s = SchemaSerializer(+        core_schema.typed_dict_schema(+            {+                'a': core_schema.typed_dict_field(core_schema.int_schema()),+                'b': core_schema.typed_dict_field(core_schema.int_schema()),+            },+            serialization=core_schema.wrap_serializer_function_ser_schema(wrap, when_used=when_used),+        )+    )+    assert s.to_python({'a': 1, 'b': 2}, exclude={'b'}) == {'a': 1}+    assert s.to_python({'a': 1, 'b': 2}, include={'a'}) == {'a': 1}+    assert s.to_python({'a': 1, 'b': 2}, mode='json', exclude={'b'}) == {'a': 1}+    assert s.to_json({'a': 1, 'b': 2}, exclude={'b'}) == b'{"a":1}'+++@pytest.mark.parametrize('when_used', ['json', 'unless-none', 'json-unless-none'])+def test_plain_function_when_used_include_exclude_fallback(when_used):+    """When the plain function is skipped by `when_used`, the fallback serializer applies include/exclude."""+    s = SchemaSerializer(+        core_schema.nullable_schema(+            core_schema.list_schema(+                core_schema.int_schema(),+                serialization=core_schema.plain_serializer_function_ser_schema(lambda v: 'custom', when_used=when_used),+            )+        )+    )+    if when_used == 'unless-none':+        assert s.to_python([1, 2, 3], exclude={1}) == 'custom'+    else:+        assert s.to_python([1, 2, 3], exclude={1}) == [1, 3]+    assert s.to_python(None, exclude={1}) is None++ def test_function_unless_none():     s = SchemaSerializer(         core_schema.any_schema(tests/test_serialize.pyindex 57832ca0..c0ff29ef 100644@@ -513,6 +513,84 @@ def test_model_serializer_wrap_info():     assert m.model_dump_json(exclude={'a'}) == '{"b":"boom","info":"mode=json exclude={\'a\'}"}'  +@pytest.mark.parametrize('when_used', ['json', 'json-unless-none'])+def test_model_serializer_wrap_when_used_json_include_exclude_python_mode(when_used) -> None:+    """https://github.com/pydantic/pydantic/issues/13601"""++    class Gated(BaseModel):+        a: int+        b: int++        @model_serializer(mode='wrap', when_used=when_used)+        def _serialize(self, handler: SerializerFunctionWrapHandler) -> object:+            return handler(self)++    m = Gated(a=1, b=2)+    assert m.model_dump() == {'a': 1, 'b': 2}+    assert m.model_dump(exclude={'b'}) == {'a': 1}+    assert m.model_dump(include={'a'}) == {'a': 1}+    assert m.model_dump(mode='json', exclude={'b'}) == {'a': 1}+    assert m.model_dump_json(exclude={'b'}) == '{"a":1}'+++@pytest.mark.parametrize('when_used', ['json', 'json-unless-none'])+def test_model_serializer_plain_when_used_json_include_exclude_python_mode(when_used) -> None:+    class Gated(BaseModel):+        a: int+        b: int++        @model_serializer(when_used=when_used)+        def _serialize(self) -> str:+            return 'custom'++    m = Gated(a=1, b=2)+    assert m.model_dump(exclude={'b'}) == {'a': 1}+    assert m.model_dump(include={'a'}) == {'a': 1}+    assert m.model_dump(mode='json', exclude={'b'}) == 'custom'+++def test_nested_model_wrap_serializer_when_used_json_exclude_python_mode() -> None:+    class Inner(BaseModel):+        x: int+        y: int++        @model_serializer(mode='wrap', when_used='json')+        def _serialize(self, handler: SerializerFunctionWrapHandler) -> object:+            return handler(self)++    class Outer(BaseModel):+        inner: Inner+        items: list[Inner]++    m = Outer(inner=Inner(x=1, y=2), items=[Inner(x=3, y=4)])+    assert m.model_dump(exclude={'inner': {'y'}, 'items': {'__all__': {'x'}}}) == {+        'inner': {'x': 1},+        'items': [{'y': 4}],+    }+    assert m.model_dump(mode='json', exclude={'inner': {'y'}, 'items': {'__all__': {'x'}}}) == {+        'inner': {'x': 1},+        'items': [{'y': 4}],+    }+++def test_field_wrap_serializer_when_used_json_exclude_python_mode() -> None:+    class Inner(BaseModel):+        x: int+        y: int++    class Outer(BaseModel):+        inner: Inner++        @field_serializer('inner', mode='wrap', when_used='json')+        def _ser_inner(self, value: Inner, handler: SerializerFunctionWrapHandler) -> object:+            return handler(value)++    m = Outer(inner=Inner(x=1, y=2))+    assert m.model_dump(exclude={'inner': {'y'}}) == {'inner': {'x': 1}}+    assert m.model_dump(mode='json', exclude={'inner': {'y'}}) == {'inner': {'x': 1}}+    assert m.model_dump_json(exclude={'inner': {'y'}}) == '{"inner":{"x":1}}'++ def test_model_serializer_plain_json_return_type():     class MyModel(BaseModel):         a: int 
Merged fix · PR #13702+44 −15
pydantic-core/src/serializers/extra.rsindex e54b05732..1551057bc 100644@@ -146,6 +146,10 @@ impl<'py> SerializationState<'py> {         self.field_name.as_ref()     } +    pub fn include_exclude(&self) -> IncludeExclude<'py> {+        self.include_exclude.clone()+    }+     pub fn include(&self) -> Option<&Bound<'py, PyAny>> {         self.include_exclude.include.as_ref()     }pydantic-core/src/serializers/type_serializers/function.rsindex 5944310cc..736763775 100644@@ -217,16 +217,16 @@ macro_rules! function_type_serializer {                 state: &mut SerializationState<'py>,             ) -> PyResult<Py<PyAny>> {                 let py = value.py();-                let (ret_serializer, v) = match self.call(value, state) {-                    Ok((true, v)) => (&*self.return_serializer, v),-                    Ok((false, v)) => (self.get_fallback_serializer(), v),+                let (ret_serializer, v, include_exclude) = match self.call(value, state) {+                    // Filtering was done by the function, so drop include/exclude for the return serializer:+                    Ok((true, v)) => (&*self.return_serializer, v, IncludeExclude::empty()),+                    Ok((false, v)) => (self.get_fallback_serializer(), v, state.include_exclude()),                     Err(err) => {                         on_error(py, err, &self.function_name, state)?;                         return infer_to_python(value, state);                     }                 };-                // None for include/exclude here, as filtering should be done-                let state = &mut state.scoped_include_exclude(IncludeExclude::empty());+                let state = &mut state.scoped_include_exclude(include_exclude);                 ret_serializer.to_python(v.bind(py), state)             } @@ -236,16 +236,16 @@ macro_rules! function_type_serializer {                 state: &mut SerializationState<'py>,             ) -> PyResult<Cow<'a, str>> {                 let py = key.py();-                let (ret_serializer, v) = match self.call(key, state) {-                    Ok((true, v)) => (&*self.return_serializer, v),-                    Ok((false, v)) => (self.get_fallback_serializer(), v),+                let (ret_serializer, v, include_exclude) = match self.call(key, state) {+                    // Filtering was done by the function, so drop include/exclude for the return serializer:+                    Ok((true, v)) => (&*self.return_serializer, v, IncludeExclude::empty()),+                    Ok((false, v)) => (self.get_fallback_serializer(), v, state.include_exclude()),                     Err(err) => {                         on_error(py, err, &self.function_name, state)?;                         return infer_json_key(key, state);                     }                 };-                // None for include/exclude here, as filtering should be done-                let state = &mut state.scoped_include_exclude(IncludeExclude::empty());+                let state = &mut state.scoped_include_exclude(include_exclude);                 ret_serializer                     .json_key(v.bind(py), state)                     .map(|cow| Cow::Owned(cow.into_owned()))@@ -258,16 +258,16 @@ macro_rules! function_type_serializer {                 state: &mut SerializationState<'py>,             ) -> Result<S::Ok, S::Error> {                 let py = value.py();-                let (ret_serializer, v) = match self.call(value, state) {-                    Ok((true, v)) => (&*self.return_serializer, v),-                    Ok((false, v)) => (self.get_fallback_serializer(), v),+                let (ret_serializer, v, include_exclude) = match self.call(value, state) {+                    // Filtering was done by the function, so drop include/exclude for the return serializer:+                    Ok((true, v)) => (&*self.return_serializer, v, IncludeExclude::empty()),+                    Ok((false, v)) => (self.get_fallback_serializer(), v, state.include_exclude()),                     Err(err) => {                         on_error(py, err, &self.function_name, state).map_err(py_err_se_err)?;                         return infer_serialize(value, serializer, state);                     }                 };-                // None for include/exclude here, as filtering should be done-                let mut state = state.scoped_include_exclude(IncludeExclude::empty());+                let mut state = state.scoped_include_exclude(include_exclude);                 ret_serializer.serde_serialize(v.bind(py), serializer, &mut state)             } tests/test_serialize.pyindex 57832ca0a..1c9e8cb7b 100644@@ -1437,3 +1437,28 @@ def test_model_serializer_index_key_type_error() -> None:         match="Error calling function `_serialize`: TypeError: 'index_key' is expected to be an integer or a string, got 'b'not_a_valid_type_for_index_key''",     ):         m.model_dump(include={'f'})+++def test_model_serializer_when_used_fallback_respects_include_exclude() -> None:+    """https://github.com/pydantic/pydantic/issues/13601"""++    class Plain(BaseModel):+        a: int+        b: int++        @model_serializer(mode='plain', when_used='json')+        def _serialize(self) -> Any:+            return {'ser': True}++    class Wrap(BaseModel):+        a: int+        b: int++        @model_serializer(mode='wrap', when_used='json')+        def _serialize(self, handler: SerializerFunctionWrapHandler) -> Any:+            return {'ser': True}++    for m in (Plain(a=1, b=2), Wrap(a=1, b=2)):+        assert m.model_dump(exclude={'b'}) == {'a': 1}+        assert m.model_dump(include={'a'}) == {'a': 1}+        assert m.model_dump(mode='json', exclude={'b'}) == {'ser': True}