Add files using upload-large-folder tool

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/getting_started_with_idempotency_redis_client.py

@@ -0,0 +1,51 @@
+import os
+from dataclasses import dataclass, field
+from uuid import uuid4
+
+from redis import Redis
+
+from aws_lambda_powertools.utilities.idempotency import (
+    idempotent,
+)
+from aws_lambda_powertools.utilities.idempotency.persistence.redis import (
+    RedisCachePersistenceLayer,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+redis_endpoint = os.getenv("REDIS_CLUSTER_ENDPOINT", "localhost")
+client = Redis(
+    host=redis_endpoint,
+    port=6379,
+    socket_connect_timeout=5,
+    socket_timeout=5,
+    max_connections=1000,
+)
+
+persistence_layer = RedisCachePersistenceLayer(client=client)
+
+
+@dataclass
+class Payment:
+    user_id: str
+    product_id: str
+    payment_id: str = field(default_factory=lambda: f"{uuid4()}")
+
+
+class PaymentError(Exception): ...
+
+
+@idempotent(persistence_store=persistence_layer)
+def lambda_handler(event: dict, context: LambdaContext):
+    try:
+        payment: Payment = create_subscription_payment(event)
+        return {
+            "payment_id": payment.payment_id,
+            "message": "success",
+            "statusCode": 200,
+        }
+    except Exception as exc:
+        raise PaymentError(f"Error creating payment {str(exc)}")
+
+
+def create_subscription_payment(event: dict) -> Payment:
+    return Payment(**event)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/getting_started_with_idempotency_redis_config.py

@@ -0,0 +1,41 @@
+import os
+from dataclasses import dataclass, field
+from uuid import uuid4
+
+from aws_lambda_powertools.utilities.idempotency import (
+    idempotent,
+)
+from aws_lambda_powertools.utilities.idempotency.persistence.redis import (
+    RedisCachePersistenceLayer,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+redis_endpoint = os.getenv("REDIS_CLUSTER_ENDPOINT", "localhost")
+persistence_layer = RedisCachePersistenceLayer(host=redis_endpoint, port=6379)
+
+
+@dataclass
+class Payment:
+    user_id: str
+    product_id: str
+    payment_id: str = field(default_factory=lambda: f"{uuid4()}")
+
+
+class PaymentError(Exception): ...
+
+
+@idempotent(persistence_store=persistence_layer)
+def lambda_handler(event: dict, context: LambdaContext):
+    try:
+        payment: Payment = create_subscription_payment(event)
+        return {
+            "payment_id": payment.payment_id,
+            "message": "success",
+            "statusCode": 200,
+        }
+    except Exception as exc:
+        raise PaymentError(f"Error creating payment {str(exc)}")
+
+
+def create_subscription_payment(event: dict) -> Payment:
+    return Payment(**event)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/integrate_idempotency_with_validator.py

@@ -0,0 +1,19 @@
+import os
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+from aws_lambda_powertools.utilities.validation import envelopes, validator
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+config = IdempotencyConfig(event_key_jmespath='["message", "username"]')
+persistence_layer = DynamoDBPersistenceLayer(table_name=table)
+
+
+@validator(envelope=envelopes.API_GATEWAY_HTTP)
+@idempotent(config=config, persistence_store=persistence_layer)
+def lambda_handler(event, context: LambdaContext):
+    return {"message": event["message"], "statusCode": 200}

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/using_redis_client_with_aws_secrets.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Any
+
+from redis import Redis
+
+from aws_lambda_powertools.utilities import parameters
+from aws_lambda_powertools.utilities.idempotency import IdempotencyConfig, idempotent
+from aws_lambda_powertools.utilities.idempotency.persistence.redis import (
+    RedisCachePersistenceLayer,
+)
+
+redis_values: dict[str, Any] = parameters.get_secret("redis_info", transform="json")  # (1)!
+
+redis_client = Redis(
+    host=redis_values.get("REDIS_HOST", "localhost"),
+    port=redis_values.get("REDIS_PORT", 6379),
+    password=redis_values.get("REDIS_PASSWORD"),
+    decode_responses=True,
+    socket_timeout=10.0,
+    ssl=True,
+    retry_on_timeout=True,
+)
+
+persistence_layer = RedisCachePersistenceLayer(client=redis_client)
+config = IdempotencyConfig(
+    expires_after_seconds=2 * 60,  # 2 minutes
+)
+
+
+@idempotent(config=config, persistence_store=persistence_layer)
+def lambda_handler(event, context):
+    return {"message": "Hello"}

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/using_redis_client_with_local_certs.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any
+
+from redis import Redis
+
+from aws_lambda_powertools.shared.functions import abs_lambda_path
+from aws_lambda_powertools.utilities import parameters
+from aws_lambda_powertools.utilities.idempotency import IdempotencyConfig, idempotent
+from aws_lambda_powertools.utilities.idempotency.persistence.redis import (
+    RedisCachePersistenceLayer,
+)
+
+redis_values: dict[str, Any] = parameters.get_secret("redis_info", transform="json")  # (1)!
+
+
+redis_client = Redis(
+    host=redis_values.get("REDIS_HOST", "localhost"),
+    port=redis_values.get("REDIS_PORT", 6379),
+    password=redis_values.get("REDIS_PASSWORD"),
+    decode_responses=True,
+    socket_timeout=10.0,
+    ssl=True,
+    retry_on_timeout=True,
+    ssl_certfile=f"{abs_lambda_path()}/certs/redis_user.crt",  # (2)!
+    ssl_keyfile=f"{abs_lambda_path()}/certs/redis_user_private.key",  # (3)!
+    ssl_ca_certs=f"{abs_lambda_path()}/certs/redis_ca.pem",  # (4)!
+)
+
+persistence_layer = RedisCachePersistenceLayer(client=redis_client)
+config = IdempotencyConfig(
+    expires_after_seconds=2 * 60,  # 2 minutes
+)
+
+
+@idempotent(config=config, persistence_store=persistence_layer)
+def lambda_handler(event, context):
+    return {"message": "Hello"}

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_dataclass_deduced_output_serializer.py

@@ -0,0 +1,51 @@
+import os
+from dataclasses import dataclass
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent_function,
+)
+from aws_lambda_powertools.utilities.idempotency.serialization.dataclass import DataclassSerializer
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+dynamodb = DynamoDBPersistenceLayer(table_name=table)
+config = IdempotencyConfig(event_key_jmespath="order_id")  # see Choosing a payload subset section
+
+
+@dataclass
+class OrderItem:
+    sku: str
+    description: str
+
+
+@dataclass
+class Order:
+    item: OrderItem
+    order_id: int
+
+
+@dataclass
+class OrderOutput:
+    order_id: int
+
+
+@idempotent_function(
+    data_keyword_argument="order",
+    config=config,
+    persistence_store=dynamodb,
+    output_serializer=DataclassSerializer,
+)
+# order output is inferred from return type
+def process_order(order: Order) -> OrderOutput:  # (1)!
+    return OrderOutput(order_id=order.order_id)
+
+
+def lambda_handler(event: dict, context: LambdaContext):
+    config.register_lambda_context(context)  # see Lambda timeouts section
+    order_item = OrderItem(sku="fake", description="sample")
+    order = Order(item=order_item, order_id=1)
+
+    # `order` parameter must be called as a keyword argument to work
+    process_order(order=order)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_idempotent_function_dataclass.py

@@ -0,0 +1,41 @@
+import os
+from dataclasses import dataclass
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent_function,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+dynamodb = DynamoDBPersistenceLayer(table_name=table)
+config = IdempotencyConfig(event_key_jmespath="order_id")  # see Choosing a payload subset section
+
+
+@dataclass
+class OrderItem:
+    sku: str
+    description: str
+
+
+@dataclass
+class Order:
+    item: OrderItem
+    order_id: int
+
+
+@idempotent_function(data_keyword_argument="order", config=config, persistence_store=dynamodb)
+def process_order(order: Order):  # (1)!
+    return f"processed order {order.order_id}"
+
+
+def lambda_handler(event: dict, context: LambdaContext):
+    # see Lambda timeouts section
+    config.register_lambda_context(context)  # (2)!
+
+    order_item = OrderItem(sku="fake", description="sample")
+    order = Order(item=order_item, order_id=1)
+
+    # `order` parameter must be called as a keyword argument to work
+    process_order(order=order)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_idempotent_function_pydantic.py

@@ -0,0 +1,37 @@
+import os
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent_function,
+)
+from aws_lambda_powertools.utilities.parser import BaseModel
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+dynamodb = DynamoDBPersistenceLayer(table_name=table)
+config = IdempotencyConfig(event_key_jmespath="order_id")  # see Choosing a payload subset section
+
+
+class OrderItem(BaseModel):
+    sku: str
+    description: str
+
+
+class Order(BaseModel):
+    item: OrderItem
+    order_id: int
+
+
+@idempotent_function(data_keyword_argument="order", config=config, persistence_store=dynamodb)
+def process_order(order: Order):
+    return f"processed order {order.order_id}"
+
+
+def lambda_handler(event: dict, context: LambdaContext):
+    config.register_lambda_context(context)  # see Lambda timeouts section
+    order_item = OrderItem(sku="fake", description="sample")
+    order = Order(item=order_item, order_id=1)
+
+    # `order` parameter must be called as a keyword argument to work
+    process_order(order=order)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_lambda_timeout.py

@@ -0,0 +1,25 @@
+import os
+
+from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent_function,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+persistence_layer = DynamoDBPersistenceLayer(table_name=table)
+
+config = IdempotencyConfig()
+
+
+@idempotent_function(data_keyword_argument="record", persistence_store=persistence_layer, config=config)
+def record_handler(record: SQSRecord):
+    return {"message": record["body"]}
+
+
+def lambda_handler(event: dict, context: LambdaContext):
+    config.register_lambda_context(context)
+
+    return record_handler(event)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_local_cache.py

@@ -0,0 +1,21 @@
+import os
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+persistence_layer = DynamoDBPersistenceLayer(table_name=table)
+config = IdempotencyConfig(
+    event_key_jmespath="powertools_json(body)",
+    # by default, it holds 256 items in a Least-Recently-Used (LRU) manner
+    use_local_cache=True,  # (1)!
+)
+
+
+@idempotent(config=config, persistence_store=persistence_layer)
+def lambda_handler(event, context: LambdaContext):
+    return event

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_payload_subset.py

@@ -0,0 +1,46 @@
+import json
+import os
+from dataclasses import dataclass, field
+from uuid import uuid4
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+persistence_layer = DynamoDBPersistenceLayer(table_name=table)
+
+# Deserialize JSON string under the "body" key
+# then extract "user" and "product_id" data
+config = IdempotencyConfig(event_key_jmespath='powertools_json(body).["user_id", "product_id"]')
+
+
+@dataclass
+class Payment:
+    user_id: str
+    product_id: str
+    payment_id: str = field(default_factory=lambda: f"{uuid4()}")
+
+
+class PaymentError(Exception): ...
+
+
+@idempotent(config=config, persistence_store=persistence_layer)
+def lambda_handler(event: dict, context: LambdaContext):
+    try:
+        payment_info: str = event.get("body", "")
+        payment: Payment = create_subscription_payment(json.loads(payment_info))
+        return {
+            "payment_id": payment.payment_id,
+            "message": "success",
+            "statusCode": 200,
+        }
+    except Exception as exc:
+        raise PaymentError(f"Error creating payment {str(exc)}")
+
+
+def create_subscription_payment(event: dict) -> Payment:
+    return Payment(**event)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_pydantic_deduced_output_serializer.py

@@ -0,0 +1,48 @@
+import os
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent_function,
+)
+from aws_lambda_powertools.utilities.idempotency.serialization.pydantic import PydanticSerializer
+from aws_lambda_powertools.utilities.parser import BaseModel
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+dynamodb = DynamoDBPersistenceLayer(table_name=table)
+config = IdempotencyConfig(event_key_jmespath="order_id")  # see Choosing a payload subset section
+
+
+class OrderItem(BaseModel):
+    sku: str
+    description: str
+
+
+class Order(BaseModel):
+    item: OrderItem
+    order_id: int
+
+
+class OrderOutput(BaseModel):
+    order_id: int
+
+
+@idempotent_function(
+    data_keyword_argument="order",
+    config=config,
+    persistence_store=dynamodb,
+    output_serializer=PydanticSerializer,
+)
+# order output is inferred from return type
+def process_order(order: Order) -> OrderOutput:  # (1)!
+    return OrderOutput(order_id=order.order_id)
+
+
+def lambda_handler(event: dict, context: LambdaContext):
+    config.register_lambda_context(context)  # see Lambda timeouts section
+    order_item = OrderItem(sku="fake", description="sample")
+    order = Order(item=order_item, order_id=1)
+
+    # `order` parameter must be called as a keyword argument to work
+    process_order(order=order)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_pydantic_explicitly_output_serializer.py

@@ -0,0 +1,47 @@
+import os
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent_function,
+)
+from aws_lambda_powertools.utilities.idempotency.serialization.pydantic import PydanticSerializer
+from aws_lambda_powertools.utilities.parser import BaseModel
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+dynamodb = DynamoDBPersistenceLayer(table_name=table)
+config = IdempotencyConfig(event_key_jmespath="order_id")  # see Choosing a payload subset section
+
+
+class OrderItem(BaseModel):
+    sku: str
+    description: str
+
+
+class Order(BaseModel):
+    item: OrderItem
+    order_id: int
+
+
+class OrderOutput(BaseModel):
+    order_id: int
+
+
+@idempotent_function(
+    data_keyword_argument="order",
+    config=config,
+    persistence_store=dynamodb,
+    output_serializer=PydanticSerializer(model=OrderOutput),
+)
+def process_order(order: Order):
+    return OrderOutput(order_id=order.order_id)
+
+
+def lambda_handler(event: dict, context: LambdaContext):
+    config.register_lambda_context(context)  # see Lambda timeouts section
+    order_item = OrderItem(sku="fake", description="sample")
+    order = Order(item=order_item, order_id=1)
+
+    # `order` parameter must be called as a keyword argument to work
+    process_order(order=order)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_record_expiration.py

@@ -0,0 +1,20 @@
+import os
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+persistence_layer = DynamoDBPersistenceLayer(table_name=table)
+config = IdempotencyConfig(
+    event_key_jmespath="body",
+    expires_after_seconds=24 * 60 * 60,  # 24 hours
+)
+
+
+@idempotent(config=config, persistence_store=persistence_layer)
+def lambda_handler(event, context: LambdaContext):
+    return event

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_record_expiration_payload.json

@@ -0,0 +1,3 @@
+{
+  "body": "{\"user_id\":\"xyz\",\"product_id\":\"123456789\"}"
+}

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_response_hook_payload.json

@@ -0,0 +1,8 @@
+{
+  "order" : {
+    "user_id": "xyz",
+    "product_id": "123456789",
+    "quantity": 2,
+    "value": 30
+  }
+}

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload.py

@@ -0,0 +1,56 @@
+import os
+from dataclasses import dataclass, field
+from uuid import uuid4
+
+from aws_lambda_powertools import Logger
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent,
+)
+from aws_lambda_powertools.utilities.idempotency.exceptions import IdempotencyValidationError
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+logger = Logger()
+
+table = os.getenv("IDEMPOTENCY_TABLE", "")
+persistence_layer = DynamoDBPersistenceLayer(table_name=table)
+config = IdempotencyConfig(
+    event_key_jmespath='["user_id", "product_id"]',
+    payload_validation_jmespath="amount",
+)
+
+
+@dataclass
+class Payment:
+    user_id: str
+    product_id: str
+    charge_type: str
+    amount: int
+    payment_id: str = field(default_factory=lambda: f"{uuid4()}")
+
+
+class PaymentError(Exception): ...
+
+
+@idempotent(config=config, persistence_store=persistence_layer)
+def lambda_handler(event: dict, context: LambdaContext):
+    try:
+        payment: Payment = create_subscription_payment(event)
+        return {
+            "payment_id": payment.payment_id,
+            "message": "success",
+            "statusCode": 200,
+        }
+    except IdempotencyValidationError:
+        logger.exception("Payload tampering detected", payment=payment, failure_type="validation")
+        return {
+            "message": "Unable to process payment at this time. Try again later.",
+            "statusCode": 500,
+        }
+    except Exception as exc:
+        raise PaymentError(f"Error creating payment {str(exc)}")
+
+
+def create_subscription_payment(event: dict) -> Payment:
+    return Payment(**event)

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload_payload1.json

@@ -0,0 +1,6 @@
+{
+  "user_id": 1,
+  "product_id": 1500,
+  "charge_type": "subscription",
+  "amount": 500
+}

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/src/working_with_validation_payload_payload2.json

@@ -0,0 +1,6 @@
+{
+  "user_id": 1,
+  "product_id": 1500,
+  "charge_type": "subscription",
+  "amount": 10
+}

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/cdk.py

@@ -0,0 +1,25 @@
+from aws_cdk import RemovalPolicy
+from aws_cdk import aws_dynamodb as dynamodb
+from aws_cdk import aws_iam as iam
+from constructs import Construct
+
+
+class IdempotencyConstruct(Construct):
+    def __init__(self, scope: Construct, name: str, lambda_role: iam.Role) -> None:
+        super().__init__(scope, name)
+        self.idempotency_table = dynamodb.Table(
+            self,
+            "IdempotencyTable",
+            partition_key=dynamodb.Attribute(name="id", type=dynamodb.AttributeType.STRING),
+            billing_mode=dynamodb.BillingMode.PAY_PER_REQUEST,
+            removal_policy=RemovalPolicy.DESTROY,
+            time_to_live_attribute="expiration",
+            point_in_time_recovery=True,
+        )
+        self.idempotency_table.grant(
+            lambda_role,
+            "dynamodb:PutItem",
+            "dynamodb:GetItem",
+            "dynamodb:UpdateItem",
+            "dynamodb:DeleteItem",
+        )

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/cfn_redis_serverless.yaml

@@ -0,0 +1,31 @@
+AWSTemplateFormatVersion: "2010-09-09"
+Transform: AWS::Serverless-2016-10-31
+
+Resources:
+  RedisServerlessIdempotency:
+    Type: AWS::ElastiCache::ServerlessCache
+    Properties:
+      Engine: redis
+      ServerlessCacheName: redis-cache
+      SecurityGroupIds: # (1)!
+        - security-{your_sg_id}
+      SubnetIds:
+        - subnet-{your_subnet_id_1}
+        - subnet-{your_subnet_id_2}
+
+  HelloWorldFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      Runtime: python3.12
+      Handler: app.py
+      VpcConfig: # (1)!
+        SecurityGroupIds:
+          - security-{your_sg_id}
+        SubnetIds:
+          - subnet-{your_subnet_id_1}
+          - subnet-{your_subnet_id_2}
+      Environment:
+        Variables:
+          POWERTOOLS_SERVICE_NAME: sample
+          REDIS_HOST: !GetAtt RedisServerlessIdempotency.Endpoint.Address
+          REDIS_PORT: !GetAtt RedisServerlessIdempotency.Endpoint.Port

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/sam.yaml

@@ -0,0 +1,34 @@
+Transform: AWS::Serverless-2016-10-31
+Resources:
+  IdempotencyTable:
+    Type: AWS::DynamoDB::Table
+    Properties:
+      AttributeDefinitions:
+        - AttributeName: id
+          AttributeType: S
+      KeySchema:
+        - AttributeName: id
+          KeyType: HASH
+      TimeToLiveSpecification:
+        AttributeName: expiration
+        Enabled: true
+      BillingMode: PAY_PER_REQUEST
+
+  HelloWorldFunction:
+    Type: AWS::Serverless::Function
+    Properties:
+      Runtime: python3.12
+      Handler: app.py
+      Policies:
+        - Statement:
+            - Sid: AllowDynamodbReadWrite
+              Effect: Allow
+              Action:
+                - dynamodb:PutItem
+                - dynamodb:GetItem
+                - dynamodb:UpdateItem
+                - dynamodb:DeleteItem
+              Resource: !GetAtt IdempotencyTable.Arn
+      Environment:
+        Variables:
+          IDEMPOTENCY_TABLE: !Ref IdempotencyTable

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/templates/terraform.tf

@@ -0,0 +1,79 @@
+terraform {
+  required_providers {
+    aws = {
+      source  = "hashicorp/aws"
+      version = "~> 4.0"
+    }
+  }
+}
+
+provider "aws" {
+  region = "us-east-1" # Replace with your desired AWS region
+}
+
+resource "aws_dynamodb_table" "IdempotencyTable" {
+  name         = "IdempotencyTable"
+  billing_mode = "PAY_PER_REQUEST"
+  hash_key     = "id"
+  attribute {
+    name = "id"
+    type = "S"
+  }
+  ttl {
+    attribute_name = "expiration"
+    enabled        = true
+  }
+}
+
+resource "aws_lambda_function" "IdempotencyFunction" {
+  function_name = "IdempotencyFunction"
+  role          = aws_iam_role.IdempotencyFunctionRole.arn
+  runtime       = "python3.12"
+  handler       = "app.lambda_handler"
+  filename      = "lambda.zip"
+
+}
+
+resource "aws_iam_role" "IdempotencyFunctionRole" {
+  name = "IdempotencyFunctionRole"
+
+  assume_role_policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Sid    = ""
+        Effect = "Allow"
+        Principal = {
+          Service = "lambda.amazonaws.com"
+        }
+        Action = "sts:AssumeRole"
+      },
+    ]
+  })
+}
+
+resource "aws_iam_policy" "LambdaDynamoDBPolicy" {
+  name        = "LambdaDynamoDBPolicy"
+  description = "IAM policy for Lambda function to access DynamoDB"
+  policy = jsonencode({
+    Version = "2012-10-17"
+    Statement = [
+      {
+        Sid    = "AllowDynamodbReadWrite"
+        Effect = "Allow"
+        Action = [
+          "dynamodb:PutItem",
+          "dynamodb:GetItem",
+          "dynamodb:UpdateItem",
+          "dynamodb:DeleteItem",
+        ]
+        Resource = aws_dynamodb_table.IdempotencyTable.arn
+      },
+    ]
+  })
+}
+
+resource "aws_iam_role_policy_attachment" "IdempotencyFunctionRoleAttachment" {
+  role       = aws_iam_role.IdempotencyFunctionRole.name
+  policy_arn = aws_iam_policy.LambdaDynamoDBPolicy.arn
+}

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_disabling_idempotency_utility.py

@@ -0,0 +1,17 @@
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    idempotent,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+persistence_layer = DynamoDBPersistenceLayer(table_name="IdempotencyTable")
+
+
+@idempotent(persistence_store=persistence_layer)
+def lambda_handler(event: dict, context: LambdaContext):
+    print("expensive operation")
+    return {
+        "payment_id": 12345,
+        "message": "success",
+        "statusCode": 200,
+    }

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_dynamodb_local.py

@@ -0,0 +1,17 @@
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    idempotent,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+persistence_layer = DynamoDBPersistenceLayer(table_name="IdempotencyTable")
+
+
+@idempotent(persistence_store=persistence_layer)
+def lambda_handler(event: dict, context: LambdaContext):
+    print("expensive operation")
+    return {
+        "payment_id": 12345,
+        "message": "success",
+        "statusCode": 200,
+    }

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/app_test_io_operations.py

@@ -0,0 +1,17 @@
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    idempotent,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+persistence_layer = DynamoDBPersistenceLayer(table_name="IdempotencyTable")
+
+
+@idempotent(persistence_store=persistence_layer)
+def lambda_handler(event: dict, context: LambdaContext):
+    print("expensive operation")
+    return {
+        "payment_id": 12345,
+        "message": "success",
+        "statusCode": 200,
+    }

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/mock_redis.py

@@ -0,0 +1,37 @@
+import time as t
+from typing import Dict
+
+
+# Mock redis class that includes all operations we used in Idempotency
+class MockRedis:
+    def __init__(self, decode_responses, cache: Dict, **kwargs):
+        self.cache = cache or {}
+        self.expire_dict: Dict = {}
+        self.decode_responses = decode_responses
+        self.acl: Dict = {}
+        self.username = ""
+
+    def hset(self, name, mapping):
+        self.expire_dict.pop(name, {})
+        self.cache[name] = mapping
+
+    def from_url(self, url: str):
+        pass
+
+    def expire(self, name, time):
+        self.expire_dict[name] = t.time() + time
+
+    # return {} if no match
+    def hgetall(self, name):
+        if self.expire_dict.get(name, t.time() + 1) < t.time():
+            self.cache.pop(name, {})
+        return self.cache.get(name, {})
+
+    def get_connection_kwargs(self):
+        return {"decode_responses": self.decode_responses}
+
+    def auth(self, username, **kwargs):
+        self.username = username
+
+    def delete(self, name):
+        self.cache.pop(name, {})

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_disabling_idempotency_utility.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+
+import app_test_disabling_idempotency_utility
+import pytest
+
+
+@pytest.fixture
+def lambda_context():
+    @dataclass
+    class LambdaContext:
+        function_name: str = "test"
+        memory_limit_in_mb: int = 128
+        invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test"
+        aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72"
+
+        def get_remaining_time_in_millis(self) -> int:
+            return 5
+
+    return LambdaContext()
+
+
+def test_idempotent_lambda_handler(monkeypatch, lambda_context):
+    # Set POWERTOOLS_IDEMPOTENCY_DISABLED before calling decorated functions
+    monkeypatch.setenv("POWERTOOLS_IDEMPOTENCY_DISABLED", 1)
+
+    result = app_test_disabling_idempotency_utility.lambda_handler({}, lambda_context)
+
+    assert result

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_dynamodb_local.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+
+import app_test_dynamodb_local
+import boto3
+import pytest
+
+
+@pytest.fixture
+def lambda_context():
+    @dataclass
+    class LambdaContext:
+        function_name: str = "test"
+        memory_limit_in_mb: int = 128
+        invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test"
+        aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72"
+
+        def get_remaining_time_in_millis(self) -> int:
+            return 5
+
+    return LambdaContext()
+
+
+def test_idempotent_lambda(lambda_context):
+    # Configure the boto3 to use the endpoint for the DynamoDB Local instance
+    dynamodb_local_client = boto3.client("dynamodb", endpoint_url="http://localhost:8000")
+    app_test_dynamodb_local.persistence_layer.client = dynamodb_local_client
+
+    # If desired, you can use a different DynamoDB Local table name than what your code already uses
+    # app.persistence_layer.table_name = "another table name" # noqa: ERA001
+
+    result = app_test_dynamodb_local.handler({"testkey": "testvalue"}, lambda_context)
+    assert result["payment_id"] == 12345

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_io_operations.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from unittest.mock import MagicMock
+
+import app_test_io_operations
+import pytest
+
+
+@pytest.fixture
+def lambda_context():
+    @dataclass
+    class LambdaContext:
+        function_name: str = "test"
+        memory_limit_in_mb: int = 128
+        invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test"
+        aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72"
+
+        def get_remaining_time_in_millis(self) -> int:
+            return 5
+
+    return LambdaContext()
+
+
+def test_idempotent_lambda(lambda_context):
+    mock_client = MagicMock()
+    app_test_io_operations.persistence_layer.client = mock_client
+    result = app_test_io_operations.handler({"testkey": "testvalue"}, lambda_context)
+    mock_client.put_item.assert_called()
+    assert result

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_mock_redis.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+
+import pytest
+from mock_redis import MockRedis
+
+from aws_lambda_powertools.utilities.idempotency import (
+    idempotent,
+)
+from aws_lambda_powertools.utilities.idempotency.persistence.redis import (
+    RedisCachePersistenceLayer,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+
+@pytest.fixture
+def lambda_context():
+    @dataclass
+    class LambdaContext:
+        function_name: str = "test"
+        memory_limit_in_mb: int = 128
+        invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test"
+        aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72"
+
+        def get_remaining_time_in_millis(self) -> int:
+            return 1000
+
+    return LambdaContext()
+
+
+def test_idempotent_lambda(lambda_context):
+    # Init the Mock redis client
+    redis_client = MockRedis(decode_responses=True)
+    # Establish persistence layer using the mock redis client
+    persistence_layer = RedisCachePersistenceLayer(client=redis_client)
+
+    # setup idempotent with redis persistence layer
+    @idempotent(persistence_store=persistence_layer)
+    def lambda_handler(event: dict, context: LambdaContext):
+        print("expensive operation")
+        return {
+            "payment_id": 12345,
+            "message": "success",
+            "statusCode": 200,
+        }
+
+    # Inovke the sim lambda handler
+    result = lambda_handler({"testkey": "testvalue"}, lambda_context)
+    assert result["payment_id"] == 12345

testbed/aws-powertools__powertools-lambda-python/examples/idempotency/tests/test_with_real_redis.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass
+
+import pytest
+import redis
+
+from aws_lambda_powertools.utilities.idempotency import (
+    idempotent,
+)
+from aws_lambda_powertools.utilities.idempotency.persistence.redis import (
+    RedisCachePersistenceLayer,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+
+@pytest.fixture
+def lambda_context():
+    @dataclass
+    class LambdaContext:
+        function_name: str = "test"
+        memory_limit_in_mb: int = 128
+        invoked_function_arn: str = "arn:aws:lambda:eu-west-1:809313241:function:test"
+        aws_request_id: str = "52fdfc07-2182-154f-163f-5f0f9a621d72"
+
+        def get_remaining_time_in_millis(self) -> int:
+            return 1000
+
+    return LambdaContext()
+
+
+@pytest.fixture
+def persistence_store_standalone_redis():
+    # init a Real Redis client and connect to the Port set in the Makefile
+    redis_client = redis.Redis(
+        host="localhost",
+        port="63005",
+        decode_responses=True,
+    )
+
+    # return a persistence layer with real Redis
+    return RedisCachePersistenceLayer(client=redis_client)
+
+
+def test_idempotent_lambda(lambda_context, persistence_store_standalone_redis):
+    # Establish persistence layer using the real redis client
+    persistence_layer = persistence_store_standalone_redis
+
+    # setup idempotent with redis persistence layer
+    @idempotent(persistence_store=persistence_layer)
+    def lambda_handler(event: dict, context: LambdaContext):
+        print("expensive operation")
+        return {
+            "payment_id": 12345,
+            "message": "success",
+            "statusCode": 200,
+        }
+
+    # Inovke the sim lambda handler
+    result = lambda_handler({"testkey": "testvalue"}, lambda_context)
+    assert result["payment_id"] == 12345

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_builtin_envelope.json

@@ -0,0 +1,20 @@
+{
+    "Records": [
+        {
+            "messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
+            "receiptHandle": "MessageReceiptHandle",
+            "body": "{\"customerId\":\"dd4649e6-2484-4993-acb8-0f9123103394\",\"booking\":{\"id\":\"5b2c4803-330b-42b7-811a-c68689425de1\",\"reference\":\"ySz7oA\",\"outboundFlightId\":\"20c0d2f2-56a3-4068-bf20-ff7703db552d\"},\"payment\":{\"receipt\":\"https:\/\/pay.stripe.com\/receipts\/acct_1Dvn7pF4aIiftV70\/ch_3JTC14F4aIiftV700iFq2CHB\/rcpt_K7QsrFln9FgFnzUuBIiNdkkRYGxUL0X\",\"amount\":100}}",
+            "attributes": {
+                "ApproximateReceiveCount": "1",
+                "SentTimestamp": "1523232000000",
+                "SenderId": "123456789012",
+                "ApproximateFirstReceiveTimestamp": "1523232000001"
+            },
+            "messageAttributes": {},
+            "md5OfBody": "7b270e59b47ff90a553787216d55d91d",
+            "eventSource": "aws:sqs",
+            "eventSourceARN": "arn:aws:sqs:us-east-1:123456789012:MyQueue",
+            "awsRegion": "us-east-1"
+        }
+    ]
+}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_builtin_envelope.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from aws_lambda_powertools import Logger
+from aws_lambda_powertools.utilities.jmespath_utils import (
+    envelopes,
+    query,
+)
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+logger = Logger()
+
+
+def handler(event: dict, context: LambdaContext) -> dict:
+    records: list = query(data=event, envelope=envelopes.SQS)
+    for record in records:  # records is a list
+        logger.info(record.get("customerId"))  # now deserialized
+
+    return {"message": "success", "statusCode": 200}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/extract_data_from_envelope.json

@@ -0,0 +1,12 @@
+{
+	"body": "{\"customerId\":\"dd4649e6-2484-4993-acb8-0f9123103394\"}",
+	"deeply_nested": [
+		{
+			"some_data": [
+				1,
+				2,
+				3
+			]
+		}
+	]
+}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_function.py

@@ -0,0 +1,41 @@
+import base64
+import binascii
+import gzip
+import json
+
+import powertools_base64_gzip_jmespath_schema as schemas
+from jmespath.exceptions import JMESPathTypeError
+
+from aws_lambda_powertools.utilities.typing import LambdaContext
+from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate
+
+
+def lambda_handler(event, context: LambdaContext) -> dict:
+    try:
+        validate(event=event, schema=schemas.INPUT, envelope="powertools_base64_gzip(payload) | powertools_json(@)")
+
+        # Alternatively, query works here too
+        encoded_payload = base64.b64decode(event["payload"])
+        uncompressed_payload = gzip.decompress(encoded_payload).decode()
+        log: dict = json.loads(uncompressed_payload)
+
+        return {
+            "message": "Logs processed",
+            "log_group": log.get("logGroup"),
+            "owner": log.get("owner"),
+            "success": True,
+        }
+
+    except JMESPathTypeError:
+        return return_error_message("The powertools_base64_gzip() envelope function must match a valid path.")
+    except binascii.Error:
+        return return_error_message("Payload must be a valid base64 encoded string")
+    except json.JSONDecodeError:
+        return return_error_message("Payload must be valid JSON (base64 encoded).")
+    except SchemaValidationError as exception:
+        # SchemaValidationError indicates where a data mismatch is
+        return return_error_message(str(exception))
+
+
+def return_error_message(message: str) -> dict:
+    return {"message": message, "success": False}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_payload.json

@@ -0,0 +1,3 @@
+{
+    "payload": "H4sIACZAXl8C/52PzUrEMBhFX2UILpX8tPbHXWHqIOiq3Q1F0ubrWEiakqTWofTdTYYB0YWL2d5zvnuTFellBIOedoiyKH5M0iwnlKH7HZL6dDB6ngLDfLFYctUKjie9gHFaS/sAX1xNEq525QxwFXRGGMEkx4Th491rUZdV3YiIZ6Ljfd+lfSyAtZloacQgAkqSJCGhxM6t7cwwuUGPz4N0YKyvO6I9WDeMPMSo8Z4Ca/kJ6vMEYW5f1MX7W1lVxaG8vqX8hNFdjlc0iCBBSF4ERT/3Pl7RbMGMXF2KZMh/C+gDpNS7RRsp0OaRGzx0/t8e0jgmcczyLCWEePhni/23JWalzjdu0a3ZvgEaNLXeugEAAA=="
+}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_gzip_jmespath_schema.py

@@ -0,0 +1,47 @@
+INPUT = {
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "$id": "http://example.com/example.json",
+    "type": "object",
+    "title": "Sample schema",
+    "description": "The root schema comprises the entire JSON document.",
+    "examples": [
+        {
+            "owner": "123456789012",
+            "logGroup": "/aws/lambda/powertools-example",
+            "logStream": "2022/08/07/[$LATEST]d3a8dcaffc7f4de2b8db132e3e106660",
+            "logEvents": {},
+        },
+    ],
+    "required": ["owner", "logGroup", "logStream", "logEvents"],
+    "properties": {
+        "owner": {
+            "$id": "#/properties/owner",
+            "type": "string",
+            "title": "The owner",
+            "examples": ["123456789012"],
+            "maxLength": 12,
+        },
+        "logGroup": {
+            "$id": "#/properties/logGroup",
+            "type": "string",
+            "title": "The logGroup",
+            "examples": ["/aws/lambda/powertools-example"],
+            "maxLength": 100,
+        },
+        "logStream": {
+            "$id": "#/properties/logStream",
+            "type": "string",
+            "title": "The logGroup",
+            "examples": ["2022/08/07/[$LATEST]d3a8dcaffc7f4de2b8db132e3e106660"],
+            "maxLength": 100,
+        },
+        "logEvents": {
+            "$id": "#/properties/logEvents",
+            "type": "array",
+            "title": "The logEvents",
+            "examples": [
+                "{'id': 'eventId1', 'message': {'username': 'lessa', 'message': 'hello world'}, 'timestamp': 1440442987000}"  # noqa E501
+            ],
+        },
+    },
+}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_function.py

@@ -0,0 +1,62 @@
+import base64
+import binascii
+import json
+from dataclasses import asdict, dataclass, field, is_dataclass
+from uuid import uuid4
+
+import powertools_base64_jmespath_schema as schemas
+from jmespath.exceptions import JMESPathTypeError
+
+from aws_lambda_powertools.utilities.typing import LambdaContext
+from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate
+
+
+@dataclass
+class Order:
+    user_id: int
+    product_id: int
+    quantity: int
+    price: float
+    currency: str
+    order_id: str = field(default_factory=lambda: f"{uuid4()}")
+
+
+class DataclassCustomEncoder(json.JSONEncoder):
+    """A custom JSON encoder to serialize dataclass obj"""
+
+    def default(self, obj):
+        # Only called for values that aren't JSON serializable
+        # where `obj` will be an instance of Todo in this example
+        return asdict(obj) if is_dataclass(obj) else super().default(obj)
+
+
+def lambda_handler(event, context: LambdaContext) -> dict:
+    # Try to validate the schema
+    try:
+        validate(event=event, schema=schemas.INPUT, envelope="powertools_json(powertools_base64(payload))")
+
+        # alternatively, query works here too
+        payload_decoded = base64.b64decode(event["payload"]).decode()
+
+        order_payload: dict = json.loads(payload_decoded)
+
+        return {
+            "order": json.dumps(Order(**order_payload), cls=DataclassCustomEncoder),
+            "message": "order created",
+            "success": True,
+        }
+    except JMESPathTypeError:
+        return return_error_message(
+            "The powertools_json(powertools_base64()) envelope function must match a valid path.",
+        )
+    except binascii.Error:
+        return return_error_message("Payload must be a valid base64 encoded string")
+    except json.JSONDecodeError:
+        return return_error_message("Payload must be valid JSON (base64 encoded).")
+    except SchemaValidationError as exception:
+        # SchemaValidationError indicates where a data mismatch is
+        return return_error_message(str(exception))
+
+
+def return_error_message(message: str) -> dict:
+    return {"order": None, "message": message, "success": False}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_payload.json

@@ -0,0 +1,3 @@
+{
+    "payload":"eyJ1c2VyX2lkIjogMTIzLCAicHJvZHVjdF9pZCI6IDEsICJxdWFudGl0eSI6IDIsICJwcmljZSI6IDEwLjQwLCAiY3VycmVuY3kiOiAiVVNEIn0="
+}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_base64_jmespath_schema.py

@@ -0,0 +1,46 @@
+INPUT = {
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "$id": "http://example.com/example.json",
+    "type": "object",
+    "title": "Sample order schema",
+    "description": "The root schema comprises the entire JSON document.",
+    "examples": [{"user_id": 123, "product_id": 1, "quantity": 2, "price": 10.40, "currency": "USD"}],
+    "required": ["user_id", "product_id", "quantity", "price", "currency"],
+    "properties": {
+        "user_id": {
+            "$id": "#/properties/user_id",
+            "type": "integer",
+            "title": "The unique identifier of the user",
+            "examples": [123],
+            "maxLength": 10,
+        },
+        "product_id": {
+            "$id": "#/properties/product_id",
+            "type": "integer",
+            "title": "The unique identifier of the product",
+            "examples": [1],
+            "maxLength": 10,
+        },
+        "quantity": {
+            "$id": "#/properties/quantity",
+            "type": "integer",
+            "title": "The quantity of the product",
+            "examples": [2],
+            "maxLength": 10,
+        },
+        "price": {
+            "$id": "#/properties/price",
+            "type": "number",
+            "title": "The individual price of the product",
+            "examples": [10.40],
+            "maxLength": 10,
+        },
+        "currency": {
+            "$id": "#/properties/currency",
+            "type": "string",
+            "title": "The currency",
+            "examples": ["The currency of the order"],
+            "maxLength": 100,
+        },
+    },
+}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_custom_jmespath_function.json

@@ -0,0 +1,9 @@
+{
+    "Records": [
+        {
+            "application": "notification",
+            "datetime": "2022-01-01T00:00:00.000Z",
+            "log": "eJxtUNFOwkAQ/JXN+dJq6e22tMD5ZHwQRYSEJpqQhtRy2AvlWq+tEr/eg6DExOzDJjM7M5tZsgCDgGPMKQaKRRAJRFjmRrUphBjRcIQXpy3gkiCvtJZ567jQVkDBwEc7JCK0sk2mSrkGh0IBc2l2qmlUpWEttZJrFz4LS/8YKP12cOjqpjUy23mQl0rqVpw9PWik+ZBGwMoDI9872ViazebJ/expARzGSTLn5BPzfm0sX7RtLTj/+xq3N0V11J+JITELnwHo2VlSzB86zQ+1CFtIiIJGcIWEmP4bDgH2AYH1GLBp9aXKMuORj+C8EF3Do9LdHvbDeBX3Xbip61I+y9eJankUDvwwBmcyTqaPHpRqK+FO5tvKhdvCVDvJCYPjYwiLbJMZdZKwQxZL02+NI3Vs"
+        }
+    ]
+}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_custom_jmespath_function.py

@@ -0,0 +1,47 @@
+import base64
+import binascii
+import zlib
+
+from jmespath.exceptions import JMESPathTypeError
+from jmespath.functions import signature
+
+from aws_lambda_powertools.utilities.jmespath_utils import (
+    PowertoolsFunctions,
+    query,
+)
+
+
+class CustomFunctions(PowertoolsFunctions):
+    # only decode if value is a string
+    # see supported data types: https://jmespath.org/specification.html#built-in-functions
+    @signature({"types": ["string"]})
+    def _func_decode_zlib_compression(self, payload: str):
+        decoded: bytes = base64.b64decode(payload)
+        return zlib.decompress(decoded)
+
+
+custom_jmespath_options = {"custom_functions": CustomFunctions()}
+
+
+def lambda_handler(event, context) -> dict:
+    try:
+        logs = []
+        logs.append(
+            query(
+                data=event,
+                # NOTE: Use the prefix `_func_` before the name of the function
+                envelope="Records[*].decode_zlib_compression(log)",
+                jmespath_options=custom_jmespath_options,
+            ),
+        )
+        return {"logs": logs, "message": "Extracted messages", "success": True}
+    except JMESPathTypeError:
+        return return_error_message("The envelope function must match a valid path.")
+    except zlib.error:
+        return return_error_message("Log must be a valid zlib compressed message")
+    except binascii.Error:
+        return return_error_message("Log must be a valid base64 encoded string")
+
+
+def return_error_message(message: str) -> dict:
+    return {"logs": None, "message": message, "success": False}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_idempotency_jmespath.json

@@ -0,0 +1,30 @@
+{
+    "version":"2.0",
+    "routeKey":"ANY /createpayment",
+    "rawPath":"/createpayment",
+    "rawQueryString":"",
+    "headers": {
+      "Header1": "value1",
+      "Header2": "value2"
+    },
+    "requestContext":{
+      "accountId":"123456789012",
+      "apiId":"api-id",
+      "domainName":"id.execute-api.us-east-1.amazonaws.com",
+      "domainPrefix":"id",
+      "http":{
+        "method":"POST",
+        "path":"/createpayment",
+        "protocol":"HTTP/1.1",
+        "sourceIp":"ip",
+        "userAgent":"agent"
+      },
+      "requestId":"id",
+      "routeKey":"ANY /createpayment",
+      "stage":"$default",
+      "time":"10/Feb/2021:13:40:43 +0000",
+      "timeEpoch":1612964443723
+    },
+    "body":"{\"user\":\"xyz\",\"product_id\":\"123456789\"}",
+    "isBase64Encoded":false
+  }

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_idempotency_jmespath.py

@@ -0,0 +1,38 @@
+import json
+from uuid import uuid4
+
+import requests
+
+from aws_lambda_powertools.utilities.idempotency import (
+    DynamoDBPersistenceLayer,
+    IdempotencyConfig,
+    idempotent,
+)
+
+persistence_layer = DynamoDBPersistenceLayer(table_name="IdempotencyTable")
+
+# Treat everything under the "body" key
+# in the event json object as our payload
+config = IdempotencyConfig(event_key_jmespath="powertools_json(body)")
+
+
+class PaymentError(Exception):
+    ...
+
+
+@idempotent(config=config, persistence_store=persistence_layer)
+def handler(event, context) -> dict:
+    body = json.loads(event["body"])
+    try:
+        payment: dict = create_subscription_payment(user=body["user"], product_id=body["product_id"])
+        return {"payment_id": payment.get("id"), "message": "success", "statusCode": 200}
+    except requests.HTTPError as e:
+        raise PaymentError("Unable to create payment subscription") from e
+
+
+def create_subscription_payment(user: str, product_id: str) -> dict:
+    payload = {"user": user, "product_id": product_id}
+    ret: requests.Response = requests.post(url="https://httpbin.org/anything", data=payload)
+    ret.raise_for_status()
+
+    return {"id": f"{uuid4()}", "message": "paid"}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_function.py

@@ -0,0 +1,56 @@
+import json
+from dataclasses import asdict, dataclass, field, is_dataclass
+from uuid import uuid4
+
+import powertools_json_jmespath_schema as schemas
+from jmespath.exceptions import JMESPathTypeError
+
+from aws_lambda_powertools.utilities.typing import LambdaContext
+from aws_lambda_powertools.utilities.validation import SchemaValidationError, validate
+
+
+@dataclass
+class Order:
+    user_id: int
+    product_id: int
+    quantity: int
+    price: float
+    currency: str
+    order_id: str = field(default_factory=lambda: f"{uuid4()}")
+
+
+class DataclassCustomEncoder(json.JSONEncoder):
+    """A custom JSON encoder to serialize dataclass obj"""
+
+    def default(self, obj):
+        # Only called for values that aren't JSON serializable
+        # where `obj` will be an instance of Order in this example
+        return asdict(obj) if is_dataclass(obj) else super().default(obj)
+
+
+def lambda_handler(event, context: LambdaContext) -> dict:
+    try:
+        # Validate order against our schema
+        validate(event=event, schema=schemas.INPUT, envelope="powertools_json(payload)")
+
+        # Deserialize JSON string order as dict
+        # alternatively, query works here too
+        order_payload: dict = json.loads(event.get("payload"))
+
+        return {
+            "order": json.dumps(Order(**order_payload), cls=DataclassCustomEncoder),
+            "message": "order created",
+            "success": True,
+        }
+    except JMESPathTypeError:
+        # The powertools_json() envelope function must match a valid path
+        return return_error_message("Invalid request.")
+    except SchemaValidationError as exception:
+        # SchemaValidationError indicates where a data mismatch is
+        return return_error_message(str(exception))
+    except json.JSONDecodeError:
+        return return_error_message("Payload must be valid JSON (base64 encoded).")
+
+
+def return_error_message(message: str) -> dict:
+    return {"order": None, "message": message, "success": False}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_payload.json

@@ -0,0 +1,3 @@
+{
+    "payload":"{\"user_id\": 123, \"product_id\": 1, \"quantity\": 2, \"price\": 10.40, \"currency\": \"USD\"}"
+}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/powertools_json_jmespath_schema.py

@@ -0,0 +1,46 @@
+INPUT = {
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "$id": "http://example.com/example.json",
+    "type": "object",
+    "title": "Sample order schema",
+    "description": "The root schema comprises the entire JSON document.",
+    "examples": [{"user_id": 123, "product_id": 1, "quantity": 2, "price": 10.40, "currency": "USD"}],
+    "required": ["user_id", "product_id", "quantity", "price", "currency"],
+    "properties": {
+        "user_id": {
+            "$id": "#/properties/user_id",
+            "type": "integer",
+            "title": "The unique identifier of the user",
+            "examples": [123],
+            "maxLength": 10,
+        },
+        "product_id": {
+            "$id": "#/properties/product_id",
+            "type": "integer",
+            "title": "The unique identifier of the product",
+            "examples": [1],
+            "maxLength": 10,
+        },
+        "quantity": {
+            "$id": "#/properties/quantity",
+            "type": "integer",
+            "title": "The quantity of the product",
+            "examples": [2],
+            "maxLength": 10,
+        },
+        "price": {
+            "$id": "#/properties/price",
+            "type": "number",
+            "title": "The individual price of the product",
+            "examples": [10.40],
+            "maxLength": 10,
+        },
+        "currency": {
+            "$id": "#/properties/currency",
+            "type": "string",
+            "title": "The currency",
+            "examples": ["The currency of the order"],
+            "maxLength": 100,
+        },
+    },
+}

testbed/aws-powertools__powertools-lambda-python/examples/jmespath_functions/src/query.py

@@ -0,0 +1,12 @@
+from aws_lambda_powertools.utilities.jmespath_utils import query
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+
+def handler(event: dict, context: LambdaContext) -> dict:
+    payload = query(data=event, envelope="powertools_json(body)")
+    customer_id = payload.get("customerId")  # now deserialized
+
+    # also works for fetching and flattening deeply nested data
+    some_data = query(data=event, envelope="deeply_nested[*].some_data[]")
+
+    return {"customer_id": customer_id, "message": "success", "context": some_data, "statusCode": 200}

testbed/aws-powertools__powertools-lambda-python/examples/logger/src/append_keys_extra.py

@@ -0,0 +1,11 @@
+from aws_lambda_powertools import Logger
+from aws_lambda_powertools.utilities.typing import LambdaContext
+
+logger = Logger()
+
+
+def lambda_handler(event: dict, context: LambdaContext) -> str:
+    fields = {"request_id": "1123"}
+    logger.info("Collecting payment", extra=fields)
+
+    return "hello world"