Backtestspydanticrun-20261009-110034#12978

Issue #12978 Merged fix PR #13441 Run 9 Oct 2026 · run-20261009-110034 pydantic/pydantic

mypy [arg-type]-error when passing in type that can be converted to RootModel

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 same core fix. They register `_RootModelMetaclass` with the metaclass hook so it is treated as a pydantic model metaclass. They also let the plugin generate `__init__` for `RootModel` itself, overriding its hand-written typed `__init__`. With `init_typed` unset, `RootModel[float]('1.0')` is then accepted, which resolves the issue.

The difference is a side effect of generating `__init__` for the bare `RootModel`. The plugin has always built the `root` argument as `ARG_OPT`, even when there is no default. Under Patch A, `RootModel[float]()` therefore type-checks cleanly with the plugin enabled. Before the change, `RootModel`'s own `__init__` reported a missing argument. So Patch A fixes the issue but removes an existing check.

Patch B avoids this. It makes the root argument `ARG_POS` when there is no default and keeps it `ARG_OPT` when there is a default or `force_optional` is set. Missing `root` is now reported for both `RootModel[float]()` and subclasses. This brings the plugin in line with the non-plugin behavior instead of loosening it.

Tests: Patch B covers more ground:
- positional and keyword `root`
- `assert_type` on `.root`
- `RootModel[int]`
- a subclass
- the missing-argument case
- a new `mypy-plugin-strict.ini` run showing typed init still reports `arg-type` errors

Patch A tests only the positional call for the alias and a subclass. Its tests do not exercise the regression it introduces.

Patch B's extra `kind` change touches a little more code, but it is directly motivated by the new `__init__` generation and closes a hole the fix would otherwise open. B is the more correct and better-tested fix.

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

48m 6s

Wall-clock time in the container

Full test suite

No new failures

0 passed · 54 skipped · 54 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

185vs 63 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

The below example code (named foo.py) passes when running python foo.py as the input "1.0"-string gets converted to float. However, running mypy foo.py (with or without --strict) gives the following error:

foo.py:11: error: Argument 1 to "RootModel" has incompatible type "str"; expected "float"  [arg-type]
Found 1 error in 1 file (checked 1 source file)

I would expect the BaseModel-fields and the RootModel-field to behave the same in this case. That is, if the value can be converted – either via a custom made validator or through the conversion table – then mypy should not raise an error.

Example Code

import pydantic


class Foo(pydantic.BaseModel):
    f: float


RFoo = pydantic.RootModel[float]

f = Foo(f="1.0")
rf = RFoo("1.0")

assert isinstance(f.f, float)
assert isinstance(rf.root, float)
assert f.f == rf.root

Python, Pydantic & OS Version

pydantic version: 2.12.5
        pydantic-core version: 2.41.5
          pydantic-core build: profile=release pgo=false
               python version: 3.11.14 (main, Feb  3 2026, 22:51:56) [Clang 21.1.4 ]
                     platform: Linux-5.15.0-173-generic-x86_64-with-glibc2.35
             related packages: typing_extensions-4.15.0 mypy-1.19.1
                       commit: unknown

The two patches

Our patch+181 −4
pydantic/mypy.pyindex cd28e700..ca1cc6d6 100644@@ -88,6 +88,7 @@ CREATE_MODEL_FULLNAME = 'pydantic.main.create_model' BASESETTINGS_FULLNAME = 'pydantic_settings.main.BaseSettings' ROOT_MODEL_FULLNAME = 'pydantic.root_model.RootModel' MODEL_METACLASS_FULLNAME = 'pydantic._internal._model_construction.ModelMetaclass'+ROOT_MODEL_METACLASS_FULLNAME = 'pydantic.root_model._RootModelMetaclass' FIELD_FULLNAME = 'pydantic.fields.Field' DATACLASS_FULLNAME = 'pydantic.dataclasses.dataclass' MODEL_VALIDATOR_FULLNAME = 'pydantic.functional_validators.model_validator'@@ -142,8 +143,8 @@ class PydanticPlugin(Plugin):         return None      def get_metaclass_hook(self, fullname: str) -> Callable[[ClassDefContext], None] | None:-        """Update Pydantic `ModelMetaclass` definition."""-        if fullname == MODEL_METACLASS_FULLNAME:+        """Update Pydantic `ModelMetaclass` (and `RootModel`'s type-checking-only metaclass) definition."""+        if fullname in (MODEL_METACLASS_FULLNAME, ROOT_MODEL_METACLASS_FULLNAME):             return self._pydantic_model_metaclass_marker_callback         return None @@ -361,7 +362,7 @@ class PydanticModelField:             variable=variable,             type_annotation=type_annotation,             initializer=None,-            kind=ARG_OPT+            kind=(ARG_OPT if force_optional or self.has_default else ARG_POS)             if is_root_model_root             else (ARG_NAMED_OPT if force_optional or self.has_default else ARG_NAMED),         )@@ -916,7 +917,13 @@ class PydanticModelTransformer:          The added `__init__` will be annotated with types vs. all `Any` depending on the plugin settings.         """-        if '__init__' in self._cls.info.names and not self._cls.info.names['__init__'].plugin_generated:+        if (+            '__init__' in self._cls.info.names+            and not self._cls.info.names['__init__'].plugin_generated+            # `RootModel` defines its own `__init__` for runtime purposes, but it can be used directly+            # (e.g. `RootModel[float]`) so we still want the fields-aware signature to be generated for it:+            and self._cls.info.fullname != ROOT_MODEL_FULLNAME+        ):             return  # Don't generate an __init__ if one already exists          typed = self.plugin_config.init_typedtests/mypy/modules/root_models.pyindex 804d1d43..d2576746 100644@@ -46,3 +46,23 @@ m = Model[str](m1=Maybe(None), m2=Maybe('dog'), m3=Maybe([])) Model(m1=None, m2={}, m3=[])  assert_type(m.m1, Maybe[int])+++# `RootModel` used directly (without subclassing) should accept input that can be validated into the root type,+# the same way fields of `BaseModel` subclasses (and `RootModel` subclasses) do:+RootFloat = RootModel[float]+root_float = RootFloat('1.0')+root_float_kw = RootFloat(root='1.0')+assert_type(root_float.root, float)+assert_type(RootModel[int]('1').root, int)+++class SubRootFloat(RootModel[float]):+    pass+++sub_root_float = SubRootFloat('1.0')++# `root` is still required when it has no default:+RootFloat()+SubRootFloat()tests/mypy/outputs/mypy-default_ini/root_models.pyindex 01cf5bbb..3a575d09 100644@@ -54,3 +54,28 @@ Model(m1=None, m2={}, m3=[]) # MYPY: error: Argument "m3" to "Model" has incompatible type "list[Never]"; expected "Maybe[Any]"  [arg-type]  assert_type(m.m1, Maybe[int])+++# `RootModel` used directly (without subclassing) should accept input that can be validated into the root type,+# the same way fields of `BaseModel` subclasses (and `RootModel` subclasses) do:+RootFloat = RootModel[float]+root_float = RootFloat('1.0')+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "float"  [arg-type]+root_float_kw = RootFloat(root='1.0')+# MYPY: error: Argument "root" to "RootModel" has incompatible type "str"; expected "float"  [arg-type]+assert_type(root_float.root, float)+assert_type(RootModel[int]('1').root, int)+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "int"  [arg-type]+++class SubRootFloat(RootModel[float]):+    pass+++sub_root_float = SubRootFloat('1.0')+# MYPY: error: Argument 1 to "SubRootFloat" has incompatible type "str"; expected "float"  [arg-type]++# `root` is still required when it has no default:+RootFloat()+SubRootFloat()+# MYPY: error: Missing positional argument "root" in call to "SubRootFloat"  [call-arg]tests/mypy/outputs/mypy-plugin-strict_ini/root_models.pynew file mode 100644index 00000000..5d8127d9@@ -0,0 +1,77 @@+from typing import Generic, TypeVar++from typing_extensions import assert_type++from pydantic import BaseModel, RootModel+++class Pets1(RootModel[list[str]]):+    pass+++pets_construct = Pets1.model_construct(['dog'])++Pets2 = RootModel[list[str]]+++class Pets3(RootModel):+# MYPY: error: Missing type parameters for generic type "RootModel"  [type-arg]+    root: list[str]+++pets1 = Pets1(['dog', 'cat'])+pets2 = Pets2(['dog', 'cat'])+pets3 = Pets3(['dog', 'cat'])+++class Pets4(RootModel[list[str]]):+    pets: list[str]+# MYPY: error: Only `root` is allowed as a field of a `RootModel`  [pydantic-field]+++T = TypeVar('T')+V = TypeVar('V')+++class Maybe(RootModel[T | None]):+    pass+++class Model(BaseModel, Generic[V]):+    m1: Maybe[int]+    m2: Maybe[V]+    m3: Maybe+# MYPY: error: Missing type parameters for generic type "Maybe"  [type-arg]+++Model[str](m1=1, m2='dog', m3=[])+m = Model[str](m1=Maybe(None), m2=Maybe('dog'), m3=Maybe([]))+Model(m1=None, m2={}, m3=[])++assert_type(m.m1, Maybe[int])+++# `RootModel` used directly (without subclassing) should accept input that can be validated into the root type,+# the same way fields of `BaseModel` subclasses (and `RootModel` subclasses) do:+RootFloat = RootModel[float]+root_float = RootFloat('1.0')+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "float"  [arg-type]+root_float_kw = RootFloat(root='1.0')+# MYPY: error: Argument "root" to "RootModel" has incompatible type "str"; expected "float"  [arg-type]+assert_type(root_float.root, float)+assert_type(RootModel[int]('1').root, int)+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "int"  [arg-type]+++class SubRootFloat(RootModel[float]):+    pass+++sub_root_float = SubRootFloat('1.0')+# MYPY: error: Argument 1 to "SubRootFloat" has incompatible type "str"; expected "float"  [arg-type]++# `root` is still required when it has no default:+RootFloat()+# MYPY: error: Missing positional argument "root" in call to "RootModel"  [call-arg]+SubRootFloat()+# MYPY: error: Missing positional argument "root" in call to "SubRootFloat"  [call-arg]tests/mypy/outputs/mypy-plugin_ini/root_models.pyindex 5bb30a04..4bad580e 100644@@ -49,3 +49,25 @@ m = Model[str](m1=Maybe(None), m2=Maybe('dog'), m3=Maybe([])) Model(m1=None, m2={}, m3=[])  assert_type(m.m1, Maybe[int])+++# `RootModel` used directly (without subclassing) should accept input that can be validated into the root type,+# the same way fields of `BaseModel` subclasses (and `RootModel` subclasses) do:+RootFloat = RootModel[float]+root_float = RootFloat('1.0')+root_float_kw = RootFloat(root='1.0')+assert_type(root_float.root, float)+assert_type(RootModel[int]('1').root, int)+++class SubRootFloat(RootModel[float]):+    pass+++sub_root_float = SubRootFloat('1.0')++# `root` is still required when it has no default:+RootFloat()+# MYPY: error: Missing positional argument "root" in call to "RootModel"  [call-arg]+SubRootFloat()+# MYPY: error: Missing positional argument "root" in call to "SubRootFloat"  [call-arg]tests/mypy/outputs/pyproject-default_toml/root_models.pyindex 01cf5bbb..3a575d09 100644@@ -54,3 +54,28 @@ Model(m1=None, m2={}, m3=[]) # MYPY: error: Argument "m3" to "Model" has incompatible type "list[Never]"; expected "Maybe[Any]"  [arg-type]  assert_type(m.m1, Maybe[int])+++# `RootModel` used directly (without subclassing) should accept input that can be validated into the root type,+# the same way fields of `BaseModel` subclasses (and `RootModel` subclasses) do:+RootFloat = RootModel[float]+root_float = RootFloat('1.0')+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "float"  [arg-type]+root_float_kw = RootFloat(root='1.0')+# MYPY: error: Argument "root" to "RootModel" has incompatible type "str"; expected "float"  [arg-type]+assert_type(root_float.root, float)+assert_type(RootModel[int]('1').root, int)+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "int"  [arg-type]+++class SubRootFloat(RootModel[float]):+    pass+++sub_root_float = SubRootFloat('1.0')+# MYPY: error: Argument 1 to "SubRootFloat" has incompatible type "str"; expected "float"  [arg-type]++# `root` is still required when it has no default:+RootFloat()+SubRootFloat()+# MYPY: error: Missing positional argument "root" in call to "SubRootFloat"  [call-arg]tests/mypy/test_mypy.pyindex c66f1964..743013ad 100644@@ -107,6 +107,7 @@ cases: list[ParameterSet | tuple[str, str]] = [         ('mypy-plugin.ini', 'plugin_optional_inheritance.py'),         ('mypy-plugin.ini', 'generics.py'),         ('mypy-plugin.ini', 'root_models.py'),+        ('mypy-plugin-strict.ini', 'root_models.py'),         ('mypy-plugin.ini', 'plugin_strict_fields.py'),         ('mypy-plugin.ini', 'final_with_default.py'),         ('mypy-plugin.ini', 'create_model_var.py'), 
Merged fix · PR #13441+61 −2
pydantic/mypy.pyindex cd28e7004..40aee0627 100644@@ -88,6 +88,7 @@ CREATE_MODEL_FULLNAME = 'pydantic.main.create_model' BASESETTINGS_FULLNAME = 'pydantic_settings.main.BaseSettings' ROOT_MODEL_FULLNAME = 'pydantic.root_model.RootModel' MODEL_METACLASS_FULLNAME = 'pydantic._internal._model_construction.ModelMetaclass'+ROOT_MODEL_METACLASS_FULLNAME = 'pydantic.root_model._RootModelMetaclass' FIELD_FULLNAME = 'pydantic.fields.Field' DATACLASS_FULLNAME = 'pydantic.dataclasses.dataclass' MODEL_VALIDATOR_FULLNAME = 'pydantic.functional_validators.model_validator'@@ -143,7 +144,7 @@ class PydanticPlugin(Plugin):      def get_metaclass_hook(self, fullname: str) -> Callable[[ClassDefContext], None] | None:         """Update Pydantic `ModelMetaclass` definition."""-        if fullname == MODEL_METACLASS_FULLNAME:+        if fullname in (MODEL_METACLASS_FULLNAME, ROOT_MODEL_METACLASS_FULLNAME):             return self._pydantic_model_metaclass_marker_callback         return None @@ -916,7 +917,13 @@ class PydanticModelTransformer:          The added `__init__` will be annotated with types vs. all `Any` depending on the plugin settings.         """-        if '__init__' in self._cls.info.names and not self._cls.info.names['__init__'].plugin_generated:+        if (+            '__init__' in self._cls.info.names+            and not self._cls.info.names['__init__'].plugin_generated+            # `RootModel` declares a typed `__init__` for the benefit of type checkers when the plugin+            # isn't used, but the plugin-generated one should take priority over it:+            and self._cls.fullname != ROOT_MODEL_FULLNAME+        ):             return  # Don't generate an __init__ if one already exists          typed = self.plugin_config.init_typedtests/mypy/modules/root_models.pyindex 804d1d43e..f95bd7fe1 100644@@ -22,6 +22,18 @@ pets1 = Pets1(['dog', 'cat']) pets2 = Pets2(['dog', 'cat']) pets3 = Pets3(['dog', 'cat']) +RFloat = RootModel[float]+++class RFloatSub(RootModel[float]):+    pass+++# When the plugin is used with `init_typed` unset, arbitrary input+# should be accepted as it may be coerced to the `root` type:+rfloat = RFloat('1.0')+rfloat_sub = RFloatSub('1.0')+  class Pets4(RootModel[list[str]]):     pets: list[str]tests/mypy/outputs/mypy-default_ini/root_models.pyindex 01cf5bbb3..df3354187 100644@@ -23,6 +23,20 @@ pets1 = Pets1(['dog', 'cat']) pets2 = Pets2(['dog', 'cat']) pets3 = Pets3(['dog', 'cat']) +RFloat = RootModel[float]+++class RFloatSub(RootModel[float]):+    pass+++# When the plugin is used with `init_typed` unset, arbitrary input+# should be accepted as it may be coerced to the `root` type:+rfloat = RFloat('1.0')+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "float"  [arg-type]+rfloat_sub = RFloatSub('1.0')+# MYPY: error: Argument 1 to "RFloatSub" has incompatible type "str"; expected "float"  [arg-type]+  class Pets4(RootModel[list[str]]):     pets: list[str]tests/mypy/outputs/mypy-plugin_ini/root_models.pyindex 5bb30a044..12b4c84bd 100644@@ -23,6 +23,18 @@ pets1 = Pets1(['dog', 'cat']) pets2 = Pets2(['dog', 'cat']) pets3 = Pets3(['dog', 'cat']) +RFloat = RootModel[float]+++class RFloatSub(RootModel[float]):+    pass+++# When the plugin is used with `init_typed` unset, arbitrary input+# should be accepted as it may be coerced to the `root` type:+rfloat = RFloat('1.0')+rfloat_sub = RFloatSub('1.0')+  class Pets4(RootModel[list[str]]):     pets: list[str]tests/mypy/outputs/pyproject-default_toml/root_models.pyindex 01cf5bbb3..df3354187 100644@@ -23,6 +23,20 @@ pets1 = Pets1(['dog', 'cat']) pets2 = Pets2(['dog', 'cat']) pets3 = Pets3(['dog', 'cat']) +RFloat = RootModel[float]+++class RFloatSub(RootModel[float]):+    pass+++# When the plugin is used with `init_typed` unset, arbitrary input+# should be accepted as it may be coerced to the `root` type:+rfloat = RFloat('1.0')+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "float"  [arg-type]+rfloat_sub = RFloatSub('1.0')+# MYPY: error: Argument 1 to "RFloatSub" has incompatible type "str"; expected "float"  [arg-type]+  class Pets4(RootModel[list[str]]):     pets: list[str]