fix: stop keeping a model alive for the lifetime of the process

Subscribing a Path or a ScimFilter to a model, and resolving a path against
one, both filed it in a module-level cache that never let go, so a server
building a model per schema it discovers accumulated every one of them. The
class cache holds its classes weakly, and the resolution cache moved onto the
model, which is the only place a resolved attribute naming that model cannot
outlive it.

Author: azmeuk

scim2_models/binding.py

@@ -1,5 +1,7 @@
+from collections.abc import MutableMapping
 from typing import TYPE_CHECKING
 from typing import Any
+from weakref import WeakValueDictionary
 
 from pydantic import GetCoreSchemaHandler
 from pydantic import GetJsonSchemaHandler
@@ -12,9 +14,15 @@
 if TYPE_CHECKING:
     from .base import BaseModel
 
-_BOUND_CLASSES: dict[tuple[type, tuple[type, ...]], type] = {}
+_BOUND_CLASSES: "MutableMapping[tuple[type, tuple[type, ...]], type]" = (
+    WeakValueDictionary()
+)
 """The classes subscription has already built, so that two subscriptions of the
-same resource types answer the same class."""
+same resource types answer the same class.
+
+The classes are held weakly: one bound to a model built at runtime, as a server
+serving a schema it discovered does, would otherwise keep that model alive for
+as long as the process runs."""
 
 
 class _BoundToModels:

scim2_models/resolution.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass
 from dataclasses import replace
-from functools import lru_cache
 from inspect import isclass
 from typing import Any
 from typing import cast
@@ -22,6 +21,9 @@
 # Python types that RFC7644 §3.4.2.2 forbids comparing with an ordering operator.
 _UNORDERABLE_TYPES = (bool, bytes)
 
+_RESOLVED_ATTRS = "__scim_resolved_attrs__"
+"""The attribute a model keeps its resolved paths under."""
+
 
 def _unwrap_annotated(type_: Any) -> type | None:
     """Strip the metadata of an :data:`~typing.Annotated` type.
@@ -189,7 +191,6 @@ def _target_model(
     raise PathNotFoundException(path=str(attr_path), field=attr_path.attr)
 
 
-@lru_cache(maxsize=1024)
 def resolve_attr_path(
     model: type[BaseModel], attr_path: AttrPath, *, strict: bool = True
 ) -> ResolvedAttribute | None:
@@ -204,6 +205,26 @@ def resolve_attr_path(
         is safe since :class:`ResolvedAttribute` is immutable.
     :raises PathNotFoundException: If ``strict`` and the attribute is unknown.
     """
+    # The cache is held by the model rather than by this module, so that it
+    # cannot outlive the model it describes: a resolved attribute names the
+    # model it was resolved on, which a cache keyed by that model would keep
+    # alive for as long as the process runs.
+    cache: dict[tuple[AttrPath, bool], ResolvedAttribute | None] | None
+    cache = model.__dict__.get(_RESOLVED_ATTRS)
+    if cache is None:
+        cache = {}
+        setattr(model, _RESOLVED_ATTRS, cache)
+
+    key = (attr_path, strict)
+    if key not in cache:
+        cache[key] = _resolve_attr_path(model, attr_path, strict=strict)
+    return cache[key]
+
+
+def _resolve_attr_path(
+    model: type[BaseModel], attr_path: AttrPath, *, strict: bool
+) -> ResolvedAttribute | None:
+    """Bind an attribute path, without going through the cache of the model."""
     target = _target_model(model, attr_path, strict=strict)
     if target is None:
         return None

tests/test_dynamic_resources.py

@@ -1,4 +1,6 @@
 import datetime
+import gc
+import weakref
 from typing import Union
 
 from pydantic import Base64Bytes
@@ -10,6 +12,8 @@
 from scim2_models.annotations import Uniqueness
 from scim2_models.attributes import ComplexAttribute
 from scim2_models.context import Context
+from scim2_models.filters import ScimFilter
+from scim2_models.path import Path
 from scim2_models.reference import URI
 from scim2_models.reference import External
 from scim2_models.reference import Reference
@@ -2868,3 +2872,32 @@ def test_extensions_built_from_a_schema_know_their_attribute_urns():
         "schemas": ["urn:example:2.0:Single", "urn:example:2.0:Ext"],
         "urn:example:2.0:Ext": {"attr": "value"},
     }
+
+
+def test_a_model_built_at_runtime_is_collected_once_it_is_dropped():
+    """A model discovered from a schema is not kept alive by what resolved against it.
+
+    A server serving the schemas of its tenants builds a model per schema, and
+    the classes a subscription answers, as well as the paths resolved against
+    them, used to hold every one of them for as long as the process ran.
+    """
+    Model = Resource.from_schema(
+        _single_attribute_schema({"name": "label", "type": "string"})
+    )
+    reference = weakref.ref(Model)
+
+    # The assertions are made on values that do not name the model, since a
+    # resolved attribute does and pytest keeps the operands of an assertion.
+    resolved = Path[Model]("label").resolve() is not None
+    matched = ScimFilter[Model]('label eq "x"').match(Model(label="x"))
+    assert resolved
+    assert matched
+
+    del Model
+
+    # The first pass frees the validators pydantic built for the model, which
+    # is what leaves the model itself unreachable for the second one.
+    gc.collect()
+    gc.collect()
+
+    assert reference() is None