aws-lambda-powertools 3.31.1__tar.gz → 3.35.0__tar.gz

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aws_lambda_powertools
-Version: 3.31.1
+Version: 3.35.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.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/event_handler/api_gateway.py

@@ -3035,21 +3035,18 @@ class ApiGatewayResolver(BaseRouter):
             An optional prefix to be added to the originally defined rule
         """
 
-        # Add reference to parent ApiGatewayResolver to support use cases where people subclass it to add custom logic
-        router.api_resolver = self
-
         logger.debug("Merging App context with Router context")
         self.context.update(**router.context)
 
+        # Delegate request state to the resolver after preserving the router context.
+        router.api_resolver = self
+
         logger.debug("Appending Router middlewares into App middlewares.")
         self._router_middlewares = self._router_middlewares + router._router_middlewares
 
         logger.debug("Appending Router exception_handler into App exception_handler.")
         self.exception_handler_manager.update_exception_handlers(router._exception_handlers)
 
-        # use pointer to allow context clearance after event is processed e.g., resolve(evt, ctx)
-        router.context = self.context
-
         # Iterate through the routes defined in the router to configure and apply middlewares for each route
         for route, func in router._routes.items():
             new_route = route
@@ -3112,9 +3109,48 @@ class Router(BaseRouter):
         self._routes: dict[tuple, Callable] = {}
         self._routes_with_middleware: dict[tuple, list[Callable]] = {}
         self.api_resolver: BaseRouter | None = None
-        self.context = {}  # early init as customers might add context before event resolution
+        self._context: dict = {}  # early init as customers might add context before event resolution
         self._exception_handlers: dict[type, Callable] = {}
 
+    @property
+    def current_event(self) -> BaseProxyEvent:
+        if self.api_resolver is not None:
+            return self.api_resolver.current_event
+        return BaseRouter.current_event
+
+    @current_event.setter
+    def current_event(self, value: BaseProxyEvent) -> None:
+        if self.api_resolver is not None:
+            self.api_resolver.current_event = value
+        else:
+            BaseRouter.current_event = value
+
+    @property
+    def lambda_context(self) -> LambdaContext:
+        if self.api_resolver is not None:
+            return self.api_resolver.lambda_context
+        return BaseRouter.lambda_context
+
+    @lambda_context.setter
+    def lambda_context(self, value: LambdaContext) -> None:
+        if self.api_resolver is not None:
+            self.api_resolver.lambda_context = value
+        else:
+            BaseRouter.lambda_context = value
+
+    @property
+    def context(self) -> dict:
+        if self.api_resolver is not None:
+            return self.api_resolver.context
+        return self._context
+
+    @context.setter
+    def context(self, value: dict) -> None:
+        if self.api_resolver is not None:
+            self.api_resolver.context = value
+        else:
+            self._context = value
+
     def route(
         self,
         rule: str,

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/event_handler/http_resolver.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import base64
+from contextvars import ContextVar
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Callable
 from urllib.parse import parse_qs
 
@@ -13,6 +15,8 @@ from aws_lambda_powertools.shared.headers_serializer import BaseHeadersSerialize
 from aws_lambda_powertools.utilities.data_classes.common import BaseProxyEvent
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping, MutableMapping
+
     from aws_lambda_powertools.shared.cookies import Cookie
 
 
@@ -95,7 +99,7 @@ class HttpProxyEvent(BaseProxyEvent):
         return instance
 
     @classmethod
-    def from_asgi(cls, scope: dict[str, Any], body: bytes | None = None) -> HttpProxyEvent:
+    def from_asgi(cls, scope: Mapping[str, Any], body: bytes | None = None) -> HttpProxyEvent:
         """
         Create an HttpProxyEvent from an ASGI scope dict.
 
@@ -159,6 +163,14 @@ class MockLambdaContext:
         return 300000  # 5 minutes
 
 
+@dataclass
+class _RequestState:
+    event: BaseProxyEvent | None = None
+    lambda_context: Any = None
+    context: dict = field(default_factory=dict)
+    processed_stack_frames: list[str] = field(default_factory=list)
+
+
 class HttpResolverLocal(ApiGatewayResolver):
     """
     ASGI-compatible HTTP resolver.
@@ -204,6 +216,8 @@ class HttpResolverLocal(ApiGatewayResolver):
         strip_prefixes: list[str | Any] | None = None,
         enable_validation: bool = False,
     ):
+        self._startup_state = _RequestState()
+        self._request_state: ContextVar[_RequestState | None] = ContextVar("local_http_request", default=None)
         super().__init__(
             proxy_type=ProxyEventType.APIGatewayProxyEvent,  # Use REST API format internally
             cors=cors,
@@ -212,7 +226,46 @@ class HttpResolverLocal(ApiGatewayResolver):
             strip_prefixes=strip_prefixes,
             enable_validation=enable_validation,
         )
-        self._is_async_mode = False
+
+    @property
+    def _state(self) -> _RequestState:
+        return self._request_state.get() or self._startup_state
+
+    # Powertools declares these as mutable attributes. Properties preserve that
+    # interface while directing each task to its own state. asyncio.to_thread
+    # propagates the ContextVar, so middleware sees the same request dictionary.
+    @property
+    def current_event(self) -> BaseProxyEvent:
+        # Preserve the inherited synchronous resolve() path outside ASGI calls.
+        return self._state.event or BaseRouter.current_event
+
+    @current_event.setter
+    def current_event(self, value: BaseProxyEvent) -> None:
+        self._state.event = value
+
+    @property
+    def lambda_context(self) -> Any:
+        return self._state.lambda_context or BaseRouter.lambda_context
+
+    @lambda_context.setter
+    def lambda_context(self, value: Any) -> None:
+        self._state.lambda_context = value
+
+    @property
+    def context(self) -> dict:
+        return self._state.context
+
+    @context.setter
+    def context(self, value: dict) -> None:
+        self._state.context = value
+
+    @property
+    def processed_stack_frames(self) -> list[str]:
+        return self._state.processed_stack_frames
+
+    @processed_stack_frames.setter
+    def processed_stack_frames(self, value: list[str]) -> None:
+        self._state.processed_stack_frames = value
 
     def _to_proxy_event(self, event: dict) -> BaseProxyEvent:
         """Convert event dict to HttpProxyEvent."""
@@ -234,7 +287,7 @@ class HttpResolverLocal(ApiGatewayResolver):
         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:
+    async def asgi_handler(self, scope: MutableMapping[str, Any], receive: Callable, send: Callable) -> None:
         """
         ASGI interface - allows running with uvicorn/hypercorn/etc.
 
@@ -274,25 +327,27 @@ class HttpResolverLocal(ApiGatewayResolver):
         # Create mock Lambda context
         context: Any = MockLambdaContext()
 
-        # Set up resolver state (similar to resolve())
-        BaseRouter.current_event = self._to_proxy_event(event._data)
-        BaseRouter.lambda_context = context
-
-        self._is_async_mode = True
-
+        # Never write BaseRouter's class attributes: another ASGI request may
+        # enter while validation or the handler is awaiting I/O.
+        state = _RequestState(
+            event=self._to_proxy_event(event._data),
+            lambda_context=context,
+            context=self._startup_state.context.copy(),
+        )
+        token = self._request_state.set(state)
         try:
-            # Use async resolve
             response = await self._resolve_async()
         finally:
-            self._is_async_mode = False
-            self.clear_context()
+            # Reset only this task's binding. Middleware threads may still be
+            # unwinding after cancellation and retain their request's state.
+            self._request_state.reset(token)
 
         # Send HTTP response
         await self._send_response(send, response)
 
     async def __call__(  # type: ignore[override]
         self,
-        scope: dict,
+        scope: MutableMapping[str, Any],
         receive: Callable,
         send: Callable,
     ) -> None:

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/event_handler/openapi/schema_generator.py

@@ -174,9 +174,15 @@ def _build_operation_parameters(
             continue
 
         if _is_pydantic_model_param(field_info):
-            parameters.extend(_expand_pydantic_model_parameters(field_info))
+            generated_parameters = _expand_pydantic_model_parameters(field_info)
         else:
-            parameters.append(_create_regular_parameter(param, model_name_map, field_mapping))
+            generated_parameters = [_create_regular_parameter(param, model_name_map, field_mapping)]
+
+        parameters.extend(
+            parameter
+            for parameter in generated_parameters
+            if not (parameter["in"] == "header" and parameter["name"].lower() == "content-type")
+        )
 
     return parameters
 
@@ -532,7 +538,7 @@ def _resolve_response_payload(
     model_payload_typed = cast(OpenAPIResponseContentModel, payload)
     return_field = next(
         filter(
-            lambda model: model.type_ is model_payload_typed["model"],
+            lambda model: model.type_ == model_payload_typed["model"],
             dependant.response_extra_models,
         ),
     )

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/metrics/metrics.py

@@ -174,7 +174,6 @@ class Metrics:
         )
 
     def set_default_dimensions(self, **dimensions) -> None:
-        self.provider.set_default_dimensions(**dimensions)
         """Persist dimensions across Lambda invocations
 
         Parameters
@@ -195,9 +194,7 @@ class Metrics:
             def lambda_handler():
                 return True
         """
-        for name, value in dimensions.items():
-            self.add_dimension(name, value)
-
+        self.provider.set_default_dimensions(**dimensions)
         self.default_dimensions.update(**dimensions)
 
     def clear_default_dimensions(self) -> None:

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/metrics/provider/cloudwatch_emf/cloudwatch.py

@@ -87,7 +87,7 @@ class AmazonCloudWatchEMFProvider(BaseProvider):
     ):
         self.metric_set = metric_set if metric_set is not None else {}
         self.dimension_set = dimension_set if dimension_set is not None else {}
-        self.default_dimensions = default_dimensions or {}
+        self.default_dimensions = default_dimensions if default_dimensions is not None else {}
         self.namespace = resolve_env_var_choice(choice=namespace, env=os.getenv(constants.METRICS_NAMESPACE_ENV))
         self.service = resolve_env_var_choice(choice=service, env=os.getenv(constants.SERVICE_NAME_ENV))
         self.function_name = function_name
@@ -317,7 +317,7 @@ class AmazonCloudWatchEMFProvider(BaseProvider):
             )
             return
 
-        if name in self.dimension_set or name in self.default_dimensions:
+        if name in self.dimension_set and self.dimension_set[name] != value:
             warnings.warn(
                 f"Dimension '{name}' has already been added. The previous value will be overwritten.",
                 category=PowertoolsUserWarning,

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/shared/version.py

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

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/tracing/base.py

@@ -14,6 +14,7 @@ if TYPE_CHECKING:
     import numbers
     import traceback
     from collections.abc import Generator, Sequence
+    from contextlib import AbstractAsyncContextManager
 
 
 class BaseSegment(abc.ABC):
@@ -99,8 +100,7 @@ class BaseProvider(abc.ABC):
         """
 
     @abc.abstractmethod
-    @contextmanager
-    def in_subsegment_async(self, name=None, **kwargs) -> Generator[BaseSegment, None, None]:
+    def in_subsegment_async(self, name=None, **kwargs) -> AbstractAsyncContextManager[BaseSegment]:
         """Return a subsegment async context manger.
 
         Parameters

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/utilities/batch/exceptions.py

@@ -6,9 +6,9 @@ from __future__ import annotations
 
 import traceback
 from types import TracebackType
-from typing import Optional, Tuple, Type
+from typing import Tuple, Type
 
-ExceptionInfo = Tuple[Optional[Type[BaseException]], Optional[BaseException], Optional[TracebackType]]
+ExceptionInfo = Tuple[Type[BaseException] | None, BaseException | None, TracebackType | None]
 
 
 class BaseBatchProcessingError(Exception):

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/utilities/batch/types.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Optional, Type, TypedDict, Union
+from typing import Type, TypedDict, Union
 
 has_pydantic = "pydantic" in sys.modules
 
@@ -14,15 +14,16 @@ if has_pydantic:  # pragma: no cover
     )
     from aws_lambda_powertools.utilities.parser.models.kafka import KafkaRecordModel
 
-    BatchTypeModels = Optional[
+    BatchTypeModels = (
         Union[
             Type[SqsRecordModel],
             Type[DynamoDBStreamRecordModel],
             Type[KinesisDataStreamRecordModel],
             Type[KafkaRecordModel],
         ]
-    ]
-    BatchSqsTypeModel = Optional[Type[SqsRecordModel]]
+        | None
+    )
+    BatchSqsTypeModel = Type[SqsRecordModel] | None
 else:  # pragma: no cover
     BatchTypeModels = "BatchTypeModels"  # type: ignore
     BatchSqsTypeModel = "BatchSqsTypeModel"  # type: ignore

aws_lambda_powertools-3.35.0/aws_lambda_powertools/utilities/circuit_breaker/__init__.py

@@ -0,0 +1,29 @@
+"""
+Circuit Breaker utility for protecting unhealthy downstream dependencies.
+"""
+
+from aws_lambda_powertools.utilities.circuit_breaker.circuit_breaker import circuit_breaker
+from aws_lambda_powertools.utilities.circuit_breaker.config import CircuitBreakerConfig
+from aws_lambda_powertools.utilities.circuit_breaker.exceptions import (
+    CircuitBreakerConfigError,
+    CircuitBreakerError,
+    CircuitBreakerOpenError,
+    CircuitBreakerPersistenceError,
+)
+from aws_lambda_powertools.utilities.circuit_breaker.states import (
+    CircuitInfo,
+    CircuitState,
+    CircuitTransition,
+)
+
+__all__ = (
+    "circuit_breaker",
+    "CircuitBreakerConfig",
+    "CircuitInfo",
+    "CircuitState",
+    "CircuitTransition",
+    "CircuitBreakerError",
+    "CircuitBreakerOpenError",
+    "CircuitBreakerConfigError",
+    "CircuitBreakerPersistenceError",
+)

{aws_lambda_powertools-3.31.1/aws_lambda_powertools/utilities/circuit_breaker_alpha → aws_lambda_powertools-3.35.0/aws_lambda_powertools/utilities/circuit_breaker}/base.py

@@ -15,17 +15,17 @@ import threading
 import uuid
 from typing import TYPE_CHECKING, Any
 
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.exceptions import CircuitBreakerOpenError
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.states import CircuitState, CircuitTransition
+from aws_lambda_powertools.utilities.circuit_breaker.exceptions import CircuitBreakerOpenError
+from aws_lambda_powertools.utilities.circuit_breaker.states import CircuitState, CircuitTransition
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from aws_lambda_powertools.utilities.circuit_breaker_alpha.config import CircuitBreakerConfig
-    from aws_lambda_powertools.utilities.circuit_breaker_alpha.persistence.base import (
+    from aws_lambda_powertools.utilities.circuit_breaker.config import CircuitBreakerConfig
+    from aws_lambda_powertools.utilities.circuit_breaker.persistence.base import (
         CircuitBreakerPersistenceLayer,
     )
-    from aws_lambda_powertools.utilities.circuit_breaker_alpha.states import CircuitInfo
+    from aws_lambda_powertools.utilities.circuit_breaker.states import CircuitInfo
 
 logger = logging.getLogger(__name__)
 

{aws_lambda_powertools-3.31.1/aws_lambda_powertools/utilities/circuit_breaker_alpha → aws_lambda_powertools-3.35.0/aws_lambda_powertools/utilities/circuit_breaker}/circuit_breaker.py

@@ -12,14 +12,14 @@ from typing import TYPE_CHECKING, Any
 
 from aws_lambda_powertools.shared import constants
 from aws_lambda_powertools.shared.functions import strtobool
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.base import CircuitBreakerHandler
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.config import CircuitBreakerConfig
+from aws_lambda_powertools.utilities.circuit_breaker.base import CircuitBreakerHandler
+from aws_lambda_powertools.utilities.circuit_breaker.config import CircuitBreakerConfig
 from aws_lambda_powertools.warnings import PowertoolsUserWarning
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from aws_lambda_powertools.utilities.circuit_breaker_alpha.persistence.base import (
+    from aws_lambda_powertools.utilities.circuit_breaker.persistence.base import (
         CircuitBreakerPersistenceLayer,
     )
 
@@ -73,8 +73,8 @@ def circuit_breaker(
     -------
     **Protect a payment backend, buffering rejected requests**
 
-        from aws_lambda_powertools.utilities.circuit_breaker_alpha import circuit_breaker, CircuitInfo
-        from aws_lambda_powertools.utilities.circuit_breaker_alpha.persistence import (
+        from aws_lambda_powertools.utilities.circuit_breaker import circuit_breaker, CircuitInfo
+        from aws_lambda_powertools.utilities.circuit_breaker.persistence import (
             CircuitBreakerDynamoDBPersistence,
         )
 

{aws_lambda_powertools-3.31.1/aws_lambda_powertools/utilities/circuit_breaker_alpha → aws_lambda_powertools-3.35.0/aws_lambda_powertools/utilities/circuit_breaker}/config.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.exceptions import CircuitBreakerConfigError
+from aws_lambda_powertools.utilities.circuit_breaker.exceptions import CircuitBreakerConfigError
 
 if TYPE_CHECKING:
     from collections.abc import Iterable

{aws_lambda_powertools-3.31.1/aws_lambda_powertools/utilities/circuit_breaker_alpha → aws_lambda_powertools-3.35.0/aws_lambda_powertools/utilities/circuit_breaker}/exceptions.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from aws_lambda_powertools.utilities.circuit_breaker_alpha.states import CircuitInfo
+    from aws_lambda_powertools.utilities.circuit_breaker.states import CircuitInfo
 
 
 class CircuitBreakerError(Exception):

aws_lambda_powertools-3.35.0/aws_lambda_powertools/utilities/circuit_breaker/persistence/__init__.py

@@ -0,0 +1,15 @@
+"""
+Persistence layers for the Circuit Breaker utility.
+"""
+
+from aws_lambda_powertools.utilities.circuit_breaker.persistence.base import CircuitBreakerPersistenceLayer
+from aws_lambda_powertools.utilities.circuit_breaker.persistence.dynamodb import (
+    CircuitBreakerDynamoDBPersistence,
+)
+from aws_lambda_powertools.utilities.circuit_breaker.persistence.record import CircuitStateRecord
+
+__all__ = (
+    "CircuitBreakerPersistenceLayer",
+    "CircuitBreakerDynamoDBPersistence",
+    "CircuitStateRecord",
+)

{aws_lambda_powertools-3.31.1/aws_lambda_powertools/utilities/circuit_breaker_alpha → aws_lambda_powertools-3.35.0/aws_lambda_powertools/utilities/circuit_breaker}/persistence/base.py

@@ -15,11 +15,11 @@ from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, NamedTuple
 
 from aws_lambda_powertools.shared.cache_dict import LRUDict
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.persistence.record import CircuitStateRecord
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.states import CircuitState
+from aws_lambda_powertools.utilities.circuit_breaker.persistence.record import CircuitStateRecord
+from aws_lambda_powertools.utilities.circuit_breaker.states import CircuitState
 
 if TYPE_CHECKING:
-    from aws_lambda_powertools.utilities.circuit_breaker_alpha.config import CircuitBreakerConfig
+    from aws_lambda_powertools.utilities.circuit_breaker.config import CircuitBreakerConfig
 
 logger = logging.getLogger(__name__)
 

{aws_lambda_powertools-3.31.1/aws_lambda_powertools/utilities/circuit_breaker_alpha → aws_lambda_powertools-3.35.0/aws_lambda_powertools/utilities/circuit_breaker}/persistence/dynamodb.py

@@ -15,13 +15,13 @@ from boto3.dynamodb.types import TypeDeserializer
 from botocore.exceptions import ClientError
 
 from aws_lambda_powertools.shared import constants, user_agent
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.exceptions import CircuitBreakerConfigError
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.persistence.base import (
+from aws_lambda_powertools.utilities.circuit_breaker.exceptions import CircuitBreakerConfigError
+from aws_lambda_powertools.utilities.circuit_breaker.persistence.base import (
     CircuitBreakerExistingLockError,
     CircuitBreakerPersistenceLayer,
 )
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.persistence.record import CircuitStateRecord
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.states import CircuitState
+from aws_lambda_powertools.utilities.circuit_breaker.persistence.record import CircuitStateRecord
+from aws_lambda_powertools.utilities.circuit_breaker.states import CircuitState
 from aws_lambda_powertools.warnings import PowertoolsUserWarning
 
 if TYPE_CHECKING:
@@ -75,7 +75,7 @@ class CircuitBreakerDynamoDBPersistence(CircuitBreakerPersistenceLayer):
     -------
     **Create a DynamoDB-backed circuit breaker store**
 
-        from aws_lambda_powertools.utilities.circuit_breaker_alpha.persistence import (
+        from aws_lambda_powertools.utilities.circuit_breaker.persistence import (
             CircuitBreakerDynamoDBPersistence,
         )
 

{aws_lambda_powertools-3.31.1/aws_lambda_powertools/utilities/circuit_breaker_alpha → aws_lambda_powertools-3.35.0/aws_lambda_powertools/utilities/circuit_breaker}/persistence/record.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from aws_lambda_powertools.utilities.circuit_breaker_alpha.states import CircuitInfo, CircuitState
+from aws_lambda_powertools.utilities.circuit_breaker.states import CircuitInfo, CircuitState
 
 
 @dataclass

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/utilities/data_classes/api_gateway_authorizer_event.py

@@ -520,8 +520,11 @@ class APIGatewayAuthorizerResponse:
         """Adds a route to the internal lists of allowed or denied routes. Each object in
         the internal list contains a resource ARN and a condition statement. The condition
         statement can be null."""
-        if http_method != "*" and http_method not in HttpVerb.__members__:
-            allowed_values = [verb.value for verb in HttpVerb]
+        allowed_values = [verb.value for verb in HttpVerb]
+        if http_method in HttpVerb.__members__:
+            http_method = HttpVerb[http_method].value
+
+        if http_method not in allowed_values:
             raise ValueError(f"Invalid HTTP verb: '{http_method}'. Use either '{allowed_values}'")
 
         if not self._resource_pattern.match(resource):

{aws_lambda_powertools-3.31.1 → aws_lambda_powertools-3.35.0}/aws_lambda_powertools/utilities/data_masking/base.py

@@ -16,11 +16,11 @@ from typing import TYPE_CHECKING, Any
 from jsonpath_ng.ext import parse
 
 from aws_lambda_powertools.utilities.data_masking.exceptions import (
+    DataMaskingError,
     DataMaskingFieldNotFoundError,
     DataMaskingUnsupportedTypeError,
 )
 from aws_lambda_powertools.utilities.data_masking.provider import BaseProvider
-from aws_lambda_powertools.warnings import PowertoolsUserWarning
 
 if TYPE_CHECKING:
     from collections.abc import Callable, Mapping, Sequence
@@ -395,10 +395,10 @@ class DataMasking:
             if not result_parse:
                 if self.raise_on_missing_field:
                     # If the data for the field is not found, raise an exception.
-                    raise DataMaskingFieldNotFoundError(f"Field or expression {field_parse} not found in {data_parsed}")
+                    raise DataMaskingFieldNotFoundError(f"Field or expression {field_parse} not found")
                 else:
                     # If the data for the field is not found, warning.
-                    warnings.warn(f"Field or expression {field_parse} not found in {data_parsed}", stacklevel=2)
+                    warnings.warn(f"Field or expression {field_parse} not found", stacklevel=2)
 
             # For in-place updates, json_parse accepts a callback function
             # that receives 3 args: field_value, fields, field_name
@@ -427,31 +427,30 @@ class DataMasking:
         for path, rule in masking_rules.items():
             try:
                 jsonpath_expr = parse(f"$.{path}")
-                matches = jsonpath_expr.find(result)
+            except Exception as exc:
+                raise DataMaskingError(f"Invalid masking path: {path}") from exc
 
-                if not matches:
-                    warnings.warn(f"No matches found for path: {path}", stacklevel=2)
-                    continue
+            matches = jsonpath_expr.find(result)
+            if not matches:
+                if self.raise_on_missing_field:
+                    raise DataMaskingFieldNotFoundError(f"Field or expression {path} not found")
 
-                for match in matches:
-                    try:
-                        value = match.value
-                        if value is not None:
-                            masked_value = self.provider.erase(str(value), **rule)
-                            match.full_path.update(result, masked_value)
-
-                    except Exception as e:
-                        warnings.warn(
-                            f"Error masking value for path {path}: {str(e)}",
-                            category=PowertoolsUserWarning,
-                            stacklevel=2,
-                        )
-                        continue
-
-            except Exception as e:
-                warnings.warn(f"Error processing path {path}: {str(e)}", category=PowertoolsUserWarning, stacklevel=2)
+                warnings.warn(f"No matches found for path: {path}", stacklevel=2)
                 continue
 
+            for match in matches:
+                value = match.value
+                if value is None:
+                    continue
+
+                try:
+                    masked_value = self.provider.erase(str(value), **rule)
+                    match.full_path.update(result, masked_value)
+                except DataMaskingError:
+                    raise
+                except Exception as exc:
+                    raise DataMaskingError(f"Failed to mask field at path: {path}") from exc
+
         return result
 
     def _mask_nested_field(self, data: dict, field_path: str, mask_function):