functools.cache on a method keeps every instance alive
A service that creates short-lived objects slowly eats memory, and the heap snapshot shows thousands of instances of a class nobody keeps a reference to. If any of its methods carries @cache or @lru_cache, that is the reason.
What happens
functools.cache is lru_cache(maxsize=None). The cache is stored on the function object, which lives on the class, which lives as long as the process. The key for a method call includes self, so every instance that ever called the method is referenced from that dictionary. Deleting your last variable does not free the object, because the cache is still holding it.
A weak reference makes it visible:

With cached_property, the value is stored in the instance's own __dict__, so it dies with the instance.
Which pattern to use
- One value per instance, no arguments:
functools.cached_property. It computes once and stores the result on the object. - Arguments that vary, cache scoped to the instance: create the cached function in
__init__, for exampleself._lookup = lru_cache(maxsize=256)(self._lookup_uncached). The cache is then owned by the instance and collected with it, although the bound method inside the cache referencesself, so you have a cycle that the garbage collector must clear. That is fine, but it will not be freed by reference counting alone. - Results that depend only on the arguments: move the function out of the class, or make it a
@staticmethodwith hashable parameters, and cache that. - A cache that must not keep objects alive at all: key by something small such as an ID, not by the object.
Two smaller notes
maxsize=None never evicts, so a cache keyed by user input can grow without limit. Use a bounded lru_cache(maxsize=...) when the key space is not small. And cache_info() shows hits, misses and current size, which is worth logging when you first add a cache, since a hit rate near zero means the cache only costs memory.
Two things the cache gives you for free
cache_info() and cache_clear() exist on any lru_cache- or cache-wrapped function, including the leaking method from above: cache_info() reports hits, misses, the configured maxsize and the current size, and cache_clear() empties it, which is a manual escape hatch when you know a cache has grown stale or too large. The cache is also thread-safe internally, protected by a lock, so concurrent calls from multiple threads will not corrupt it, though the lock does mean heavy concurrent use of a single cached method serialises around it.
One more detail from recent Python versions: combining @staticmethod with @cache used to be order-sensitive, since a staticmethod object was not directly callable and confused the cache decorator if stacked in the wrong order. As of Python 3.12, both orders work. If you support older Python versions, put @cache closer to the function and @staticmethod outermost, and test it rather than assuming.