Hacer que @lru_cache ignore algunos de los argumentos de la función

como puedo hacer @functools.lru_cache ¿El decorador ignora algunos de los argumentos de la función con respecto a la clave de almacenamiento en caché?

Por ejemplo, tengo una función que se ve así:

def find_object(db_handle, query):
    # (omitted code)
    return result

si aplico lru_cache decorador así, db_handle se incluirán en la clave de caché. Como resultado, si intento llamar a la función con el mismo querypero diferente db_handle, se ejecutará nuevamente, lo que me gustaría evitar. Quiero lru_cache considerar query argumento solamente.

Con cachetools puedes escribir:

from cachetools import cached
from cachetools.keys import hashkey

from random import randint

@cached(cache={}, key=lambda db_handle, query: hashkey(query))
def find_object(db_handle, query):
    print("processing {0}".format(query))
    return query

queries = list(range(5))
queries.extend(range(5))
for q in queries:
    print("result: {0}".format(find_object(randint(0, 1000), q)))

Deberá instalar cachetools (pip install cachetools).

La sintaxis es:

@cached(
    cache={},
    key=lambda <all-function-args>: hashkey(<relevant-args>)
)

Aquí hay otro ejemplo que incluye argumentos de palabras clave:

@cached(
    cache={},
    key=lambda a, b, c=1, d=2: hashkey(a, c)
)
def my_func(a, b, c=1, d=2):
    return a + c

En el ejemplo anterior, tenga en cuenta que los argumentos de entrada de la función lambda coinciden con el my_func argumentos No es necesario que coincida exactamente con argspec si no es necesario. Por ejemplo, puede usar kwargs para eliminar cosas que no son necesarias en el hashkey:

@cached(
    cache={},
    key=lambda a, b, c=1, **kwargs: hashkey(a, c)
)
def my_func(a, b, c=1, d=2, e=3, f=4):
    return a + c

En el ejemplo anterior no nos importa d=, e= y f= args al buscar un valor de caché, por lo que podemos aplastarlos con **kwargs.

Tengo al menos una solución muy fea. Envoltura db_handle en un objeto que siempre es igual, y desenvuélvelo dentro de la función.

Requiere un decorador con bastantes funciones de ayuda, lo que hace que el seguimiento de la pila sea bastante confuso.

class _Equals(object):
    def __init__(self, o):
        self.obj = o

    def __eq__(self, other):
        return True

    def __hash__(self):
        return 0

def lru_cache_ignoring_first_argument(*args, **kwargs):
    lru_decorator = functools.lru_cache(*args, **kwargs)

    def decorator(f):
        @lru_decorator
        def helper(arg1, *args, **kwargs):
            arg1 = arg1.obj
            return f(arg1, *args, **kwargs)

        @functools.wraps(f)
        def function(arg1, *args, **kwargs):
            arg1 = _Equals(arg1)
            return helper(arg1, *args, **kwargs)

        return function

    return decorator