aws-lambda-powertools 2.34.2__tar.gz → 2.35.0__tar.gz

{aws_lambda_powertools-2.34.2 → aws_lambda_powertools-2.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-lambda-powertools
-Version: 2.34.2
+Version: 2.35.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
@@ -63,6 +63,7 @@ Powertools for AWS Lambda (Python) is a developer toolkit to implement Serverles
 * **[Metrics](https://docs.powertools.aws.dev/lambda/python/latest/core/metrics/)** - Custom Metrics created asynchronously via CloudWatch Embedded Metric Format (EMF)
 * **[Event handler: AppSync](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/appsync/)** - AWS AppSync event handler for Lambda Direct Resolver and Amplify GraphQL Transformer function
 * **[Event handler: API Gateway and ALB](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/)** - Amazon API Gateway REST/HTTP API and ALB event handler for Lambda functions invoked using Proxy integration
+* **[Event handler: Agents for Amazon Bedrock](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/bedrock_agents/)** - Create Agents for Amazon Bedrock, automatically generating OpenAPI schemas
 * **[Bring your own middleware](https://docs.powertools.aws.dev/lambda/python/latest/utilities/middleware_factory/)** - Decorator factory to create your own middleware to run logic before, and after each Lambda invocation
 * **[Parameters utility](https://docs.powertools.aws.dev/lambda/python/latest/utilities/parameters/)** - Retrieve and cache parameter values from Parameter Store, Secrets Manager, or DynamoDB
 * **[Batch processing](https://docs.powertools.aws.dev/lambda/python/latest/utilities/batch/)** - Handle partial failures for AWS SQS batch processing

{aws_lambda_powertools-2.34.2 → aws_lambda_powertools-2.35.0}/README.md

@@ -20,6 +20,7 @@ Powertools for AWS Lambda (Python) is a developer toolkit to implement Serverles
 * **[Metrics](https://docs.powertools.aws.dev/lambda/python/latest/core/metrics/)** - Custom Metrics created asynchronously via CloudWatch Embedded Metric Format (EMF)
 * **[Event handler: AppSync](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/appsync/)** - AWS AppSync event handler for Lambda Direct Resolver and Amplify GraphQL Transformer function
 * **[Event handler: API Gateway and ALB](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/)** - Amazon API Gateway REST/HTTP API and ALB event handler for Lambda functions invoked using Proxy integration
+* **[Event handler: Agents for Amazon Bedrock](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/bedrock_agents/)** - Create Agents for Amazon Bedrock, automatically generating OpenAPI schemas
 * **[Bring your own middleware](https://docs.powertools.aws.dev/lambda/python/latest/utilities/middleware_factory/)** - Decorator factory to create your own middleware to run logic before, and after each Lambda invocation
 * **[Parameters utility](https://docs.powertools.aws.dev/lambda/python/latest/utilities/parameters/)** - Retrieve and cache parameter values from Parameter Store, Secrets Manager, or DynamoDB
 * **[Batch processing](https://docs.powertools.aws.dev/lambda/python/latest/utilities/batch/)** - Handle partial failures for AWS SQS batch processing

{aws_lambda_powertools-2.34.2 → aws_lambda_powertools-2.35.0}/aws_lambda_powertools/event_handler/api_gateway.py

@@ -1455,10 +1455,25 @@ class ApiGatewayResolver(BaseRouter):
             get_definitions,
         )
         from aws_lambda_powertools.event_handler.openapi.models import OpenAPI, PathItem, Server, Tag
+        from aws_lambda_powertools.event_handler.openapi.pydantic_loader import PYDANTIC_V2
         from aws_lambda_powertools.event_handler.openapi.types import (
             COMPONENT_REF_TEMPLATE,
         )
 
+        # Pydantic V2 has no support for OpenAPI schema 3.0
+        if PYDANTIC_V2 and not openapi_version.startswith("3.1"):
+            warnings.warn(
+                "You are using Pydantic v2, which is incompatible with OpenAPI schema 3.0. Forcing OpenAPI 3.1",
+                stacklevel=2,
+            )
+            openapi_version = "3.1.0"
+        elif not PYDANTIC_V2 and not openapi_version.startswith("3.0"):
+            warnings.warn(
+                "You are using Pydantic v1, which is incompatible with OpenAPI schema 3.1. Forcing OpenAPI 3.0",
+                stacklevel=2,
+            )
+            openapi_version = "3.0.3"
+
         # Start with the bare minimum required for a valid OpenAPI schema
         info: Dict[str, Any] = {"title": title, "version": version}
 

aws_lambda_powertools-2.35.0/aws_lambda_powertools/event_handler/bedrock_agent.py

@@ -0,0 +1,255 @@
+from re import Match
+from typing import Any, Callable, Dict, List, Optional
+
+from typing_extensions import override
+
+from aws_lambda_powertools.event_handler import ApiGatewayResolver
+from aws_lambda_powertools.event_handler.api_gateway import (
+    _DEFAULT_OPENAPI_RESPONSE_DESCRIPTION,
+    ProxyEventType,
+    ResponseBuilder,
+)
+from aws_lambda_powertools.event_handler.openapi.types import OpenAPIResponse
+from aws_lambda_powertools.utilities.data_classes import BedrockAgentEvent
+
+
+class BedrockResponseBuilder(ResponseBuilder):
+    """
+    Bedrock Response Builder. This builds the response dict to be returned by Lambda when using Bedrock Agents.
+
+    Since the payload format is different from the standard API Gateway Proxy event, we override the build method.
+    """
+
+    @override
+    def build(self, event: BedrockAgentEvent, *args) -> Dict[str, Any]:
+        """Build the full response dict to be returned by the lambda"""
+        self._route(event, None)
+
+        body = self.response.body
+        if self.response.is_json() and not isinstance(self.response.body, str):
+            body = self.serializer(self.response.body)
+
+        return {
+            "messageVersion": "1.0",
+            "response": {
+                "actionGroup": event.action_group,
+                "apiPath": event.api_path,
+                "httpMethod": event.http_method,
+                "httpStatusCode": self.response.status_code,
+                "responseBody": {
+                    self.response.content_type: {
+                        "body": body,
+                    },
+                },
+            },
+        }
+
+
+class BedrockAgentResolver(ApiGatewayResolver):
+    """Bedrock Agent Resolver
+
+    See https://aws.amazon.com/bedrock/agents/ for more information.
+
+    Examples
+    --------
+    Simple example with a custom lambda handler using the Tracer capture_lambda_handler decorator
+
+    ```python
+    from aws_lambda_powertools import Tracer
+    from aws_lambda_powertools.event_handler import BedrockAgentResolver
+
+    tracer = Tracer()
+    app = BedrockAgentResolver()
+
+    @app.get("/claims")
+    def simple_get():
+        return "You have 3 claims"
+
+    @tracer.capture_lambda_handler
+    def lambda_handler(event, context):
+        return app.resolve(event, context)
+    ```
+
+    """
+
+    current_event: BedrockAgentEvent
+
+    def __init__(self, debug: bool = False, enable_validation: bool = True):
+        super().__init__(
+            proxy_type=ProxyEventType.BedrockAgentEvent,
+            cors=None,
+            debug=debug,
+            serializer=None,
+            strip_prefixes=None,
+            enable_validation=enable_validation,
+        )
+        self._response_builder_class = BedrockResponseBuilder
+
+    # Note: we need ignore[override] because we are making the optional `description` field required.
+    @override
+    def get(  # type: ignore[override]
+        self,
+        rule: str,
+        description: str,
+        cors: Optional[bool] = None,
+        compress: bool = False,
+        cache_control: Optional[str] = None,
+        summary: Optional[str] = None,
+        responses: Optional[Dict[int, OpenAPIResponse]] = None,
+        response_description: str = _DEFAULT_OPENAPI_RESPONSE_DESCRIPTION,
+        tags: Optional[List[str]] = None,
+        operation_id: Optional[str] = None,
+        include_in_schema: bool = True,
+        middlewares: Optional[List[Callable[..., Any]]] = None,
+    ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        return super(BedrockAgentResolver, self).get(
+            rule,
+            cors,
+            compress,
+            cache_control,
+            summary,
+            description,
+            responses,
+            response_description,
+            tags,
+            operation_id,
+            include_in_schema,
+            middlewares,
+        )
+
+    # Note: we need ignore[override] because we are making the optional `description` field required.
+    @override
+    def post(  # type: ignore[override]
+        self,
+        rule: str,
+        description: str,
+        cors: Optional[bool] = None,
+        compress: bool = False,
+        cache_control: Optional[str] = None,
+        summary: Optional[str] = None,
+        responses: Optional[Dict[int, OpenAPIResponse]] = None,
+        response_description: str = _DEFAULT_OPENAPI_RESPONSE_DESCRIPTION,
+        tags: Optional[List[str]] = None,
+        operation_id: Optional[str] = None,
+        include_in_schema: bool = True,
+        middlewares: Optional[List[Callable[..., Any]]] = None,
+    ):
+        return super().post(
+            rule,
+            cors,
+            compress,
+            cache_control,
+            summary,
+            description,
+            responses,
+            response_description,
+            tags,
+            operation_id,
+            include_in_schema,
+            middlewares,
+        )
+
+    # Note: we need ignore[override] because we are making the optional `description` field required.
+    @override
+    def put(  # type: ignore[override]
+        self,
+        rule: str,
+        description: str,
+        cors: Optional[bool] = None,
+        compress: bool = False,
+        cache_control: Optional[str] = None,
+        summary: Optional[str] = None,
+        responses: Optional[Dict[int, OpenAPIResponse]] = None,
+        response_description: str = _DEFAULT_OPENAPI_RESPONSE_DESCRIPTION,
+        tags: Optional[List[str]] = None,
+        operation_id: Optional[str] = None,
+        include_in_schema: bool = True,
+        middlewares: Optional[List[Callable[..., Any]]] = None,
+    ):
+        return super().put(
+            rule,
+            cors,
+            compress,
+            cache_control,
+            summary,
+            description,
+            responses,
+            response_description,
+            tags,
+            operation_id,
+            include_in_schema,
+            middlewares,
+        )
+
+    # Note: we need ignore[override] because we are making the optional `description` field required.
+    @override
+    def patch(  # type: ignore[override]
+        self,
+        rule: str,
+        description: str,
+        cors: Optional[bool] = None,
+        compress: bool = False,
+        cache_control: Optional[str] = None,
+        summary: Optional[str] = None,
+        responses: Optional[Dict[int, OpenAPIResponse]] = None,
+        response_description: str = _DEFAULT_OPENAPI_RESPONSE_DESCRIPTION,
+        tags: Optional[List[str]] = None,
+        operation_id: Optional[str] = None,
+        include_in_schema: bool = True,
+        middlewares: Optional[List[Callable]] = None,
+    ):
+        return super().patch(
+            rule,
+            cors,
+            compress,
+            cache_control,
+            summary,
+            description,
+            responses,
+            response_description,
+            tags,
+            operation_id,
+            include_in_schema,
+            middlewares,
+        )
+
+    # Note: we need ignore[override] because we are making the optional `description` field required.
+    @override
+    def delete(  # type: ignore[override]
+        self,
+        rule: str,
+        description: str,
+        cors: Optional[bool] = None,
+        compress: bool = False,
+        cache_control: Optional[str] = None,
+        summary: Optional[str] = None,
+        responses: Optional[Dict[int, OpenAPIResponse]] = None,
+        response_description: str = _DEFAULT_OPENAPI_RESPONSE_DESCRIPTION,
+        tags: Optional[List[str]] = None,
+        operation_id: Optional[str] = None,
+        include_in_schema: bool = True,
+        middlewares: Optional[List[Callable[..., Any]]] = None,
+    ):
+        return super().delete(
+            rule,
+            cors,
+            compress,
+            cache_control,
+            summary,
+            description,
+            responses,
+            response_description,
+            tags,
+            operation_id,
+            include_in_schema,
+            middlewares,
+        )
+
+    @override
+    def _convert_matches_into_route_keys(self, match: Match) -> Dict[str, str]:
+        # In Bedrock Agents, all the parameters come inside the "parameters" key, not on the apiPath
+        # So we have to search for route parameters in the parameters key
+        parameters: Dict[str, str] = {}
+        if match.groupdict() and self.current_event.parameters:
+            parameters = {parameter["name"]: parameter["value"] for parameter in self.current_event.parameters}
+        return parameters

aws_lambda_powertools-2.35.0/aws_lambda_powertools/event_handler/openapi/constants.py

@@ -0,0 +1,2 @@
+DEFAULT_API_VERSION = "1.0.0"
+DEFAULT_OPENAPI_VERSION = "3.0.3"

{aws_lambda_powertools-2.34.2 → aws_lambda_powertools-2.35.0}/aws_lambda_powertools/event_handler/openapi/models.py

@@ -45,7 +45,6 @@ class License(BaseModel):
 # https://swagger.io/specification/#info-object
 class Info(BaseModel):
     title: str
-    summary: Optional[str] = None
     description: Optional[str] = None
     termsOfService: Optional[str] = None
     contact: Optional[Contact] = None
@@ -53,12 +52,13 @@ class Info(BaseModel):
     version: str
 
     if PYDANTIC_V2:
-        model_config = {"extra": "allow"}
+        summary: Optional[str] = None
+        model_config = {"extra": "ignore"}
 
     else:
 
         class Config:
-            extra = "allow"
+            extra = "ignore"
 
 
 # https://swagger.io/specification/#server-variable-object