Backtestspydanticrun-20261022-024030#13621
Memory leak: transient models using Enum methods or Field(exclude_if=...) survive GC
Our patch was judged better than the merged fix.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches apply the same three root-cause fixes the issue identifies (traverse SerField.serialization_exclude_if, EnumSerializer.class, and EnumValidator.lookup for all four enum validator variants), and both pass every independent test. The differences are in completeness, tests, and churn. Patch A also traverses ComputedField.serialization_exclude_if, which is the same bug class for computed_field(exclude_if=...) and squarely within the issue's 'Field(exclude_if=...)' ask, and makes LiteralLookup traverse expected_py_values and expected_py_primitives so the lookup edge is actually complete rather than only covering the hashable-dict case. Patch A's tests are stronger: a parametrized pydantic-core test over plain/int/str/float enums for both validator and serializer, an exclude_if test across model/typed_dict/dataclass/computed fields, and a pydantic-level test in tests/test_main.py that reproduces the issue's exact transient-module scenario (including the computed-field variant). Patch B's three new tests are valid and would fail before the fix, but B also makes unrelated and risky edits to existing tests: it removes the free-threaded xfail markers and the is_free_threaded import from test_gc_schema_serializer/validator, renames dunder attributes in those tests, and converts comments to docstrings. Dropping those xfails can turn existing passing-as-xfail runs into hard failures on free-threaded builds, and B's new GC tests also omit that marker. That churn obscures the fix and adds risk without addressing the issue. A is more correct at the edges, better tested, and cleaner in scope.
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
10m 10s
Wall-clock time in the container
Full test suite
No new failures
566 passed · 116 skipped · 682 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
196vs 139 merged
Changed lines, ours vs merged
The issue
View on GitHubInitial Checks
- I confirm that I'm using Pydantic V2
Description
Transient BaseModel classes are not collected when either:
- A model field references an
Enumwhose 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:
SerFieldownsserialization_exclude_if, but traverses onlyserializer: https://github.com/pydantic/pydantic/blob/c67a1397327c6abc1a2e2e921af01aebbbeedf1c/pydantic-core/src/serializers/fields.rs#L26-L38EnumSerializerownsclass, but traverses onlyserializer: https://github.com/pydantic/pydantic/blob/c67a1397327c6abc1a2e2e921af01aebbbeedf1c/pydantic-core/src/serializers/type_serializers/enum_.rs- Each
EnumValidator<T>ownslookup, but traverses onlyclassandmissing: https://github.com/pydantic/pydantic/blob/c67a1397327c6abc1a2e2e921af01aebbbeedf1c/pydantic-core/src/validators/enum_.rs
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_iftoSerFieldtraversal. - Add
classtoEnumSerializertraversal. - Add
lookupto everyEnumValidator<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:
- https://github.com/pydantic/pydantic/issues/5136
- https://github.com/pydantic/pydantic-core/pull/787
- https://github.com/pydantic/pydantic-core/pull/1100
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: unknownThe two patches
pydantic-core/src/serializers/computed_fields.rsindex 5bb3841b..f5546358 100644@@ -110,7 +110,7 @@ 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..0d182849 100644@@ -35,7 +35,7 @@ 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 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/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/tests/test_garbage_collection.pyindex e53cdc56..fb2b27f4 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,111 @@ def test_gc_validator_iterator() -> None: del iterable assert_gc(lambda: len(cache) == 0)+++def _assert_classes_collected(make_class: Callable[[], type[Any]], iterations: int = 1_000) -> None:+ cache: WeakValueDictionary[int, Any] = WeakValueDictionary()++ for _ in range(iterations):+ cls = make_class()+ cache[id(cls)] = cls+ del cls++ 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'+)+@pytest.mark.skipif(platform.python_implementation() == 'GraalVM', reason='Cannot reliably trigger GC on GraalPy')+@pytest.mark.parametrize('enum_base,sub_type', [(Enum, None), (int, 'int'), (str, 'str'), (float, 'float')])+@pytest.mark.parametrize('kind', ['validator', 'serializer'])+def test_gc_enum(enum_base: type[Any], sub_type: Any, kind: str) -> None:+ # test for https://github.com/pydantic/pydantic/issues/13621+ def make_class() -> type[Any]:+ bases = (enum_base,) if enum_base is Enum else (enum_base, Enum)++ class MyEnum(*bases):+ A = 1 if enum_base is not str else 'a'++ schema = core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type=sub_type)+ if kind == 'validator':+ MyEnum._schema_holder = SchemaValidator(schema)+ else:+ MyEnum._schema_holder = SchemaSerializer(schema)+ return MyEnum++ _assert_classes_collected(make_class)+++@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')+def test_gc_literal_unhashable_value() -> None:+ # test for https://github.com/pydantic/pydantic/issues/13621+ def make_class() -> type[Any]:+ class MyModel:+ pass++ MyModel.__validator__ = SchemaValidator(core_schema.literal_schema([[MyModel]]))+ return MyModel++ _assert_classes_collected(make_class)+++@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('field_kind', ['model', 'typed_dict', 'dataclass', 'computed'])+def test_gc_serialization_exclude_if(field_kind: str) -> None:+ # test for https://github.com/pydantic/pydantic/issues/13621+ def make_class() -> type[Any]:+ class MyModel:+ @property+ def b(self) -> int:+ return 1++ def exclude_if(value: Any) -> bool:+ # reference the class to create a reference cycle through the serializer+ return isinstance(value, MyModel)++ if field_kind == 'model':+ schema = core_schema.model_schema(+ MyModel,+ core_schema.model_fields_schema(+ {'a': core_schema.model_field(core_schema.int_schema(), serialization_exclude_if=exclude_if)}+ ),+ )+ elif field_kind == 'typed_dict':+ schema = core_schema.typed_dict_schema(+ {'a': core_schema.typed_dict_field(core_schema.int_schema(), serialization_exclude_if=exclude_if)}+ )+ elif field_kind == 'dataclass':+ schema = core_schema.dataclass_schema(+ MyModel,+ core_schema.dataclass_args_schema(+ 'MyModel',+ [core_schema.dataclass_field('a', core_schema.int_schema(), serialization_exclude_if=exclude_if)],+ ),+ ['a'],+ )+ else:+ schema = core_schema.model_schema(+ MyModel,+ core_schema.model_fields_schema(+ {'a': core_schema.model_field(core_schema.int_schema())},+ computed_fields=[+ core_schema.computed_field('b', core_schema.int_schema(), serialization_exclude_if=exclude_if)+ ],+ ),+ )++ MyModel.__serializer__ = SchemaSerializer(schema)+ return MyModel++ _assert_classes_collected(make_class)tests/test_main.pyindex db2b8539..e089ec53 100644@@ -1,10 +1,13 @@+import gc import json import platform import re import sys import threading+import types import typing import warnings+import weakref from collections import defaultdict from collections.abc import Callable, Mapping from copy import deepcopy@@ -3901,3 +3904,65 @@ def test_replace() -> None: m = Model(x=1, y=2) assert replace(m, x=3) == Model(x=3, y=2)+++def _transient_module_class_refs(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__)+ return tuple(weakref.ref(module.__dict__[class_name]) for class_name in class_names)+ finally:+ del sys.modules[name]+++@pytest.mark.thread_unsafe(reason='GC is flaky')+@pytest.mark.skipif(platform.python_implementation() == 'PyPy', reason='PyPy does not play nice with PyO3 gc')+@pytest.mark.parametrize(+ 'source,class_names',+ [+ pytest.param(+ """+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'),+ id='enum-with-method',+ ),+ pytest.param(+ """+from pydantic import BaseModel, Field+class Model(BaseModel):+ value: int = Field(exclude_if=lambda value: False)+""",+ ('Model',),+ id='field-exclude-if',+ ),+ pytest.param(+ """+from pydantic import BaseModel, computed_field+class Model(BaseModel):+ @computed_field(exclude_if=lambda value: False)+ @property+ def value(self) -> int:+ return 1+""",+ ('Model',),+ id='computed-field-exclude-if',+ ),+ ],+)+def test_transient_model_is_garbage_collected(source: str, class_names: tuple[str, ...]) -> None:+ # https://github.com/pydantic/pydantic/issues/13621+ refs = _transient_module_class_refs('_pydantic_transient_gc_test', source, class_names)++ for _ in range(5):+ gc.collect()++ assert [ref() for ref in refs] == [None] * len(refs)
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)