Backtestspydanticrun-20260923-170312#13453

Issue #13453 Merged fix PR # Run 23 Sep 2026 · run-20260923-170312 pydantic/pydantic

RootModel.model_dump() typing signature rejects supported serialization arguments

Better

Our patch was judged better than the merged fix.

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

Both patches make the essentially identical core fix to the TYPE_CHECKING signature (include/exclude → IncEx | None, context → Any | None, add fallback and polymorphic_serialization), so correctness of the runtime-signature fix is a wash. The decisive differences are in tests, scope, and craft. Patch B adds regression cases exactly where the issue asks and where they matter — tests/typechecking/root_model.py — which are consumed by the mypy/pyright/pyrefly suites that actually exercise the reported bug (type-checkers rejecting valid calls). Its cases mirror the issue's example precisely (non-dict context, fallback=, polymorphic_serialization=) and would fail type-checking before the fix and pass after. Patch B is otherwise minimal: it leaves the original docstring untouched. Patch A instead adds a runtime test in tests/test_root_model.py that monkeypatches typing.TYPE_CHECKING=True and re-execs the module to compare inspect.signature parameter lists. This is fragile and, more importantly, tests the wrong thing: it verifies runtime signature/docstring parity, not that type-checkers accept the calls — the actual regression. Worse, its assertion that RootModel.model_dump.__doc__ must equal BaseModel.model_dump.__doc__ forces Patch A to wholesale replace RootModel's intentionally distinct docstring (which explained the RootModelRootType return semantics) with a copy of BaseModel's, demoting the original explanation to a comment. That is real scope creep driven by the test's own artificial requirement, plus added churn and coupling. Patch A's use of collections.abc.Callable is marginally more modern than Patch B's typing.Callable, but that minor craft point does not outweigh Patch B's superior test placement, faithful adherence to the issue's proposal, and tighter scope.

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

4m 36s19 turns

Wall-clock time in the container

Full test suite

No new failures

6,419 passed · 368 skipped · 6,787 total

Contamination audit

Unknown

See the audit notes for this run

Patch size

44vs 84 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

RootModel inherits the runtime implementation of BaseModel.model_dump(), but defines a separate declaration under TYPE_CHECKING to preserve its more precise return type.

That declaration has diverged from the base method:

  • context is restricted to dict[str, Any] | None instead of Any | None.
  • fallback is missing.
  • polymorphic_serialization is missing.

As a result, Mypy, Pyright, and Pyrefly reject valid calls that succeed at runtime.

All three calls in the example below succeed at runtime.

Mypy currently reports errors equivalent to:

Argument "context" to "model_dump" of "RootModel" has incompatible type "str"
Unexpected keyword argument "fallback" for "model_dump" of "RootModel"
Unexpected keyword argument "polymorphic_serialization" for "model_dump" of "RootModel"

Pyright and Pyrefly report the same signature incompatibilities.

Expected behavior

The type-checking-only RootModel.model_dump() declaration should accept the same parameters, annotations, defaults, and ordering as BaseModel.model_dump(), while preserving the more precise RootModel return annotation.

Cause

The declaration appears to have drifted as the base method evolved:

  • Serialization context originally updated both signatures.
  • BaseModel.context was later widened to Any.
  • fallback was subsequently added to BaseModel.model_dump().
  • polymorphic_serialization was later added to BaseModel.model_dump().

Those later changes were not propagated to the manually maintained RootModel declaration.

Proposed fix

Update only the static RootModel.model_dump() signature and add focused regression cases to tests/typechecking/root_model.py.

No runtime serialization behavior needs to change.

I have prepared and locally validated a focused two-file fix. The following checks pass:

  • Mypy type-checking suite
  • Pyright type-checking suite
  • Pyrefly type-checking suite
  • Focused RootModel serialization tests
  • Ruff lint and formatting checks
  • git diff --check

I would be happy to submit the PR after the issue is reviewed and assigned.

Example Code

from typing import Any

from pydantic import BaseModel, RootModel, SerializationInfo, model_serializer


class ContextRoot(RootModel[str]):
    @model_serializer
    def serialize_root(self, info: SerializationInfo) -> str:
        return f'{info.context}:{self.root}'


class Unknown:
    pass


class Base(BaseModel):
    x: int


class Sub(Base):
    y: int


ContextRoot(root='value').model_dump(context='prefix')

RootModel[Any](root=Unknown()).model_dump(
    mode='json',
    fallback=lambda _: 'fallback',
)

RootModel[list[Base]](root=[Sub(x=1, y=2)]).model_dump(
    polymorphic_serialization=True,
)

Python, Pydantic & OS Version

pydantic version: 2.14.0a1
        pydantic-core version: 2.47.0
          pydantic-core build: profile=debug pgo=false
               python version: 3.13.5 | packaged by Anaconda, Inc. | (main, Jun 12 2025, 11:23:37) [Clang 14.0.6 ]
                     platform: macOS-15.7.3-arm64-arm-64bit-Mach-O
             related packages: mypy-1.18.2 typing_extensions-4.15.0 pydantic-settings-2.7.1 pyright-1.1.407
                       commit: b281d5aed

The two patches

Our patch+38 −6
pydantic/root_model.pyindex d2900433..860024b9 100644@@ -3,14 +3,14 @@ from __future__ import annotations as _annotations  from copy import copy, deepcopy-from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar+from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, TypeVar  from pydantic_core import PydanticUndefined from typing_extensions import Self, dataclass_transform  from . import PydanticUserError from ._internal import _model_construction, _repr-from .main import BaseModel, _object_setattr+from .main import BaseModel, IncEx, _object_setattr  if TYPE_CHECKING:     from .fields import Field as PydanticModelField@@ -121,9 +121,9 @@ class RootModel(BaseModel, Generic[RootModelRootType], metaclass=_RootModelMetac             self,             *,             mode: Literal['json', 'python'] | str = 'python',-            include: Any = None,-            exclude: Any = None,-            context: dict[str, Any] | None = None,+            include: IncEx | None = None,+            exclude: IncEx | None = None,+            context: Any | None = None,             by_alias: bool | None = None,             exclude_unset: bool = False,             exclude_defaults: bool = False,@@ -131,7 +131,9 @@ class RootModel(BaseModel, Generic[RootModelRootType], metaclass=_RootModelMetac             exclude_computed_fields: bool = False,             round_trip: bool = False,             warnings: bool | Literal['none', 'warn', 'error'] = True,+            fallback: Callable[[Any], Any] | None = None,             serialize_as_any: bool = False,+            polymorphic_serialization: bool | None = None,         ) -> Any:             """This method is included just to get a more accurate return type for type checkers.             It is included in this `if TYPE_CHECKING:` block since no override is actually necessary.tests/typechecking/root_model.pyindex 1149472b..633d57ec 100644@@ -1,6 +1,8 @@+from typing import Any+ from typing_extensions import assert_type -from pydantic import RootModel+from pydantic import BaseModel, RootModel, SerializationInfo, model_serializer  IntRootModel = RootModel[int] @@ -17,3 +19,31 @@ class StrRootModel(RootModel[str]): str_root_model = StrRootModel(root='a')  assert_type(str_root_model.root, str)+++class ContextRoot(RootModel[str]):+    @model_serializer+    def serialize_root(self, info: SerializationInfo) -> str:+        return f'{info.context}:{self.root}'+++class Base(BaseModel):+    x: int+++class Sub(Base):+    y: int+++class Unknown:+    pass+++# `model_dump()` should accept a non-dict `context`:+ContextRoot(root='value').model_dump(context='prefix')++# `model_dump()` should accept `fallback=`:+RootModel[Any](root=Unknown()).model_dump(mode='json', fallback=lambda _: 'fallback')++# `model_dump()` should accept `polymorphic_serialization=`:+RootModel[list[Base]](root=[Sub(x=1, y=2)]).model_dump(polymorphic_serialization=True) 
Merged fix · PR #+71 −13
pydantic/root_model.pyindex d2900433e..4548bd326 100644@@ -2,6 +2,7 @@  from __future__ import annotations as _annotations +from collections.abc import Callable from copy import copy, deepcopy from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar @@ -15,6 +16,7 @@ from .main import BaseModel, _object_setattr if TYPE_CHECKING:     from .fields import Field as PydanticModelField     from .fields import PrivateAttr as PydanticModelPrivateAttr+    from .main import IncEx      # dataclass_transform could be applied to RootModel directly, but `ModelMetaclass`'s dataclass_transform     # takes priority (at least with pyright). We trick type checkers into thinking we apply dataclass_transform@@ -116,14 +118,20 @@ class RootModel(BaseModel, Generic[RootModelRootType], metaclass=_RootModelMetac         return m      if TYPE_CHECKING:+        # This `model_dump()` definition is only provided to get a more accurate return type for type checkers+        # (no override is actually necessary at runtime). Generally, the return type will be `RootModelRootType`,+        # assuming that `RootModelRootType` is not a `BaseModel` subclass. If `RootModelRootType` is a `BaseModel`+        # subclass, then the return type will likely be `dict[str, Any]`, as `model_dump()` calls are recursive.+        # The return type could even be something different, in the case of a custom serializer. Thus, `Any` is+        # used here to catch all of these cases.          def model_dump(  # type: ignore             self,             *,             mode: Literal['json', 'python'] | str = 'python',-            include: Any = None,-            exclude: Any = None,-            context: dict[str, Any] | None = None,+            include: IncEx | None = None,+            exclude: IncEx | None = None,+            context: Any | None = None,             by_alias: bool | None = None,             exclude_unset: bool = False,             exclude_defaults: bool = False,@@ -131,18 +139,39 @@ class RootModel(BaseModel, Generic[RootModelRootType], metaclass=_RootModelMetac             exclude_computed_fields: bool = False,             round_trip: bool = False,             warnings: bool | Literal['none', 'warn', 'error'] = True,+            fallback: Callable[[Any], Any] | None = None,             serialize_as_any: bool = False,+            polymorphic_serialization: bool | None = None,         ) -> Any:-            """This method is included just to get a more accurate return type for type checkers.-            It is included in this `if TYPE_CHECKING:` block since no override is actually necessary.--            See the documentation of `BaseModel.model_dump` for more details about the arguments.--            Generally, this method will have a return type of `RootModelRootType`, assuming that `RootModelRootType` is-            not a `BaseModel` subclass. If `RootModelRootType` is a `BaseModel` subclass, then the return-            type will likely be `dict[str, Any]`, as `model_dump` calls are recursive. The return type could-            even be something different, in the case of a custom serializer.-            Thus, `Any` is used here to catch all of these cases.+            """!!! abstract "Usage Documentation"+                [`model_dump`](../concepts/serialization.md#python-mode)++            Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.++            Args:+                mode: The mode in which `to_python` should run.+                    If mode is 'json', the output will only contain JSON serializable types.+                    If mode is 'python', the output may contain non-JSON-serializable Python objects.+                include: A set of fields to include in the output.+                exclude: A set of fields to exclude from the output.+                context: Additional context to pass to the serializer.+                by_alias: Whether to use the field's alias in the dictionary key if defined.+                exclude_unset: Whether to exclude fields that have not been explicitly set.+                exclude_defaults: Whether to exclude fields that are set to their default value.+                exclude_none: Whether to exclude fields that have a value of `None`.+                exclude_computed_fields: Whether to exclude computed fields.+                    While this can be useful for round-tripping, it is usually recommended to use the dedicated+                    `round_trip` parameter instead.+                round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].+                warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,+                    "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].+                fallback: A function to call when an unknown value is encountered. If not provided,+                    a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.+                serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.+                polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.++            Returns:+                A dictionary representation of the model.             """             ... tests/test_root_model.pyindex fa2ca4612..ce97fca28 100644@@ -1,4 +1,7 @@+import importlib.util+import inspect import pickle+import typing from datetime import date, datetime from typing import Annotated, Any, Generic, Literal, TypeVar @@ -721,3 +724,29 @@ def test_model_with_both_docstring_and_field_description() -> None:         'type': 'integer',         'description': 'More detailed description',     }+++def test_type_checking_model_dump_signature_in_sync_with_base_model() -> None:++    import pydantic.root_model++    spec = importlib.util.spec_from_file_location('pydantic._root_model_type_checking', pydantic.root_model.__file__)+    assert spec is not None and spec.loader is not None+    module = importlib.util.module_from_spec(spec)++    typing.TYPE_CHECKING = True+    try:+        spec.loader.exec_module(module)+    finally:+        typing.TYPE_CHECKING = False++    base_sig = inspect.signature(BaseModel.model_dump)+    root_sig = inspect.signature(module.RootModel.model_dump)++    # The return annotation intentionally differs (`Any` instead of `dict[str, Any]`),+    # but the parameters must match exactly:+    assert list(root_sig.parameters.values()) == list(base_sig.parameters.values())++    assert module.RootModel.model_dump.__doc__ is not None+    assert BaseModel.model_dump.__doc__ is not None+    assert inspect.cleandoc(module.RootModel.model_dump.__doc__) == inspect.cleandoc(BaseModel.model_dump.__doc__) 

What the agent reported

The fix is complete and verified.

What was wrong

RootModel.model_dump() has a TYPE_CHECKING-only signature stub (in pydantic/root_model.py) whose sole purpose is to give type checkers a more precise -> Any return type. This stub had drifted from the authoritative BaseModel.model_dump():

  • context was typed dict[str, Any] | None instead of Any | None
  • fallback was missing
  • polymorphic_serialization was missing

As a result, mypy/pyright/pyrefly rejected three calls that succeed at runtime.

What I changed

pydantic/root_model.py (the only runtime-adjacent edits are two import lines; the signature itself is inside the existing if TYPE_CHECKING: block, so no runtime behavior changes):

  • Added Callable to the typing import and IncEx to the from .main import ... line.
  • Aligned the stub's parameters/annotations/defaults/ordering exactly with BaseModel.model_dump(): include/exclude → IncEx | None, context → Any | None, added fallback: Callable[[Any], Any] | None = None and polymorphic_serialization: bool | None = None. Return annotation kept as -> Any.

tests/typechecking/root_model.py: added the three regression cases from the report (non-dict context, fallback=, polymorphic_serialization=), with no suppression comments so they must type-check cleanly.

Test evidence

Type-check gate run with pyright (the harness .exe was blocked by an OS App Control policy, so I invoked it via python -m pyright using the repo's config; mypy/pyrefly aren't installed in this environment, but the report confirms all three checkers fail identically, and the fix is a signature alignment that resolves all three by construction):

  • Before fix (production change stashed): exactly 3 errors — line 43 context, line 46 fallback, line 49 polymorphic_serialization — matching the report precisely.
  • After fix: 0 errors, 0 warnings, 0 informations.

Note reportUnnecessaryTypeIgnoreComment = true is enabled in the config, so the clean run also confirms the new test lines correctly carry no suppressions. Removed a stray tests/typechecking/uv.lock created by an earlier tooling attempt; final git status shows only the two intended files modified. Reviewer confirmed all criteria pass.

Requirements disposition

  1. Update RootModel.model_dump() static signature to match BaseModel — ✅ Implemented; verified by diff review and pyright.
  2. context → Any | None — ✅ Implemented; before/after pyright shows the error resolved.
  3. Add fallback — ✅ Implemented; error resolved.
  4. Add polymorphic_serialization — ✅ Implemented; error resolved.
  5. Add focused regression cases to tests/typechecking/root_model.py — ✅ Implemented; the three cases fail before the fix (3 errors) and pass after (0 errors).
  6. No runtime serialization behavior changes — ✅ Confirmed; all logic changes are inside if TYPE_CHECKING:, only imports live at runtime scope.