metodos - importar clases en python

Functools de Python lru_cache con métodos de clase: liberar objeto

Question

¿Cómo puedo usar functools ''lru_cache dentro de las clases sin pérdida de memoria? En el siguiente ejemplo mínimo, la instancia de foo no se lanzará aunque se salga del alcance y no tenga referencia (excepto la caché lru).

from functools import lru_cache
class BigClass:
    pass
class Foo:
    def __init__(self):
        self.big = BigClass()
    @lru_cache(maxsize=16)
    def cached_method(self, x):
        return x + 5

def fun():
    foo = Foo()
    print(foo.cached_method(10))
    print(foo.cached_method(10)) # use cache
    return ''something''

fun()

Pero foo y por foo.big tanto foo.big (una gran BigClass ) siguen vivos

import gc; gc.collect()  # collect garbage
len([obj for obj in gc.get_objects() if isinstance(obj, Foo)]) # is 1

Eso significa que las instancias de Foo / BigClass aún residen en la memoria. Incluso la eliminación de Foo (del Foo ) no los liberará.

¿Por qué lru_cache se aferra a la instancia? ¿El caché no usa el hash y no el objeto real?

¿Cuál es la forma recomendada de usar lru_caches dentro de las clases?

Sé de dos soluciones: utilizar cachés por instancia o hacer que la memoria caché ignore el objeto (lo que podría dar lugar a resultados erróneos)

Answer 1

Esta no es la solución más limpia, pero es completamente transparente para el programador:

import functools
import weakref

def memoized_method(*lru_args, **lru_kwargs):
    def decorator(func):
        @functools.wraps(func)
        def wrapped_func(self, *args, **kwargs):
            # We''re storing the wrapped method inside the instance. If we had
            # a strong reference to self the instance would never die.
            self_weak = weakref.ref(self)
            @functools.wraps(func)
            @functools.lru_cache(*lru_args, **lru_kwargs)
            def cached_method(*args, **kwargs):
                return func(self_weak(), *args, **kwargs)
            setattr(self, func.__name__, cached_method)
            return cached_method(*args, **kwargs)
        return wrapped_func
    return decorator

Toma exactamente los mismos parámetros que lru_cache , y funciona exactamente igual. Sin embargo, nunca pasa self a lru_cache y en su lugar utiliza un lru_cache por instancia.