aws-lambda-powertools 2.38.1__tar.gz → 2.39.0__tar.gz

{aws_lambda_powertools-2.38.1 → aws_lambda_powertools-2.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-lambda-powertools
-Version: 2.38.1
+Version: 2.39.0
 Summary: Powertools for AWS Lambda (Python) is a developer toolkit to implement Serverless best practices and increase developer velocity.
 Home-page: https://github.com/aws-powertools/powertools-lambda-python
 License: MIT
@@ -29,8 +29,9 @@ Provides-Extra: validation
 Requires-Dist: aws-encryption-sdk (>=3.1.1,<4.0.0) ; extra == "datamasking"
 Requires-Dist: aws-xray-sdk (>=2.8.0,<3.0.0) ; extra == "tracer" or extra == "all"
 Requires-Dist: boto3 (>=1.26.164,<2.0.0) ; extra == "aws-sdk"
-Requires-Dist: datadog-lambda (>=4.77,<6.0) ; extra == "datadog"
+Requires-Dist: datadog-lambda (>=4.77,<7.0) ; extra == "datadog"
 Requires-Dist: fastjsonschema (>=2.14.5,<3.0.0) ; extra == "validation" or extra == "all"
+Requires-Dist: jmespath (>=1.0.1,<2.0.0)
 Requires-Dist: jsonpath-ng (>=1.6.0,<2.0.0) ; extra == "datamasking"
 Requires-Dist: pydantic (>=1.8.2,<2.0.0) ; extra == "parser" or extra == "all"
 Requires-Dist: redis (>=4.4,<6.0) ; extra == "redis"
@@ -104,6 +105,7 @@ The following companies, among others, use Powertools:
 * [IMS](https://ims.tech/)
 * [Jit Security](https://www.jit.io/)
 * [Propellor.ai](https://www.propellor.ai/)
+* [Recast](https://getrecast.com/)
 * [TopSport](https://www.topsport.com.au/)
 * [Transformity](https://transformity.tech/)
 * [Trek10](https://www.trek10.com/)

{aws_lambda_powertools-2.38.1 → aws_lambda_powertools-2.39.0}/README.md

@@ -61,6 +61,7 @@ The following companies, among others, use Powertools:
 * [IMS](https://ims.tech/)
 * [Jit Security](https://www.jit.io/)
 * [Propellor.ai](https://www.propellor.ai/)
+* [Recast](https://getrecast.com/)
 * [TopSport](https://www.topsport.com.au/)
 * [Transformity](https://transformity.tech/)
 * [Trek10](https://www.trek10.com/)

{aws_lambda_powertools-2.38.1 → aws_lambda_powertools-2.39.0}/aws_lambda_powertools/event_handler/api_gateway.py

@@ -33,7 +33,7 @@ from typing import (
 from aws_lambda_powertools.event_handler import content_types
 from aws_lambda_powertools.event_handler.exceptions import NotFoundError, ServiceError
 from aws_lambda_powertools.event_handler.openapi.constants import DEFAULT_API_VERSION, DEFAULT_OPENAPI_VERSION
-from aws_lambda_powertools.event_handler.openapi.exceptions import RequestValidationError
+from aws_lambda_powertools.event_handler.openapi.exceptions import RequestValidationError, SchemaValidationError
 from aws_lambda_powertools.event_handler.openapi.types import (
     COMPONENT_REF_PREFIX,
     METHODS_WITH_BODY,
@@ -43,7 +43,12 @@ from aws_lambda_powertools.event_handler.openapi.types import (
     validation_error_definition,
     validation_error_response_definition,
 )
-from aws_lambda_powertools.event_handler.util import _FrozenDict
+from aws_lambda_powertools.event_handler.util import (
+    _FrozenDict,
+    _FrozenListDict,
+    _validate_openapi_security_parameters,
+    extract_origin_header,
+)
 from aws_lambda_powertools.shared.cookies import Cookie
 from aws_lambda_powertools.shared.functions import powertools_dev_is_set
 from aws_lambda_powertools.shared.json_encoder import Encoder
@@ -206,7 +211,7 @@ class CORSConfig:
         # The origin matched an allowed origin, so return the CORS headers
         headers = {
             "Access-Control-Allow-Origin": origin,
-            "Access-Control-Allow-Headers": ",".join(sorted(self.allow_headers)),
+            "Access-Control-Allow-Headers": CORSConfig.build_allow_methods(self.allow_headers),
         }
 
         if self.expose_headers:
@@ -217,6 +222,23 @@ class CORSConfig:
             headers["Access-Control-Allow-Credentials"] = "true"
         return headers
 
+    @staticmethod
+    def build_allow_methods(methods: Set[str]) -> str:
+        """Build sorted comma delimited methods for Access-Control-Allow-Methods header
+
+        Parameters
+        ----------
+        methods : set[str]
+            Set of HTTP Methods
+
+        Returns
+        -------
+        set[str]
+            Formatted string with all HTTP Methods allowed for CORS e.g., `GET, OPTIONS`
+
+        """
+        return ",".join(sorted(methods))
+
 
 class Response(Generic[ResponseT]):
     """Response data class that provides greater control over what is returned from the proxy event"""
@@ -277,16 +299,16 @@ class Route:
         func: Callable,
         cors: bool,
         compress: bool,
-        cache_control: Optional[str],
-        summary: Optional[str],
-        description: Optional[str],
-        responses: Optional[Dict[int, OpenAPIResponse]],
-        response_description: Optional[str],
-        tags: Optional[List[str]],
-        operation_id: Optional[str],
-        include_in_schema: bool,
-        security: Optional[List[Dict[str, List[str]]]],
-        middlewares: Optional[List[Callable[..., Response]]],
+        cache_control: Optional[str] = None,
+        summary: Optional[str] = None,
+        description: Optional[str] = None,
+        responses: Optional[Dict[int, OpenAPIResponse]] = None,
+        response_description: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        operation_id: Optional[str] = None,
+        include_in_schema: bool = True,
+        security: Optional[List[Dict[str, List[str]]]] = None,
+        middlewares: Optional[List[Callable[..., Response]]] = None,
     ):
         """
 
@@ -703,6 +725,7 @@ class Route:
         from aws_lambda_powertools.event_handler.openapi.params import Param
 
         parameters = []
+        parameter: Dict[str, Any]
         for param in all_route_params:
             field_info = param.field_info
             field_info = cast(Param, field_info)
@@ -782,7 +805,8 @@ class ResponseBuilder(Generic[ResponseEventT]):
 
     def _add_cors(self, event: ResponseEventT, cors: CORSConfig):
         """Update headers to include the configured Access-Control headers"""
-        self.response.headers.update(cors.to_dict(event.get_header_value("Origin")))
+        extracted_origin_header = extract_origin_header(event.resolved_headers_field)
+        self.response.headers.update(cors.to_dict(extracted_origin_header))
 
     def _add_cache_control(self, cache_control: str):
         """Set the specified cache control headers for 200 http responses. For non-200 `no-cache` is used."""
@@ -1399,7 +1423,6 @@ def _registered_api_adapter(
     """
     route_args: Dict = app.context.get("_route_args", {})
     logger.debug(f"Calling API Route Handler: {route_args}")
-
     return app._to_response(next_middleware(**route_args))
 
 
@@ -1587,6 +1610,16 @@ class ApiGatewayResolver(BaseRouter):
 
         # Add routes to the OpenAPI schema
         for route in all_routes:
+
+            if route.security and not _validate_openapi_security_parameters(
+                security=route.security,
+                security_schemes=security_schemes,
+            ):
+                raise SchemaValidationError(
+                    "Security configuration was not found in security_schemas or security_schema was not defined. "
+                    "See: https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/#security-schemes",
+                )
+
             if not route.include_in_schema:
                 continue
 
@@ -1629,15 +1662,15 @@ class ApiGatewayResolver(BaseRouter):
         security: Optional[List[Dict[str, List[str]]]],
         security_schemes: Optional[Dict[str, "SecurityScheme"]],
     ) -> Optional[List[Dict[str, List[str]]]]:
+
         if not security:
             return None
 
-        if not security_schemes:
-            raise ValueError("security_schemes must be provided if security is provided")
-
-        # Check if all keys in security are present in the security_schemes
-        if any(key not in security_schemes for sec in security for key in sec):
-            raise ValueError("Some security schemes not found in security_schemes")
+        if not _validate_openapi_security_parameters(security=security, security_schemes=security_schemes):
+            raise SchemaValidationError(
+                "Security configuration was not found in security_schemas or security_schema was not defined. "
+                "See: https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/#security-schemes",
+            )
 
         return security
 
@@ -1950,6 +1983,36 @@ class ApiGatewayResolver(BaseRouter):
     def resolve(self, event, context) -> Dict[str, Any]:
         """Resolves the response based on the provide event and decorator routes
 
+        ## Internals
+
+        Request processing chain is triggered by a Route object being called _(`_call_route` -> `__call__`)_:
+
+        1. **When a route is matched**
+          1.1. Exception handlers _(if any exception bubbled up and caught)_
+          1.2. Global middlewares _(before, and after on the way back)_
+          1.3. Path level middleware _(before, and after on the way back)_
+          1.4. Middleware adapter to ensure Response is homogenous (_registered_api_adapter)
+          1.5. Run actual route
+        2. **When a route is NOT matched**
+          2.1. Exception handlers _(if any exception bubbled up and caught)_
+          2.2. Global middlewares _(before, and after on the way back)_
+          2.3. Path level middleware _(before, and after on the way back)_
+          2.4. Middleware adapter to ensure Response is homogenous (_registered_api_adapter)
+          2.5. Run 404 route handler
+        3. **When a route is a pre-flight CORS (often not matched)**
+          3.1. Exception handlers _(if any exception bubbled up and caught)_
+          3.2. Global middlewares _(before, and after on the way back)_
+          3.3. Path level middleware _(before, and after on the way back)_
+          3.4. Middleware adapter to ensure Response is homogenous (_registered_api_adapter)
+          3.5. Return 204 with appropriate CORS headers
+        4. **When a route is matched with Data Validation enabled**
+          4.1. Exception handlers _(if any exception bubbled up and caught)_
+          4.2. Data Validation middleware _(before, and after on the way back)_
+          4.3. Global middlewares _(before, and after on the way back)_
+          4.4. Path level middleware _(before, and after on the way back)_
+          4.5. Middleware adapter to ensure Response is homogenous (_registered_api_adapter)
+          4.6. Run actual route
+
         Parameters
         ----------
         event: Dict[str, Any]
@@ -2073,7 +2136,9 @@ class ApiGatewayResolver(BaseRouter):
         method = self.current_event.http_method.upper()
         path = self._remove_prefix(self.current_event.path)
 
-        for route in self._static_routes + self._dynamic_routes:
+        registered_routes = self._static_routes + self._dynamic_routes
+
+        for route in registered_routes:
             if method != route.method:
                 continue
             match_results: Optional[Match] = route.rule.match(path)
@@ -2085,8 +2150,7 @@ class ApiGatewayResolver(BaseRouter):
                 route_keys = self._convert_matches_into_route_keys(match_results)
                 return self._call_route(route, route_keys)  # pass fn args
 
-        logger.debug(f"No match found for path {path} and method {method}")
-        return self._not_found(method)
+        return self._handle_not_found(method=method, path=path)
 
     def _remove_prefix(self, path: str) -> str:
         """Remove the configured prefix from the path"""
@@ -2124,35 +2188,65 @@ class ApiGatewayResolver(BaseRouter):
 
         return path.startswith(prefix + "/")
 
-    def _not_found(self, method: str) -> ResponseBuilder:
+    def _handle_not_found(self, method: str, path: str) -> ResponseBuilder:
         """Called when no matching route was found and includes support for the cors preflight response"""
-        headers = {}
-        if self._cors:
-            logger.debug("CORS is enabled, updating headers.")
-            headers.update(self._cors.to_dict(self.current_event.get_header_value("Origin")))
-
-            if method == "OPTIONS":
-                logger.debug("Pre-flight request detected. Returning CORS with null response")
-                headers["Access-Control-Allow-Methods"] = ",".join(sorted(self._cors_methods))
-                return ResponseBuilder(
-                    response=Response(status_code=204, content_type=None, headers=headers, body=""),
-                    serializer=self._serializer,
-                )
+        logger.debug(f"No match found for path {path} and method {method}")
 
-        handler = self._lookup_exception_handler(NotFoundError)
-        if handler:
-            return self._response_builder_class(response=handler(NotFoundError()), serializer=self._serializer)
+        def not_found_handler():
+            """Route handler for 404s
 
-        return self._response_builder_class(
-            response=Response(
+            It handles in the following order:
+
+            1. Pre-flight CORS requests (OPTIONS)
+            2. Detects and calls custom HTTP 404 handler
+            3. Returns standard 404 along with CORS headers
+
+            Returns
+            -------
+            Response
+                HTTP 404 response
+            """
+            _headers: Dict[str, Any] = {}
+
+            # Pre-flight request? Return immediately to avoid browser error
+            if self._cors and method == "OPTIONS":
+                logger.debug("Pre-flight request detected. Returning CORS with empty response")
+                _headers["Access-Control-Allow-Methods"] = CORSConfig.build_allow_methods(self._cors_methods)
+
+                return Response(status_code=204, content_type=None, headers=_headers, body="")
+
+            # Customer registered 404 route? Call it.
+            custom_not_found_handler = self._lookup_exception_handler(NotFoundError)
+            if custom_not_found_handler:
+                return custom_not_found_handler(NotFoundError())
+
+            # No CORS and no custom 404 fn? Default response
+            return Response(
                 status_code=HTTPStatus.NOT_FOUND.value,
                 content_type=content_types.APPLICATION_JSON,
-                headers=headers,
+                headers=_headers,
                 body={"statusCode": HTTPStatus.NOT_FOUND.value, "message": "Not found"},
-            ),
-            serializer=self._serializer,
+            )
+
+        # We create a route to trigger entire request chain (middleware+exception handlers)
+        route = Route(
+            rule=self._compile_regex(r".*"),
+            method=method,
+            path=path,
+            func=not_found_handler,
+            cors=self._cors_enabled,
+            compress=False,
         )
 
+        # Add matched Route reference into the Resolver context
+        self.append_context(_route=route, _path=path)
+
+        # Kick-off request chain:
+        # -> exception_handlers()
+        # --> middlewares()
+        # ---> not_found_route()
+        return self._call_route(route=route, route_arguments={})
+
     def _call_route(self, route: Route, route_arguments: Dict[str, str]) -> ResponseBuilder:
         """Actually call the matching route with any provided keyword arguments."""
         try:
@@ -2384,6 +2478,7 @@ class Router(BaseRouter):
             methods = (method,) if isinstance(method, str) else tuple(method)
             frozen_responses = _FrozenDict(responses) if responses else None
             frozen_tags = frozenset(tags) if tags else None
+            frozen_security = _FrozenListDict(security) if security else None
 
             route_key = (
                 rule,
@@ -2398,7 +2493,7 @@ class Router(BaseRouter):
                 frozen_tags,
                 operation_id,
                 include_in_schema,
-                security,
+                frozen_security,
             )
 
             # Collate Middleware for routes

{aws_lambda_powertools-2.38.1 → aws_lambda_powertools-2.39.0}/aws_lambda_powertools/event_handler/openapi/encoders.py

@@ -14,6 +14,7 @@ from pydantic.color import Color
 from pydantic.types import SecretBytes, SecretStr
 
 from aws_lambda_powertools.event_handler.openapi.compat import _model_dump
+from aws_lambda_powertools.event_handler.openapi.exceptions import SerializationError
 from aws_lambda_powertools.event_handler.openapi.types import IncEx
 
 """
@@ -69,88 +70,94 @@ 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)
+            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,
+            )
 
-    # 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_none=exclude_none,
+                exclude_unset=exclude_unset,
+            )
+
+        # 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,
+            )
 
-    # Sequences
-    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple, deque)):
-        return _dump_sequence(
+        # 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,
         )
-
-    # 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(

{aws_lambda_powertools-2.38.1 → aws_lambda_powertools-2.39.0}/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-2.39.0/aws_lambda_powertools/event_handler/util.py

@@ -0,0 +1,100 @@
+from typing import Any, Dict, List, Optional
+
+from aws_lambda_powertools.event_handler.openapi.models import SecurityScheme
+from aws_lambda_powertools.utilities.data_classes.shared_functions import get_header_value
+
+
+class _FrozenDict(dict):
+    """
+    A dictionary that can be used as a key in another dictionary.
+
+    This is needed because the default dict implementation is not hashable.
+    The only usage for this right now is to store dicts as part of the Router key.
+    The implementation only takes into consideration the keys of the dictionary.
+
+    MAINTENANCE: this is a temporary solution until we refactor the route key into a class.
+    """
+
+    def __hash__(self):
+        return hash(frozenset(self.keys()))
+
+
+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(resolver_headers: Dict[str, Any]):
+    """
+    Extracts the 'origin' or 'Origin' header from the provided resolver headers.
+
+    The 'origin' or 'Origin' header can be either a single header or a multi-header.
+
+    Parameters
+    ----------
+    resolver_headers: Dict
+        A dictionary containing the headers.
+
+    Returns
+    -------
+    Optional[str]
+        The value(s) of the origin header or None.
+    """
+    resolved_header = get_header_value(
+        headers=resolver_headers,
+        name="origin",
+        default_value=None,
+        case_sensitive=False,
+    )
+    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: Optional[Dict[str, "SecurityScheme"]] = 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, "SecurityScheme"]]
+        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-2.38.1 → aws_lambda_powertools-2.39.0}/aws_lambda_powertools/shared/version.py

@@ -1,3 +1,3 @@
 """Exposes version constant to avoid circular dependencies."""
 
-VERSION = "2.38.1"
+VERSION = "2.39.0"

{aws_lambda_powertools-2.38.1 → aws_lambda_powertools-2.39.0}/aws_lambda_powertools/utilities/data_classes/__init__.py

@@ -17,6 +17,7 @@ from .cloud_watch_alarm_event import (
 )
 from .cloud_watch_custom_widget_event import CloudWatchDashboardCustomWidgetEvent
 from .cloud_watch_logs_event import CloudWatchLogsEvent
+from .cloudformation_custom_resource_event import CloudFormationCustomResourceEvent
 from .code_pipeline_job_event import CodePipelineJobEvent
 from .connect_contact_flow_event import ConnectContactFlowEvent
 from .dynamo_db_stream_event import DynamoDBStreamEvent
@@ -81,4 +82,5 @@ __all__ = [
     "AWSConfigRuleEvent",
     "VPCLatticeEvent",
     "VPCLatticeEventV2",
+    "CloudFormationCustomResourceEvent",
 ]