aws-lambda-powertools 2.14.0__tar.gz → 2.15.0__tar.gz

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-lambda-powertools
-Version: 2.14.0
+Version: 2.15.0
 Summary: AWS Lambda Powertools is a developer toolkit to implement Serverless best practices and increase developer velocity.
 Home-page: https://github.com/awslabs/aws-lambda-powertools-python
 License: MIT
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -41,7 +42,7 @@ Description-Content-Type: text/markdown
 
 [![Build](https://github.com/awslabs/aws-lambda-powertools-python/actions/workflows/python_build.yml/badge.svg)](https://github.com/awslabs/aws-lambda-powertools-python/actions/workflows/python_build.yml)
 [![codecov.io](https://codecov.io/github/awslabs/aws-lambda-powertools-python/branch/develop/graphs/badge.svg)](https://app.codecov.io/gh/awslabs/aws-lambda-powertools-python)
-![PythonSupport](https://img.shields.io/static/v1?label=python&message=%203.7|%203.8|%203.9&color=blue?style=flat-square&logo=python) ![PyPI version](https://badge.fury.io/py/aws-lambda-powertools.svg) ![PyPi monthly downloads](https://img.shields.io/pypi/dm/aws-lambda-powertools) [![Join our Discord](https://dcbadge.vercel.app/api/server/B8zZKbbyET)](https://discord.gg/B8zZKbbyET)
+![PythonSupport](https://img.shields.io/static/v1?label=python&message=%203.7|%203.8|%203.9|%203.10&color=blue?style=flat-square&logo=python) ![PyPI version](https://badge.fury.io/py/aws-lambda-powertools.svg) ![PyPi monthly downloads](https://img.shields.io/pypi/dm/aws-lambda-powertools) [![Join our Discord](https://dcbadge.vercel.app/api/server/B8zZKbbyET)](https://discord.gg/B8zZKbbyET)
 
 Powertools is a developer toolkit to implement Serverless [best practices and increase developer velocity](https://awslabs.github.io/aws-lambda-powertools-python/latest/#features).
 
@@ -83,6 +84,31 @@ With [pip](https://pip.pypa.io/en/latest/index.html) installed, run: ``pip insta
 * [Serverless E-commerce platform](https://github.com/aws-samples/aws-serverless-ecommerce-platform)
 * [Serverless GraphQL Nanny Booking Api](https://github.com/trey-rosius/babysitter_api)
 
+## How to support AWS Lambda Powertools for Python?
+
+### Becoming a reference customer
+
+Knowing which companies are using this library is important to help prioritize the project internally. If your company is using AWS Lambda Powertools for Python, you can request to have your name and logo added to the README file by raising a [Support Lambda Powertools (become a reference)](https://github.com/awslabs/aws-lambda-powertools-python/issues/new?assignees=&labels=customer-reference&template=support_powertools.yml&title=%5BSupport+Lambda+Powertools%5D%3A+%3Cyour+organization+name%3E) issue.
+
+The following companies, among others, use Powertools:
+
+* [CPQi (Exadel Financial Services)](https://cpqi.com/)
+* [CloudZero](https://www.cloudzero.com/)
+* [CyberArk](https://www.cyberark.com/)
+* [globaldatanet](https://globaldatanet.com/)
+* [IMS](https://ims.tech/)
+* [Propellor.ai](https://www.propellor.ai/)
+* [TopSport](https://www.topsport.com.au/)
+* [Trek10](https://www.trek10.com/)
+
+### Sharing your work
+
+Share what you did with Powertools 💞💞. Blog post, workshops, presentation, sample apps and others. Check out what the community has already shared about Powertools [here](https://awslabs.github.io/aws-lambda-powertools-python/latest/we_made_this/).
+
+### Using Lambda Layer or SAR
+
+This helps us understand who uses Powertools in a non-intrusive way, and helps us gain future investments for other Powertools languages. When [using Layers](https://awslabs.github.io/aws-lambda-powertools-python/latest/#lambda-layer), you can add Powertools as a dev dependency (or as part of your virtual env) to not impact the development process.
+
 ## Credits
 
 * Structured logging initial implementation from [aws-lambda-logging](https://gitlab.com/hadrien/aws_lambda_logging)

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/README.md

@@ -3,7 +3,7 @@
 
 [![Build](https://github.com/awslabs/aws-lambda-powertools-python/actions/workflows/python_build.yml/badge.svg)](https://github.com/awslabs/aws-lambda-powertools-python/actions/workflows/python_build.yml)
 [![codecov.io](https://codecov.io/github/awslabs/aws-lambda-powertools-python/branch/develop/graphs/badge.svg)](https://app.codecov.io/gh/awslabs/aws-lambda-powertools-python)
-![PythonSupport](https://img.shields.io/static/v1?label=python&message=%203.7|%203.8|%203.9&color=blue?style=flat-square&logo=python) ![PyPI version](https://badge.fury.io/py/aws-lambda-powertools.svg) ![PyPi monthly downloads](https://img.shields.io/pypi/dm/aws-lambda-powertools) [![Join our Discord](https://dcbadge.vercel.app/api/server/B8zZKbbyET)](https://discord.gg/B8zZKbbyET)
+![PythonSupport](https://img.shields.io/static/v1?label=python&message=%203.7|%203.8|%203.9|%203.10&color=blue?style=flat-square&logo=python) ![PyPI version](https://badge.fury.io/py/aws-lambda-powertools.svg) ![PyPi monthly downloads](https://img.shields.io/pypi/dm/aws-lambda-powertools) [![Join our Discord](https://dcbadge.vercel.app/api/server/B8zZKbbyET)](https://discord.gg/B8zZKbbyET)
 
 Powertools is a developer toolkit to implement Serverless [best practices and increase developer velocity](https://awslabs.github.io/aws-lambda-powertools-python/latest/#features).
 
@@ -45,6 +45,31 @@ With [pip](https://pip.pypa.io/en/latest/index.html) installed, run: ``pip insta
 * [Serverless E-commerce platform](https://github.com/aws-samples/aws-serverless-ecommerce-platform)
 * [Serverless GraphQL Nanny Booking Api](https://github.com/trey-rosius/babysitter_api)
 
+## How to support AWS Lambda Powertools for Python?
+
+### Becoming a reference customer
+
+Knowing which companies are using this library is important to help prioritize the project internally. If your company is using AWS Lambda Powertools for Python, you can request to have your name and logo added to the README file by raising a [Support Lambda Powertools (become a reference)](https://github.com/awslabs/aws-lambda-powertools-python/issues/new?assignees=&labels=customer-reference&template=support_powertools.yml&title=%5BSupport+Lambda+Powertools%5D%3A+%3Cyour+organization+name%3E) issue.
+
+The following companies, among others, use Powertools:
+
+* [CPQi (Exadel Financial Services)](https://cpqi.com/)
+* [CloudZero](https://www.cloudzero.com/)
+* [CyberArk](https://www.cyberark.com/)
+* [globaldatanet](https://globaldatanet.com/)
+* [IMS](https://ims.tech/)
+* [Propellor.ai](https://www.propellor.ai/)
+* [TopSport](https://www.topsport.com.au/)
+* [Trek10](https://www.trek10.com/)
+
+### Sharing your work
+
+Share what you did with Powertools 💞💞. Blog post, workshops, presentation, sample apps and others. Check out what the community has already shared about Powertools [here](https://awslabs.github.io/aws-lambda-powertools-python/latest/we_made_this/).
+
+### Using Lambda Layer or SAR
+
+This helps us understand who uses Powertools in a non-intrusive way, and helps us gain future investments for other Powertools languages. When [using Layers](https://awslabs.github.io/aws-lambda-powertools-python/latest/#lambda-layer), you can add Powertools as a dev dependency (or as part of your virtual env) to not impact the development process.
+
 ## Credits
 
 * Structured logging initial implementation from [aws-lambda-logging](https://gitlab.com/hadrien/aws_lambda_logging)

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/logging/formatter.py

@@ -139,11 +139,11 @@ class LambdaPowertoolsFormatter(BasePowertoolsFormatter):
         if self.utc:
             self.converter = time.gmtime
 
-        super(LambdaPowertoolsFormatter, self).__init__(datefmt=self.datefmt)
-
         self.keys_combined = {**self._build_default_keys(), **kwargs}
         self.log_format.update(**self.keys_combined)
 
+        super().__init__(datefmt=self.datefmt)
+
     def serialize(self, log: Dict) -> str:
         """Serialize structured log dict to JSON str"""
         return self.json_serializer(log)

aws_lambda_powertools-2.15.0/aws_lambda_powertools/logging/formatters/__init__.py

@@ -0,0 +1,5 @@
+"""Built-in Logger formatters for Observability Providers that require custom config."""
+
+# NOTE: we don't expose formatters directly (barrel import)
+# as we cannot know if they'll need additional dependencies in the future
+# so we isolate to avoid a performance hit and workarounds like lazy imports

aws_lambda_powertools-2.15.0/aws_lambda_powertools/logging/formatters/datadog.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from aws_lambda_powertools.logging.formatter import LambdaPowertoolsFormatter
+
+
+class DatadogLogFormatter(LambdaPowertoolsFormatter):
+    def __init__(
+        self,
+        json_serializer: Callable[[dict], str] | None = None,
+        json_deserializer: Callable[[dict | str | bool | int | float], str] | None = None,
+        json_default: Callable[[Any], Any] | None = None,
+        datefmt: str | None = None,
+        use_datetime_directive: bool = False,
+        log_record_order: list[str] | None = None,
+        utc: bool = False,
+        use_rfc3339: bool = True,  # NOTE: The only change from our base formatter
+        **kwargs,
+    ):
+        """Datadog formatter to comply with Datadog log parsing
+
+        Changes compared to the default Logger Formatter:
+
+        - timestamp format to use RFC3339 e.g., "2023-05-01T15:34:26.841+0200"
+
+
+        Parameters
+        ----------
+        log_record_order : list[str] | None, optional
+            _description_, by default None
+
+        Parameters
+        ----------
+        json_serializer : Callable, optional
+            function to serialize `obj` to a JSON formatted `str`, by default json.dumps
+        json_deserializer : Callable, optional
+            function to deserialize `str`, `bytes`, bytearray` containing a JSON document to a Python `obj`,
+            by default json.loads
+        json_default : Callable, optional
+            function to coerce unserializable values, by default str
+
+            Only used when no custom JSON encoder is set
+
+        datefmt : str, optional
+            String directives (strftime) to format log timestamp.
+
+            See https://docs.python.org/3/library/time.html#time.strftime or
+        use_datetime_directive: str, optional
+            Interpret `datefmt` as a format string for `datetime.datetime.strftime`, rather than
+            `time.strftime` - Only useful when used alongside `datefmt`.
+
+            See https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior . This
+            also supports a custom %F directive for milliseconds.
+
+        log_record_order : list, optional
+            set order of log keys when logging, by default ["level", "location", "message", "timestamp"]
+
+        utc : bool, optional
+            set logging timestamp to UTC, by default False to continue to use local time as per stdlib
+        use_rfc3339: bool, optional
+            Whether to use a popular dateformat that complies with both RFC3339 and ISO8601.
+            e.g., 2022-10-27T16:27:43.738+02:00.
+        kwargs
+            Key-value to persist in all log messages
+        """
+        super().__init__(
+            json_serializer=json_serializer,
+            json_deserializer=json_deserializer,
+            json_default=json_default,
+            datefmt=datefmt,
+            use_datetime_directive=use_datetime_directive,
+            log_record_order=log_record_order,
+            utc=utc,
+            use_rfc3339=use_rfc3339,
+            **kwargs,
+        )

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/metrics/base.py

@@ -328,6 +328,28 @@ class MetricManager:
         self.dimension_set.clear()
         self.metadata_set.clear()
 
+    def flush_metrics(self, raise_on_empty_metrics: bool = False) -> None:
+        """Manually flushes the metrics. This is normally not necessary,
+        unless you're running on other runtimes besides Lambda, where the @log_metrics
+        decorator already handles things for you.
+
+        Parameters
+        ----------
+        raise_on_empty_metrics : bool, optional
+            raise exception if no metrics are emitted, by default False
+        """
+        if not raise_on_empty_metrics and not self.metric_set:
+            warnings.warn(
+                "No application metrics to publish. The cold-start metric may be published if enabled. "
+                "If application metrics should never be empty, consider using 'raise_on_empty_metrics'",
+                stacklevel=2,
+            )
+        else:
+            logger.debug("Flushing existing metrics")
+            metrics = self.serialize_metric_set()
+            print(json.dumps(metrics, separators=(",", ":")))
+            self.clear_metrics()
+
     def log_metrics(
         self,
         lambda_handler: Union[Callable[[Dict, Any], Any], Optional[Callable[[Dict, Any, Optional[Dict]], Any]]] = None,
@@ -390,16 +412,7 @@ class MetricManager:
                 if capture_cold_start_metric:
                     self._add_cold_start_metric(context=context)
             finally:
-                if not raise_on_empty_metrics and not self.metric_set:
-                    warnings.warn(
-                        "No application metrics to publish. The cold-start metric may be published if enabled. "
-                        "If application metrics should never be empty, consider using 'raise_on_empty_metrics'",
-                        stacklevel=2,
-                    )
-                else:
-                    metrics = self.serialize_metric_set()
-                    self.clear_metrics()
-                    print(json.dumps(metrics, separators=(",", ":")))
+                self.flush_metrics(raise_on_empty_metrics=raise_on_empty_metrics)
 
             return response
 

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/batch/base.py

@@ -26,7 +26,6 @@ from aws_lambda_powertools.utilities.data_classes.kinesis_stream_event import (
     KinesisStreamRecord,
 )
 from aws_lambda_powertools.utilities.data_classes.sqs_event import SQSRecord
-from aws_lambda_powertools.utilities.parser import ValidationError
 from aws_lambda_powertools.utilities.typing import LambdaContext
 
 logger = logging.getLogger(__name__)
@@ -496,9 +495,15 @@ class BatchProcessor(BasePartialBatchProcessor):  # Keep old name for compatibil
                 result = self.handler(record=data)
 
             return self.success_handler(record=record, result=result)
-        except ValidationError:
-            return self._register_model_validation_error_record(record)
-        except Exception:
+        except Exception as exc:
+            # NOTE: Pydantic is an optional dependency, but when used and a poison pill scenario happens
+            # we need to handle that exception differently.
+            # We check for a public attr in validation errors coming from Pydantic exceptions (subclass or not)
+            # and we compare if it's coming from the same model that trigger the exception in the first place
+            model = getattr(exc, "model", None)
+            if model == self.model:
+                return self._register_model_validation_error_record(record)
+
             return self.failure_handler(record=data, exception=sys.exc_info())
 
 
@@ -634,7 +639,13 @@ class AsyncBatchProcessor(BasePartialBatchProcessor):
                 result = await self.handler(record=data)
 
             return self.success_handler(record=record, result=result)
-        except ValidationError:
-            return self._register_model_validation_error_record(record)
-        except Exception:
+        except Exception as exc:
+            # NOTE: Pydantic is an optional dependency, but when used and a poison pill scenario happens
+            # we need to handle that exception differently.
+            # We check for a public attr in validation errors coming from Pydantic exceptions (subclass or not)
+            # and we compare if it's coming from the same model that trigger the exception in the first place
+            model = getattr(exc, "model", None)
+            if model == self.model:
+                return self._register_model_validation_error_record(record)
+
             return self.failure_handler(record=data, exception=sys.exc_info())

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/batch/exceptions.py

@@ -1,6 +1,8 @@
 """
 Batch processing exceptions
 """
+from __future__ import annotations
+
 import traceback
 from types import TracebackType
 from typing import List, Optional, Tuple, Type
@@ -9,10 +11,10 @@ ExceptionInfo = Tuple[Optional[Type[BaseException]], Optional[BaseException], Op
 
 
 class BaseBatchProcessingError(Exception):
-    def __init__(self, msg="", child_exceptions: Optional[List[ExceptionInfo]] = None):
+    def __init__(self, msg="", child_exceptions: List[ExceptionInfo] | None = None):
         super().__init__(msg)
         self.msg = msg
-        self.child_exceptions = child_exceptions
+        self.child_exceptions = child_exceptions or []
 
     def format_exceptions(self, parent_exception_str):
         exception_list = [f"{parent_exception_str}\n"]
@@ -27,7 +29,7 @@ class BaseBatchProcessingError(Exception):
 class BatchProcessingError(BaseBatchProcessingError):
     """When all batch records failed to be processed"""
 
-    def __init__(self, msg="", child_exceptions: Optional[List[ExceptionInfo]] = None):
+    def __init__(self, msg="", child_exceptions: List[ExceptionInfo] | None = None):
         super().__init__(msg, child_exceptions)
 
     def __str__(self):

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/data_classes/api_gateway_authorizer_event.py

@@ -21,8 +21,9 @@ class APIGatewayRouteArn:
         stage: str,
         http_method: str,
         resource: str,
+        partition: str = "aws",
     ):
-        self.partition = "aws"
+        self.partition = partition
         self.region = region
         self.aws_account_id = aws_account_id
         self.api_id = api_id
@@ -55,6 +56,7 @@ def parse_api_gateway_arn(arn: str) -> APIGatewayRouteArn:
     arn_parts = arn.split(":")
     api_gateway_arn_parts = arn_parts[5].split("/")
     return APIGatewayRouteArn(
+        partition=arn_parts[1],
         region=arn_parts[3],
         aws_account_id=arn_parts[4],
         api_id=api_gateway_arn_parts[0],
@@ -369,6 +371,7 @@ class APIGatewayAuthorizerResponse:
         stage: str,
         context: Optional[Dict] = None,
         usage_identifier_key: Optional[str] = None,
+        partition: str = "aws",
     ):
         """
         Parameters
@@ -401,6 +404,9 @@ class APIGatewayAuthorizerResponse:
             If the API uses a usage plan (the apiKeySource is set to `AUTHORIZER`), the Lambda authorizer function
             must return one of the usage plan's API keys as the usageIdentifierKey property value.
             > **Note:** This only applies for REST APIs.
+        partition: str, optional
+            Optional, arn partition.
+            See https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html
         """
         self.principal_id = principal_id
         self.region = region
@@ -412,6 +418,7 @@ class APIGatewayAuthorizerResponse:
         self._allow_routes: List[Dict] = []
         self._deny_routes: List[Dict] = []
         self._resource_pattern = re.compile(self.path_regex)
+        self.partition = partition
 
     @staticmethod
     def from_route_arn(
@@ -443,7 +450,7 @@ class APIGatewayAuthorizerResponse:
             raise ValueError(f"Invalid resource path: {resource}. Path should match {self.path_regex}")
 
         resource_arn = APIGatewayRouteArn(
-            self.region, self.aws_account_id, self.api_id, self.stage, http_method, resource
+            self.region, self.aws_account_id, self.api_id, self.stage, http_method, resource, self.partition
         ).arn
 
         route = {"resourceArn": resource_arn, "conditions": conditions}

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/data_classes/code_pipeline_job_event.py

@@ -80,6 +80,8 @@ class CodePipelineArtifact(DictWrapper):
 
 
 class CodePipelineArtifactCredentials(DictWrapper):
+    _sensitive_properties = ["secret_access_key", "session_token"]
+
     @property
     def access_key_id(self) -> str:
         return self["accessKeyId"]

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/data_classes/common.py

@@ -1,7 +1,7 @@
 import base64
 import json
 from collections.abc import Mapping
-from typing import Any, Dict, Iterator, Optional
+from typing import Any, Callable, Dict, Iterator, List, Optional
 
 from aws_lambda_powertools.shared.headers_serializer import BaseHeadersSerializer
 
@@ -9,9 +9,19 @@ from aws_lambda_powertools.shared.headers_serializer import BaseHeadersSerialize
 class DictWrapper(Mapping):
     """Provides a single read only access to a wrapper dict"""
 
-    def __init__(self, data: Dict[str, Any]):
+    def __init__(self, data: Dict[str, Any], json_deserializer: Optional[Callable] = None):
+        """
+        Parameters
+        ----------
+        data : Dict[str, Any]
+            Lambda Event Source Event payload
+        json_deserializer : Callable, optional
+            function to deserialize `str`, `bytes`, bytearray` containing a JSON document to a Python `obj`,
+            by default json.loads
+        """
         self._data = data
         self._json_data: Optional[Any] = None
+        self._json_deserializer = json_deserializer or json.loads
 
     def __getitem__(self, key: str) -> Any:
         return self._data[key]
@@ -28,6 +38,49 @@ class DictWrapper(Mapping):
     def __len__(self) -> int:
         return len(self._data)
 
+    def __str__(self) -> str:
+        return str(self._str_helper())
+
+    def _str_helper(self) -> Dict[str, Any]:
+        """
+        Recursively get a Dictionary of DictWrapper properties primarily
+        for use by __str__ for debugging purposes.
+
+        Will remove "raw_event" properties, and any defined by the Data Class
+        `_sensitive_properties` list field.
+        This should be used in case where secrets, such as access keys, are
+        stored in the Data Class but should not be logged out.
+        """
+        properties = self._properties()
+        sensitive_properties = ["raw_event"]
+        if hasattr(self, "_sensitive_properties"):
+            sensitive_properties.extend(self._sensitive_properties)  # pyright: ignore
+
+        result: Dict[str, Any] = {}
+        for property_key in properties:
+            if property_key in sensitive_properties:
+                result[property_key] = "[SENSITIVE]"
+            else:
+                try:
+                    property_value = getattr(self, property_key)
+                    result[property_key] = property_value
+
+                    # Checks whether the class is a subclass of the parent class to perform a recursive operation.
+                    if issubclass(property_value.__class__, DictWrapper):
+                        result[property_key] = property_value._str_helper()
+                    # Checks if the key is a list and if it is a subclass of the parent class
+                    elif isinstance(property_value, list):
+                        for seq, item in enumerate(property_value):
+                            if issubclass(item.__class__, DictWrapper):
+                                result[property_key][seq] = item._str_helper()
+                except Exception:
+                    result[property_key] = "[Cannot be deserialized]"
+
+        return result
+
+    def _properties(self) -> List[str]:
+        return [p for p in dir(self.__class__) if isinstance(getattr(self.__class__, p), property)]
+
     def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
         return self._data.get(key, default)
 
@@ -79,7 +132,7 @@ class BaseProxyEvent(DictWrapper):
     def json_body(self) -> Any:
         """Parses the submitted body as json"""
         if self._json_data is None:
-            self._json_data = json.loads(self.decoded_body)
+            self._json_data = self._json_deserializer(self.decoded_body)
         return self._json_data
 
     @property

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/data_classes/kafka_event.py

@@ -1,5 +1,4 @@
 import base64
-import json
 from typing import Any, Dict, Iterator, List, Optional
 
 from aws_lambda_powertools.utilities.data_classes.common import DictWrapper
@@ -55,7 +54,7 @@ class KafkaEventRecord(DictWrapper):
     def json_value(self) -> Any:
         """Decodes the text encoded data as JSON."""
         if self._json_data is None:
-            self._json_data = json.loads(self.decoded_value.decode("utf-8"))
+            self._json_data = self._json_deserializer(self.decoded_value.decode("utf-8"))
         return self._json_data
 
     @property
@@ -117,7 +116,7 @@ class KafkaEvent(DictWrapper):
         """The Kafka records."""
         for chunk in self["records"].values():
             for record in chunk:
-                yield KafkaEventRecord(record)
+                yield KafkaEventRecord(data=record, json_deserializer=self._json_deserializer)
 
     @property
     def record(self) -> KafkaEventRecord:

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/data_classes/kinesis_firehose_event.py

@@ -1,5 +1,4 @@
 import base64
-import json
 from typing import Iterator, Optional
 
 from aws_lambda_powertools.utilities.data_classes.common import DictWrapper
@@ -75,7 +74,7 @@ class KinesisFirehoseRecord(DictWrapper):
     def data_as_json(self) -> dict:
         """Decoded base64-encoded data loaded to json"""
         if self._json_data is None:
-            self._json_data = json.loads(self.data_as_text)
+            self._json_data = self._json_deserializer(self.data_as_text)
         return self._json_data
 
 
@@ -110,4 +109,4 @@ class KinesisFirehoseEvent(DictWrapper):
     @property
     def records(self) -> Iterator[KinesisFirehoseRecord]:
         for record in self["records"]:
-            yield KinesisFirehoseRecord(record)
+            yield KinesisFirehoseRecord(data=record, json_deserializer=self._json_deserializer)

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/data_classes/sqs_event.py

@@ -1,4 +1,4 @@
-from typing import Dict, Iterator, Optional
+from typing import Any, Dict, Iterator, Optional
 
 from aws_lambda_powertools.utilities.data_classes.common import DictWrapper
 
@@ -103,6 +103,35 @@ class SQSRecord(DictWrapper):
         """The message's contents (not URL-encoded)."""
         return self["body"]
 
+    @property
+    def json_body(self) -> Any:
+        """Deserializes JSON string available in 'body' property
+
+        Notes
+        -----
+
+        **Strict typing**
+
+        Caller controls the type as we can't use recursive generics here.
+
+        JSON Union types would force caller to have to cast a type. Instead,
+        we choose Any to ease ergonomics and other tools receiving this data.
+
+        Examples
+        --------
+
+        **Type deserialized data from JSON string**
+
+        ```python
+        data: dict = record.json_body  # {"telemetry": [], ...}
+        # or
+        data: list = record.json_body  # ["telemetry_values"]
+        ```
+        """
+        if self._json_data is None:
+            self._json_data = self._json_deserializer(self["body"])
+        return self._json_data
+
     @property
     def attributes(self) -> SQSRecordAttributes:
         """A map of the attributes requested in ReceiveMessage to their respective values."""
@@ -133,6 +162,18 @@ class SQSRecord(DictWrapper):
         """aws region eg: us-east-1"""
         return self["awsRegion"]
 
+    @property
+    def queue_url(self) -> str:
+        """The URL of the queue."""
+        arn_parts = self["eventSourceARN"].split(":")
+        region = arn_parts[3]
+        account_id = arn_parts[4]
+        queue_name = arn_parts[5]
+
+        queue_url = f"https://sqs.{region}.amazonaws.com/{account_id}/{queue_name}"
+
+        return queue_url
+
 
 class SQSEvent(DictWrapper):
     """SQS Event
@@ -145,4 +186,4 @@ class SQSEvent(DictWrapper):
     @property
     def records(self) -> Iterator[SQSRecord]:
         for record in self["Records"]:
-            yield SQSRecord(record)
+            yield SQSRecord(data=record, json_deserializer=self._json_deserializer)

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/jmespath_utils/envelopes.py

@@ -6,3 +6,8 @@ EVENTBRIDGE = "detail"
 CLOUDWATCH_EVENTS_SCHEDULED = EVENTBRIDGE
 KINESIS_DATA_STREAM = "Records[*].kinesis.powertools_json(powertools_base64(data))"
 CLOUDWATCH_LOGS = "awslogs.powertools_base64_gzip(data) | powertools_json(@).logEvents[*]"
+S3_SNS_SQS = "Records[*].powertools_json(body).powertools_json(Message).Records[0]"
+S3_SQS = "Records[*].powertools_json(body).Records[0]"
+S3_SNS_KINESIS_FIREHOSE = "records[*].powertools_json(powertools_base64(data)).powertools_json(Message).Records[0]"
+S3_KINESIS_FIREHOSE = "records[*].powertools_json(powertools_base64(data)).Records[0]"
+S3_EVENTBRIDGE_SQS = "Records[*].powertools_json(body).detail"

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/parser/models/__init__.py

@@ -50,6 +50,10 @@ from .s3 import (
     S3Model,
     S3RecordModel,
 )
+from .s3_event_notification import (
+    S3SqsEventNotificationModel,
+    S3SqsEventNotificationRecordModel,
+)
 from .s3_object_event import (
     S3ObjectConfiguration,
     S3ObjectContext,
@@ -130,6 +134,8 @@ __all__ = [
     "SqsRecordModel",
     "SqsMsgAttributeModel",
     "SqsAttributesModel",
+    "S3SqsEventNotificationModel",
+    "S3SqsEventNotificationRecordModel",
     "APIGatewayProxyEventModel",
     "APIGatewayEventRequestContext",
     "APIGatewayEventAuthorizer",

aws_lambda_powertools-2.15.0/aws_lambda_powertools/utilities/parser/models/s3_event_notification.py

@@ -0,0 +1,14 @@
+from typing import List
+
+from pydantic import Json
+
+from aws_lambda_powertools.utilities.parser.models.s3 import S3Model
+from aws_lambda_powertools.utilities.parser.models.sqs import SqsModel, SqsRecordModel
+
+
+class S3SqsEventNotificationRecordModel(SqsRecordModel):
+    body: Json[S3Model]
+
+
+class S3SqsEventNotificationModel(SqsModel):
+    Records: List[S3SqsEventNotificationRecordModel]

{aws_lambda_powertools-2.14.0 → aws_lambda_powertools-2.15.0}/aws_lambda_powertools/utilities/parser/models/sqs.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Dict, List, Optional, Type, Union
+from typing import Dict, List, Optional, Sequence, Type, Union
 
 from pydantic import BaseModel
 
@@ -63,4 +63,4 @@ class SqsRecordModel(BaseModel):
 
 
 class SqsModel(BaseModel):
-    Records: List[SqsRecordModel]
+    Records: Sequence[SqsRecordModel]