aws-lambda-powertools 3.8.1a6__py3-none-any.whl → 3.8.1a8__py3-none-any.whl

aws_lambda_powertools/utilities/data_classes/common.py

@@ -205,7 +205,6 @@ class BaseProxyEvent(DictWrapper):
         """Parses the submitted body as json"""
         if self.decoded_body:
             return self._json_deserializer(self.decoded_body)
-
         return None
 
     @cached_property
@@ -370,81 +369,81 @@ class RequestContextClientCert(DictWrapper):
 class APIGatewayEventIdentity(DictWrapper):
     @property
     def access_key(self) -> str | None:
-        return self["requestContext"]["identity"].get("accessKey")
+        return self.get("accessKey")
 
     @property
     def account_id(self) -> str | None:
         """The AWS account ID associated with the request."""
-        return self["requestContext"]["identity"].get("accountId")
+        return self.get("accountId")
 
     @property
     def api_key(self) -> str | None:
         """For API methods that require an API key, this variable is the API key associated with the method request.
         For methods that don't require an API key, this variable is null."""
-        return self["requestContext"]["identity"].get("apiKey")
+        return self.get("apiKey")
 
     @property
     def api_key_id(self) -> str | None:
         """The API key ID associated with an API request that requires an API key."""
-        return self["requestContext"]["identity"].get("apiKeyId")
+        return self.get("apiKeyId")
 
     @property
     def caller(self) -> str | None:
         """The principal identifier of the caller making the request."""
-        return self["requestContext"]["identity"].get("caller")
+        return self.get("caller")
 
     @property
     def cognito_authentication_provider(self) -> str | None:
         """A comma-separated list of the Amazon Cognito authentication providers used by the caller
         making the request. Available only if the request was signed with Amazon Cognito credentials."""
-        return self["requestContext"]["identity"].get("cognitoAuthenticationProvider")
+        return self.get("cognitoAuthenticationProvider")
 
     @property
     def cognito_authentication_type(self) -> str | None:
         """The Amazon Cognito authentication type of the caller making the request.
         Available only if the request was signed with Amazon Cognito credentials."""
-        return self["requestContext"]["identity"].get("cognitoAuthenticationType")
+        return self.get("cognitoAuthenticationType")
 
     @property
     def cognito_identity_id(self) -> str | None:
         """The Amazon Cognito identity ID of the caller making the request.
         Available only if the request was signed with Amazon Cognito credentials."""
-        return self["requestContext"]["identity"].get("cognitoIdentityId")
+        return self.get("cognitoIdentityId")
 
     @property
     def cognito_identity_pool_id(self) -> str | None:
         """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["requestContext"]["identity"].get("cognitoIdentityPoolId")
+        return self.get("cognitoIdentityPoolId")
 
     @property
     def principal_org_id(self) -> str | None:
         """The AWS organization ID."""
-        return self["requestContext"]["identity"].get("principalOrgId")
+        return self.get("principalOrgId")
 
     @property
     def source_ip(self) -> str:
         """The source IP address of the TCP connection making the request to API Gateway."""
-        return self["requestContext"]["identity"]["sourceIp"]
+        return self["sourceIp"]
 
     @property
     def user(self) -> str | None:
         """The principal identifier of the user making the request."""
-        return self["requestContext"]["identity"].get("user")
+        return self.get("user")
 
     @property
     def user_agent(self) -> str | None:
         """The User Agent of the API caller."""
-        return self["requestContext"]["identity"].get("userAgent")
+        return self.get("userAgent")
 
     @property
     def user_arn(self) -> str | None:
         """The Amazon Resource Name (ARN) of the effective user identified after authentication."""
-        return self["requestContext"]["identity"].get("userArn")
+        return self.get("userArn")
 
     @property
     def client_cert(self) -> RequestContextClientCert | None:
-        client_cert = self["requestContext"]["identity"].get("clientCert")
+        client_cert = self.get("clientCert")
         return None if client_cert is None else RequestContextClientCert(client_cert)
 
 
@@ -452,153 +451,153 @@ class BaseRequestContext(DictWrapper):
     @property
     def account_id(self) -> str:
         """The AWS account ID associated with the request."""
-        return self["requestContext"]["accountId"]
+        return self["accountId"]
 
     @property
     def api_id(self) -> str:
         """The identifier API Gateway assigns to your API."""
-        return self["requestContext"]["apiId"]
+        return self["apiId"]
 
     @property
     def domain_name(self) -> str | None:
         """A domain name"""
-        return self["requestContext"].get("domainName")
+        return self.get("domainName")
 
     @property
     def domain_prefix(self) -> str | None:
-        return self["requestContext"].get("domainPrefix")
+        return self.get("domainPrefix")
 
     @property
     def extended_request_id(self) -> str | None:
         """An automatically generated ID for the API call, which contains more useful information
         for debugging/troubleshooting."""
-        return self["requestContext"].get("extendedRequestId")
+        return self.get("extendedRequestId")
 
     @property
     def protocol(self) -> str:
         """The request protocol, for example, HTTP/1.1."""
-        return self["requestContext"]["protocol"]
+        return self["protocol"]
 
     @property
     def http_method(self) -> str:
         """The HTTP method used. Valid values include: DELETE, GET, HEAD, OPTIONS, PATCH, POST, and PUT."""
-        return self["requestContext"]["httpMethod"]
+        return self["httpMethod"]
 
     @property
     def identity(self) -> APIGatewayEventIdentity:
-        return APIGatewayEventIdentity(self._data)
+        return APIGatewayEventIdentity(self["identity"])
 
     @property
     def path(self) -> str:
-        return self["requestContext"]["path"]
+        return self["path"]
 
     @property
     def stage(self) -> str:
         """The deployment stage of the API request"""
-        return self["requestContext"]["stage"]
+        return self["stage"]
 
     @property
     def request_id(self) -> str:
         """The ID that API Gateway assigns to the API request."""
-        return self["requestContext"]["requestId"]
+        return self["requestId"]
 
     @property
     def request_time(self) -> str | None:
         """The CLF-formatted request time (dd/MMM/yyyy:HH:mm:ss +-hhmm)"""
-        return self["requestContext"].get("requestTime")
+        return self.get("requestTime")
 
     @property
     def request_time_epoch(self) -> int:
         """The Epoch-formatted request time."""
-        return self["requestContext"]["requestTimeEpoch"]
+        return self["requestTimeEpoch"]
 
     @property
     def resource_id(self) -> str:
-        return self["requestContext"]["resourceId"]
+        return self["resourceId"]
 
     @property
     def resource_path(self) -> str:
-        return self["requestContext"]["resourcePath"]
+        return self["resourcePath"]
 
 
 class RequestContextV2Http(DictWrapper):
     @property
     def method(self) -> str:
-        return self["requestContext"]["http"]["method"]
+        return self["method"]
 
     @property
     def path(self) -> str:
-        return self["requestContext"]["http"]["path"]
+        return self["path"]
 
     @property
     def protocol(self) -> str:
         """The request protocol, for example, HTTP/1.1."""
-        return self["requestContext"]["http"]["protocol"]
+        return self["protocol"]
 
     @property
     def source_ip(self) -> str:
         """The source IP address of the TCP connection making the request to API Gateway."""
-        return self["requestContext"]["http"]["sourceIp"]
+        return self["sourceIp"]
 
     @property
     def user_agent(self) -> str:
         """The User Agent of the API caller."""
-        return self["requestContext"]["http"]["userAgent"]
+        return self["userAgent"]
 
 
 class BaseRequestContextV2(DictWrapper):
     @property
     def account_id(self) -> str:
         """The AWS account ID associated with the request."""
-        return self["requestContext"]["accountId"]
+        return self["accountId"]
 
     @property
     def api_id(self) -> str:
         """The identifier API Gateway assigns to your API."""
-        return self["requestContext"]["apiId"]
+        return self["apiId"]
 
     @property
     def domain_name(self) -> str:
         """A domain name"""
-        return self["requestContext"]["domainName"]
+        return self["domainName"]
 
     @property
     def domain_prefix(self) -> str:
-        return self["requestContext"]["domainPrefix"]
+        return self["domainPrefix"]
 
     @property
     def http(self) -> RequestContextV2Http:
-        return RequestContextV2Http(self._data)
+        return RequestContextV2Http(self["http"])
 
     @property
     def request_id(self) -> str:
         """The ID that API Gateway assigns to the API request."""
-        return self["requestContext"]["requestId"]
+        return self["requestId"]
 
     @property
     def route_key(self) -> str:
         """The selected route key."""
-        return self["requestContext"]["routeKey"]
+        return self["routeKey"]
 
     @property
     def stage(self) -> str:
         """The deployment stage of the API request"""
-        return self["requestContext"]["stage"]
+        return self["stage"]
 
     @property
     def time(self) -> str:
         """The CLF-formatted request time (dd/MMM/yyyy:HH:mm:ss +-hhmm)."""
-        return self["requestContext"]["time"]
+        return self["time"]
 
     @property
     def time_epoch(self) -> int:
         """The Epoch-formatted request time."""
-        return self["requestContext"]["timeEpoch"]
+        return self["timeEpoch"]
 
     @property
     def authentication(self) -> RequestContextClientCert | None:
         """Optional when using mutual TLS authentication"""
         # FunctionURL might have NONE as AuthZ
-        authentication = self["requestContext"].get("authentication") or {}
+        authentication = self.get("authentication") or {}
         client_cert = authentication.get("clientCert")
         return None if client_cert is None else RequestContextClientCert(client_cert)

aws_lambda_powertools/utilities/data_classes/kinesis_firehose_event.py

@@ -177,30 +177,25 @@ class KinesisFirehoseDataTransformationResponse:
 
 
 class KinesisFirehoseRecordMetadata(DictWrapper):
-    @property
-    def _metadata(self) -> dict:
-        """Optional: metadata associated with this record; present only when Kinesis Stream is source"""
-        return self["kinesisRecordMetadata"]  # could raise KeyError
-
     @property
     def shard_id(self) -> str:
         """Kinesis stream shard ID; present only when Kinesis Stream is source"""
-        return self._metadata["shardId"]
+        return self["shardId"]
 
     @property
     def partition_key(self) -> str:
         """Kinesis stream partition key; present only when Kinesis Stream is source"""
-        return self._metadata["partitionKey"]
+        return self["partitionKey"]
 
     @property
     def approximate_arrival_timestamp(self) -> int:
         """Kinesis stream approximate arrival ISO timestamp; present only when Kinesis Stream is source"""
-        return self._metadata["approximateArrivalTimestamp"]
+        return self["approximateArrivalTimestamp"]
 
     @property
     def sequence_number(self) -> str:
         """Kinesis stream sequence number; present only when Kinesis Stream is source"""
-        return self._metadata["sequenceNumber"]
+        return self["sequenceNumber"]
 
     @property
     def subsequence_number(self) -> int:
@@ -208,7 +203,7 @@ class KinesisFirehoseRecordMetadata(DictWrapper):
 
         Note: this will only be present for Kinesis streams using record aggregation
         """
-        return self._metadata["subsequenceNumber"]
+        return self["subsequenceNumber"]
 
 
 class KinesisFirehoseRecord(DictWrapper):
@@ -230,7 +225,8 @@ class KinesisFirehoseRecord(DictWrapper):
     @property
     def metadata(self) -> KinesisFirehoseRecordMetadata | None:
         """Optional: metadata associated with this record; present only when Kinesis Stream is source"""
-        return KinesisFirehoseRecordMetadata(self._data) if self.get("kinesisRecordMetadata") else None
+        metadata = self.get("kinesisRecordMetadata")
+        return KinesisFirehoseRecordMetadata(metadata) if metadata else None
 
     @property
     def data_as_bytes(self) -> bytes:

aws_lambda_powertools/utilities/data_classes/kinesis_stream_event.py

@@ -15,27 +15,27 @@ class KinesisStreamRecordPayload(DictWrapper):
     @property
     def approximate_arrival_timestamp(self) -> float:
         """The approximate time that the record was inserted into the stream"""
-        return float(self["kinesis"]["approximateArrivalTimestamp"])
+        return float(self["approximateArrivalTimestamp"])
 
     @property
     def data(self) -> str:
         """The data blob"""
-        return self["kinesis"]["data"]
+        return self["data"]
 
     @property
     def kinesis_schema_version(self) -> str:
         """Schema version for the record"""
-        return self["kinesis"]["kinesisSchemaVersion"]
+        return self["kinesisSchemaVersion"]
 
     @property
     def partition_key(self) -> str:
         """Identifies which shard in the stream the data record is assigned to"""
-        return self["kinesis"]["partitionKey"]
+        return self["partitionKey"]
 
     @property
     def sequence_number(self) -> str:
         """The unique identifier of the record within its shard"""
-        return self["kinesis"]["sequenceNumber"]
+        return self["sequenceNumber"]
 
     def data_as_bytes(self) -> bytes:
         """Decode binary encoded data as bytes"""
@@ -94,7 +94,7 @@ class KinesisStreamRecord(DictWrapper):
     @property
     def kinesis(self) -> KinesisStreamRecordPayload:
         """Underlying Kinesis record associated with the event"""
-        return KinesisStreamRecordPayload(self._data)
+        return KinesisStreamRecordPayload(self["kinesis"])
 
 
 class KinesisStreamEvent(DictWrapper):

aws_lambda_powertools/utilities/data_classes/s3_event.py

@@ -18,7 +18,7 @@ class S3Identity(DictWrapper):
 class S3RequestParameters(DictWrapper):
     @property
     def source_ip_address(self) -> str:
-        return self["requestParameters"]["sourceIPAddress"]
+        return self["sourceIPAddress"]
 
 
 class S3EventNotificationEventBridgeBucket(DictWrapper):
@@ -40,8 +40,8 @@ class S3EventBridgeNotificationObject(DictWrapper):
 
     @property
     def etag(self) -> str:
-        """Object etag. Object deletion event doesn't contain etag; we default to empty string"""
-        return self.get("etag", "")  # type: ignore[return-value]  # false positive
+        """Object eTag. Object deletion event doesn't contain eTag; we default to empty string"""
+        return self.get("etag") or ""
 
     @property
     def version_id(self) -> str:
@@ -156,77 +156,77 @@ class S3EventBridgeNotificationEvent(EventBridgeEvent):
 class S3Bucket(DictWrapper):
     @property
     def name(self) -> str:
-        return self["s3"]["bucket"]["name"]
+        return self["name"]
 
     @property
     def owner_identity(self) -> S3Identity:
-        return S3Identity(self["s3"]["bucket"]["ownerIdentity"])
+        return S3Identity(self["ownerIdentity"])
 
     @property
     def arn(self) -> str:
-        return self["s3"]["bucket"]["arn"]
+        return self["arn"]
 
 
 class S3Object(DictWrapper):
     @property
     def key(self) -> str:
         """Object key"""
-        return self["s3"]["object"]["key"]
+        return self["key"]
 
     @property
     def size(self) -> int:
         """Object byte size"""
-        return int(self["s3"]["object"]["size"])
+        return int(self["size"])
 
     @property
     def etag(self) -> str:
         """Object eTag. Object deletion event doesn't contain eTag; we default to empty string"""
-        return self["s3"]["object"].get("eTag", "")
+        return self.get("eTag") or ""
 
     @property
     def version_id(self) -> str | None:
         """Object version if bucket is versioning-enabled, otherwise null"""
-        return self["s3"]["object"].get("versionId")
+        return self.get("versionId")
 
     @property
     def sequencer(self) -> str:
         """A string representation of a hexadecimal value used to determine event sequence,
         only used with PUTs and DELETEs
         """
-        return self["s3"]["object"]["sequencer"]
+        return self["sequencer"]
 
 
 class S3Message(DictWrapper):
     @property
     def s3_schema_version(self) -> str:
-        return self["s3"]["s3SchemaVersion"]
+        return self["s3SchemaVersion"]
 
     @property
     def configuration_id(self) -> str:
         """ID found in the bucket notification configuration"""
-        return self["s3"]["configurationId"]
+        return self["configurationId"]
 
     @property
     def bucket(self) -> S3Bucket:
-        return S3Bucket(self._data)
+        return S3Bucket(self["bucket"])
 
     @property
     def get_object(self) -> S3Object:
         """Get the `object` property as an S3Object"""
         # Note: this name conflicts with existing python builtins
-        return S3Object(self._data)
+        return S3Object(self["object"])
 
 
 class S3EventRecordGlacierRestoreEventData(DictWrapper):
     @property
     def lifecycle_restoration_expiry_time(self) -> str:
         """Time when the object restoration will be expired."""
-        return self["restoreEventData"]["lifecycleRestorationExpiryTime"]
+        return self["lifecycleRestorationExpiryTime"]
 
     @property
     def lifecycle_restore_storage_class(self) -> str:
         """Source storage class for restore"""
-        return self["restoreEventData"]["lifecycleRestoreStorageClass"]
+        return self["lifecycleRestoreStorageClass"]
 
 
 class S3EventRecordGlacierEventData(DictWrapper):
@@ -236,7 +236,7 @@ class S3EventRecordGlacierEventData(DictWrapper):
 
         The glacierEventData key is only visible for s3:ObjectRestore:Completed events
         """
-        return S3EventRecordGlacierRestoreEventData(self._data)
+        return S3EventRecordGlacierRestoreEventData(self["restoreEventData"])
 
 
 class S3EventRecord(DictWrapper):
@@ -272,7 +272,7 @@ class S3EventRecord(DictWrapper):
 
     @property
     def request_parameters(self) -> S3RequestParameters:
-        return S3RequestParameters(self._data)
+        return S3RequestParameters(self["requestParameters"])
 
     @property
     def response_elements(self) -> dict[str, str]:
@@ -286,7 +286,7 @@ class S3EventRecord(DictWrapper):
 
     @property
     def s3(self) -> S3Message:
-        return S3Message(self._data)
+        return S3Message(self["s3"])
 
     @property
     def glacier_event_data(self) -> S3EventRecordGlacierEventData | None:

aws_lambda_powertools/utilities/data_classes/ses_event.py

@@ -212,11 +212,11 @@ class SESReceipt(DictWrapper):
 class SESMessage(DictWrapper):
     @property
     def mail(self) -> SESMail:
-        return SESMail(self["ses"]["mail"])
+        return SESMail(self["mail"])
 
     @property
     def receipt(self) -> SESReceipt:
-        return SESReceipt(self["ses"]["receipt"])
+        return SESReceipt(self["receipt"])
 
 
 class SESEventRecord(DictWrapper):
@@ -232,7 +232,7 @@ class SESEventRecord(DictWrapper):
 
     @property
     def ses(self) -> SESMessage:
-        return SESMessage(self._data)
+        return SESMessage(self["ses"])
 
 
 class SESEvent(DictWrapper):

aws_lambda_powertools/utilities/data_classes/vpc_lattice.py

@@ -16,6 +16,8 @@ from aws_lambda_powertools.utilities.data_classes.shared_functions import base64
 
 
 class VPCLatticeEventBase(BaseProxyEvent):
+    # is_base64_encoded and path are inherited from BaseProxyEvent class.
+
     @property
     def body(self) -> str:
         """The VPC Lattice body."""
@@ -169,16 +171,6 @@ class VPCLatticeEventV2(VPCLatticeEventBase):
         """The VPC Lattice v2 Event version"""
         return self["version"]
 
-    @property
-    def is_base64_encoded(self) -> bool | None:
-        """A boolean flag to indicate if the applicable request payload is Base64-encode"""
-        return self.get("isBase64Encoded")
-
-    @property
-    def path(self) -> str:
-        """The VPC Lattice v2 Event path"""
-        return self["path"]
-
     @property
     def request_context(self) -> vpcLatticeEventV2RequestContext:
         """The VPC Lattice v2 Event request context."""

{aws_lambda_powertools-3.8.1a6.dist-info → aws_lambda_powertools-3.8.1a8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aws_lambda_powertools
-Version: 3.8.1a6
+Version: 3.8.1a8
 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
@@ -28,7 +28,7 @@ Provides-Extra: validation
 Requires-Dist: aws-encryption-sdk (>=3.1.1,<5.0.0) ; extra == "all" or extra == "datamasking"
 Requires-Dist: aws-xray-sdk (>=2.8.0,<3.0.0) ; extra == "tracer" or extra == "all"
 Requires-Dist: boto3 (>=1.34.32,<2.0.0) ; extra == "aws-sdk"
-Requires-Dist: datadog-lambda (>=4.77,<7.0) ; extra == "datadog"
+Requires-Dist: datadog-lambda (>=6.106.0,<7.0.0) ; extra == "datadog"
 Requires-Dist: fastjsonschema (>=2.14.5,<3.0.0) ; extra == "validation" or extra == "all"
 Requires-Dist: jmespath (>=1.0.1,<2.0.0)
 Requires-Dist: jsonpath-ng (>=1.6.0,<2.0.0) ; extra == "all" or extra == "datamasking"