aws-lambda-powertools 3.0.1.dev2__py3-none-any.whl → 3.0.2.dev1__py3-none-any.whl

aws_lambda_powertools/event_handler/openapi/encoders.py

@@ -19,6 +19,8 @@ from aws_lambda_powertools.event_handler.openapi.compat import _model_dump
 if TYPE_CHECKING:
     from aws_lambda_powertools.event_handler.openapi.types import IncEx
 
+from aws_lambda_powertools.event_handler.openapi.exceptions import SerializationError
+
 """
 This module contains the encoders used by jsonable_encoder to convert Python objects to JSON serializable data types.
 """
@@ -72,88 +74,98 @@ def jsonable_encoder(  # noqa: PLR0911
     if exclude is not None and not isinstance(exclude, (set, dict)):
         exclude = set(exclude)
 
-    # Pydantic models
-    if isinstance(obj, BaseModel):
-        return _dump_base_model(
-            obj=obj,
-            include=include,
-            exclude=exclude,
-            by_alias=by_alias,
-            exclude_unset=exclude_unset,
-            exclude_none=exclude_none,
-            exclude_defaults=exclude_defaults,
-        )
+    try:
+        # Pydantic models
+        if isinstance(obj, BaseModel):
+            return _dump_base_model(
+                obj=obj,
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_none=exclude_none,
+                exclude_defaults=exclude_defaults,
+            )
 
-    # Dataclasses
-    if dataclasses.is_dataclass(obj):
-        obj_dict = dataclasses.asdict(obj)
-        return jsonable_encoder(
-            obj_dict,
-            include=include,
-            exclude=exclude,
-            by_alias=by_alias,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
-            exclude_none=exclude_none,
-        )
+        # Dataclasses
+        if dataclasses.is_dataclass(obj):
+            obj_dict = dataclasses.asdict(obj)  # type: ignore[call-overload]
+            return jsonable_encoder(
+                obj_dict,
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+                custom_serializer=custom_serializer,
+            )
 
-    # Enums
-    if isinstance(obj, Enum):
-        return obj.value
+        # Enums
+        if isinstance(obj, Enum):
+            return obj.value
 
-    # Paths
-    if isinstance(obj, PurePath):
-        return str(obj)
+        # Paths
+        if isinstance(obj, PurePath):
+            return str(obj)
 
-    # Scalars
-    if isinstance(obj, (str, int, float, type(None))):
-        return obj
+        # Scalars
+        if isinstance(obj, (str, int, float, type(None))):
+            return obj
 
-    # Dictionaries
-    if isinstance(obj, dict):
-        return _dump_dict(
-            obj=obj,
-            include=include,
-            exclude=exclude,
-            by_alias=by_alias,
-            exclude_none=exclude_none,
-            exclude_unset=exclude_unset,
-        )
+        # Dictionaries
+        if isinstance(obj, dict):
+            return _dump_dict(
+                obj=obj,
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_none=exclude_none,
+                custom_serializer=custom_serializer,
+            )
 
-    # Sequences
-    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple, deque)):
-        return _dump_sequence(
+        # Sequences
+        if isinstance(obj, (list, set, frozenset, GeneratorType, tuple, deque)):
+            return _dump_sequence(
+                obj=obj,
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                exclude_none=exclude_none,
+                exclude_defaults=exclude_defaults,
+                exclude_unset=exclude_unset,
+                custom_serializer=custom_serializer,
+            )
+
+        # Other types
+        if type(obj) in ENCODERS_BY_TYPE:
+            return ENCODERS_BY_TYPE[type(obj)](obj)
+
+        for encoder, classes_tuple in encoders_by_class_tuples.items():
+            if isinstance(obj, classes_tuple):
+                return encoder(obj)
+
+        # Use custom serializer if present
+        if custom_serializer:
+            return custom_serializer(obj)
+
+        # Default
+        return _dump_other(
             obj=obj,
             include=include,
             exclude=exclude,
             by_alias=by_alias,
             exclude_none=exclude_none,
-            exclude_defaults=exclude_defaults,
             exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            custom_serializer=custom_serializer,
         )
-
-    # Other types
-    if type(obj) in ENCODERS_BY_TYPE:
-        return ENCODERS_BY_TYPE[type(obj)](obj)
-
-    for encoder, classes_tuple in encoders_by_class_tuples.items():
-        if isinstance(obj, classes_tuple):
-            return encoder(obj)
-
-    # Use custom serializer if present
-    if custom_serializer:
-        return custom_serializer(obj)
-
-    # Default
-    return _dump_other(
-        obj=obj,
-        include=include,
-        exclude=exclude,
-        by_alias=by_alias,
-        exclude_none=exclude_none,
-        exclude_unset=exclude_unset,
-        exclude_defaults=exclude_defaults,
-    )
+    except ValueError as exc:
+        raise SerializationError(
+            f"Unable to serialize the object {obj} as it is not a supported type. Error details: {exc}",
+            "See: https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/#serializing-objects",
+        ) from exc
 
 
 def _dump_base_model(
@@ -197,9 +209,15 @@ def _dump_dict(
     by_alias: bool = True,
     exclude_unset: bool = False,
     exclude_none: bool = False,
+    custom_serializer: Callable[[Any], str] | None = None,
 ) -> dict[str, Any]:
     """
     Dump a dict to a dict, using the same parameters as jsonable_encoder
+
+    Parameters
+    ----------
+    custom_serializer : Callable, optional
+        A custom serializer to use for encoding the object, when everything else fails.
     """
     encoded_dict = {}
     allowed_keys = set(obj.keys())
@@ -218,12 +236,14 @@ def _dump_dict(
                 by_alias=by_alias,
                 exclude_unset=exclude_unset,
                 exclude_none=exclude_none,
+                custom_serializer=custom_serializer,
             )
             encoded_value = jsonable_encoder(
                 value,
                 by_alias=by_alias,
                 exclude_unset=exclude_unset,
                 exclude_none=exclude_none,
+                custom_serializer=custom_serializer,
             )
             encoded_dict[encoded_key] = encoded_value
     return encoded_dict
@@ -238,9 +258,10 @@ def _dump_sequence(
     exclude_unset: bool = False,
     exclude_none: bool = False,
     exclude_defaults: bool = False,
+    custom_serializer: Callable[[Any], str] | None = None,
 ) -> list[Any]:
     """
-    Dump a sequence to a list, using the same parameters as jsonable_encoder
+    Dump a sequence to a list, using the same parameters as jsonable_encoder.
     """
     encoded_list = []
     for item in obj:
@@ -253,6 +274,7 @@ def _dump_sequence(
                 exclude_unset=exclude_unset,
                 exclude_defaults=exclude_defaults,
                 exclude_none=exclude_none,
+                custom_serializer=custom_serializer,
             ),
         )
     return encoded_list
@@ -267,6 +289,7 @@ def _dump_other(
     exclude_unset: bool = False,
     exclude_none: bool = False,
     exclude_defaults: bool = False,
+    custom_serializer: Callable[[Any], str] | None = None,
 ) -> Any:
     """
     Dump an object to a hashable object, using the same parameters as jsonable_encoder
@@ -288,6 +311,7 @@ def _dump_other(
         exclude_unset=exclude_unset,
         exclude_defaults=exclude_defaults,
         exclude_none=exclude_none,
+        custom_serializer=custom_serializer,
     )
 
 

aws_lambda_powertools/event_handler/openapi/exceptions.py

@@ -21,3 +21,15 @@ class RequestValidationError(ValidationException):
     def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:
         super().__init__(errors)
         self.body = body
+
+
+class SerializationError(Exception):
+    """
+    Base exception for all encoding errors
+    """
+
+
+class SchemaValidationError(ValidationException):
+    """
+    Raised when the OpenAPI schema validation fails
+    """

aws_lambda_powertools/event_handler/openapi/models.py

@@ -2,10 +2,11 @@
 from enum import Enum
 from typing import Any, Dict, List, Literal, Optional, Set, Union
 
-from pydantic import AnyUrl, BaseModel, ConfigDict, Field
+from pydantic import AnyUrl, BaseModel, ConfigDict, Field, model_validator
 from typing_extensions import Annotated
 
 from aws_lambda_powertools.event_handler.openapi.compat import model_rebuild
+from aws_lambda_powertools.event_handler.openapi.exceptions import SchemaValidationError
 
 MODEL_CONFIG_ALLOW = ConfigDict(extra="allow")
 MODEL_CONFIG_IGNORE = ConfigDict(extra="ignore")
@@ -16,6 +17,38 @@ These models can be used to parse OpenAPI JSON/YAML files into Python objects, o
 """
 
 
+class OpenAPIExtensions(BaseModel):
+    """
+    This class serves as a Pydantic proxy model to add OpenAPI extensions.
+
+    OpenAPI extensions are arbitrary fields, so we remove openapi_extensions when dumping
+    and add only the provided value in the schema.
+    """
+
+    openapi_extensions: Optional[Dict[str, Any]] = None
+
+    # If the 'openapi_extensions' field is present in the 'values' dictionary,
+    # And if the extension starts with x- (must respect the RFC)
+    # update the 'values' dictionary with the contents of 'openapi_extensions',
+    # and then remove the 'openapi_extensions' field from the 'values' dictionary
+    model_config = {"extra": "allow"}
+
+    @model_validator(mode="before")
+    def serialize_openapi_extension_v2(self):
+        if isinstance(self, dict) and self.get("openapi_extensions"):
+
+            openapi_extension_value = self.get("openapi_extensions")
+
+            for extension_key in openapi_extension_value:
+                if not str(extension_key).startswith("x-"):
+                    raise SchemaValidationError("An OpenAPI extension key must start with x-")
+
+            self.update(openapi_extension_value)
+            self.pop("openapi_extensions", None)
+
+        return self
+
+
 # https://swagger.io/specification/#contact-object
 class Contact(BaseModel):
     name: Optional[str] = None
@@ -57,7 +90,7 @@ class ServerVariable(BaseModel):
 
 
 # https://swagger.io/specification/#server-object
-class Server(BaseModel):
+class Server(OpenAPIExtensions):
     url: Union[AnyUrl, str]
     description: Optional[str] = None
     variables: Optional[Dict[str, ServerVariable]] = None
@@ -287,7 +320,7 @@ class Tag(BaseModel):
 
 
 # https://swagger.io/specification/#operation-object
-class Operation(BaseModel):
+class Operation(OpenAPIExtensions):
     tags: Optional[List[str]] = None
     summary: Optional[str] = None
     description: Optional[str] = None
@@ -332,7 +365,7 @@ class SecuritySchemeType(Enum):
     openIdConnect = "openIdConnect"
 
 
-class SecurityBase(BaseModel):
+class SecurityBase(OpenAPIExtensions):
     type_: SecuritySchemeType = Field(alias="type")
     description: Optional[str] = None
 
@@ -428,7 +461,7 @@ class Components(BaseModel):
 
 
 # https://swagger.io/specification/#openapi-object
-class OpenAPI(BaseModel):
+class OpenAPI(OpenAPIExtensions):
     openapi: str
     info: Info
     jsonSchemaDialect: Optional[str] = None

aws_lambda_powertools/event_handler/openapi/swagger_ui/html.py

@@ -8,7 +8,6 @@ if TYPE_CHECKING:
 
 def generate_swagger_html(
     spec: str,
-    path: str,
     swagger_js: str,
     swagger_css: str,
     swagger_base_url: str,
@@ -22,8 +21,6 @@ def generate_swagger_html(
     ----------
     spec: str
         The OpenAPI spec
-    path: str
-        The path to the Swagger documentation
     swagger_js: str
        Swagger UI JavaScript source code or URL
     swagger_css: str
@@ -97,7 +94,7 @@ def generate_swagger_html(
   }}
 
   var ui = SwaggerUIBundle(swaggerUIOptions)
-  ui.specActions.updateUrl('{path}?format=json');
+  ui.specActions.updateUrl(currentUrl.pathname + "?format=json");
   {oauth2_content}
 </script>
 </html>

aws_lambda_powertools/event_handler/util.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Mapping
+from typing import Any, Dict, List, Mapping
 
 
 class _FrozenDict(dict):
@@ -18,7 +18,31 @@ class _FrozenDict(dict):
         return hash(frozenset(self.keys()))
 
 
-def extract_origin_header(resolved_headers: Mapping[str, Any]) -> str | None:
+class _FrozenListDict(List[Dict[str, List[str]]]):
+    """
+    Freezes a list of dictionaries containing lists of strings.
+
+    This function takes a list of dictionaries where the values are lists of strings and converts it into
+    a frozen set of frozen sets of frozen dictionaries. This is done by iterating over the input list,
+    converting each dictionary's values (lists of strings) into frozen sets of strings, and then
+    converting the resulting dictionary into a frozen dictionary. Finally, all these frozen dictionaries
+    are collected into a frozen set of frozen sets.
+
+    This operation is useful when you want to ensure the immutability of the data structure and make it
+    hashable, which is required for certain operations like using it as a key in a dictionary or as an
+    element in a set.
+
+    Example: [{"TestAuth": ["test", "test1"]}]
+    """
+
+    def __hash__(self):
+        hashable_items = []
+        for item in self:
+            hashable_items.extend((key, frozenset(value)) for key, value in item.items())
+        return hash(frozenset(hashable_items))
+
+
+def extract_origin_header(resolved_headers: Mapping[str, Any]):
     """
     Extracts the 'origin' or 'Origin' header from the provided resolver headers.
 
@@ -34,3 +58,32 @@ def extract_origin_header(resolved_headers: Mapping[str, Any]) -> str | None:
     if isinstance(resolved_header, list):
         return resolved_header[0]
     return resolved_header
+
+
+def _validate_openapi_security_parameters(
+    security: list[dict[str, list[str]]],
+    security_schemes: dict[str, Any] | None = None,
+) -> bool:
+    """
+    This function checks if all security requirements listed in the 'security'
+    parameter are defined in the 'security_schemes' dictionary, as specified
+    in the OpenAPI schema.
+
+    Parameters
+    ----------
+    security: List[Dict[str, List[str]]]
+        A list of security requirements
+    security_schemes: Optional[Dict[str, Any]]
+        A dictionary mapping security scheme names to their corresponding security scheme objects.
+
+    Returns
+    -------
+    bool
+        Whether list of security schemes match allowed security_schemes.
+    """
+
+    security_schemes = security_schemes or {}
+
+    security_schema_match = all(key in security_schemes for sec in security for key in sec)
+
+    return bool(security_schema_match and security_schemes)

aws_lambda_powertools/logging/utils.py

@@ -7,6 +7,7 @@ if TYPE_CHECKING:
     from aws_lambda_powertools.logging.logger import Logger
 
 PACKAGE_LOGGER = "aws_lambda_powertools"
+LOGGER = logging.getLogger(__name__)
 
 
 def copy_config_to_registered_loggers(
@@ -59,7 +60,7 @@ def copy_config_to_registered_loggers(
         loggers = exclude
         filter_func = _exclude_registered_loggers_filter
 
-    registered_loggers = _find_registered_loggers(source_logger, loggers, filter_func)
+    registered_loggers = _find_registered_loggers(loggers=loggers, filter_func=filter_func)
     for logger in registered_loggers:
         _configure_logger(source_logger=source_logger, logger=logger, level=level, ignore_log_level=ignore_log_level)
 
@@ -75,13 +76,12 @@ def _exclude_registered_loggers_filter(loggers: set[str]) -> list[logging.Logger
 
 
 def _find_registered_loggers(
-    source_logger: Logger,
     loggers: set[str],
     filter_func: Callable[[set[str]], list[logging.Logger]],
 ) -> list[logging.Logger]:
     """Filter root loggers based on provided parameters."""
     root_loggers = filter_func(loggers)
-    source_logger.debug(f"Filtered root loggers: {root_loggers}")
+    LOGGER.debug(f"Filtered root loggers: {root_loggers}")
     return root_loggers
 
 
@@ -94,7 +94,7 @@ def _configure_logger(
     # customers may not want to copy the same log level from Logger to discovered loggers
     if not ignore_log_level:
         logger.setLevel(level)
-        source_logger.debug(f"Logger {logger} reconfigured to use logging level {level}")
+        LOGGER.debug(f"Logger {logger} reconfigured to use logging level {level}")
 
     logger.handlers = []
     logger.propagate = False  # ensure we don't propagate logs to existing loggers, #1073
@@ -102,4 +102,4 @@ def _configure_logger(
 
     for source_handler in source_logger.handlers:
         logger.addHandler(source_handler)
-        source_logger.debug(f"Logger {logger} reconfigured to use {source_handler}")
+        LOGGER.debug(f"Logger {logger} reconfigured to use {source_handler}")

aws_lambda_powertools/metrics/provider/cloudwatch_emf/metric_properties.py

@@ -30,6 +30,7 @@ class MetricUnit(Enum):
     GigabitsPerSecond = "Gigabits/Second"
     TerabitsPerSecond = "Terabits/Second"
     CountPerSecond = "Count/Second"
+    NoUnit = "None"
 
 
 class MetricResolution(Enum):

aws_lambda_powertools/shared/cookies.py

@@ -101,10 +101,10 @@ class Cookie:
 
         if self.max_age:
             if self.max_age > 0:
-                payload.write(f"; MaxAge={self.max_age}")
+                payload.write(f"; Max-Age={self.max_age}")
             else:
                 # negative or zero max-age should be set to 0
-                payload.write("; MaxAge=0")
+                payload.write("; Max-Age=0")
 
         if self.http_only:
             payload.write("; HttpOnly")

aws_lambda_powertools/shared/dynamodb_deserializer.py

@@ -72,6 +72,19 @@ class TypeDeserializer:
         return value
 
     def _deserialize_n(self, value: str) -> Decimal:
+        # value is None or "."? It's zero
+        # then return early
+        value = value.lstrip("0")
+        if not value or value == ".":
+            return DYNAMODB_CONTEXT.create_decimal(0)
+
+        if len(value) > 38:
+            # See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.Number
+            # Calculate the number of trailing zeros after the 38th character
+            tail = len(value[38:]) - len(value[38:].rstrip("0"))
+            # Trim the value: remove trailing zeros if any, or just take the first 38 characters
+            value = value[:-tail] if tail > 0 else value[:38]
+
         return DYNAMODB_CONTEXT.create_decimal(value)
 
     def _deserialize_s(self, value: str) -> str:

aws_lambda_powertools/shared/version.py

@@ -1,3 +1,3 @@
 """Exposes version constant to avoid circular dependencies."""
 
-VERSION = "3.0.1.dev2"
+VERSION = "3.0.2.dev1"

aws_lambda_powertools/tracing/tracer.py

@@ -6,7 +6,7 @@ import functools
 import inspect
 import logging
 import os
-from typing import TYPE_CHECKING, Any, Callable, Sequence, cast, overload
+from typing import TYPE_CHECKING, Any, Callable, Sequence, TypeVar, cast, overload
 
 from aws_lambda_powertools.shared import constants
 from aws_lambda_powertools.shared.functions import (
@@ -27,6 +27,8 @@ logger = logging.getLogger(__name__)
 
 aws_xray_sdk = LazyLoader(constants.XRAY_SDK_MODULE, globals(), constants.XRAY_SDK_MODULE)
 
+T = TypeVar("T")
+
 
 class Tracer:
     """Tracer using AWS-XRay to provide decorators with known defaults for Lambda functions
@@ -255,7 +257,7 @@ class Tracer:
 
     def capture_lambda_handler(
         self,
-        lambda_handler: Callable[[dict, Any], Any] | Callable[[dict, Any, dict | None], Any] | None = None,
+        lambda_handler: Callable[[T, Any], Any] | Callable[[T, Any, Any], Any] | None = None,
         capture_response: bool | None = None,
         capture_error: bool | None = None,
     ):

aws_lambda_powertools/utilities/batch/base.py

@@ -229,7 +229,12 @@ class BasePartialProcessor(ABC):
 class BasePartialBatchProcessor(BasePartialProcessor):  # noqa
     DEFAULT_RESPONSE: PartialItemFailureResponse = {"batchItemFailures": []}
 
-    def __init__(self, event_type: EventType, model: BatchTypeModels | None = None):
+    def __init__(
+        self,
+        event_type: EventType,
+        model: BatchTypeModels | None = None,
+        raise_on_entire_batch_failure: bool = True,
+    ):
         """Process batch and partially report failed items
 
         Parameters
@@ -238,6 +243,9 @@ class BasePartialBatchProcessor(BasePartialProcessor):  # noqa
             Whether this is a SQS, DynamoDB Streams, or Kinesis Data Stream event
         model: BatchTypeModels | None
             Parser's data model using either SqsRecordModel, DynamoDBStreamRecordModel, KinesisDataStreamRecord
+        raise_on_entire_batch_failure: bool
+            Raise an exception when the entire batch has failed processing.
+            When set to False, partial failures are reported in the response
 
         Exceptions
         ----------
@@ -246,6 +254,7 @@ class BasePartialBatchProcessor(BasePartialProcessor):  # noqa
         """
         self.event_type = event_type
         self.model = model
+        self.raise_on_entire_batch_failure = raise_on_entire_batch_failure
         self.batch_response: PartialItemFailureResponse = copy.deepcopy(self.DEFAULT_RESPONSE)
         self._COLLECTOR_MAPPING = {
             EventType.SQS: self._collect_sqs_failures,
@@ -281,7 +290,7 @@ class BasePartialBatchProcessor(BasePartialProcessor):  # noqa
         if not self._has_messages_to_report():
             return
 
-        if self._entire_batch_failed():
+        if self._entire_batch_failed() and self.raise_on_entire_batch_failure:
             raise BatchProcessingError(
                 msg=f"All records failed processing. {len(self.exceptions)} individual errors logged "
                 f"separately below.",
@@ -478,7 +487,7 @@ class BatchProcessor(BasePartialBatchProcessor):  # Keep old name for compatibil
     Raises
     ------
     BatchProcessingError
-        When all batch records fail processing
+        When all batch records fail processing and raise_on_entire_batch_failure is True
 
     Limitations
     -----------
@@ -627,7 +636,7 @@ class AsyncBatchProcessor(BasePartialBatchProcessor):
     Raises
     ------
     BatchProcessingError
-        When all batch records fail processing
+        When all batch records fail processing and raise_on_entire_batch_failure is True
 
     Limitations
     -----------