aws-lambda-powertools 2.37.0__tar.gz → 2.38.0__tar.gz

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-lambda-powertools
-Version: 2.37.0
+Version: 2.38.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

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/THIRD-PARTY-LICENSES

@@ -1,3 +1,27 @@
+** FastAPI - https://github.com/tiangolo/fastapi/ - Used in the OpenAPI feature
+
+   The MIT License (MIT)
+
+   Copyright (c) 2018 Sebastián Ramírez
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+   THE SOFTWARE.
+
 ** Tensorflow - https://github.com/tensorflow/tensorflow/
 
                                  Apache License

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/event_handler/api_gateway.py

@@ -1222,6 +1222,63 @@ class BaseRouter(ABC):
             middlewares,
         )
 
+    def head(
+        self,
+        rule: str,
+        cors: Optional[bool] = None,
+        compress: bool = False,
+        cache_control: Optional[str] = None,
+        summary: Optional[str] = None,
+        description: 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,
+        security: Optional[List[Dict[str, List[str]]]] = None,
+        middlewares: Optional[List[Callable]] = None,
+    ):
+        """Head route decorator with HEAD `method`
+
+        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 APIGatewayRestResolver, Response, content_types
+
+        tracer = Tracer()
+        app = APIGatewayRestResolver()
+
+        @app.head("/head-call")
+        def simple_head():
+            return Response(status_code=200,
+                            content_type=content_types.APPLICATION_JSON,
+                            headers={"Content-Length": "123"})
+
+        @tracer.capture_lambda_handler
+        def lambda_handler(event, context):
+            return app.resolve(event, context)
+        ```
+        """
+        return self.route(
+            rule,
+            "HEAD",
+            cors,
+            compress,
+            cache_control,
+            summary,
+            description,
+            responses,
+            response_description,
+            tags,
+            operation_id,
+            include_in_schema,
+            security,
+            middlewares,
+        )
+
     def _push_processed_stack_frame(self, frame: str):
         """
         Add Current Middleware to the Middleware Stack Frames
@@ -1589,13 +1646,13 @@ class ApiGatewayResolver(BaseRouter):
         from aws_lambda_powertools.event_handler.openapi.pydantic_loader import PYDANTIC_V2
 
         # Pydantic V2 has no support for OpenAPI schema 3.0
-        if PYDANTIC_V2 and not openapi_version.startswith("3.1"):
+        if PYDANTIC_V2 and not openapi_version.startswith("3.1"):  # pragma: no cover
             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"):
+        elif not PYDANTIC_V2 and not openapi_version.startswith("3.0"):  # pragma: no cover
             warnings.warn(
                 "You are using Pydantic v1, which is incompatible with OpenAPI schema 3.1. Forcing OpenAPI 3.0",
                 stacklevel=2,
@@ -1696,6 +1753,7 @@ class ApiGatewayResolver(BaseRouter):
         security_schemes: Optional[Dict[str, "SecurityScheme"]] = None,
         security: Optional[List[Dict[str, List[str]]]] = None,
         oauth2_config: Optional["OAuth2Config"] = None,
+        persist_authorization: bool = False,
     ):
         """
         Returns the OpenAPI schema as a JSON serializable dict
@@ -1736,6 +1794,8 @@ class ApiGatewayResolver(BaseRouter):
             A declaration of which security mechanisms are applied globally across the API.
         oauth2_config: OAuth2Config, optional
             The OAuth2 configuration for the Swagger UI.
+        persist_authorization: bool, optional
+            Whether to persist authorization data on browser close/refresh.
         """
         from aws_lambda_powertools.event_handler.openapi.compat import model_json
         from aws_lambda_powertools.event_handler.openapi.models import Server
@@ -1814,6 +1874,7 @@ class ApiGatewayResolver(BaseRouter):
                 swagger_css,
                 swagger_base_url,
                 oauth2_config,
+                persist_authorization,
             )
 
             return Response(
@@ -2135,7 +2196,7 @@ class ApiGatewayResolver(BaseRouter):
 
     def exception_handler(self, exc_class: Union[Type[Exception], List[Type[Exception]]]):
         def register_exception_handler(func: Callable):
-            if isinstance(exc_class, list):
+            if isinstance(exc_class, list):  # pragma: no cover
                 for exp in exc_class:
                     self._exception_handlers[exp] = func
             else:

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/event_handler/middlewares/openapi_validation.py

@@ -410,7 +410,7 @@ def _normalize_multi_query_string_with_param(
     return resolved_query_string
 
 
-def _normalize_multi_header_values_with_param(headers: Optional[Dict[str, str]], params: Sequence[ModelField]):
+def _normalize_multi_header_values_with_param(headers: Dict[str, Any], params: Sequence[ModelField]):
     """
     Extract and normalize resolved_headers_field
 

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/event_handler/openapi/compat.py

@@ -40,7 +40,7 @@ sequence_types = tuple(sequence_annotation_to_type.keys())
 
 RequestErrorModel: Type[BaseModel] = create_model("Request")
 
-if PYDANTIC_V2:
+if PYDANTIC_V2:  # pragma: no cover # false positive; dropping in v3
     from pydantic import TypeAdapter, ValidationError
     from pydantic._internal._typing_extra import eval_type_lenient
     from pydantic.fields import FieldInfo

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/event_handler/openapi/pydantic_loader.py

@@ -3,4 +3,4 @@ try:
 
     PYDANTIC_V2 = PYDANTIC_VERSION.startswith("2.")
 except ImportError:
-    PYDANTIC_V2 = False
+    PYDANTIC_V2 = False  # pragma: no cover  # false positive; dropping in v3

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/event_handler/openapi/swagger_ui/html.py

@@ -10,6 +10,7 @@ def generate_swagger_html(
     swagger_css: str,
     swagger_base_url: str,
     oauth2_config: Optional[OAuth2Config],
+    persist_authorization: bool = False,
 ) -> str:
     """
     Generate Swagger UI HTML page
@@ -28,6 +29,8 @@ def generate_swagger_html(
         The base URL for Swagger UI
     oauth2_config: OAuth2Config, optional
         The OAuth2 configuration.
+    persist_authorization: bool, optional
+        Whether to persist authorization data on browser close/refresh.
     """
 
     # If Swagger base URL is present, generate HTML content with linked CSS and JavaScript files
@@ -86,6 +89,7 @@ def generate_swagger_html(
       SwaggerUIBundle.plugins.DownloadUrl
     ],
     withCredentials: true,
+    persistAuthorization: {str(persist_authorization).lower()},
     oauth2RedirectUrl: baseUrl + "?format=oauth2-redirect",
   }}
 

aws_lambda_powertools-2.38.0/aws_lambda_powertools/logging/constants.py

@@ -0,0 +1,5 @@
+# logger.powertools_handler is set with Powertools Logger handler; useful when there are many handlers
+LOGGER_ATTRIBUTE_POWERTOOLS_HANDLER = "powertools_handler"
+# logger.init attribute is set when Logger has been configured 
+LOGGER_ATTRIBUTE_PRECONFIGURED = "init"
+LOGGER_ATTRIBUTE_HANDLER = "logger_handler"

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/logging/exceptions.py

@@ -1,2 +1,6 @@
 class InvalidLoggerSamplingRateError(Exception):
     pass
+
+
+class OrphanedChildLoggerError(Exception):
+    pass

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/logging/logger.py

@@ -19,9 +19,15 @@ from typing import (
     Optional,
     TypeVar,
     Union,
+    cast,
     overload,
 )
 
+from aws_lambda_powertools.logging.constants import (
+    LOGGER_ATTRIBUTE_HANDLER,
+    LOGGER_ATTRIBUTE_POWERTOOLS_HANDLER,
+    LOGGER_ATTRIBUTE_PRECONFIGURED,
+)
 from aws_lambda_powertools.shared import constants
 from aws_lambda_powertools.shared.functions import (
     extract_event_from_common_models,
@@ -31,7 +37,7 @@ from aws_lambda_powertools.shared.functions import (
 from aws_lambda_powertools.utilities import jmespath_utils
 
 from ..shared.types import AnyCallableT
-from .exceptions import InvalidLoggerSamplingRateError
+from .exceptions import InvalidLoggerSamplingRateError, OrphanedChildLoggerError
 from .filters import SuppressFilter
 from .formatter import (
     RESERVED_FORMATTER_CUSTOM_KEYS,
@@ -233,7 +239,6 @@ class Logger:
         self.child = child
         self.logger_formatter = logger_formatter
         self._stream = stream or sys.stdout
-        self.logger_handler = logger_handler or logging.StreamHandler(self._stream)
         self.log_uncaught_exceptions = log_uncaught_exceptions
 
         self._is_deduplication_disabled = resolve_truthy_env_var_choice(
@@ -241,6 +246,7 @@ class Logger:
         )
         self._default_log_keys = {"service": self.service, "sampling_rate": self.sampling_rate}
         self._logger = self._get_logger()
+        self.logger_handler = logger_handler or self._get_handler()
 
         # NOTE: This is primarily to improve UX, so IDEs can autocomplete LambdaPowertoolsFormatter options
         # previously, we masked all of them as kwargs thus limiting feature discovery
@@ -264,7 +270,7 @@ class Logger:
 
     # Prevent __getattr__ from shielding unknown attribute errors in type checkers
     # https://github.com/aws-powertools/powertools-lambda-python/issues/1660
-    if not TYPE_CHECKING:
+    if not TYPE_CHECKING:  # pragma: no cover
 
         def __getattr__(self, name):
             # Proxy attributes not found to actual logger to support backward compatibility
@@ -279,6 +285,18 @@ class Logger:
 
         return logging.getLogger(logger_name)
 
+    def _get_handler(self) -> logging.Handler:
+        # is a logger handler already configured?
+        if getattr(self, LOGGER_ATTRIBUTE_HANDLER, None):
+            return self.logger_handler
+
+        # for children, use parent's handler
+        if self.child:
+            return getattr(self._logger.parent, LOGGER_ATTRIBUTE_POWERTOOLS_HANDLER, None)  # type: ignore[return-value] # always checked in formatting
+
+        # otherwise, create a new stream handler (first time init)
+        return logging.StreamHandler(self._stream)
+
     def _init_logger(
         self,
         formatter_options: Optional[Dict] = None,
@@ -292,7 +310,7 @@ class Logger:
         #   a) multiple handlers being attached
         #   b) different sampling mechanisms
         #   c) multiple messages from being logged as handlers can be duplicated
-        is_logger_preconfigured = getattr(self._logger, "init", False)
+        is_logger_preconfigured = getattr(self._logger, LOGGER_ATTRIBUTE_PRECONFIGURED, False)
         if self.child or is_logger_preconfigured:
             return
 
@@ -317,6 +335,7 @@ class Logger:
         # std logging will return the same Logger with our attribute if name is reused
         logger.debug(f"Marking logger {self.service} as preconfigured")
         self._logger.init = True  # type: ignore[attr-defined]
+        self._logger.powertools_handler = self.logger_handler  # type: ignore[attr-defined]
 
     def _configure_sampling(self) -> None:
         """Dynamically set log level based on sampling rate
@@ -613,7 +632,7 @@ class Logger:
 
         # Mode 1
         log_keys = {**self._default_log_keys, **keys}
-        is_logger_preconfigured = getattr(self._logger, "init", False)
+        is_logger_preconfigured = getattr(self._logger, LOGGER_ATTRIBUTE_PRECONFIGURED, False)
         if not is_logger_preconfigured:
             formatter = self.logger_formatter or LambdaPowertoolsFormatter(**formatter_options, **log_keys)
             self.registered_handler.setFormatter(formatter)
@@ -672,15 +691,20 @@ class Logger:
     @property
     def registered_handler(self) -> logging.Handler:
         """Convenience property to access the first logger handler"""
-        # We ignore mypy here because self.child encodes whether or not self._logger.parent is
-        # None, mypy can't see this from context but we can
-        handlers = self._logger.parent.handlers if self.child else self._logger.handlers  # type: ignore[union-attr]
-        return handlers[0]
+        return self._get_handler()
 
     @property
     def registered_formatter(self) -> BasePowertoolsFormatter:
         """Convenience property to access the first logger formatter"""
-        return self.registered_handler.formatter  # type: ignore[return-value]
+        handler = self.registered_handler
+        if handler is None:
+            raise OrphanedChildLoggerError(
+                "Orphan child loggers cannot append nor remove keys until a parent is initialized first. "
+                "To solve this issue, you can A) make sure a parent logger is initialized first, or B) move append/remove keys operations to a later stage."  # noqa: E501
+                "Reference: https://docs.powertools.aws.dev/lambda/python/latest/core/logger/#reusing-logger-across-your-code",
+            )
+
+        return cast(BasePowertoolsFormatter, handler.formatter)
 
     @property
     def log_level(self) -> int:

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/logging/utils.py

@@ -9,6 +9,7 @@ PACKAGE_LOGGER = "aws_lambda_powertools"
 def copy_config_to_registered_loggers(
     source_logger: Logger,
     log_level: Optional[Union[int, str]] = None,
+    ignore_log_level=False,
     exclude: Optional[Set[str]] = None,
     include: Optional[Set[str]] = None,
 ) -> None:
@@ -16,10 +17,13 @@ def copy_config_to_registered_loggers(
 
     Parameters
     ----------
+    ignore_log_level
     source_logger : Logger
         Powertools for AWS Lambda (Python) Logger to copy configuration from
     log_level : Union[int, str], optional
         Logging level to set to registered loggers, by default uses source_logger logging level
+    ignore_log_level: bool
+        Whether to not touch log levels for discovered loggers. log_level param is disregarded when this is set.
     include : Optional[Set[str]], optional
         List of logger names to include, by default all registered loggers are included
     exclude : Optional[Set[str]], optional
@@ -54,7 +58,7 @@ def copy_config_to_registered_loggers(
 
     registered_loggers = _find_registered_loggers(source_logger, loggers, filter_func)
     for logger in registered_loggers:
-        _configure_logger(source_logger, logger, level)
+        _configure_logger(source_logger=source_logger, logger=logger, level=level, ignore_log_level=ignore_log_level)
 
 
 def _include_registered_loggers_filter(loggers: Set[str]):
@@ -78,13 +82,21 @@ def _find_registered_loggers(
     return root_loggers
 
 
-def _configure_logger(source_logger: Logger, logger: logging.Logger, level: Union[int, str]) -> None:
+def _configure_logger(
+    source_logger: Logger,
+    logger: logging.Logger,
+    level: Union[int, str],
+    ignore_log_level: bool = False,
+) -> None:
+    # 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.handlers = []
-    logger.setLevel(level)
     logger.propagate = False  # ensure we don't propagate logs to existing loggers, #1073
     source_logger.append_keys(name="%(name)s")  # include logger name, see #1267
 
-    source_logger.debug(f"Logger {logger} reconfigured to use logging level {level}")
     for source_handler in source_logger.handlers:
         logger.addHandler(source_handler)
         source_logger.debug(f"Logger {logger} reconfigured to use {source_handler}")

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/shared/constants.py

@@ -9,6 +9,7 @@ MIDDLEWARE_FACTORY_TRACE_ENV: str = "POWERTOOLS_TRACE_MIDDLEWARES"
 INVALID_XRAY_NAME_CHARACTERS = r"[?;*()!$~^<>]"
 
 # Logger constants
+# maintenance: future major version should start having localized `constants.py` to ease future modularization
 LOGGER_LOG_SAMPLING_RATE: str = "POWERTOOLS_LOGGER_SAMPLE_RATE"
 LOGGER_LOG_EVENT_ENV: str = "POWERTOOLS_LOGGER_LOG_EVENT"
 LOGGER_LOG_DEDUPLICATION_ENV: str = "POWERTOOLS_LOG_DEDUPLICATION_DISABLED"
@@ -61,7 +62,7 @@ POWERTOOLS_DEBUG_ENV: str = "POWERTOOLS_DEBUG"
 
 # JSON constants
 PRETTY_INDENT: int = 4
-COMPACT_INDENT = None
+COMPACT_INDENT: None = None
 
 # Idempotency constants
 IDEMPOTENCY_DISABLED_ENV: str = "POWERTOOLS_IDEMPOTENCY_DISABLED"

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/shared/version.py

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

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/utilities/batch/types.py

@@ -7,7 +7,7 @@ has_pydantic = "pydantic" in sys.modules
 
 # For IntelliSense and Mypy to work, we need to account for possible SQS subclasses
 # We need them as subclasses as we must access their message ID or sequence number metadata via dot notation
-if has_pydantic:
+if has_pydantic:  # pragma: no cover
     from aws_lambda_powertools.utilities.parser.models import DynamoDBStreamRecordModel, SqsRecordModel
     from aws_lambda_powertools.utilities.parser.models import (
         KinesisDataStreamRecord as KinesisDataStreamRecordModel,
@@ -17,7 +17,7 @@ if has_pydantic:
         Union[Type[SqsRecordModel], Type[DynamoDBStreamRecordModel], Type[KinesisDataStreamRecordModel]]
     ]
     BatchSqsTypeModel = Optional[Type[SqsRecordModel]]
-else:
+else:  # pragma: no cover
     BatchTypeModels = "BatchTypeModels"  # type: ignore
     BatchSqsTypeModel = "BatchSqsTypeModel"  # type: ignore
 

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/utilities/data_classes/alb_event.py

@@ -43,7 +43,7 @@ class ALBEvent(BaseProxyEvent):
         return super().resolved_query_string_parameters
 
     @property
-    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+    def resolved_headers_field(self) -> Dict[str, Any]:
         headers: Dict[str, Any] = {}
 
         if self.multi_value_headers:

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/utilities/data_classes/api_gateway_proxy_event.py

@@ -15,18 +15,18 @@ from aws_lambda_powertools.utilities.data_classes.common import (
 
 class APIGatewayEventAuthorizer(DictWrapper):
     @property
-    def claims(self) -> Optional[Dict[str, Any]]:
-        return self.get("claims")
+    def claims(self) -> Dict[str, Any]:
+        return self.get("claims") or {}  # key might exist but can be `null`
 
     @property
-    def scopes(self) -> Optional[List[str]]:
-        return self.get("scopes")
+    def scopes(self) -> List[str]:
+        return self.get("scopes") or []  # key might exist but can be `null`
 
     @property
-    def principal_id(self) -> Optional[str]:
+    def principal_id(self) -> str:
         """The principal user identification associated with the token sent by the client and returned from an
         API Gateway Lambda authorizer (formerly known as a custom authorizer)"""
-        return self.get("principalId")
+        return self.get("principalId") or ""  # key might exist but can be `null`
 
     @property
     def integration_latency(self) -> Optional[int]:
@@ -91,7 +91,8 @@ class APIGatewayEventRequestContext(BaseRequestContext):
 
     @property
     def authorizer(self) -> APIGatewayEventAuthorizer:
-        return APIGatewayEventAuthorizer(self._data["requestContext"]["authorizer"])
+        authz_data = self._data.get("requestContext", {}).get("authorizer", {})
+        return APIGatewayEventAuthorizer(authz_data)
 
 
 class APIGatewayProxyEvent(BaseProxyEvent):
@@ -112,11 +113,11 @@ class APIGatewayProxyEvent(BaseProxyEvent):
 
     @property
     def multi_value_headers(self) -> Dict[str, List[str]]:
-        return self.get("multiValueHeaders") or {}
+        return self.get("multiValueHeaders") or {}  # key might exist but can be `null`
 
     @property
     def multi_value_query_string_parameters(self) -> Dict[str, List[str]]:
-        return self.get("multiValueQueryStringParameters") or {}
+        return self.get("multiValueQueryStringParameters") or {}  # key might exist but can be `null`
 
     @property
     def resolved_query_string_parameters(self) -> Dict[str, List[str]]:
@@ -126,7 +127,7 @@ class APIGatewayProxyEvent(BaseProxyEvent):
         return super().resolved_query_string_parameters
 
     @property
-    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+    def resolved_headers_field(self) -> Dict[str, Any]:
         headers: Dict[str, Any] = {}
 
         if self.multi_value_headers:
@@ -154,72 +155,72 @@ class APIGatewayProxyEvent(BaseProxyEvent):
 
 class RequestContextV2AuthorizerIam(DictWrapper):
     @property
-    def access_key(self) -> Optional[str]:
+    def access_key(self) -> str:
         """The IAM user access key associated with the request."""
-        return self.get("accessKey")
+        return self.get("accessKey") or ""  # key might exist but can be `null`
 
     @property
-    def account_id(self) -> Optional[str]:
+    def account_id(self) -> str:
         """The AWS account ID associated with the request."""
-        return self.get("accountId")
+        return self.get("accountId") or ""  # key might exist but can be `null`
 
     @property
-    def caller_id(self) -> Optional[str]:
+    def caller_id(self) -> str:
         """The principal identifier of the caller making the request."""
-        return self.get("callerId")
+        return self.get("callerId") or ""  # key might exist but can be `null`
 
     def _cognito_identity(self) -> Dict:
-        return self.get("cognitoIdentity", {}) or {}  # not available in FunctionURL
+        return self.get("cognitoIdentity") or {}  # not available in FunctionURL; key might exist but can be `null`
 
     @property
-    def cognito_amr(self) -> Optional[List[str]]:
+    def cognito_amr(self) -> List[str]:
         """This represents how the user was authenticated.
         AMR stands for  Authentication Methods References as per the openid spec"""
-        return self._cognito_identity().get("amr")
+        return self._cognito_identity().get("amr", [])
 
     @property
-    def cognito_identity_id(self) -> Optional[str]:
+    def cognito_identity_id(self) -> str:
         """The Amazon Cognito identity ID of the caller making the request.
         Available only if the request was signed with Amazon Cognito credentials."""
-        return self._cognito_identity().get("identityId")
+        return self._cognito_identity().get("identityId", "")
 
     @property
-    def cognito_identity_pool_id(self) -> Optional[str]:
+    def cognito_identity_pool_id(self) -> str:
         """The Amazon Cognito identity pool ID of the caller making the request.
         Available only if the request was signed with Amazon Cognito credentials."""
-        return self._cognito_identity().get("identityPoolId")
+        return self._cognito_identity().get("identityPoolId") or ""  # key might exist but can be `null`
 
     @property
-    def principal_org_id(self) -> Optional[str]:
+    def principal_org_id(self) -> str:
         """The AWS organization ID."""
-        return self.get("principalOrgId")
+        return self.get("principalOrgId") or ""  # key might exist but can be `null`
 
     @property
-    def user_arn(self) -> Optional[str]:
+    def user_arn(self) -> str:
         """The Amazon Resource Name (ARN) of the effective user identified after authentication."""
-        return self.get("userArn")
+        return self.get("userArn") or ""  # key might exist but can be `null`
 
     @property
-    def user_id(self) -> Optional[str]:
+    def user_id(self) -> str:
         """The IAM user ID of the effective user identified after authentication."""
-        return self.get("userId")
+        return self.get("userId") or ""  # key might exist but can be `null`
 
 
 class RequestContextV2Authorizer(DictWrapper):
     @property
-    def jwt_claim(self) -> Optional[Dict[str, Any]]:
-        jwt = self.get("jwt") or {}  # not available in FunctionURL
-        return jwt.get("claims")
+    def jwt_claim(self) -> Dict[str, Any]:
+        jwt = self.get("jwt") or {}  # not available in FunctionURL; key might exist but can be `null`
+        return jwt.get("claims") or {}  # key might exist but can be `null`
 
     @property
-    def jwt_scopes(self) -> Optional[List[str]]:
-        jwt = self.get("jwt") or {}  # not available in FunctionURL
-        return jwt.get("scopes")
+    def jwt_scopes(self) -> List[str]:
+        jwt = self.get("jwt") or {}  # not available in FunctionURL; key might exist but can be `null`
+        return jwt.get("scopes", [])
 
     @property
-    def get_lambda(self) -> Optional[Dict[str, Any]]:
+    def get_lambda(self) -> Dict[str, Any]:
         """Lambda authorization context details"""
-        return self.get("lambda")
+        return self.get("lambda") or {}  # key might exist but can be `null`
 
     def get_context(self) -> Dict[str, Any]:
         """Retrieve the authorization context details injected by a Lambda Authorizer.
@@ -238,20 +239,20 @@ class RequestContextV2Authorizer(DictWrapper):
         Dict[str, Any]
             A dictionary containing Lambda authorization context details.
         """
-        return self.get("lambda", {}) or {}
+        return self.get_lambda
 
     @property
-    def iam(self) -> Optional[RequestContextV2AuthorizerIam]:
+    def iam(self) -> RequestContextV2AuthorizerIam:
         """IAM authorization details used for making the request."""
-        iam = self.get("iam")
-        return None if iam is None else RequestContextV2AuthorizerIam(iam)
+        iam = self.get("iam") or {}  # key might exist but can be `null`
+        return RequestContextV2AuthorizerIam(iam)
 
 
 class RequestContextV2(BaseRequestContextV2):
     @property
-    def authorizer(self) -> Optional[RequestContextV2Authorizer]:
-        authorizer = self["requestContext"].get("authorizer")
-        return None if authorizer is None else RequestContextV2Authorizer(authorizer)
+    def authorizer(self) -> RequestContextV2Authorizer:
+        ctx = self.get("requestContext") or {}  # key might exist but can be `null`
+        return RequestContextV2Authorizer(ctx.get("authorizer", {}))
 
 
 class APIGatewayProxyEventV2(BaseProxyEvent):
@@ -319,7 +320,7 @@ class APIGatewayProxyEventV2(BaseProxyEvent):
         return HttpApiHeadersSerializer()
 
     @property
-    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+    def resolved_headers_field(self) -> Dict[str, Any]:
         if self.headers is not None:
             headers = {key.lower(): value.split(",") if "," in value else value for key, value in self.headers.items()}
             return headers

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/utilities/data_classes/bedrock_agent_event.py

@@ -111,7 +111,7 @@ class BedrockAgentEvent(BaseProxyEvent):
         return {x["name"]: x["value"] for x in self["parameters"]} if self.get("parameters") else None
 
     @property
-    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+    def resolved_headers_field(self) -> Dict[str, Any]:
         return {}
 
     @cached_property

{aws_lambda_powertools-2.37.0 → aws_lambda_powertools-2.38.0}/aws_lambda_powertools/utilities/data_classes/common.py

@@ -124,7 +124,7 @@ class BaseProxyEvent(DictWrapper):
         return {}
 
     @property
-    def resolved_headers_field(self) -> Optional[Dict[str, Any]]:
+    def resolved_headers_field(self) -> Dict[str, Any]:
         """
         This property determines the appropriate header to be used
         as a trusted source for validating OpenAPI.