first working basic expires decorator

Signed-off-by: Grant Ramsay <seapagan@gmail.com>

Author: seapagan

fastapi_redis_cache/__init__.py

@@ -8,6 +8,7 @@
     cache_one_month,
     cache_one_week,
     cache_one_year,
+    expires,
 )
 from fastapi_redis_cache.client import FastApiRedisCache
 
@@ -19,5 +20,6 @@
     "cache_one_month",
     "cache_one_week",
     "cache_one_year",
+    "expires",
     "FastApiRedisCache",
 ]

fastapi_redis_cache/cache.py

@@ -127,13 +127,19 @@ async def inner_wrapper(
     return outer_wrapper
 
 
-def expires(tag: str | None = None) -> Callable[..., Any]:
+def expires(
+    tag: str | None = None,
+    arg: str | None = None,  # noqa: ARG001
+) -> Callable[..., Any]:
     """Invalidate all cached responses with the same tag.
 
     Args:
-        tag (str, optional): A tag to associate with the cached response. This
-            can later be used to invalidate all cached responses with the same
-            tag, or for further fine-grained cache expiry. Defaults to None.
+        tag (str, optional): The tag to search for keys to expire.
+            Defaults to None.
+        arg: (str, optional): The function arguement to filter for expiry. This
+            would generally be the varying arguement suppplied to the route.
+            Defaults to None. If not specified, the kwargs for the route will
+            be used to search for the key to expire.
     """
 
     def outer_wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
@@ -144,14 +150,26 @@ async def inner_wrapper(
         ) -> Any:  # noqa: ANN401
             """Invalidate all cached responses with the same tag."""
             redis_cache = FastApiRedisCache()
-            if redis_cache.not_connected:
-                return await get_api_response_async(func, *args, **kwargs)
-            if tag:
-                # expire all keys with the same tag. This is a test we will
-                # later only expire keys that have the search argument in the
-                # key.
+            orig_response = await get_api_response_async(func, *args, **kwargs)
+
+            if not redis_cache.redis or not redis_cache.connected or not tag:
+                # we only want to invalidate the cache if the redis client is
+                # connected and a tag is provided.
+                return orig_response
+            if kwargs:
+                search = "".join(
+                    [f"({key}={value})" for key, value in kwargs.items()]
+                )
+                tag_keys = redis_cache.get_tagged_keys(tag)
+                found_keys = [key for key in tag_keys if search.encode() in key]
+                for key in found_keys:
+                    redis_cache.redis.delete(key)
+                    redis_cache.redis.srem(tag, key)
+            else:
+                # will fill this later, what to do if no kwargs are provided
                 pass
-            return await get_api_response_async(func, *args, **kwargs)
+
+            return orig_response
 
         return inner_wrapper
 

fastapi_redis_cache/client.py

@@ -20,6 +20,8 @@
 from fastapi_redis_cache.util import serialize_json
 
 if TYPE_CHECKING:  # pragma: no cover
+    from collections.abc import ByteString
+
     from fastapi import Request, Response
     from redis import client
 
@@ -158,7 +160,7 @@ def add_key_to_tag_set(self, tag: str, key: str) -> None:
         if self.redis:
             self.redis.sadd(tag, key)
 
-    def get_tagged_keys(self, tag: str) -> set[str]:
+    def get_tagged_keys(self, tag: str) -> set[ByteString]:
         """Return a set of keys associated with a tag."""
         return self.redis.smembers(tag) if self.redis else set()
 

tests/live_test.py

@@ -19,6 +19,7 @@
     cache,
     cache_one_hour,
     cache_one_minute,
+    expires,
 )
 
 REDIS_SERVER_URL = "redis://127.0.0.1:"
@@ -104,3 +105,13 @@ def cache_with_args(user: int) -> dict[str, Union[bool, str]]:
         "success": True,
         "message": f"this data is for user {user}",
     }
+
+
+@app.put("/cache_with_args/{user}")
+@expires(tag="user_tag")
+def put_cache_with_args(user: int) -> dict[str, Union[bool, str]]:
+    """Put request to change data for a specific user."""
+    return {
+        "success": True,
+        "message": f"New data for User {user}",
+    }