feat(cache): add exclude arguments feature for cache key generation

- Introduce `exclude_positional_args` and `exclude_keyword_args` parameters to the `exec`, `aexec`, and decorator methods
- Implement logic to filter out specified positional and keyword arguments before cache key generation
- Update the `_before_get` method to handle the new exclude parameters
- Add unit tests to verify the functionality of excluding arguments

Author: tanbro

src/redis_func_cache/cache.py

@@ -441,10 +441,19 @@ async def aput(
         ext_args = ext_args or ()
         await script(keys=key_pair, args=chain((maxsize, ttl, hash_, value, encoded_options), ext_args))
 
-    def _before_get(self, user_function, user_args, user_kwds):
-        keys = self.policy.calc_keys(user_function, user_args, user_kwds)
-        hash_value = self.policy.calc_hash(user_function, user_args, user_kwds)
-        ext_args = self.policy.calc_ext_args(user_function, user_args, user_kwds) or ()
+    def _before_get(
+        self,
+        user_function,
+        user_args,
+        user_kwds,
+        exclude_positional_args: Optional[Sequence[int]] = None,
+        exclude_keyword_args: Optional[Sequence[str]] = None,
+    ):
+        args = [x for i, x in enumerate(user_args) if i not in (exclude_positional_args or [])]
+        kwds = {k: v for k, v in user_kwds.items() if k not in (exclude_keyword_args or {})}
+        keys = self.policy.calc_keys(user_function, args, kwds)
+        hash_value = self.policy.calc_hash(user_function, args, kwds)
+        ext_args = self.policy.calc_ext_args(user_function, args, kwds) or ()
         return keys, hash_value, ext_args
 
     def exec(
@@ -454,6 +463,8 @@ def exec(
         user_kwds: Mapping[str, Any],
         serialize_func: Optional[SerializerT] = None,
         deserialize_func: Optional[DeserializerT] = None,
+        exclude_positional_args: Optional[Sequence[int]] = None,
+        exclude_keyword_args: Optional[Sequence[str]] = None,
         **options,
     ):
         """Execute the given user function with the provided arguments.
@@ -476,7 +487,9 @@ def exec(
         script_0, script_1 = self.policy.lua_scripts
         if not (isinstance(script_0, redis.commands.core.Script) and isinstance(script_1, redis.commands.core.Script)):
             raise RuntimeError("Can not eval redis lua script in asynchronous mode on a synchronous redis client")
-        keys, hash_value, ext_args = self._before_get(user_function, user_args, user_kwds)
+        keys, hash_value, ext_args = self._before_get(
+            user_function, user_args, user_kwds, exclude_positional_args, exclude_keyword_args
+        )
         cached_return_value = self.get(script_0, keys, hash_value, self.ttl, options, ext_args)
         if cached_return_value is not None:
             return self.deserialize(cached_return_value, deserialize_func)
@@ -492,6 +505,8 @@ async def aexec(
         user_kwds: Mapping[str, Any],
         serialize_func: Optional[SerializerT] = None,
         deserialize_func: Optional[DeserializerT] = None,
+        exclude_positional_args: Optional[Sequence[int]] = None,
+        exclude_keyword_args: Optional[Sequence[str]] = None,
         **options,
     ):
         """Asynchronous version of :meth:`.exec`"""
@@ -501,7 +516,9 @@ async def aexec(
             and isinstance(script_1, redis.commands.core.AsyncScript)
         ):
             raise RuntimeError("Can not eval redis lua script in synchronous mode on an asynchronous redis client")
-        keys, hash_value, ext_args = self._before_get(user_function, user_args, user_kwds)
+        keys, hash_value, ext_args = self._before_get(
+            user_function, user_args, user_kwds, exclude_positional_args, exclude_keyword_args
+        )
         cached = await self.aget(script_0, keys, hash_value, self.ttl, options, ext_args)
         if cached is not None:
             return self.deserialize(cached, deserialize_func)
@@ -515,8 +532,8 @@ def decorate(
         user_function: Optional[CallableTV] = None,
         /,
         serializer: Optional[SerializerSetterValueT] = None,
-        ignore_positional_args: Optional[Sequence[int]] = None,
-        ignore_keyword_args: Optional[Sequence[str]] = None,
+        exclude_positional_args: Optional[Sequence[int]] = None,
+        exclude_keyword_args: Optional[Sequence[str]] = None,
         **options,
     ) -> CallableTV:
         """Decorate the given function with caching.
@@ -530,14 +547,13 @@ def decorate(
                 - A string key mapping to predefined serializers (like "yaml" or "json")
                 - A tuple of (`serialize_func`, `deserialize_func`) functions
 
-                If defined, it overrides the :attr:`serializer` property of the cache instance.
-
+                If assigned, it overwrite the :attr:`serializer` property of the cache instance on the decorated function.
 
-            ignore_positional_args: A list of positional argument indices to exclude from cache key generation.
+            exclude_positional_args: A list of positional argument indices to exclude from cache key generation.
 
                 These arguments will be filtered out before cache operations.
 
-            ignore_keyword_args: A list of keyword argument names to exclude from cache key generation.
+            exclude_keyword_args: A list of keyword argument names to exclude from cache key generation.
 
                 These parameters will be filtered out before cache operations.
 
@@ -600,31 +616,30 @@ def my_func(a, b):
         elif serializer is not None:
             serialize_func, deserialize_func = serializer
 
-        if ignore_positional_args is None:
-            ignore_positional_args = []
-        if ignore_keyword_args is None:
-            ignore_keyword_args = []
-
         def decorator(user_func: CallableTV):
             @wraps(user_func)
             def wrapper(*user_args, **user_kwargs):
                 return self.exec(
                     user_func,
-                    [x for i, x in enumerate(user_args) if i not in ignore_positional_args],
-                    {k: v for k, v in user_kwargs.items() if k not in ignore_keyword_args},
+                    user_args,
+                    user_kwargs,
                     serialize_func,
                     deserialize_func,
+                    exclude_positional_args,
+                    exclude_keyword_args,
                     **options,
                 )
 
             @wraps(user_func)
             async def awrapper(*user_args, **user_kwargs):
                 return await self.aexec(
                     user_func,
-                    [x for i, x in enumerate(user_args) if i not in ignore_positional_args],
-                    {k: v for k, v in user_kwargs.items() if k not in ignore_keyword_args},
+                    user_args,
+                    user_kwargs,
                     serialize_func,
                     deserialize_func,
+                    exclude_positional_args,
+                    exclude_keyword_args,
                     **options,
                 )
 

tests/test_basic.py

@@ -356,3 +356,33 @@ def test_lambda(self):
             for _ in range(cache.maxsize * 2 + 1):
                 v = uuid4().hex
                 self.assertEqual(v, f(v))
+
+
+class ExcludeArgsTestCase(TestCase):
+    def setUp(self):
+        for cache in CACHES.values():
+            cache.policy.purge()
+
+    def test_exclude_positional_args(self):
+        def user_func(func, value):
+            return func(value)
+
+        unpickable_func = lambda x: x  # noqa: E731
+
+        for cache in CACHES.values():
+            f = cache(user_func, exclude_positional_args=[0])
+            for _ in range(cache.maxsize * 2 + 1):
+                v = uuid4().hex
+                self.assertEqual(f(unpickable_func, v), v)
+
+    def test_exclude_keyword_args(self):
+        def user_func(func, value):
+            return func(value)
+
+        unpickable_func = lambda x: x  # noqa: E731
+
+        for cache in CACHES.values():
+            f = cache(user_func, exclude_keyword_args=["func"])
+            for _ in range(cache.maxsize * 2 + 1):
+                v = uuid4().hex
+                self.assertEqual(f(func=unpickable_func, value=v), v)