Backtestspydanticrun-20261022-024030#12978
mypy [arg-type]-error when passing in type that can be converted to RootModel
The merged fix was judged better than our patch.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches fix the root cause identically: they register the `_RootModelMetaclass` in the metaclass hook and stop `add_initializer` from bailing out on `RootModel` itself because it has a hand-written `__init__`, so the plugin-generated `__init__` (typed `Any` when `init_typed` is unset) replaces the stub signature and `RootModel[float]('1.0')` no longer errors under the plugin. Under the default (no-plugin) config both patches leave the error in place, which is the only sensible outcome there. On correctness for the reported issue they are equivalent.
Patch A goes further: it changes the `root` argument kind from unconditional `ARG_OPT` to `ARG_POS` unless a default exists (keeping it optional only on `RootModel` itself via a new `force_optional` condition). This is a behavior change outside the issue's ask: existing user code like `Pets1()` that previously type-checked now gets a new `call-arg` error (visible in A's updated expected outputs). It may well be the more accurate runtime model, but it is an unrelated tightening bundled into a bug fix, adding regression risk for downstream users and obscuring the minimal fix. It also adds a new `mypy-plugin-strict.ini` test case whose outputs mostly re-verify unchanged behavior.
Patch A's tests are somewhat broader (keyword `root=` form, strict config), which is a point in its favor. Patch B's tests cover the issue's exact scenario plus the subclass case across the plugin and non-plugin configs, which is adequate and would fail before the change under the plugin config.
Patch B's edit is narrower, uses an equally valid `self._cls.fullname` check, and leaves the established `ARG_OPT` semantics for `root` untouched. Given equal correctness, B wins on scope and risk; A's extra test coverage does not outweigh the unrequested semantic change.
Four judges ruled on this ticket in parallel, and the verdict comes from counting their votes. Each saw the issue and the two patches, labelled A and B in random order (two of them saw ours as A), with issue links and version numbers removed. Where tests could check the fix, they also saw the results of tests a separate agent wrote for the issue, run on both patches. None was told which patch was ours. The reasoning above is one judge's, shown verbatim.
Solve
1h 5m
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
134vs 63 merged
Changed lines, ours vs merged
The issue
View on GitHubInitial 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: unknownThe two patches
pydantic/mypy.pyindex cd28e700..1e840c93 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 the `RootModel` specific 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,14 @@ 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 we still want the+ # generated one so that the plugin settings (e.g. `init_typed`) are respected when+ # parametrized `RootModel` classes are used directly (e.g. `RootModel[int]('1')`):+ and self._cls.info.fullname != ROOT_MODEL_FULLNAME+ ): return # Don't generate an __init__ if one already exists typed = self.plugin_config.init_typed@@ -1180,7 +1188,8 @@ class PydanticModelTransformer: info, typed=typed, model_strict=model_strict,- force_optional=requires_dynamic_aliases or is_settings,+ # `RootModel.__init__` itself gives `root` a default (to support the keyword arguments form):+ force_optional=requires_dynamic_aliases or is_settings or info.fullname == ROOT_MODEL_FULLNAME, use_alias=use_alias, api=self._api, force_typevars_invariant=force_typevars_invariant,tests/mypy/modules/root_models.pyindex 804d1d43..cbc8195f 100644@@ -46,3 +46,13 @@ m = Model[str](m1=Maybe(None), m2=Maybe('dog'), m3=Maybe([])) Model(m1=None, m2={}, m3=[]) assert_type(m.m1, Maybe[int])++# Parametrized `RootModel` classes used directly should respect the `init_typed` plugin setting,+# in the same way as `RootModel` subclasses and `BaseModel` fields:+FloatRootModel = RootModel[float]++float_root_model = FloatRootModel(1.0)+float_root_model_from_str = FloatRootModel('1.0')+float_root_model_from_str_kw = FloatRootModel(root='1.0')+pets1_from_str = Pets1('dog')+pets1_missing_root = Pets1()tests/mypy/outputs/mypy-default_ini/root_models.pyindex 01cf5bbb..cf716bfa 100644@@ -54,3 +54,17 @@ 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])++# Parametrized `RootModel` classes used directly should respect the `init_typed` plugin setting,+# in the same way as `RootModel` subclasses and `BaseModel` fields:+FloatRootModel = RootModel[float]++float_root_model = FloatRootModel(1.0)+float_root_model_from_str = FloatRootModel('1.0')+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "float" [arg-type]+float_root_model_from_str_kw = FloatRootModel(root='1.0')+# MYPY: error: Argument "root" to "RootModel" has incompatible type "str"; expected "float" [arg-type]+pets1_from_str = Pets1('dog')+# MYPY: error: Argument 1 to "Pets1" has incompatible type "str"; expected "list[str]" [arg-type]+pets1_missing_root = Pets1()+# MYPY: error: Missing positional argument "root" in call to "Pets1" [call-arg]tests/mypy/outputs/mypy-plugin-strict_ini/root_models.pynew file mode 100644index 00000000..808cfed5@@ -0,0 +1,65 @@+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])++# Parametrized `RootModel` classes used directly should respect the `init_typed` plugin setting,+# in the same way as `RootModel` subclasses and `BaseModel` fields:+FloatRootModel = RootModel[float]++float_root_model = FloatRootModel(1.0)+float_root_model_from_str = FloatRootModel('1.0')+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "float" [arg-type]+float_root_model_from_str_kw = FloatRootModel(root='1.0')+# MYPY: error: Argument "root" to "RootModel" has incompatible type "str"; expected "float" [arg-type]+pets1_from_str = Pets1('dog')+# MYPY: error: Argument 1 to "Pets1" has incompatible type "str"; expected "list[str]" [arg-type]+pets1_missing_root = Pets1()+# MYPY: error: Missing positional argument "root" in call to "Pets1" [call-arg]tests/mypy/outputs/mypy-plugin_ini/root_models.pyindex 5bb30a04..02ef831a 100644@@ -49,3 +49,14 @@ m = Model[str](m1=Maybe(None), m2=Maybe('dog'), m3=Maybe([])) Model(m1=None, m2={}, m3=[]) assert_type(m.m1, Maybe[int])++# Parametrized `RootModel` classes used directly should respect the `init_typed` plugin setting,+# in the same way as `RootModel` subclasses and `BaseModel` fields:+FloatRootModel = RootModel[float]++float_root_model = FloatRootModel(1.0)+float_root_model_from_str = FloatRootModel('1.0')+float_root_model_from_str_kw = FloatRootModel(root='1.0')+pets1_from_str = Pets1('dog')+pets1_missing_root = Pets1()+# MYPY: error: Missing positional argument "root" in call to "Pets1" [call-arg]tests/mypy/outputs/pyproject-default_toml/root_models.pyindex 01cf5bbb..cf716bfa 100644@@ -54,3 +54,17 @@ 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])++# Parametrized `RootModel` classes used directly should respect the `init_typed` plugin setting,+# in the same way as `RootModel` subclasses and `BaseModel` fields:+FloatRootModel = RootModel[float]++float_root_model = FloatRootModel(1.0)+float_root_model_from_str = FloatRootModel('1.0')+# MYPY: error: Argument 1 to "RootModel" has incompatible type "str"; expected "float" [arg-type]+float_root_model_from_str_kw = FloatRootModel(root='1.0')+# MYPY: error: Argument "root" to "RootModel" has incompatible type "str"; expected "float" [arg-type]+pets1_from_str = Pets1('dog')+# MYPY: error: Argument 1 to "Pets1" has incompatible type "str"; expected "list[str]" [arg-type]+pets1_missing_root = Pets1()+# MYPY: error: Missing positional argument "root" in call to "Pets1" [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'),
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]