aws-lambda-powertools 3.25.0__tar.gz → 3.26.0__tar.gz

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aws_lambda_powertools
-Version: 3.25.0
+Version: 3.26.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.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/event_handler/middlewares/openapi_validation.py

@@ -228,20 +228,27 @@ class OpenAPIResponseValidationMiddleware(BaseMiddlewareHandler):
         return self._handle_response(route=route, response=response)
 
     def _handle_response(self, *, route: Route, response: Response):
-        # Process the response body if it exists
-        if response.body and response.is_json():
-            response.body = self._serialize_response(
-                field=route.dependant.return_param,
+        field = route.dependant.return_param
+
+        if field is None:
+            if not response.is_json():
+                return response
+            else:
+                # JSON serialize the body without validation
+                response.body = jsonable_encoder(response.body, custom_serializer=self._validation_serializer)
+        else:
+            response.body = self._serialize_response_with_validation(
+                field=field,
                 response_content=response.body,
                 has_route_custom_response_validation=route.custom_response_validation_http_code is not None,
             )
 
         return response
 
-    def _serialize_response(
+    def _serialize_response_with_validation(
         self,
         *,
-        field: ModelField | None = None,
+        field: ModelField,
         response_content: Any,
         include: IncEx | None = None,
         exclude: IncEx | None = None,
@@ -254,33 +261,23 @@ class OpenAPIResponseValidationMiddleware(BaseMiddlewareHandler):
         """
         Serialize the response content according to the field type.
         """
-        if field:
-            errors: list[dict[str, Any]] = []
-            value = _validate_field(field=field, value=response_content, loc=("response",), existing_errors=errors)
-            if errors:
-                # route-level validation must take precedence over app-level
-                if has_route_custom_response_validation:
-                    raise ResponseValidationError(
-                        errors=_normalize_errors(errors),
-                        body=response_content,
-                        source="route",
-                    )
-                if self._has_response_validation_error:
-                    raise ResponseValidationError(errors=_normalize_errors(errors), body=response_content, source="app")
-
-                raise RequestValidationError(errors=_normalize_errors(errors), body=response_content)
-
-            if hasattr(field, "serialize"):
-                return field.serialize(
-                    value,
-                    include=include,
-                    exclude=exclude,
-                    by_alias=by_alias,
-                    exclude_unset=exclude_unset,
-                    exclude_defaults=exclude_defaults,
-                    exclude_none=exclude_none,
+        errors: list[dict[str, Any]] = []
+        value = _validate_field(field=field, value=response_content, loc=("response",), existing_errors=errors)
+        if errors:
+            # route-level validation must take precedence over app-level
+            if has_route_custom_response_validation:
+                raise ResponseValidationError(
+                    errors=_normalize_errors(errors),
+                    body=response_content,
+                    source="route",
                 )
-            return jsonable_encoder(
+            if self._has_response_validation_error:
+                raise ResponseValidationError(errors=_normalize_errors(errors), body=response_content, source="app")
+
+            raise RequestValidationError(errors=_normalize_errors(errors), body=response_content)
+
+        if hasattr(field, "serialize"):
+            return field.serialize(
                 value,
                 include=include,
                 exclude=exclude,
@@ -288,11 +285,18 @@ class OpenAPIResponseValidationMiddleware(BaseMiddlewareHandler):
                 exclude_unset=exclude_unset,
                 exclude_defaults=exclude_defaults,
                 exclude_none=exclude_none,
-                custom_serializer=self._validation_serializer,
             )
-        else:
-            # Just serialize the response content returned from the handler.
-            return jsonable_encoder(response_content, custom_serializer=self._validation_serializer)
+
+        return jsonable_encoder(
+            value,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            custom_serializer=self._validation_serializer,
+        )
 
     def _prepare_response_content(
         self,

aws_lambda_powertools-3.26.0/aws_lambda_powertools/logging/buffer/handler.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from aws_lambda_powertools.logging.buffer.functions import _check_minimum_buffer_log_level
+
+if TYPE_CHECKING:
+    from aws_lambda_powertools.logging.buffer.cache import LoggerBufferCache
+    from aws_lambda_powertools.logging.buffer.config import LoggerBufferConfig
+    from aws_lambda_powertools.logging.logger import Logger
+
+
+class BufferingHandler(logging.Handler):
+    """
+    Handler that buffers logs from external libraries using the source logger's buffer.
+
+    The handler intercepts log records from external libraries and
+    stores them in the source logger's buffer using the same tracer_id mechanism.
+    Logs above the buffer verbosity threshold are emitted directly through the source logger.
+    Logs at or below the threshold are buffered and flushed together with application logs.
+    """
+
+    def __init__(
+        self,
+        buffer_cache: LoggerBufferCache,
+        buffer_config: LoggerBufferConfig,
+        source_logger: Logger,
+    ):
+        """
+        Initialize the BufferingHandler.
+
+        Parameters
+        ----------
+        buffer_cache : LoggerBufferCache
+            Shared buffer cache from the source logger
+        buffer_config : LoggerBufferConfig
+            Buffer configuration from the source logger
+        source_logger : Logger
+            The Powertools Logger instance to delegate buffering logic to
+        """
+        super().__init__()
+        self.buffer_cache = buffer_cache
+        self.buffer_config = buffer_config
+        self.source_logger = source_logger
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """
+        Buffer or emit the log record based on the buffer verbosity threshold.
+
+        Logs above the configured buffer_at_verbosity are emitted directly
+        through the source logger. Logs at or below the threshold are buffered.
+
+        Parameters
+        ----------
+        record : logging.LogRecord
+            The log record from an external logger
+        """
+        level_name = logging.getLevelName(record.levelno)
+
+        # If log level exceeds buffer threshold, emit directly through source logger
+        if _check_minimum_buffer_log_level(self.buffer_config.buffer_at_verbosity, level_name):
+            self.source_logger._logger.handle(record)
+            return
+
+        self.source_logger._add_log_record_to_buffer(
+            level=record.levelno,
+            msg=record.msg,
+            args=record.args,
+            exc_info=record.exc_info,
+            stack_info=False,
+        )

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/logging/utils.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING
 
+from aws_lambda_powertools.logging.buffer.handler import BufferingHandler
+
 if TYPE_CHECKING:
     from collections.abc import Callable
 
@@ -16,6 +18,7 @@ def copy_config_to_registered_loggers(
     source_logger: Logger,
     log_level: int | str | None = None,
     ignore_log_level=False,
+    include_buffering=False,
     exclude: set[str] | None = None,
     include: set[str] | None = None,
 ) -> None:
@@ -30,6 +33,8 @@ def copy_config_to_registered_loggers(
         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_buffering: bool
+        Whether to buffer logs from external libraries and report to powertools logger
     include : set[str] | None, optional
         List of logger names to include, by default all registered loggers are included
     exclude : set[str] | None, optional
@@ -64,7 +69,13 @@ def copy_config_to_registered_loggers(
 
     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)
+        _configure_logger(
+            source_logger=source_logger,
+            logger=logger,
+            level=level,
+            ignore_log_level=ignore_log_level,
+            include_buffering=include_buffering,
+        )
 
 
 def _include_registered_loggers_filter(loggers: set[str]):
@@ -92,6 +103,7 @@ def _configure_logger(
     logger: logging.Logger,
     level: int | str,
     ignore_log_level: bool = False,
+    include_buffering: bool = False,
 ) -> None:
     # customers may not want to copy the same log level from Logger to discovered loggers
     if not ignore_log_level:
@@ -102,6 +114,17 @@ def _configure_logger(
     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
 
+    buffer_config = getattr(source_logger, "_buffer_config", None)
+    if include_buffering and buffer_config is not None:
+        buffer_handler = BufferingHandler(
+            buffer_cache=source_logger._buffer_cache,
+            buffer_config=buffer_config,
+            source_logger=source_logger,
+        )
+        logger.addHandler(buffer_handler)
+        LOGGER.debug(f"Logger {logger} configured with BufferingHandler")
+        return  # exit earlier and don't add source handlers, would cause double logging
+
     for source_handler in source_logger.handlers:
         logger.addHandler(source_handler)
         LOGGER.debug(f"Logger {logger} reconfigured to use {source_handler}")

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/shared/constants.py

@@ -67,5 +67,12 @@ POWERTOOLS_DEBUG_ENV: str = "POWERTOOLS_DEBUG"
 PRETTY_INDENT: int = 4
 COMPACT_INDENT: None = None
 
+# Metadata constants
+LAMBDA_METADATA_API_ENV: str = "AWS_LAMBDA_METADATA_API"
+LAMBDA_METADATA_TOKEN_ENV: str = "AWS_LAMBDA_METADATA_TOKEN"
+METADATA_API_VERSION: str = "2026-01-15"
+METADATA_PATH: str = "/metadata/execution-environment"
+METADATA_DEFAULT_TIMEOUT_SECS: float = 1.0
+
 # Idempotency constants
 IDEMPOTENCY_DISABLED_ENV: str = "POWERTOOLS_IDEMPOTENCY_DISABLED"

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/shared/version.py

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

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/utilities/batch/base.py

@@ -25,6 +25,9 @@ from aws_lambda_powertools.utilities.batch.types import BatchTypeModels
 from aws_lambda_powertools.utilities.data_classes.dynamo_db_stream_event import (
     DynamoDBRecord,
 )
+from aws_lambda_powertools.utilities.data_classes.kafka_event import (
+    KafkaEventRecord,
+)
 from aws_lambda_powertools.utilities.data_classes.kinesis_stream_event import (
     KinesisStreamRecord,
 )
@@ -46,12 +49,13 @@ class EventType(Enum):
     SQS = "SQS"
     KinesisDataStreams = "KinesisDataStreams"
     DynamoDBStreams = "DynamoDBStreams"
+    Kafka = "Kafka"
 
 
 # When using processor with default arguments, records will carry EventSourceDataClassTypes
 # and depending on what EventType it's passed it'll correctly map to the right record
-# When using Pydantic Models, it'll accept any subclass from SQS, DynamoDB and Kinesis
-EventSourceDataClassTypes = Union[SQSRecord, KinesisStreamRecord, DynamoDBRecord]
+# When using Pydantic Models, it'll accept any subclass from SQS, DynamoDB, Kinesis and Kafka
+EventSourceDataClassTypes = Union[SQSRecord, KinesisStreamRecord, DynamoDBRecord, KafkaEventRecord]
 BatchEventTypes = Union[EventSourceDataClassTypes, BatchTypeModels]
 SuccessResponse = Tuple[str, Any, BatchEventTypes]
 FailureResponse = Tuple[str, str, BatchEventTypes]
@@ -272,11 +276,13 @@ class BasePartialBatchProcessor(BasePartialProcessor):  # noqa
             EventType.SQS: self._collect_sqs_failures,
             EventType.KinesisDataStreams: self._collect_kinesis_failures,
             EventType.DynamoDBStreams: self._collect_dynamodb_failures,
+            EventType.Kafka: self._collect_kafka_failures,
         }
         self._DATA_CLASS_MAPPING = {
             EventType.SQS: SQSRecord,
             EventType.KinesisDataStreams: KinesisStreamRecord,
             EventType.DynamoDBStreams: DynamoDBRecord,
+            EventType.Kafka: KafkaEventRecord,
         }
 
         super().__init__()
@@ -365,6 +371,21 @@ class BasePartialBatchProcessor(BasePartialProcessor):  # noqa
             failures.append({"itemIdentifier": msg_id})
         return failures
 
+    def _collect_kafka_failures(self):
+        failures = []
+        for msg in self.fail_messages:
+            # Kafka uses a composite identifier with partition and offset
+            # Both data class and Pydantic model use the same field names
+            failures.append(
+                {
+                    "itemIdentifier": {
+                        "partition": f"{msg.topic}-{msg.partition}",
+                        "offset": msg.offset,
+                    },
+                },
+            )
+        return failures
+
     @overload
     def _to_batch_type(
         self,

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/utilities/batch/decorators.py

@@ -22,6 +22,47 @@ if TYPE_CHECKING:
     from aws_lambda_powertools.utilities.typing import LambdaContext
 
 
+def _get_records_from_event(
+    event: dict[str, Any],
+    processor: BasePartialBatchProcessor,
+) -> list[dict]:
+    """
+    Extract records from the event based on the processor's event type.
+
+    For SQS, Kinesis, and DynamoDB: Records are in event["Records"] as a list
+    For Kafka: Records are in event["records"] as a dict with topic-partition keys
+
+    Parameters
+    ----------
+    event: dict
+        Lambda's original event
+    processor: BasePartialBatchProcessor
+        Batch Processor to determine event type
+
+    Returns
+    -------
+    records: list[dict]
+        Flattened list of records to process
+    """
+    # Kafka events use lowercase "records" and have a nested dict structure
+    if processor.event_type == EventType.Kafka:
+        kafka_records = event.get("records", {})
+        if not kafka_records or not isinstance(kafka_records, dict):
+            raise UnexpectedBatchTypeError(
+                "Invalid Kafka event structure. Expected 'records' to be a non-empty dict with topic-partition keys.",
+            )
+        # Flatten the nested dict: {"topic-0": [r1, r2], "topic-1": [r3]} -> [r1, r2, r3]
+        return [record for topic_records in kafka_records.values() for record in topic_records]
+
+    # SQS, Kinesis, DynamoDB use uppercase "Records" as a list
+    records = event.get("Records", [])
+    if not records or not isinstance(records, list):
+        raise UnexpectedBatchTypeError(
+            "Unexpected batch event type. Possible values are: SQS, KinesisDataStreams, DynamoDBStreams, Kafka",
+        )
+    return records
+
+
 @lambda_handler_decorator
 @deprecated(
     "`async_batch_processor` decorator is deprecated; use `async_process_partial_response` function instead.",
@@ -206,12 +247,7 @@ def process_partial_response(
     * Async batch processors. Use `async_process_partial_response` instead.
     """
     try:
-        records: list[dict] = event.get("Records", [])
-        if not records or not isinstance(records, list):
-            raise UnexpectedBatchTypeError(
-                "Unexpected batch event type. Possible values are: SQS, KinesisDataStreams, DynamoDBStreams",
-            )
-
+        records = _get_records_from_event(event, processor)
     except AttributeError:
         event_types = ", ".join(list(EventType.__members__))
         docs = "https://docs.powertools.aws.dev/lambda/python/latest/utilities/batch/#processing-messages-from-sqs"  # noqa: E501 # long-line
@@ -275,12 +311,7 @@ def async_process_partial_response(
     * Sync batch processors. Use `process_partial_response` instead.
     """
     try:
-        records: list[dict] = event.get("Records", [])
-        if not records or not isinstance(records, list):
-            raise UnexpectedBatchTypeError(
-                "Unexpected batch event type. Possible values are: SQS, KinesisDataStreams, DynamoDBStreams",
-            )
-
+        records = _get_records_from_event(event, processor)
     except AttributeError:
         event_types = ", ".join(list(EventType.__members__))
         docs = "https://docs.powertools.aws.dev/lambda/python/latest/utilities/batch/#processing-messages-from-sqs"  # noqa: E501 # long-line

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/utilities/batch/types.py

@@ -12,9 +12,15 @@ if has_pydantic:  # pragma: no cover
     from aws_lambda_powertools.utilities.parser.models import (
         KinesisDataStreamRecord as KinesisDataStreamRecordModel,
     )
+    from aws_lambda_powertools.utilities.parser.models.kafka import KafkaRecordModel
 
     BatchTypeModels = Optional[
-        Union[Type[SqsRecordModel], Type[DynamoDBStreamRecordModel], Type[KinesisDataStreamRecordModel]]
+        Union[
+            Type[SqsRecordModel],
+            Type[DynamoDBStreamRecordModel],
+            Type[KinesisDataStreamRecordModel],
+            Type[KafkaRecordModel],
+        ]
     ]
     BatchSqsTypeModel = Optional[Type[SqsRecordModel]]
 else:  # pragma: no cover
@@ -22,8 +28,22 @@ else:  # pragma: no cover
     BatchSqsTypeModel = "BatchSqsTypeModel"  # type: ignore
 
 
+class KafkaItemIdentifier(TypedDict):
+    """Kafka uses a composite identifier with partition and offset."""
+
+    partition: str
+    offset: int
+
+
 class PartialItemFailures(TypedDict):
-    itemIdentifier: str
+    """
+    Represents a partial item failure response.
+
+    For SQS, Kinesis, and DynamoDB: itemIdentifier is a string (message_id or sequence_number)
+    For Kafka: itemIdentifier is a KafkaItemIdentifier dict with partition and offset
+    """
+
+    itemIdentifier: str | KafkaItemIdentifier
 
 
 class PartialItemFailureResponse(TypedDict):

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/utilities/data_classes/api_gateway_authorizer_event.py

@@ -14,7 +14,7 @@ from aws_lambda_powertools.utilities.data_classes.common import (
     DictWrapper,
 )
 from aws_lambda_powertools.utilities.data_classes.shared_functions import (
-    get_header_value,
+    get_header_value,  # ty: ignore[deprecated]
 )
 from aws_lambda_powertools.warnings import PowertoolsDeprecationWarning
 
@@ -232,7 +232,7 @@ class APIGatewayAuthorizerRequestEvent(DictWrapper):
             category=PowertoolsDeprecationWarning,
             stacklevel=2,
         )
-        return get_header_value(self.headers, name, default_value, case_sensitive)
+        return get_header_value(self.headers, name, default_value, case_sensitive)  # ty: ignore[deprecated]
 
 
 class APIGatewayAuthorizerEventV2(DictWrapper):
@@ -358,7 +358,7 @@ class APIGatewayAuthorizerEventV2(DictWrapper):
             category=PowertoolsDeprecationWarning,
             stacklevel=2,
         )
-        return get_header_value(self.headers, name, default_value, case_sensitive)
+        return get_header_value(self.headers, name, default_value, case_sensitive)  # ty: ignore[deprecated]
 
 
 class APIGatewayAuthorizerResponseV2:
@@ -691,12 +691,12 @@ class APIGatewayAuthorizerResponseWebSocket(APIGatewayAuthorizerResponse):
             self._deny_routes.append(route)
 
     @override
-    def allow_all_routes(self):
+    def allow_all_routes(self, http_method: str = HttpVerb.ALL.value):  # type: ignore[override]  # noqa: ARG002
         """Adds a '*' allow to the policy to authorize access to all methods of an API"""
         self._add_route(effect="Allow", resource="*")
 
     @override
-    def deny_all_routes(self):
+    def deny_all_routes(self, http_method: str = HttpVerb.ALL.value):  # type: ignore[override]  # noqa: ARG002
         """Adds a '*' allow to the policy to deny access to all methods of an API"""
 
         self._add_route(effect="Deny", resource="*")

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/utilities/data_classes/appsync/scalar_types_utils.py

@@ -55,7 +55,7 @@ def aws_date(timezone_offset: int = 0) -> str:
     str
         Returns current time as AWSDate scalar string with optional timezone offset
     """
-    return _formatted_time(datetime.datetime.utcnow(), "%Y-%m-%d", timezone_offset)
+    return _formatted_time(datetime.datetime.now(datetime.timezone.utc), "%Y-%m-%d", timezone_offset)
 
 
 def aws_time(timezone_offset: int = 0) -> str:
@@ -71,7 +71,7 @@ def aws_time(timezone_offset: int = 0) -> str:
     str
         Returns current time as AWSTime scalar string with optional timezone offset
     """
-    return _formatted_time(datetime.datetime.utcnow(), "%H:%M:%S.%f", timezone_offset)
+    return _formatted_time(datetime.datetime.now(datetime.timezone.utc), "%H:%M:%S.%f", timezone_offset)
 
 
 def aws_datetime(timezone_offset: int = 0) -> str:
@@ -87,7 +87,7 @@ def aws_datetime(timezone_offset: int = 0) -> str:
     str
         Returns current time as AWSDateTime scalar string with optional timezone offset
     """
-    return _formatted_time(datetime.datetime.utcnow(), "%Y-%m-%dT%H:%M:%S.%f", timezone_offset)
+    return _formatted_time(datetime.datetime.now(datetime.timezone.utc), "%Y-%m-%dT%H:%M:%S.%f", timezone_offset)
 
 
 def aws_timestamp() -> int:

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/utilities/data_classes/appsync_resolver_event.py

@@ -7,7 +7,7 @@ from typing_extensions import deprecated
 
 from aws_lambda_powertools.utilities.data_classes.common import CaseInsensitiveDict, DictWrapper
 from aws_lambda_powertools.utilities.data_classes.shared_functions import (
-    get_header_value,
+    get_header_value,  # ty: ignore[deprecated]
 )
 from aws_lambda_powertools.warnings import PowertoolsDeprecationWarning
 
@@ -275,4 +275,4 @@ class AppSyncResolverEvent(AppSyncEventBase):
             category=PowertoolsDeprecationWarning,
             stacklevel=2,
         )
-        return get_header_value(self.request_headers, name, default_value, case_sensitive)
+        return get_header_value(self.request_headers, name, default_value, case_sensitive)  # ty: ignore[deprecated]

{aws_lambda_powertools-3.25.0 → aws_lambda_powertools-3.26.0}/aws_lambda_powertools/utilities/data_classes/common.py

@@ -23,7 +23,7 @@ if TYPE_CHECKING:
     from aws_lambda_powertools.shared.headers_serializer import BaseHeadersSerializer
 
 from aws_lambda_powertools.utilities.data_classes.shared_functions import (
-    get_header_value,
+    get_header_value,  # ty: ignore[deprecated]
     get_multi_value_query_string_values,
     get_query_string_value,
 )
@@ -39,8 +39,8 @@ class CaseInsensitiveDict(dict):
     def get(self, k, default=None):
         return super().get(k.lower(), default)
 
-    def pop(self, k):
-        return super().pop(k.lower())
+    def pop(self, k, *args):
+        return super().pop(k.lower(), *args)
 
     def setdefault(self, k, default=None):
         return super().setdefault(k.lower(), default)
@@ -125,7 +125,7 @@ class DictWrapper(Mapping):
         properties = self._properties()
         sensitive_properties = ["raw_event"]
         if hasattr(self, "_sensitive_properties"):
-            sensitive_properties.extend(self._sensitive_properties)  # pyright: ignore
+            sensitive_properties.extend(self._sensitive_properties)  # pyright: ignore  # type: ignore[arg-type]
 
         result: dict[str, Any] = {}
         for property_key in properties:
@@ -142,7 +142,7 @@ class DictWrapper(Mapping):
                     # Checks if the key is a list and if it is a subclass of the parent class
                     elif isinstance(property_value, list):
                         for seq, item in enumerate(property_value):
-                            if issubclass(item.__class__, DictWrapper):
+                            if issubclass(item.__class__, DictWrapper) and isinstance(item, DictWrapper):
                                 result[property_key][seq] = item._str_helper()
                 except Exception:
                     result[property_key] = "[Cannot be deserialized]"
@@ -331,7 +331,7 @@ class BaseProxyEvent(DictWrapper):
             category=PowertoolsDeprecationWarning,
             stacklevel=2,
         )
-        return get_header_value(
+        return get_header_value(  # ty: ignore[deprecated]
             headers=self.headers,
             name=name,
             default_value=default_value,

aws_lambda_powertools-3.26.0/aws_lambda_powertools/utilities/metadata/__init__.py

@@ -0,0 +1,17 @@
+"""
+Utility to fetch data from the AWS Lambda Metadata Endpoint
+"""
+
+from aws_lambda_powertools.utilities.metadata.exceptions import LambdaMetadataError
+from aws_lambda_powertools.utilities.metadata.lambda_metadata import (
+    LambdaMetadata,
+    clear_metadata_cache,
+    get_lambda_metadata,
+)
+
+__all__ = [
+    "LambdaMetadata",
+    "LambdaMetadataError",
+    "get_lambda_metadata",
+    "clear_metadata_cache",
+]

aws_lambda_powertools-3.26.0/aws_lambda_powertools/utilities/metadata/exceptions.py

@@ -0,0 +1,11 @@
+"""
+Lambda Metadata Service exceptions
+"""
+
+
+class LambdaMetadataError(Exception):
+    """Raised when the Lambda Metadata Endpoint is unavailable or returns an error."""
+
+    def __init__(self, message: str, status_code: int = -1):
+        self.status_code = status_code
+        super().__init__(message)