Backtestspydanticrun-20261009-110034#13601

Issue #13601 Merged fix PR #13702 Run 9 Oct 2026 · run-20261009-110034 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 root cause the same way, and their runtime behaviour is equivalent. In function.rs, when `call()` returns `(false, v)` (the function was skipped because of `when_used`), the fallback serializer now receives the caller's include/exclude instead of `IncludeExclude::empty()`. When the function did run, the filter is still cleared. Patch A passes the original `state` straight through in the skipped branch. Patch B adds an `include_exclude()` clone accessor and re-scopes with the same values. Both cover `to_python`, `json_key` and `serde_serialize`, so they are equally correct and both resolve the issue's scenario.

Craft: Patch B is slightly tidier. It folds the choice into the match tuple and avoids duplicating the branch bodies, while Patch A repeats nearly identical code in each if/else arm. This is minor, and B's change to extra.rs is a small, low-risk addition.

Tests are where the patches differ. Patch A's tests are more thorough:
- They parametrize over both `when_used='json'` and `'json-unless-none'`.
- They check `exclude` and `include` in python mode, plus `mode='json'` and `model_dump_json`, for the wrap case from the issue.
- They cover plain model serializers, including confirming that JSON mode still hands filtering to the function.
- They cover nested include/exclude through plain and wrap `field_serializer`s with `when_used='json'`. This exercises the same code path for field-level functions, which Patch B does not test.

Patch B's single test covers plain and wrap model serializers with `when_used='json'` only, and has no nested or field-serializer coverage. Since correctness is equal and craft differences are small, Patch A's broader and meaningful regression tests make it the better 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

7m 39s

Wall-clock time in the container

Full test suite

No new failures

12,403 passed · 501 skipped · 12,904 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

118vs 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+98 −20
pydantic-core/src/serializers/type_serializers/function.rsindex 5944310c..58aab6a0 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 (`when_used`), so the fallback serializer sees the original+                    // value and must apply include/exclude itself+                    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)?+                } else {+                    // the function was skipped (`when_used`), so the fallback serializer sees the original+                    // value and must apply include/exclude itself+                    ret_serializer.json_key(v.bind(py), state)?+                };+                Ok(Cow::Owned(key.into_owned()))             }              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 (`when_used`), so the fallback serializer sees the original+                    // value and must apply include/exclude itself+                    ret_serializer.serde_serialize(v.bind(py), serializer, state)+                }             }              fn get_name(&self) -> &str {tests/test_serialize.pyindex 57832ca0..e3bc0c24 100644@@ -513,6 +513,67 @@ 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(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(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(when_used) -> None:+    class Gated(BaseModel):+        a: int+        b: int++        @model_serializer(when_used=when_used)+        def _serialize(self) -> dict[str, Any]:+            return {'a': self.a, 'b': self.b, 'c': 3}++    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'}) == {'a': 1, 'b': 2, 'c': 3}+++@pytest.mark.parametrize('mode', ['plain', 'wrap'])+def test_field_serializer_when_used_json_nested_include_exclude(mode) -> None:+    class Inner(BaseModel):+        x: int+        y: int++    class Outer(BaseModel):+        inner: Inner++        if mode == 'plain':++            @field_serializer('inner', when_used='json')+            def _ser_inner(self, v: Inner) -> dict[str, Any]:+                return {'x': v.x, 'y': v.y}++        else:++            @field_serializer('inner', mode='wrap', when_used='json')+            def _ser_inner(self, v: Inner, handler: SerializerFunctionWrapHandler) -> Any:+                return handler(v)++    m = Outer(inner=Inner(x=1, y=2))+    assert m.model_dump(exclude={'inner': {'y'}}) == {'inner': {'x': 1}}+    assert m.model_dump(include={'inner': {'x'}}) == {'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}