aws-lambda-powertools 3.29.0__tar.gz → 3.30.0__tar.gz

{aws_lambda_powertools-3.29.0 → aws_lambda_powertools-3.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aws_lambda_powertools
-Version: 3.29.0
+Version: 3.30.0
 Summary: Powertools for AWS Lambda (Python) is a developer toolkit to implement Serverless best practices and increase developer velocity.
 License: MIT
 Keywords: aws_lambda_powertools,aws,tracing,logging,lambda,powertools,feature_flags,idempotency,middleware

{aws_lambda_powertools-3.29.0 → aws_lambda_powertools-3.30.0}/aws_lambda_powertools/event_handler/__init__.py

@@ -18,7 +18,7 @@ from aws_lambda_powertools.event_handler.bedrock_agent_function import (
 )
 from aws_lambda_powertools.event_handler.depends import DependencyResolutionError, Depends
 from aws_lambda_powertools.event_handler.events_appsync.appsync_events import AppSyncEventsResolver
-from aws_lambda_powertools.event_handler.http_resolver import HttpResolverLocal
+from aws_lambda_powertools.event_handler.http_resolver import HttpResolver, HttpResolverLocal
 from aws_lambda_powertools.event_handler.lambda_function_url import (
     LambdaFunctionUrlResolver,
 )
@@ -39,6 +39,7 @@ __all__ = [
     "CORSConfig",
     "Depends",
     "DependencyResolutionError",
+    "HttpResolver",
     "HttpResolverLocal",
     "LambdaFunctionUrlResolver",
     "Request",

{aws_lambda_powertools-3.29.0 → aws_lambda_powertools-3.30.0}/aws_lambda_powertools/event_handler/appsync.py

@@ -392,7 +392,7 @@ class AppSyncResolver(Router):
         ----------
         type_name : str, optional
             GraphQL type e.g., Query, Mutation, by default "*" meaning any
-        field_name : Optional[str], optional
+        field_name : str | None, optional
             GraphQL field e.g., getTodo, createTodo, by default None
 
         Returns
@@ -447,7 +447,7 @@ class AppSyncResolver(Router):
         ----------
         type_name : str, optional
             GraphQL type e.g., Query, Mutation, by default "*" meaning any
-        field_name : Optional[str], optional
+        field_name : str | None, optional
             GraphQL field e.g., getTodo, createTodo, by default None
         raise_on_error : bool, optional
             Whether to fail entire batch upon error, or handle errors gracefully (None), by default False

{aws_lambda_powertools-3.29.0 → aws_lambda_powertools-3.30.0}/aws_lambda_powertools/event_handler/bedrock_agent.py

@@ -99,12 +99,17 @@ class BedrockAgentResolver(ApiGatewayResolver):
 
     current_event: BedrockAgentEvent
 
-    def __init__(self, debug: bool = False, enable_validation: bool = True):
+    def __init__(
+        self,
+        debug: bool = False,
+        enable_validation: bool = True,
+        serializer: Callable[[dict], str] | None = None,
+    ):
         super().__init__(
             proxy_type=ProxyEventType.BedrockAgentEvent,
             cors=None,
             debug=debug,
-            serializer=None,
+            serializer=serializer,
             strip_prefixes=None,
             enable_validation=enable_validation,
             json_body_deserializer=None,

{aws_lambda_powertools-3.29.0 → aws_lambda_powertools-3.30.0}/aws_lambda_powertools/event_handler/graphql_appsync/_registry.py

@@ -64,7 +64,7 @@ class ResolverRegistry:
             Field name
         Return
         ----------
-        Optional[Dict]
+        dict | None
             A dictionary with the resolver and if raise exception on error
         """
         logger.debug(f"Looking for resolver for type={type_name}, field={field_name}.")

{aws_lambda_powertools-3.29.0 → aws_lambda_powertools-3.30.0}/aws_lambda_powertools/event_handler/graphql_appsync/base.py

@@ -25,8 +25,6 @@ class BaseRouter(ABC):
         Examples
         --------
         ```python
-        from typing import Optional
-
         from aws_lambda_powertools.event_handler import AppSyncResolver
         from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
         from aws_lambda_powertools.utilities.typing import LambdaContext
@@ -34,7 +32,7 @@ class BaseRouter(ABC):
         app = AppSyncResolver()
 
         @app.resolver(type_name="Query", field_name="getPost")
-        def related_posts(event: AppSyncResolverEvent) -> Optional[list]:
+        def related_posts(event: AppSyncResolverEvent) -> list | None:
             return {"success": "ok"}
 
         def lambda_handler(event, context: LambdaContext) -> dict:
@@ -76,8 +74,6 @@ class BaseRouter(ABC):
         Examples
         --------
         ```python
-        from typing import Optional
-
         from aws_lambda_powertools.event_handler import AppSyncResolver
         from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
         from aws_lambda_powertools.utilities.typing import LambdaContext
@@ -85,7 +81,7 @@ class BaseRouter(ABC):
         app = AppSyncResolver()
 
         @app.batch_resolver(type_name="Query", field_name="getPost")
-        def related_posts(event: AppSyncResolverEvent, id) -> Optional[list]:
+        def related_posts(event: AppSyncResolverEvent, id) -> list | None:
             return {"post_id": id}
 
         def lambda_handler(event, context: LambdaContext) -> dict:
@@ -127,8 +123,6 @@ class BaseRouter(ABC):
         Examples
         --------
         ```python
-        from typing import Optional
-
         from aws_lambda_powertools.event_handler import AppSyncResolver
         from aws_lambda_powertools.utilities.data_classes import AppSyncResolverEvent
         from aws_lambda_powertools.utilities.typing import LambdaContext
@@ -136,7 +130,7 @@ class BaseRouter(ABC):
         app = AppSyncResolver()
 
         @app.async_batch_resolver(type_name="Query", field_name="getPost")
-        async def related_posts(event: AppSyncResolverEvent, id) -> Optional[list]:
+        async def related_posts(event: AppSyncResolverEvent, id) -> list | None:
             return {"post_id": id}
 
         def lambda_handler(event, context: LambdaContext) -> dict:

{aws_lambda_powertools-3.29.0 → aws_lambda_powertools-3.30.0}/aws_lambda_powertools/event_handler/http_resolver.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
 import base64
-import inspect
-import warnings
 from typing import TYPE_CHECKING, Any, Callable
 from urllib.parse import parse_qs
 
@@ -10,10 +8,7 @@ from aws_lambda_powertools.event_handler.api_gateway import (
     ApiGatewayResolver,
     BaseRouter,
     ProxyEventType,
-    Response,
-    Route,
 )
-from aws_lambda_powertools.event_handler.middlewares.async_utils import wrap_middleware_async
 from aws_lambda_powertools.shared.headers_serializer import BaseHeadersSerializer
 from aws_lambda_powertools.utilities.data_classes.common import BaseProxyEvent
 
@@ -166,21 +161,16 @@ class MockLambdaContext:
 
 class HttpResolverLocal(ApiGatewayResolver):
     """
-    ASGI-compatible HTTP resolver for local development and testing.
+    ASGI-compatible HTTP resolver.
 
-    This resolver is designed specifically for local development workflows.
-    It allows you to run your Powertools application locally with any ASGI server
+    It allows you to run your Powertools application with any ASGI server
     (uvicorn, hypercorn, daphne, etc.) while maintaining full compatibility with Lambda.
 
     The same code works in both environments - locally via ASGI and in Lambda via the handler.
+    If your Lambda is behind Lambda Web Adapter or any other HTTP proxy, it works seamlessly.
 
     Supports both sync and async route handlers.
 
-    WARNING
-    -------
-    This is intended for local development and testing only.
-    The API may change in future releases. Do not use in production environments.
-
     Example
     -------
     ```python
@@ -214,11 +204,6 @@ class HttpResolverLocal(ApiGatewayResolver):
         strip_prefixes: list[str | Any] | None = None,
         enable_validation: bool = False,
     ):
-        warnings.warn(
-            "HttpResolverLocal is intended for local development and testing only. "
-            "The API may change in future releases. Do not use in production environments.",
-            stacklevel=2,
-        )
         super().__init__(
             proxy_type=ProxyEventType.APIGatewayProxyEvent,  # Use REST API format internally
             cors=cors,
@@ -240,113 +225,13 @@ class HttpResolverLocal(ApiGatewayResolver):
         return ""
 
     async def _resolve_async(self) -> dict:  # type: ignore[override]
-        """Async version of resolve that supports async handlers."""
-        method = self.current_event.http_method.upper()
-        path = self._remove_prefix(self.current_event.path)
-
-        registered_routes = self._static_routes + self._dynamic_routes
-
-        for route in registered_routes:
-            if method != route.method:
-                continue
-            match_results = route.rule.match(path)
-            if match_results:
-                self.append_context(_route=route, _path=path)
-                route_keys = self._convert_matches_into_route_keys(match_results)
-                return await self._call_route_async(route, route_keys)
-
-        # Handle not found
-        return await self._handle_not_found_async()
-
-    async def _call_route_async(self, route: Route, route_arguments: dict[str, str]) -> dict:  # type: ignore[override]
-        """Call route handler, supporting both sync and async handlers."""
-        from aws_lambda_powertools.event_handler.api_gateway import ResponseBuilder
-
-        try:
-            self._reset_processed_stack()
-
-            # Get the route args (may be modified by validation middleware)
-            self.append_context(_route_args=route_arguments)
-
-            # Run middleware chain (sync for now, handlers can be async)
-            response = await self._run_middleware_chain_async(route)
-
-            response_builder: ResponseBuilder = ResponseBuilder(
-                response=response,
-                serializer=self._serializer,
-                route=route,
-            )
-
-            return response_builder.build(self.current_event, self._cors)
-
-        except Exception as exc:
-            exc_response_builder = self._call_exception_handler(exc, route)
-            if exc_response_builder:
-                return exc_response_builder.build(self.current_event, self._cors)
-            raise
-
-    async def _run_middleware_chain_async(self, route: Route) -> Response:
-        """Run the middleware chain, awaiting async handlers."""
-        # Build middleware list
-        all_middlewares: list[Callable[..., Any]] = []
-
-        # Determine if validation should be enabled for this route
-        # If route has explicit enable_validation setting, use it; otherwise, use resolver's global setting
-        route_validation_enabled = (
-            route.enable_validation if route.enable_validation is not None else self._enable_validation
-        )
-
-        if route_validation_enabled and hasattr(self, "_request_validation_middleware"):
-            all_middlewares.append(self._request_validation_middleware)
-
-        all_middlewares.extend(self._router_middlewares + route.middlewares)
-
-        if route_validation_enabled and hasattr(self, "_response_validation_middleware"):
-            all_middlewares.append(self._response_validation_middleware)
-
-        # Create the final handler that calls the route function
-        async def final_handler(app):
-            route_args = app.context.get("_route_args", {})
-            result = route.func(**route_args)
-
-            # Await if coroutine
-            if inspect.iscoroutine(result):
-                result = await result
-
-            return self._to_response(result)
-
-        # Build middleware chain from end to start
-        next_handler = final_handler
-
-        for middleware in reversed(all_middlewares):
-            next_handler = wrap_middleware_async(middleware, next_handler)
-
-        return await next_handler(self)
-
-    async def _handle_not_found_async(self, method: str = "", path: str = "") -> dict:  # type: ignore[override]
-        """Handle 404 responses, using custom not_found handler if registered."""
-        from http import HTTPStatus
-
-        from aws_lambda_powertools.event_handler.api_gateway import ResponseBuilder
-        from aws_lambda_powertools.event_handler.exceptions import NotFoundError
-
-        # Check for custom not_found handler
-        custom_not_found_handler = self.exception_handler_manager.lookup_exception_handler(NotFoundError)
-        if custom_not_found_handler:
-            response = custom_not_found_handler(NotFoundError())
-        else:
-            response = Response(
-                status_code=HTTPStatus.NOT_FOUND.value,
-                content_type="application/json",
-                body={"statusCode": HTTPStatus.NOT_FOUND.value, "message": "Not found"},
-            )
-
-        response_builder: ResponseBuilder = ResponseBuilder(
-            response=response,
-            serializer=self._serializer,
-            route=None,
-        )
+        """Thin async resolver: delegates entirely to the parent and serializes to dict.
 
+        The parent's _resolve_async handles route matching, CORS preflight, not-found
+        logic, and exception handling. The only adaptation needed here is converting
+        the returned ResponseBuilder into the dict format that asgi_handler expects.
+        """
+        response_builder = await super()._resolve_async()
         return response_builder.build(self.current_event, self._cors)
 
     async def asgi_handler(self, scope: dict, receive: Callable, send: Callable) -> None:
@@ -455,3 +340,6 @@ class HttpResolverLocal(ApiGatewayResolver):
                 "body": body_bytes,
             },
         )
+
+
+HttpResolver = HttpResolverLocal

{aws_lambda_powertools-3.29.0 → aws_lambda_powertools-3.30.0}/aws_lambda_powertools/event_handler/middlewares/openapi_validation.py

@@ -505,11 +505,11 @@ def _is_or_contains_sequence(annotation: Any) -> bool:
 
     This function handles complex type annotations like:
     - List[Model] - direct sequence
-    - Union[Model, List[Model]] - checks if any Union member is a sequence
-    - Optional[List[Model]] - Union[List[Model], None]
-    - RootModel[List[Model]] - checks if the RootModel wraps a sequence
-    - Optional[RootModel[List[Model]]] - Union member that is a RootModel
-    - RootModel[Union[Model, List[Model]]] - RootModel wrapping a Union with a sequence
+    - Union[Model, list[Model]] - checks if any Union member is a sequence
+    - list[Model] | None - Union[list[Model], None]
+    - RootModel[list[Model]] - checks if the RootModel wraps a sequence
+    - RootModel[list[Model]] | None - Union member that is a RootModel
+    - RootModel[Union[Model, list[Model]]] - RootModel wrapping a Union with a sequence
     """
     # Direct sequence check
     if field_annotation_is_sequence(annotation):