Remove generics cache workaround

Viicos · Viicos · commit 9f76e24eeee9 · 2025-04-17T18:41:23.000+02:00
Backport of: #11755
diff --git a/pydantic/main.py b/pydantic/main.py
@@ -908,12 +908,7 @@ def __class_getitem__(
 
                 submodel = _generics.create_generic_submodel(model_name, origin, args, params)
 
-                # Cache the generated model *only* if not in the process of parametrizing
-                # another model. In some valid scenarios, we miss the opportunity to cache
-                # it but in some cases this results in `PydanticRecursiveRef` instances left
-                # on `FieldInfo` annotations:
-                if len(_generics.recursively_defined_type_refs()) == 1:
-                    _generics.set_cached_generic_type(cls, typevar_values, submodel, origin, args)
+                _generics.set_cached_generic_type(cls, typevar_values, submodel, origin, args)
 
         return submodel
 
diff --git a/tests/test_forward_ref.py b/tests/test_forward_ref.py
@@ -718,15 +718,9 @@ def test_recursive_models_union(create_module):
     # This test should pass because PydanticRecursiveRef.__or__ is implemented,
     # not because `eval_type_backport` magically makes `|` work,
     # since it's installed for tests but otherwise optional.
-    # When generic models are involved in recursive models, parametrizing a model
-    # can result in a `PydanticRecursiveRef` instance. This isn't ideal, as in the
-    # example below, this results in the `FieldInfo.annotation` attribute being changed,
-    # e.g. for `bar` to something like `PydanticRecursiveRef(...) | None`.
-    # We currently have a workaround (avoid caching parametrized models where this bad
-    # annotation mutation can happen).
     sys.modules['eval_type_backport'] = None  # type: ignore
     try:
-        create_module(
+        module = create_module(
             # language=Python
             """
 from __future__ import annotations
@@ -742,14 +736,20 @@ class Foo(BaseModel):
 
 class Bar(BaseModel, Generic[T]):
     foo: Foo
+
+Foo.model_rebuild()
     """
         )
     finally:
         del sys.modules['eval_type_backport']
 
+    assert module.Foo.model_fields['bar'].annotation == typing.Optional[module.Bar[str]]
+    assert module.Foo.model_fields['bar2'].annotation == typing.Union[int, module.Bar[float]]
+    assert module.Bar.model_fields['foo'].annotation == module.Foo
+
 
 def test_recursive_models_union_backport(create_module):
-    create_module(
+    module = create_module(
         # language=Python
         """
 from __future__ import annotations
@@ -768,9 +768,15 @@ class Foo(BaseModel):
 
 class Bar(BaseModel, Generic[T]):
     foo: Foo
+
+Foo.model_rebuild()
 """
     )
 
+    assert module.Foo.model_fields['bar'].annotation == typing.Optional[module.Bar[str]]
+    assert module.Foo.model_fields['bar2'].annotation == typing.Union[int, str, module.Bar[float]]
+    assert module.Bar.model_fields['foo'].annotation == module.Foo
+
 
 def test_force_rebuild():
     class Foobar(BaseModel):
diff --git a/tests/test_generics.py b/tests/test_generics.py
@@ -27,6 +27,7 @@
     Never,
     NotRequired,
     ParamSpec,
+    TypeAliasType,
     TypedDict,
     TypeVarTuple,
     Unpack,
@@ -519,6 +520,37 @@ class M(BaseModel):
     del generics
 
 
+def test_generics_reused() -> None:
+    """https://github.com/pydantic/pydantic/issues/11747
+
+    To fix an issue with recursive generics, we introduced a change in 2.11 that would
+    skip caching the parameterized model under specific circumstances. The following setup
+    is an example of where this would happen. As a result, we ended up with two different `A[int]`
+    classes, although they were the same in practice.
+    When serializing, we check that the value instances are matching the type, but we ended up
+    with warnings as `isinstance(value, A[int])` fails.
+    The fix was reverted as a refactor (https://github.com/pydantic/pydantic/pull/11388) fixed
+    the underlying issue.
+    """
+
+    T = TypeVar('T')
+
+    class A(BaseModel, Generic[T]):
+        pass
+
+    class B(BaseModel, Generic[T]):
+        pass
+
+    AorB = TypeAliasType('AorB', Union[A[T], B[T]], type_params=(T,))
+
+    class Main(BaseModel, Generic[T]):
+        ls: list[AorB[T]] = []
+
+    m = Main[int]()
+    m.ls.append(A[int]())
+    m.model_dump_json(warnings='error')
+
+
 def test_generic_config():
     data_type = TypeVar('data_type')
 
@@ -1445,7 +1477,9 @@ class InnerModel(OuterModel[T], Generic[T]):
 
     with pytest.raises(ValidationError):
         InnerModel[int](a=['s', {'a': 'wrong'}])
+
     assert InnerModel[int](a=['s', {'a': 1}]).a[1].a == 1
+    assert InnerModel[int].model_fields['a'].annotation == Optional[list[Union[ReferencedModel[int], str]]]
 
 
 def test_deep_generic_with_multiple_typevars():
