fastapi-cachekit 0.1.4__tar.gz → 0.2.0__tar.gz

{fastapi_cachekit-0.1.4/fastapi_cachekit.egg-info → fastapi_cachekit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-cachekit
-Version: 0.1.4
+Version: 0.2.0
 Summary: High-performance caching solution for FastAPI applications
 Author-email: Bijay Nayak <bijay6779@gmail.com>
 License-Expression: MIT
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
@@ -28,6 +29,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: fastapi>=0.75.0
+Requires-Dist: apscheduler>=3.4.0
 Provides-Extra: redis
 Requires-Dist: redis>=4.2.0; extra == "redis"
 Provides-Extra: postgres
@@ -36,7 +38,7 @@ Provides-Extra: memcached
 Requires-Dist: aiomcache>=0.8.1; extra == "memcached"
 Requires-Dist: pymemcache>=4.0.0; extra == "memcached"
 Provides-Extra: mongodb
-Requires-Dist: pymongo[gssapi,snappy,srv]>=4.6.0; extra == "mongodb"
+Requires-Dist: pymongo[gssapi,snappy]>=4.6.0; extra == "mongodb"
 Provides-Extra: firestore
 Requires-Dist: google-cloud-firestore>=2.3.0; extra == "firestore"
 Provides-Extra: dynamodb
@@ -45,6 +47,7 @@ Requires-Dist: aioboto3>=6.0.0; extra == "dynamodb"
 Provides-Extra: all
 Requires-Dist: redis>=4.2.0; extra == "all"
 Requires-Dist: psycopg[pool]>=3.2.9; extra == "all"
+Requires-Dist: apscheduler>=3.4.0; extra == "all"
 Requires-Dist: aiomcache>=0.8.1; extra == "all"
 Requires-Dist: pymemcache>=4.0.0; extra == "all"
 Requires-Dist: pymongo[gssapi,snappy,srv]>=4.6.0; extra == "all"

{fastapi_cachekit-0.1.4 → fastapi_cachekit-0.2.0}/fast_cache/__init__.py

@@ -1,6 +1,10 @@
+from importlib.metadata import version
+
 from .integration import FastAPICache
 from .backends.backend import CacheBackend
 
+__version__ = version("fastapi-cachekit")
+
 from .backends.redis import RedisBackend
 from .backends.memory import InMemoryBackend
 from .backends.postgres import PostgresBackend
@@ -19,7 +23,7 @@ __all__ = [
     "MemcachedBackend",
     "MongoDBBackend",
     "FirestoreBackend",
-    "DynamoDBBackend"
+    "DynamoDBBackend",
 ]
 
 

{fastapi_cachekit-0.1.4 → fastapi_cachekit-0.2.0}/fast_cache/backends/backend.py

@@ -12,28 +12,30 @@ class CacheBackend(ABC):
     """
 
     @abstractmethod
-    async def aget(self, key: str) -> Optional[Any]:
+    async def aget(self, key: str, default: Any = None) -> Any:
         """
         Asynchronously retrieve a value from the cache.
 
         Args:
             key (str): The key to retrieve.
+            default (Any): Value to return if key is not found. Defaults to None.
 
         Returns:
-            Optional[Any]: The cached value, or None if not found.
+            Any: The cached value, or default if not found.
         """
         pass
 
     @abstractmethod
-    def get(self, key: str) -> Optional[Any]:
+    def get(self, key: str, default: Any = None) -> Any:
         """
         Synchronously retrieve a value from the cache.
 
         Args:
             key (str): The key to retrieve.
+            default (Any): Value to return if key is not found. Defaults to None.
 
         Returns:
-            Optional[Any]: The cached value, or None if not found.
+            Any: The cached value, or default if not found.
         """
         pass
 

{fastapi_cachekit-0.1.4 → fastapi_cachekit-0.2.0}/fast_cache/backends/dynamodb.py

@@ -1,4 +1,6 @@
+import asyncio
 import hashlib
+import logging
 from typing import Any, Optional, Union
 from datetime import timedelta
 import pickle
@@ -6,6 +8,8 @@ import time
 
 from .backend import CacheBackend
 
+logger = logging.getLogger(__name__)
+
 
 class DynamoDBBackend(CacheBackend):
     """
@@ -79,24 +83,32 @@ class DynamoDBBackend(CacheBackend):
         self._async_resource = None
         self._async_table = None
         self._async_session = aioboto3.Session()
+        self._async_table_lock = asyncio.Lock()
 
         # Create table if requested
         if create_table:
             self._ensure_table_exists()
 
     async def _get_async_table(self):
-        if self._async_table is None:
-            # Create the resource context
+        if self._async_table is not None:
+            return self._async_table
+        async with self._async_table_lock:
+            if self._async_table is not None:
+                return self._async_table
+            # Create the resource context manager
             self._async_resource = self._async_session.resource(
                 "dynamodb", **self._connection_params
             )
 
-            # Enter the context and get the actual resource
-            actual_resource = await self._async_resource.__aenter__()
-
-            # Create the table from the actual resource
-            self._async_table = await actual_resource.Table(self._table_name)
-
+            # Enter the context and get the actual resource,
+            # ensuring cleanup on failure to prevent leaks
+            try:
+                actual_resource = await self._async_resource.__aenter__()
+                self._async_table = await actual_resource.Table(self._table_name)
+            except BaseException:
+                await self._async_resource.__aexit__(None, None, None)
+                self._async_resource = None
+                raise
 
         return self._async_table
 
@@ -234,60 +246,64 @@ class DynamoDBBackend(CacheBackend):
 
         return item
 
-    def get(self, key: str) -> Optional[Any]:
+    def get(self, key: str, default: Any = None) -> Any:
         """
         Synchronously retrieve a value from the cache.
 
         Args:
             key (str): The key to retrieve.
+            default (Any): Value to return if key is not found. Defaults to None.
 
         Returns:
-            Optional[Any]: The cached value, or None if not found.
+            Any: The cached value, or default if not found.
         """
         try:
             response = self._sync_table.get_item(Key={"cache_key": self._make_key(key)})
 
             if "Item" not in response:
-                return None
+                return default
 
             item = response["Item"]
 
             # Check if item has expired and delete if so
             if self._is_expired(item):
                 self.delete(key)
-                return None
+                return default
             value = self._deserialize_value(item["value"])
             return value
-        except Exception:
-            return None
+        except Exception as e:
+            logger.warning("Cache get failed: %s", e)
+            return default
 
-    async def aget(self, key: str) -> Optional[Any]:
+    async def aget(self, key: str, default: Any = None) -> Any:
         """
         Asynchronously retrieve a value from the cache.
 
         Args:
             key (str): The key to retrieve.
+            default (Any): Value to return if key is not found. Defaults to None.
 
         Returns:
-            Optional[Any]: The cached value, or None if not found.
+            Any: The cached value, or default if not found.
         """
         try:
             table = await self._get_async_table()
             response = await table.get_item(Key={"cache_key": self._make_key(key)})
 
             if "Item" not in response:
-                return None
+                return default
 
             item = response["Item"]
 
             # Check if item has expired and delete if so
             if self._is_expired(item):
                 await self.adelete(key)
-                return None
+                return default
 
             return self._deserialize_value(item["value"])
-        except Exception:
-            return None
+        except Exception as e:
+            logger.warning("Cache aget failed: %s", e)
+            return default
 
     def set(
         self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
@@ -303,8 +319,8 @@ class DynamoDBBackend(CacheBackend):
         try:
             item = self._build_item(key, value, expire)
             self._sync_table.put_item(Item=item)
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning("Cache set failed: %s", e)
 
     async def aset(
         self, key: str, value: Any, expire: Optional[Union[int, timedelta]] = None
@@ -321,8 +337,8 @@ class DynamoDBBackend(CacheBackend):
             table = await self._get_async_table()
             item = self._build_item(key, value, expire)
             await table.put_item(Item=item)
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning("Cache aset failed: %s", e)
 
     def delete(self, key: str) -> None:
         """
@@ -333,8 +349,8 @@ class DynamoDBBackend(CacheBackend):
         """
         try:
             self._sync_table.delete_item(Key={"cache_key": self._make_key(key)})
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning("Cache delete failed: %s", e)
 
     async def adelete(self, key: str) -> None:
         """
@@ -346,8 +362,8 @@ class DynamoDBBackend(CacheBackend):
         try:
             table = await self._get_async_table()
             await table.delete_item(Key={"cache_key": self._make_key(key)})
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning("Cache adelete failed: %s", e)
 
     def has(self, key: str) -> bool:
         """
@@ -366,7 +382,6 @@ class DynamoDBBackend(CacheBackend):
                 ExpressionAttributeNames={"#ttl": "ttl"},
             )
 
-
             if "Item" not in response:
                 return False
 
@@ -378,7 +393,8 @@ class DynamoDBBackend(CacheBackend):
                 return False
 
             return True
-        except Exception:
+        except Exception as e:
+            logger.warning("Cache has failed: %s", e)
             return False
 
     async def ahas(self, key: str) -> bool:
@@ -410,7 +426,8 @@ class DynamoDBBackend(CacheBackend):
                 return False
 
             return True
-        except Exception:
+        except Exception as e:
+            logger.warning("Cache ahas failed: %s", e)
             return False
 
     def clear(self) -> None:
@@ -445,8 +462,8 @@ class DynamoDBBackend(CacheBackend):
                         for item in response["Items"]:
                             batch.delete_item(Key={"cache_key": item["cache_key"]})
 
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning("Cache clear failed: %s", e)
 
     async def aclear(self) -> None:
         """
@@ -480,10 +497,12 @@ class DynamoDBBackend(CacheBackend):
                 if response.get("Items"):
                     async with table.batch_writer() as batch:
                         for item in response["Items"]:
-                            await batch.delete_item(Key={"cache_key": item["cache_key"]})
+                            await batch.delete_item(
+                                Key={"cache_key": item["cache_key"]}
+                            )
 
-        except Exception:
-            pass
+        except Exception as e:
+            logger.warning("Cache aclear failed: %s", e)
 
     async def close(self) -> None:
         """