aws-lambda-powertools 3.12.1a8__py3-none-any.whl → 3.12.1a9__py3-none-any.whl

aws_lambda_powertools/shared/version.py

@@ -1,3 +1,3 @@
 """Exposes version constant to avoid circular dependencies."""
 
-VERSION = "3.12.1a8"
+VERSION = "3.12.1a9"

aws_lambda_powertools/utilities/idempotency/persistence/cache.py

@@ -0,0 +1,11 @@
+from aws_lambda_powertools.utilities.idempotency.persistence.redis import (
+    CacheClientProtocol,
+    CacheConnection,
+    CachePersistenceLayer,
+)
+
+__all__ = [
+    "CacheClientProtocol",
+    "CachePersistenceLayer",
+    "CacheConnection",
+]

aws_lambda_powertools/utilities/idempotency/persistence/redis.py

@@ -8,6 +8,7 @@ from datetime import timedelta
 from typing import Any, Literal, Protocol
 
 import redis
+from typing_extensions import TypeAlias, deprecated
 
 from aws_lambda_powertools.utilities.idempotency import BasePersistenceLayer
 from aws_lambda_powertools.utilities.idempotency.exceptions import (
@@ -25,11 +26,12 @@ from aws_lambda_powertools.utilities.idempotency.persistence.base import (
 logger = logging.getLogger(__name__)
 
 
+@deprecated("RedisPersistenceLayer will be removed in v4.0.0. Please use CacheProtocol instead.")
 class RedisClientProtocol(Protocol):
     """
-    Protocol class defining the interface for a Redis client.
+    Protocol class defining the interface for a Cache client.
 
-    This protocol outlines the expected behavior of a Redis client, allowing for
+    This protocol outlines the expected behavior of a Cache client, allowing for
     standardization among different implementations and allowing customers to extend it
     in their own implementation.
 
@@ -78,6 +80,7 @@ class RedisClientProtocol(Protocol):
         raise NotImplementedError
 
 
+@deprecated("RedisConnection will be removed in v4.0.0. Please use CacheConnection instead.")
 class RedisConnection:
     def __init__(
         self,
@@ -85,32 +88,32 @@ class RedisConnection:
         host: str = "",
         port: int = 6379,
         username: str = "",
-        password: str = "",  # nosec - password for Redis connection
+        password: str = "",  # nosec - password for Cache connection
         db_index: int = 0,
         mode: Literal["standalone", "cluster"] = "standalone",
         ssl: bool = True,
     ) -> None:
         """
-        Initialize Redis connection which will be used in Redis persistence_store to support Idempotency
+        Initialize Cache connection which will be used in Cache persistence_store to support Idempotency
 
         Parameters
         ----------
         host: str, optional
-            Redis host
+            Cache host
         port: int, optional: default 6379
-            Redis port
+            Cache port
         username: str, optional
-            Redis username
+            Cache username
         password: str, optional
-            Redis password
+            Cache password
         url: str, optional
-            Redis connection string, using url will override the host/port in the previous parameters
+            Cache connection string, using url will override the host/port in the previous parameters
         db_index: int, optional: default 0
-            Redis db index
+            Cache db index
         mode: str, Literal["standalone","cluster"]
-            set Redis client mode, choose from standalone/cluster. The default is standalone
+            set Cache client mode, choose from standalone/cluster. The default is standalone
         ssl: bool, optional: default True
-            set whether to use ssl for Redis connection
+            set whether to use ssl for Cache connection
 
         Example
         --------
@@ -122,13 +125,13 @@ class RedisConnection:
         from aws_lambda_powertools.utilities.idempotency import (
             idempotent,
         )
-        from aws_lambda_powertools.utilities.idempotency.persistence.redis import (
-            RedisCachePersistenceLayer,
+        from aws_lambda_powertools.utilities.idempotency.persistence.cache import (
+            CachePersistenceLayer,
         )
 
         from aws_lambda_powertools.utilities.typing import LambdaContext
 
-        persistence_layer = RedisCachePersistenceLayer(host="localhost", port=6379)
+        persistence_layer = CachePersistenceLayer(host="localhost", port=6379)
 
 
         @dataclass
@@ -181,15 +184,15 @@ class RedisConnection:
 
         try:
             if self.url:
-                logger.debug(f"Using URL format to connect to Redis: {self.host}")
+                logger.debug(f"Using URL format to connect to Cache: {self.host}")
                 return client.from_url(url=self.url)
             else:
-                # Redis in cluster mode doesn't support db parameter
+                # Cache in cluster mode doesn't support db parameter
                 extra_param_connection: dict[str, Any] = {}
                 if self.mode != "cluster":
                     extra_param_connection = {"db": self.db_index}
 
-                logger.debug(f"Using arguments to connect to Redis: {self.host}")
+                logger.debug(f"Using arguments to connect to Cache: {self.host}")
                 return client(
                     host=self.host,
                     port=self.port,
@@ -200,10 +203,11 @@ class RedisConnection:
                     **extra_param_connection,
                 )
         except redis.exceptions.ConnectionError as exc:
-            logger.debug(f"Cannot connect in Redis: {self.host}")
-            raise IdempotencyPersistenceConnectionError("Could not to connect to Redis", exc) from exc
+            logger.debug(f"Cannot connect to Cache endpoint: {self.host}")
+            raise IdempotencyPersistenceConnectionError("Could not to connect to Cache endpoint", exc) from exc
 
 
+@deprecated("RedisCachePersistenceLayer will be removed in v4.0.0. Please use CachePersistenceLayer instead.")
 class RedisCachePersistenceLayer(BasePersistenceLayer):
     def __init__(
         self,
@@ -211,7 +215,7 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
         host: str = "",
         port: int = 6379,
         username: str = "",
-        password: str = "",  # nosec - password for Redis connection
+        password: str = "",  # nosec - password for Cache connection
         db_index: int = 0,
         mode: Literal["standalone", "cluster"] = "standalone",
         ssl: bool = True,
@@ -223,39 +227,39 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
         validation_key_attr: str = "validation",
     ):
         """
-        Initialize the Redis Persistence Layer
+        Initialize the Cache Persistence Layer
 
         Parameters
         ----------
         host: str, optional
-            Redis host
+            Cache host
         port: int, optional: default 6379
-            Redis port
+            Cache port
         username: str, optional
-            Redis username
+            Cache username
         password: str, optional
-            Redis password
+            Cache password
         url: str, optional
-            Redis connection string, using url will override the host/port in the previous parameters
+            Cache connection string, using url will override the host/port in the previous parameters
         db_index: int, optional: default 0
-            Redis db index
+            Cache db index
         mode: str, Literal["standalone","cluster"]
-            set Redis client mode, choose from standalone/cluster
+            set Cache client mode, choose from standalone/cluster
         ssl: bool, optional: default True
-            set whether to use ssl for Redis connection
-        client: RedisClientProtocol, optional
-            Bring your own Redis client that follows RedisClientProtocol.
+            set whether to use ssl for Cache connection
+        client: CacheClientProtocol, optional
+            Bring your own Cache client that follows CacheClientProtocol.
             If provided, all other connection configuration options will be ignored
         expiry_attr: str, optional
-            Redis json attribute name for expiry timestamp, by default "expiration"
+            Cache json attribute name for expiry timestamp, by default "expiration"
         in_progress_expiry_attr: str, optional
-            Redis json attribute name for in-progress expiry timestamp, by default "in_progress_expiration"
+            Cache json attribute name for in-progress expiry timestamp, by default "in_progress_expiration"
         status_attr: str, optional
-            Redis json attribute name for status, by default "status"
+            Cache json attribute name for status, by default "status"
         data_attr: str, optional
-            Redis json attribute name for response data, by default "data"
+            Cache json attribute name for response data, by default "data"
         validation_key_attr: str, optional
-            Redis json attribute name for hashed representation of the parts of the event used for validation
+            Cache json attribute name for hashed representation of the parts of the event used for validation
 
         Examples
         --------
@@ -266,8 +270,8 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
             idempotent,
         )
 
-        from aws_lambda_powertools.utilities.idempotency.persistence.redis import (
-            RedisCachePersistenceLayer,
+        from aws_lambda_powertools.utilities.idempotency.persistence.cache import (
+            CachePersistenceLayer,
         )
 
         client = redis.Redis(
@@ -275,7 +279,7 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
             port="6379",
             decode_responses=True,
         )
-        persistence_layer = RedisCachePersistenceLayer(client=client)
+        persistence_layer = CachePersistenceLayer(client=client)
 
         @idempotent(persistence_store=persistence_layer)
         def lambda_handler(event: dict, context: LambdaContext):
@@ -288,7 +292,7 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
         ```
         """
 
-        # Initialize Redis client with Redis config if no client is passed in
+        # Initialize Cache client with cache config if no client is passed in
         if client is None:
             self.client = RedisConnection(
                 host=host,
@@ -330,11 +334,11 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
             in_progress_expiry_timestamp=in_progress_expiry_timestamp,
             response_data=str(item.get(self.data_attr)),
             payload_hash=str(item.get(self.validation_key_attr)),
-            expiry_timestamp=item.get("expiration", None),
+            expiry_timestamp=item.get("expiration"),
         )
 
     def _get_record(self, idempotency_key) -> DataRecord:
-        # See: https://redis.io/commands/get/
+        # See: https://valkey.io/valkey-glide/python/core/#glide.async_commands.CoreCommands.set
         response = self.client.get(idempotency_key)
 
         # key not found
@@ -384,25 +388,25 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
             # The idempotency key does not exist:
             #    - first time that this invocation key is used
             #    - previous invocation with the same key was deleted due to TTL
-            #    - SET see https://redis.io/commands/set/
+            #    - SET see https://valkey.io/valkey-glide/python/core/#glide.async_commands.CoreCommands.set
 
-            logger.debug(f"Putting record on Redis for idempotency key: {data_record.idempotency_key}")
+            logger.debug(f"Putting record on Cache for idempotency key: {data_record.idempotency_key}")
             encoded_item = self._json_serializer(item["mapping"])
             ttl = self._get_expiry_second(expiry_timestamp=data_record.expiry_timestamp)
 
-            redis_response = self.client.set(name=data_record.idempotency_key, value=encoded_item, ex=ttl, nx=True)
+            cache_response = self.client.set(name=data_record.idempotency_key, value=encoded_item, ex=ttl, nx=True)
 
-            # If redis_response is True, the Redis SET operation was successful and the idempotency key was not
+            # If cache_response is True, the Cache SET operation was successful and the idempotency key was not
             # previously set. This indicates that we can safely proceed to the handler execution phase.
             # Most invocations should successfully proceed past this point.
-            if redis_response:
+            if cache_response:
                 return
 
-            # If redis_response is None, it indicates an existing record in Redis for the given idempotency key.
+            # If cache_response is None, it indicates an existing record in Cache for the given idempotency key.
             # This could be due to:
             # - An active idempotency record from a previous invocation that has not yet expired.
             # - An orphan record where a previous invocation has timed out.
-            # - An expired idempotency record that has not been deleted by Redis.
+            # - An expired idempotency record that has not been deleted by Cache.
             # In any case, we proceed to retrieve the record for further inspection.
 
             idempotency_record = self._get_record(data_record.idempotency_key)
@@ -427,7 +431,7 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
 
             # Reaching this point indicates that the idempotency record found is an orphan record. An orphan record is
             # one that is neither completed nor in-progress within its expected time frame. It may result from a
-            # previous invocation that has timed out or an expired record that has yet to be cleaned up by Redis.
+            # previous invocation that has timed out or an expired record that has yet to be cleaned up by Cache.
             # We raise an error to handle this exceptional scenario appropriately.
             raise IdempotencyPersistenceConsistencyError
 
@@ -435,24 +439,22 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
             # Handle an orphan record by attempting to acquire a lock, which by default lasts for 10 seconds.
             # The purpose of acquiring the lock is to prevent race conditions with other processes that might
             # also be trying to handle the same orphan record. Once the lock is acquired, we set a new value
-            # for the idempotency record in Redis with the appropriate time-to-live (TTL).
+            # for the idempotency record in Cache with the appropriate time-to-live (TTL).
             with self._acquire_lock(name=item["name"]):
                 self.client.set(name=item["name"], value=encoded_item, ex=ttl)
 
             # Not removing the lock here serves as a safeguard against race conditions,
             # preventing another operation from mistakenly treating this record as an orphan while the
             # current operation is still in progress.
-        except (redis.exceptions.RedisError, redis.exceptions.RedisClusterException) as e:
-            raise e
         except Exception as e:
-            logger.debug(f"encountered non-Redis exception: {e}")
-            raise e
+            logger.debug(f"An error occurred: {e}")
+            raise
 
     @contextmanager
     def _acquire_lock(self, name: str):
         """
         Attempt to acquire a lock for a specified resource name, with a default timeout.
-        This context manager attempts to set a lock using Redis to prevent concurrent
+        This context manager attempts to set a lock using Cache to prevent concurrent
         access to a resource identified by 'name'. It uses the 'nx' flag to ensure that
         the lock is only set if it does not already exist, thereby enforcing mutual exclusion.
         """
@@ -496,9 +498,9 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
 
     def _delete_record(self, data_record: DataRecord) -> None:
         """
-        Deletes the idempotency record associated with a given DataRecord from Redis.
+        Deletes the idempotency record associated with a given DataRecord from Cache.
         This function is designed to be called after a Lambda handler invocation has completed processing.
-        It ensures that the idempotency key associated with the DataRecord is removed from Redis to
+        It ensures that the idempotency key associated with the DataRecord is removed from Cache to
         prevent future conflicts and to maintain the idempotency integrity.
 
         Note: it is essential that the idempotency key is not empty, as that would indicate the Lambda
@@ -506,5 +508,10 @@ class RedisCachePersistenceLayer(BasePersistenceLayer):
         """
         logger.debug(f"Deleting record for idempotency key: {data_record.idempotency_key}")
 
-        # See: https://redis.io/commands/del/
+        # See: https://valkey.io/valkey-glide/python/core/#glide.async_commands.CoreCommands.delete
         self.client.delete(data_record.idempotency_key)
+
+
+CachePersistenceLayer: TypeAlias = RedisCachePersistenceLayer
+CacheClientProtocol: TypeAlias = RedisClientProtocol
+CacheConnection: TypeAlias = RedisConnection

{aws_lambda_powertools-3.12.1a8.dist-info → aws_lambda_powertools-3.12.1a9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aws_lambda_powertools
-Version: 3.12.1a8
+Version: 3.12.1a9
 Summary: Powertools for AWS Lambda (Python) is a developer toolkit to implement Serverless best practices and increase developer velocity.
 License: MIT
 Keywords: aws_lambda_powertools,aws,tracing,logging,lambda,powertools,feature_flags,idempotency,middleware
@@ -25,6 +25,7 @@ Provides-Extra: parser
 Provides-Extra: redis
 Provides-Extra: tracer
 Provides-Extra: validation
+Provides-Extra: valkey
 Requires-Dist: aws-encryption-sdk (>=3.1.1,<5.0.0) ; extra == "all" or extra == "datamasking"
 Requires-Dist: aws-xray-sdk (>=2.8.0,<3.0.0) ; extra == "tracer" or extra == "all"
 Requires-Dist: boto3 (>=1.34.32,<2.0.0) ; extra == "aws-sdk"
@@ -36,6 +37,7 @@ Requires-Dist: pydantic (>=2.4.0,<3.0.0) ; extra == "parser" or extra == "all"
 Requires-Dist: pydantic-settings (>=2.6.1,<3.0.0) ; extra == "all"
 Requires-Dist: redis (>=4.4,<7.0) ; extra == "redis"
 Requires-Dist: typing-extensions (>=4.11.0,<5.0.0)
+Requires-Dist: valkey-glide (>=1.3.5,<2.0) ; extra == "valkey"
 Project-URL: Documentation, https://docs.powertools.aws.dev/lambda/python/
 Project-URL: Issue tracker, https://github.com/aws-powertools/powertools-lambda-python/issues
 Project-URL: Repository, https://github.com/aws-powertools/powertools-lambda-python

{aws_lambda_powertools-3.12.1a8.dist-info → aws_lambda_powertools-3.12.1a9.dist-info}/RECORD

@@ -97,7 +97,7 @@ aws_lambda_powertools/shared/json_encoder.py,sha256=JQeWNu-4M7_xI_hqYExrxsb3OcEH
 aws_lambda_powertools/shared/lazy_import.py,sha256=TbXQm2bcwXdZrYdBaJJXIswyLlumM85RJ_A_0w-h-GU,2019
 aws_lambda_powertools/shared/types.py,sha256=EZ_tbX3F98LA4Zcra1hTEjzRacpZAtggK957Zcv1oKg,135
 aws_lambda_powertools/shared/user_agent.py,sha256=DrCMFQuT4a4iIrpcWpAIjY37EFqR9-QxlxDGD-Nn9Gg,7081
-aws_lambda_powertools/shared/version.py,sha256=bu4rkF3HQmnJsPfy-G3Y4DAkyVwhXd9KxIWdlMLqQo0,85
+aws_lambda_powertools/shared/version.py,sha256=-vsxq2DhrkC6gFTyPBzHdPbaHnfg2-EwEu03tvXjNbQ,85
 aws_lambda_powertools/tracing/__init__.py,sha256=f4bMThOPBPWTPVcYqcAIErAJPerMsf3H_Z4gCXCsK9I,141
 aws_lambda_powertools/tracing/base.py,sha256=WSO986XGBOe9K0F2SnG6ustJokIrtO0m0mcL8N7mfno,4544
 aws_lambda_powertools/tracing/extensions.py,sha256=APOfXOq-hRBKaK5WyfIyrd_6M1_9SWJZ3zxLA9jDZzU,492
@@ -175,9 +175,10 @@ aws_lambda_powertools/utilities/idempotency/hook.py,sha256=XHj6q0dP65C8Cj-TPJ9a8
 aws_lambda_powertools/utilities/idempotency/idempotency.py,sha256=_t_OmCzL8vBcmrif_9PrAnoCkfBMnG3p2T3sVGHhUqw,7429
 aws_lambda_powertools/utilities/idempotency/persistence/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aws_lambda_powertools/utilities/idempotency/persistence/base.py,sha256=slYzih7C-tpAUugXdM2DMemNVA_HnxsbtpsvZKiH3gY,16022
+aws_lambda_powertools/utilities/idempotency/persistence/cache.py,sha256=GgGmp-5HtbZoVKUxp70-8rw-lq1d3Fwq9HmGXiINQDk,245
 aws_lambda_powertools/utilities/idempotency/persistence/datarecord.py,sha256=brtO34whh_ioHkB6GfIjcIUyvzBI7BrEiwQVwFjEVXc,3644
 aws_lambda_powertools/utilities/idempotency/persistence/dynamodb.py,sha256=H0dm8U1dwNPzAHtmARBoPIq-ajI1ih62bgQFX1RyVxo,13908
-aws_lambda_powertools/utilities/idempotency/persistence/redis.py,sha256=KN3XfUZzGwEqkkXZB7OGadYGdf7IiwwChtVzZRuZUQE,21588
+aws_lambda_powertools/utilities/idempotency/persistence/redis.py,sha256=dJZ2afGILfhy-ov2Nwim51s4q7zKyz2C6ZjuaLBwUT4,22126
 aws_lambda_powertools/utilities/idempotency/serialization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aws_lambda_powertools/utilities/idempotency/serialization/base.py,sha256=E6ZO7uGOJnhepSkS4NkUbPhw9BNU1581HRmdgEaXe8k,1445
 aws_lambda_powertools/utilities/idempotency/serialization/custom_dict.py,sha256=QhPDPoa-MHAqo8APjSaQEENPeRiOnTovHWhQgCBkfIg,1018
@@ -268,7 +269,7 @@ aws_lambda_powertools/utilities/validation/envelopes.py,sha256=YD5HOFx6IClQgii0n
 aws_lambda_powertools/utilities/validation/exceptions.py,sha256=PKy_19zQMBJGCMMFl-sMkcm-cc0v3zZBn_bhGE4wKNo,2084
 aws_lambda_powertools/utilities/validation/validator.py,sha256=khCqFhACSdn0nKyYRRPiC5Exht956hTfSfhlV3IRmpg,10099
 aws_lambda_powertools/warnings/__init__.py,sha256=vqDVeZz8wGtD8WGYNSkQE7AHwqtIrPGRxuoJR_BBnSs,1193
-aws_lambda_powertools-3.12.1a8.dist-info/LICENSE,sha256=vMHS2eBgmwPUIMPb7LQ4p7ib_FPVQXarVjAasflrTwo,951
-aws_lambda_powertools-3.12.1a8.dist-info/METADATA,sha256=kbbxlZPoQd66od3VYsZquoN7rpWOUnWH5X-MaKtdK_A,11187
-aws_lambda_powertools-3.12.1a8.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-aws_lambda_powertools-3.12.1a8.dist-info/RECORD,,
+aws_lambda_powertools-3.12.1a9.dist-info/LICENSE,sha256=vMHS2eBgmwPUIMPb7LQ4p7ib_FPVQXarVjAasflrTwo,951
+aws_lambda_powertools-3.12.1a9.dist-info/METADATA,sha256=Hoz_WlCMO7qqUjQ9nK3nDvfM0gE41MiEQmUaEpBWL1I,11273
+aws_lambda_powertools-3.12.1a9.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+aws_lambda_powertools-3.12.1a9.dist-info/RECORD,,