Backtestspydanticrun-20261003-150343#13621

Issue #13621 Merged fix PR #13624 Run 3 Oct 2026 · run-20261003-150343 pydantic/pydantic

Memory leak: transient models using Enum methods or Field(exclude_if=...) survive GC

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 three core changes the issue identifies: `serialization_exclude_if` is added to the `SerField` traversal, `class` to the `EnumSerializer` traversal, and `lookup` to all four `EnumValidator<T>` traversals. Their fix of the reported leak is therefore equivalent.

Patch A adds three focused core tests: an enum serializer test, an enum validator test (str enums only) and a field `exclude_if` test. However, it also churns the existing tests without reason. It removes the `xfail(is_free_threaded and sys.version_info < (3, 14))` markers from `test_gc_schema_serializer` and `test_gc_schema_validator`, and drops the `sys` and `is_free_threaded` imports. Those tests could start failing on free-threaded Python before 3.14. It also renames `__schema__`/`__validator__` to `__pydantic_core_schema__`/`__pydantic_validator__` and converts comments to docstrings. This is unrelated and adds risk, and its new tests also omit the free-threaded xfail.

Patch B keeps the existing tests untouched and their conventions intact. Its tests are much stronger:
- A parametrized enum test covers the plain, int, str and float `EnumValidator` variants with both validator and serializer attached.
- A parametrized schema-holder test covers field `exclude_if` and several other paths.
- A new top-level `tests/test_garbage_collection.py` reproduces the issue's exact scenario through pydantic's `BaseModel` with enum methods and `Field(exclude_if=...)`. This scenario would fail before the fix and pass after.

B also plugs analogous missing traversal edges: `ComputedField.serialization_exclude_if`, `GeneralFieldsSerializer.extra_serializer`, `ModelFieldsValidator.extras_keys_validator`, `DataclassArgsValidator.extras_validator`, and the `LiteralLookup` unhashable values and primitives. Each has a test. That breadth is neutral under the scope criterion and adds little risk, since these are additional GC visits on owned references.

With equal correctness on the core issue, B wins on test quality and avoids A's risky removal of the existing xfail markers.

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

19m 1s

Wall-clock time in the container

Full test suite

No new failures

12,338 passed · 500 skipped · 12,838 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

316vs 139 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

Transient BaseModel classes are not collected when either:

  • A model field references an Enum whose class defines a Python method.
  • A model field uses Field(exclude_if=<Python callable>).

After the defining module is removed from sys.modules and every ordinary strong reference is dropped, weak references to the model and enum classes remain alive after repeated full gc.collect() calls. Repeating this construction in disposable module namespaces causes linear memory growth.

Controls using an enum without methods or a field without exclude_if are collected normally.

I encountered this in combination with a Temporal workflow sandbox. With a large interconnected model graph and high volume Temporal workflows this can result in multi-GiB process growth relatively quickly.

The likely cause is missing PyGcTraverse edges for Python objects held by pydantic-core:

Traversing py_schema does not compensate for another unreported direct reference: CPython’s collector accounts for every actual strong edge individually.

I tested a temporary build from Pydantic main at c67a1397327c6abc1a2e2e921af01aebbbeedf1c. Adding only these traversal edges made all objects in the reproduction collectible:

  • Add serialization_exclude_if to SerField traversal.
  • Add class to EnumSerializer traversal.
  • Add lookup to every EnumValidator<T> traversal.

For the enum case, changing only the serializer or only the validator was insufficient; both missing edges were required.

This appears related to earlier missing-traversal fixes such as:

I would be happy to submit a focused patch.

(please note that this analysis was LLM assisted)

Example Code

import gc
import sys
import types
import weakref

def transient_module(name, source, class_names):
    module = types.ModuleType(name)
    sys.modules[name] = module
    exec(compile(source, f"<{name}>", "exec"), module.__dict__)
    refs = tuple(
        weakref.ref(module.__dict__[class_name])
        for class_name in class_names
    )
    del sys.modules[name]
    del module
    return refs

enum_ref, enum_model_ref = transient_module(
    "_pydantic_enum_gc_repro",
    """
from enum import Enum
from pydantic import BaseModel
class Membership(str, Enum):
    FULL = "full"
    def label(self) -> str:
        return self.value
class Model(BaseModel):
    membership: Membership
""",
    ("Membership", "Model"),
)

(exclude_if_model_ref,) = transient_module(
    "_pydantic_exclude_if_gc_repro",
    """
from pydantic import BaseModel, Field
class Model(BaseModel):
    value: int = Field(exclude_if=lambda value: False)
""",
    ("Model",),
)

for _ in range(5):
    gc.collect()

# All three should be False because no intentional strong references remain.
print("enum alive:", enum_ref() is not None)
print("enum model alive:", enum_model_ref() is not None)
print("exclude_if model alive:", exclude_if_model_ref() is not None)

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.15 (main, Aug  5 2026, 03:58:57) [GCC 12.2.0]
                     platform: Linux-6.5.0-1018-oem-x86_64-with-glibc2.36
             related packages: typing_extensions-4.15.0 pydantic-extra-types-2.10.5 mypy-1.16.0
                       commit: unknown

The two patches

Our patch+306 −10
pydantic-core/src/serializers/computed_fields.rsindex 5bb3841b..4e1946dd 100644@@ -110,7 +110,10 @@ impl ComputedField {     } } -impl_py_gc_traverse!(ComputedField { serializer });+impl_py_gc_traverse!(ComputedField {+    serializer,+    serialization_exclude_if+});  impl PyGcTraverse for ComputedFields {     fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {pydantic-core/src/serializers/fields.rsindex ba18ee4f..d0905aac 100644@@ -35,7 +35,10 @@ pub(super) struct SerField {     pub serialization_exclude_if: Option<Py<PyAny>>, } -impl_py_gc_traverse!(SerField { serializer });+impl_py_gc_traverse!(SerField {+    serializer,+    serialization_exclude_if+});  impl SerField {     pub fn new(@@ -337,6 +340,7 @@ pub fn exclude_field_by_value<'py>(  impl_py_gc_traverse!(GeneralFieldsSerializer {     fields,+    extra_serializer,     computed_fields }); pydantic-core/src/serializers/type_serializers/enum_.rsindex 0d2819ac..1ad123e9 100644@@ -48,7 +48,7 @@ impl BuildSerializer for EnumSerializer {     } } -impl_py_gc_traverse!(EnumSerializer { serializer });+impl_py_gc_traverse!(EnumSerializer { class, serializer });  impl TypeSerializer for EnumSerializer {     fn to_python<'py>(&self, value: &Bound<'py, PyAny>, state: &mut SerializationState<'py>) -> PyResult<Py<PyAny>> {pydantic-core/src/validators/dataclass.rsindex 93f9c56c..87c9d836 100644@@ -136,7 +136,10 @@ impl BuildValidator for DataclassArgsValidator {  impl_py_gc_traverse!(Field { validator }); -impl_py_gc_traverse!(DataclassArgsValidator { fields });+impl_py_gc_traverse!(DataclassArgsValidator {+    fields,+    extras_validator+});  impl Validator for DataclassArgsValidator {     fn validate<'py>(pydantic-core/src/validators/enum_.rsindex 6ef685da..28a32a87 100644@@ -168,7 +168,7 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> { #[derive(Debug, Clone)] pub struct PlainEnumValidator; -impl_py_gc_traverse!(EnumValidator<PlainEnumValidator> { class, missing });+impl_py_gc_traverse!(EnumValidator<PlainEnumValidator> { class, lookup, missing });  impl EnumValidateValue for PlainEnumValidator {     fn validate_value<'py, I: Input<'py> + ?Sized>(@@ -200,7 +200,7 @@ impl EnumValidateValue for PlainEnumValidator { #[derive(Debug, Clone)] pub struct IntEnumValidator; -impl_py_gc_traverse!(EnumValidator<IntEnumValidator> { class, missing });+impl_py_gc_traverse!(EnumValidator<IntEnumValidator> { class, lookup, missing });  impl EnumValidateValue for IntEnumValidator {     fn validate_value<'py, I: Input<'py> + ?Sized>(@@ -216,7 +216,7 @@ impl EnumValidateValue for IntEnumValidator { #[derive(Debug, Clone)] pub struct StrEnumValidator; -impl_py_gc_traverse!(EnumValidator<StrEnumValidator> { class, missing });+impl_py_gc_traverse!(EnumValidator<StrEnumValidator> { class, lookup, missing });  impl EnumValidateValue for StrEnumValidator {     fn validate_value<'py, I: Input<'py> + ?Sized>(@@ -232,7 +232,7 @@ impl EnumValidateValue for StrEnumValidator { #[derive(Debug, Clone)] pub struct FloatEnumValidator; -impl_py_gc_traverse!(EnumValidator<FloatEnumValidator> { class, missing });+impl_py_gc_traverse!(EnumValidator<FloatEnumValidator> { class, lookup, missing });  impl EnumValidateValue for FloatEnumValidator {     fn validate_value<'py, I: Input<'py> + ?Sized>(pydantic-core/src/validators/literal.rsindex c9195a78..681137fc 100644@@ -230,6 +230,12 @@ impl<T: Debug> LiteralLookup<T> { impl<T: PyGcTraverse + Debug> PyGcTraverse for LiteralLookup<T> {     fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {         self.expected_py_dict.py_gc_traverse(visit)?;+        if let Some(expected_py_values) = &self.expected_py_values {+            for (value, _) in expected_py_values {+                value.py_gc_traverse(visit)?;+            }+        }+        self.expected_py_primitives.py_gc_traverse(visit)?;         self.values.py_gc_traverse(visit)?;         Ok(())     }pydantic-core/src/validators/model_fields.rsindex 5e8fe034..d9078f13 100644@@ -126,7 +126,8 @@ impl BuildValidator for ModelFieldsValidator {  impl_py_gc_traverse!(ModelFieldsValidator {     fields,-    extras_validator+    extras_validator,+    extras_keys_validator });  impl Validator for ModelFieldsValidator {pydantic-core/tests/test_garbage_collection.pyindex e53cdc56..01067e08 100644@@ -1,6 +1,7 @@ import platform import sys-from collections.abc import Iterable+from collections.abc import Callable, Iterable+from enum import Enum from typing import Any from weakref import WeakValueDictionary @@ -114,3 +115,171 @@ def test_gc_validator_iterator() -> None:         del iterable      assert_gc(lambda: len(cache) == 0)+++def _assert_schema_holder_collected(build: Callable[[type[Any]], Any]) -> None:+    """Build a schema validator/serializer that is referenced from (and references) a transient class,+    and assert the class can be garbage collected."""++    class Base:+        __holder__: Any++        def __init_subclass__(cls) -> None:+            cls.__holder__ = build(cls)++    cache: WeakValueDictionary[int, Any] = WeakValueDictionary()++    for _ in range(1_000):++        class MyModel(Base):+            pass++        cache[id(MyModel)] = MyModel++        del MyModel++    assert_gc(lambda: len(cache) == 0)+++def _plain_function_schema(cls: type[Any]) -> core_schema.CoreSchema:+    # the function's default argument creates a reference back to the transient class+    def func(value: Any, _cls: type[Any] = cls) -> Any:+        return value++    return core_schema.no_info_plain_validator_function(+        func, serialization=core_schema.plain_serializer_function_ser_schema(func)+    )+++python_reference_schemas = pytest.mark.parametrize(+    'build',+    [+        pytest.param(+            lambda cls: SchemaSerializer(+                core_schema.model_schema(+                    cls,+                    core_schema.model_fields_schema(+                        {+                            'x': core_schema.model_field(+                                core_schema.int_schema(),+                                serialization_exclude_if=lambda value, _cls=cls: False,+                            )+                        }+                    ),+                )+            ),+            id='field_serialization_exclude_if',+        ),+        pytest.param(+            lambda cls: SchemaSerializer(+                core_schema.model_schema(+                    cls,+                    core_schema.model_fields_schema(+                        {'x': core_schema.model_field(core_schema.int_schema())},+                        computed_fields=[+                            core_schema.computed_field(+                                'x',+                                core_schema.int_schema(),+                                serialization_exclude_if=lambda value, _cls=cls: False,+                            )+                        ],+                    ),+                )+            ),+            id='computed_field_serialization_exclude_if',+        ),+        pytest.param(+            lambda cls: SchemaSerializer(+                core_schema.model_schema(+                    cls,+                    core_schema.model_fields_schema(+                        {'x': core_schema.model_field(core_schema.int_schema())},+                        extras_schema=_plain_function_schema(cls),+                        extra_behavior='allow',+                    ),+                )+            ),+            id='model_extras_serializer',+        ),+        pytest.param(+            lambda cls: SchemaValidator(+                core_schema.model_schema(+                    cls,+                    core_schema.model_fields_schema(+                        {'x': core_schema.model_field(core_schema.int_schema())},+                        extras_keys_schema=_plain_function_schema(cls),+                        extra_behavior='allow',+                    ),+                )+            ),+            id='model_extras_keys_validator',+        ),+        pytest.param(+            lambda cls: SchemaValidator(+                core_schema.dataclass_schema(+                    cls,+                    {+                        **core_schema.dataclass_args_schema(+                            'MyModel',+                            [core_schema.dataclass_field('x', core_schema.int_schema())],+                            extra_behavior='allow',+                        ),+                        'extras_schema': _plain_function_schema(cls),+                    },+                    ['x'],+                )+            ),+            id='dataclass_extras_validator',+        ),+        pytest.param(+            # unhashable expected values are stored separately in the literal lookup+            lambda cls: SchemaValidator(core_schema.literal_schema([[cls]])),+            id='literal_unhashable_expected_value',+        ),+    ],+)+++@pytest.mark.xfail(is_free_threaded and sys.version_info < (3, 14), reason='GC leaks on free-threaded (<3.14)')+@pytest.mark.xfail(+    condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'+)+@pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy')+@python_reference_schemas+def test_gc_schema_python_references(build: Callable[[type[Any]], Any]) -> None:+    _assert_schema_holder_collected(build)+++@pytest.mark.xfail(is_free_threaded and sys.version_info < (3, 14), reason='GC leaks on free-threaded (<3.14)')+@pytest.mark.xfail(+    condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'+)+@pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy')+@pytest.mark.parametrize(+    'enum_bases,values,sub_type',+    [+        ((Enum,), [1, 2], None),+        ((int, Enum), [1, 2], 'int'),+        ((str, Enum), ['a', 'b'], 'str'),+        ((float, Enum), [1.5, 2.5], 'float'),+    ],+)+def test_gc_enum_schema(enum_bases: tuple[type[Any], ...], values: list[Any], sub_type: Any) -> None:+    # the validator's lookup holds the enum members and the serializer holds the enum class+    cache: WeakValueDictionary[int, Any] = WeakValueDictionary()++    for _ in range(1_000):++        class MyEnum(*enum_bases):+            A = values[0]+            B = values[1]++        schema = core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type=sub_type)+        setattr(MyEnum, '__validator__', SchemaValidator(schema))+        setattr(MyEnum, '__serializer__', SchemaSerializer(schema))++        cache[id(MyEnum)] = MyEnum++        del MyEnum, schema++    assert_gc(lambda: len(cache) == 0)tests/test_garbage_collection.pynew file mode 100644index 00000000..a0977821@@ -0,0 +1,110 @@+import gc+import platform+import sys+import types+import weakref++import pytest++pytestmark = [+    pytest.mark.skipif(platform.python_implementation() == 'PyPy', reason='PyPy does not play nice with PyO3 gc'),+    pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy'),+    pytest.mark.skipif(+        hasattr(sys, '_is_gil_enabled') and not sys._is_gil_enabled() and sys.version_info < (3, 14),+        reason='GC leaks on free-threaded (<3.14)',+    ),+]+++def _transient_module(name: str, source: str, class_names: tuple[str, ...]) -> tuple[weakref.ref, ...]:+    module = types.ModuleType(name)+    sys.modules[name] = module+    try:+        exec(compile(source, f'<{name}>', 'exec'), module.__dict__)+        refs = tuple(weakref.ref(module.__dict__[class_name]) for class_name in class_names)+    finally:+        del sys.modules[name]+    del module+    return refs+++def _collect() -> None:+    for _ in range(5):+        gc.collect()+++@pytest.mark.parametrize('enum_base', ['', 'str, ', 'int, ', 'float, '])+def test_model_with_enum_with_methods_is_collected(enum_base: str) -> None:+    # https://github.com/pydantic/pydantic/issues/13621+    value = {'': '1', 'str, ': '"full"', 'int, ': '1', 'float, ': '1.5'}[enum_base]+    refs = _transient_module(+        '_pydantic_enum_gc_test',+        f"""+from enum import Enum+from pydantic import BaseModel++class Membership({enum_base}Enum):+    FULL = {value}++    def label(self) -> str:+        return str(self.value)++class Model(BaseModel):+    membership: Membership++Model(membership=Membership.FULL).model_dump()+""",+        ('Membership', 'Model'),+    )++    _collect()++    assert [ref() for ref in refs] == [None, None]+++def test_model_with_field_exclude_if_is_collected() -> None:+    # https://github.com/pydantic/pydantic/issues/13621+    (ref,) = _transient_module(+        '_pydantic_exclude_if_gc_test',+        """+from pydantic import BaseModel, Field++class Model(BaseModel):+    value: int = Field(exclude_if=lambda value: False)++Model(value=1).model_dump()+""",+        ('Model',),+    )++    _collect()++    assert ref() is None+++def test_model_with_validated_extra_keys_is_collected() -> None:+    (ref,) = _transient_module(+        '_pydantic_extra_keys_gc_test',+        """+from typing import Any+from pydantic import BaseModel, ConfigDict+from pydantic_core import core_schema++class Key(str):+    # not using `Annotated` here, as `typing` caches parametrized `Annotated` forms (and their metadata)+    @classmethod+    def __get_pydantic_core_schema__(cls, source: Any, handler: Any) -> core_schema.CoreSchema:+        return core_schema.no_info_after_validator_function(lambda v: v, core_schema.str_schema())++class Model(BaseModel):+    model_config = ConfigDict(extra='allow')+    __pydantic_extra__: dict[Key, int]++Model(a=1).model_dump()+""",+        ('Model',),+    )++    _collect()++    assert ref() is None 
Merged fix · PR #13624+118 −21
pydantic-core/src/serializers/fields.rsindex ba18ee4f3..8631d0b09 100644@@ -35,7 +35,10 @@ pub(super) struct SerField {     pub serialization_exclude_if: Option<Py<PyAny>>, } -impl_py_gc_traverse!(SerField { serializer });+impl_py_gc_traverse!(SerField {+    serializer,+    serialization_exclude_if+});  impl SerField {     pub fn new(pydantic-core/src/serializers/type_serializers/enum_.rsindex 0d2819ac2..b4e76133c 100644@@ -23,6 +23,8 @@ pub struct EnumSerializer {     serializer: Option<Arc<CombinedSerializer>>, } +impl_py_gc_traverse!(EnumSerializer { class, serializer });+ impl BuildSerializer for EnumSerializer {     const EXPECTED_TYPE: &'static str = "enum"; @@ -48,8 +50,6 @@ impl BuildSerializer for EnumSerializer {     } } -impl_py_gc_traverse!(EnumSerializer { serializer });- impl TypeSerializer for EnumSerializer {     fn to_python<'py>(&self, value: &Bound<'py, PyAny>, state: &mut SerializationState<'py>) -> PyResult<Py<PyAny>> {         let py = value.py();pydantic-core/src/validators/enum_.rsindex 6ef685daf..28a32a874 100644@@ -168,7 +168,7 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> { #[derive(Debug, Clone)] pub struct PlainEnumValidator; -impl_py_gc_traverse!(EnumValidator<PlainEnumValidator> { class, missing });+impl_py_gc_traverse!(EnumValidator<PlainEnumValidator> { class, lookup, missing });  impl EnumValidateValue for PlainEnumValidator {     fn validate_value<'py, I: Input<'py> + ?Sized>(@@ -200,7 +200,7 @@ impl EnumValidateValue for PlainEnumValidator { #[derive(Debug, Clone)] pub struct IntEnumValidator; -impl_py_gc_traverse!(EnumValidator<IntEnumValidator> { class, missing });+impl_py_gc_traverse!(EnumValidator<IntEnumValidator> { class, lookup, missing });  impl EnumValidateValue for IntEnumValidator {     fn validate_value<'py, I: Input<'py> + ?Sized>(@@ -216,7 +216,7 @@ impl EnumValidateValue for IntEnumValidator { #[derive(Debug, Clone)] pub struct StrEnumValidator; -impl_py_gc_traverse!(EnumValidator<StrEnumValidator> { class, missing });+impl_py_gc_traverse!(EnumValidator<StrEnumValidator> { class, lookup, missing });  impl EnumValidateValue for StrEnumValidator {     fn validate_value<'py, I: Input<'py> + ?Sized>(@@ -232,7 +232,7 @@ impl EnumValidateValue for StrEnumValidator { #[derive(Debug, Clone)] pub struct FloatEnumValidator; -impl_py_gc_traverse!(EnumValidator<FloatEnumValidator> { class, missing });+impl_py_gc_traverse!(EnumValidator<FloatEnumValidator> { class, lookup, missing });  impl EnumValidateValue for FloatEnumValidator {     fn validate_value<'py, I: Input<'py> + ?Sized>(pydantic-core/tests/test_garbage_collection.pyindex e53cdc564..7ac338f77 100644@@ -1,6 +1,6 @@ import platform-import sys from collections.abc import Iterable+from enum import Enum from typing import Any from weakref import WeakValueDictionary @@ -8,7 +8,7 @@ import pytest  from pydantic_core import SchemaSerializer, SchemaValidator, core_schema -from .conftest import assert_gc, is_free_threaded+from .conftest import assert_gc  GC_TEST_SCHEMA_INNER = core_schema.definitions_schema(     core_schema.definition_reference_schema(schema_ref='model'),@@ -21,18 +21,18 @@ GC_TEST_SCHEMA_INNER = core_schema.definitions_schema( )  -@pytest.mark.xfail(is_free_threaded and sys.version_info < (3, 14), reason='GC leaks on free-threaded (<3.14)') @pytest.mark.xfail(-    condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'+    condition=platform.python_implementation() == 'PyPy', reason='https://github.com/pypy/pypy/issues/3898' ) @pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy') def test_gc_schema_serializer() -> None:-    # test for https://github.com/pydantic/pydantic/issues/5136+    """https://github.com/pydantic/pydantic/issues/5136"""+     class BaseModel:-        __schema__: SchemaSerializer+        __pydantic_core_schema__: SchemaSerializer          def __init_subclass__(cls) -> None:-            cls.__schema__ = SchemaSerializer(+            cls.__pydantic_core_schema__ = SchemaSerializer(                 core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER), config={'ser_json_timedelta': 'float'}             ) @@ -50,18 +50,18 @@ def test_gc_schema_serializer() -> None:     assert_gc(lambda: len(cache) == 0)  -@pytest.mark.xfail(is_free_threaded and sys.version_info < (3, 14), reason='GC leaks on free-threaded (<3.14)') @pytest.mark.xfail(-    condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'+    condition=platform.python_implementation() == 'PyPy', reason='https://github.com/pypy/pypy/issues/3898' ) @pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy') def test_gc_schema_validator() -> None:-    # test for https://github.com/pydantic/pydantic/issues/5136+    """https://github.com/pydantic/pydantic/issues/5136"""+     class BaseModel:-        __validator__: SchemaValidator+        __pydantic_validator__: SchemaValidator          def __init_subclass__(cls) -> None:-            cls.__validator__ = SchemaValidator(+            cls.__pydantic_validator__ = SchemaValidator(                 schema=core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER),                 config=core_schema.CoreConfig(extra_fields_behavior='allow'),             )@@ -81,11 +81,12 @@ def test_gc_schema_validator() -> None:   @pytest.mark.xfail(-    condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'+    condition=platform.python_implementation() == 'PyPy', reason='https://github.com/pypy/pypy/issues/3898' ) @pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy') def test_gc_validator_iterator() -> None:-    # test for https://github.com/pydantic/pydantic/issues/9243+    """https://github.com/pydantic/pydantic/issues/9243"""+     class MyModel:         iter: Iterable[int] @@ -114,3 +115,96 @@ def test_gc_validator_iterator() -> None:         del iterable      assert_gc(lambda: len(cache) == 0)+++@pytest.mark.xfail(+    condition=platform.python_implementation() == 'PyPy', reason='https://github.com/pypy/pypy/issues/3898'+)+@pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy')+def test_gc_enum_serializer_class() -> None:+    """https://github.com/pydantic/pydantic/issues/13621"""++    class EnumBase:+        __pydantic_serializer__: SchemaSerializer++    cache: WeakValueDictionary[int, Any] = WeakValueDictionary()++    for _ in range(10_000):++        class MyEnum(EnumBase, str, Enum):+            FULL = 'full'++        MyEnum.__pydantic_serializer__ = SchemaSerializer(core_schema.enum_schema(MyEnum, list(MyEnum), sub_type='str'))++        cache[id(MyEnum)] = MyEnum++        del MyEnum++    assert_gc(lambda: len(cache) == 0)+++@pytest.mark.xfail(+    condition=platform.python_implementation() == 'PyPy', reason='https://github.com/pypy/pypy/issues/3898'+)+@pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy')+def test_gc_enum_validator_lookup() -> None:+    """https://github.com/pydantic/pydantic/issues/13621"""++    class EnumBase:+        __pydantic_validator__: SchemaValidator++    cache: WeakValueDictionary[int, Any] = WeakValueDictionary()++    for _ in range(10_000):++        class MyEnum(EnumBase, str, Enum):+            FULL = 'full'++        MyEnum.__pydantic_validator__ = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum), sub_type='str'))++        cache[id(MyEnum)] = MyEnum++        del MyEnum++    assert_gc(lambda: len(cache) == 0)+++@pytest.mark.xfail(+    condition=platform.python_implementation() == 'PyPy', reason='https://github.com/pypy/pypy/issues/3898'+)+@pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy')+def test_gc_field_exclude_if() -> None:+    """https://github.com/pydantic/pydantic/issues/13621"""++    class Dummy:+        pass++    class BaseModel:+        __pydantic_serializer__: SchemaSerializer++        def __init_subclass__(cls) -> None:+            cls.__pydantic_serializer__ = SchemaSerializer(+                core_schema.model_schema(+                    Dummy,+                    core_schema.model_fields_schema(+                        {+                            'value': core_schema.model_field(+                                core_schema.int_schema(), serialization_exclude_if=lambda value, _cls=cls: False+                            )+                        }+                    ),+                )+            )++    cache: WeakValueDictionary[int, Any] = WeakValueDictionary()++    for _ in range(10_000):++        class MyModel(BaseModel):+            pass++        cache[id(MyModel)] = MyModel++        del MyModel++    assert_gc(lambda: len(cache) == 0)