localstack-core 4.6.1.dev60__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/s3/cors.py

@@ -1,6 +1,6 @@
 import logging
 import re
-from typing import Optional, Protocol, Tuple
+from typing import Protocol
 
 from werkzeug.datastructures import Headers
 
@@ -21,13 +21,13 @@ from localstack.aws.protocol.op_router import RestServiceOperationRouter
 from localstack.aws.spec import get_service_catalog
 from localstack.config import S3_VIRTUAL_HOSTNAME
 from localstack.http import Request, Response
+from localstack.services.s3.constants import S3_HOST_ID
 from localstack.services.s3.utils import S3_VIRTUAL_HOSTNAME_REGEX
 
 # TODO: add more logging statements
 LOG = logging.getLogger(__name__)
 
 _s3_virtual_host_regex = re.compile(S3_VIRTUAL_HOSTNAME_REGEX)
-FAKE_HOST_ID = "9Gjjt1m+cjU4OPvX9O9/8RuvnG41MRb/18Oux2o5H5MY7ISNTlXN+Dz9IG62/ILVxhAGI0qyPfg="
 
 # TODO: refactor those to expose the needed methods maybe in another way that both can import
 add_default_headers = CorsResponseEnricher.add_cors_headers
@@ -58,7 +58,7 @@ class S3CorsHandler(Handler):
     def __call__(self, chain: HandlerChain, context: RequestContext, response: Response):
         self.handle_cors(chain, context, response)
 
-    def pre_parse_s3_request(self, request: Request) -> Tuple[bool, Optional[str]]:
+    def pre_parse_s3_request(self, request: Request) -> tuple[bool, str | None]:
         """
         Parse the request to try to determine if it's directed towards S3. It tries to match on host, then check
         if the targeted bucket exists. If we could not determine it was a s3 request from the host, but the first
@@ -135,7 +135,7 @@ class S3CorsHandler(Handler):
             if is_options_request:
                 context.operation = self._get_op_from_request(request)
                 raise BadRequest(
-                    "Insufficient information. Origin request header needed.", HostId=FAKE_HOST_ID
+                    "Insufficient information. Origin request header needed.", HostId=S3_HOST_ID
                 )
             else:
                 # If the header is missing, Amazon S3 doesn't treat the request as a cross-origin request,
@@ -167,7 +167,7 @@ class S3CorsHandler(Handler):
                     context.operation = self._get_op_from_request(request)
                     raise AccessForbidden(
                         message,
-                        HostId=FAKE_HOST_ID,
+                        HostId=S3_HOST_ID,
                         Method=request.headers.get("Access-Control-Request-Method", "OPTIONS"),
                         ResourceType="BUCKET",
                     )
@@ -182,7 +182,7 @@ class S3CorsHandler(Handler):
                 context.operation = self._get_op_from_request(request)
                 raise AccessForbidden(
                     "CORSResponse: This CORS request is not allowed. This is usually because the evalution of Origin, request method / Access-Control-Request-Method or Access-Control-Request-Headers are not whitelisted by the resource's CORS spec.",
-                    HostId=FAKE_HOST_ID,
+                    HostId=S3_HOST_ID,
                     Method=request.headers.get("Access-Control-Request-Method"),
                     ResourceType="OBJECT",
                 )
@@ -224,7 +224,7 @@ class S3CorsHandler(Handler):
     def invalidate_cache(self):
         self.bucket_cors_index.invalidate()
 
-    def match_rules(self, request: Request, rules: CORSRules) -> Optional[CORSRule]:
+    def match_rules(self, request: Request, rules: CORSRules) -> CORSRule | None:
         """
         Try to match the request to the bucket rules. How to match rules:
           - The request's Origin header must match AllowedOrigin elements.
@@ -243,7 +243,7 @@ class S3CorsHandler(Handler):
                 return matched_rule
 
     @staticmethod
-    def _match_rule(rule: CORSRule, method: str, headers: Headers) -> Optional[CORSRule]:
+    def _match_rule(rule: CORSRule, method: str, headers: Headers) -> CORSRule | None:
         """
         Check if the request method and headers matches the given CORS rule.
         :param rule: CORSRule: a CORS Rule from the bucket

localstack/services/s3/models.py

@@ -4,7 +4,7 @@ import logging
 from collections import defaultdict
 from datetime import datetime
 from secrets import token_urlsafe
-from typing import Literal, NamedTuple, Optional, Union
+from typing import Literal, NamedTuple, Union
 from zoneinfo import ZoneInfo
 
 from localstack.aws.api import CommonServiceException
@@ -105,25 +105,25 @@ class S3Bucket:
     multiparts: dict[MultipartUploadId, "S3Multipart"]
     objects: Union["KeyStore", "VersionedKeyStore"]
     versioning_status: BucketVersioningStatus | None
-    lifecycle_rules: Optional[LifecycleRules]
-    transition_default_minimum_object_size: Optional[TransitionDefaultMinimumObjectSize]
-    policy: Optional[Policy]
-    website_configuration: Optional[WebsiteConfiguration]
+    lifecycle_rules: LifecycleRules | None
+    transition_default_minimum_object_size: TransitionDefaultMinimumObjectSize | None
+    policy: Policy | None
+    website_configuration: WebsiteConfiguration | None
     acl: AccessControlPolicy
-    cors_rules: Optional[CORSConfiguration]
+    cors_rules: CORSConfiguration | None
     logging: LoggingEnabled
     notification_configuration: NotificationConfiguration
     payer: Payer
-    encryption_rule: Optional[ServerSideEncryptionRule]
-    public_access_block: Optional[PublicAccessBlockConfiguration]
-    accelerate_status: Optional[BucketAccelerateStatus]
+    encryption_rule: ServerSideEncryptionRule | None
+    public_access_block: PublicAccessBlockConfiguration | None
+    accelerate_status: BucketAccelerateStatus | None
     object_lock_enabled: bool
     object_ownership: ObjectOwnership
     intelligent_tiering_configurations: dict[IntelligentTieringId, IntelligentTieringConfiguration]
     analytics_configurations: dict[AnalyticsId, AnalyticsConfiguration]
     inventory_configurations: dict[InventoryId, InventoryConfiguration]
     metric_configurations: dict[MetricsId, MetricsConfiguration]
-    object_lock_default_retention: Optional[DefaultRetention]
+    object_lock_default_retention: DefaultRetention | None
     replication: ReplicationConfiguration
     owner: Owner
 
@@ -256,58 +256,58 @@ class S3Bucket:
 
 class S3Object:
     key: ObjectKey
-    version_id: Optional[ObjectVersionId]
+    version_id: ObjectVersionId | None
     bucket: BucketName
-    owner: Optional[Owner]
-    size: Optional[Size]
-    etag: Optional[ETag]
+    owner: Owner | None
+    size: Size | None
+    etag: ETag | None
     user_metadata: Metadata
     system_metadata: Metadata
     last_modified: datetime
-    expires: Optional[datetime]
-    expiration: Optional[Expiration]  # right now, this is stored in the provider cache
+    expires: datetime | None
+    expiration: Expiration | None  # right now, this is stored in the provider cache
     storage_class: StorageClass | ObjectStorageClass
-    encryption: Optional[ServerSideEncryption]  # inherit bucket
-    kms_key_id: Optional[SSEKMSKeyId]  # inherit bucket
-    bucket_key_enabled: Optional[bool]  # inherit bucket
-    sse_key_hash: Optional[SSECustomerKeyMD5]
+    encryption: ServerSideEncryption | None  # inherit bucket
+    kms_key_id: SSEKMSKeyId | None  # inherit bucket
+    bucket_key_enabled: bool | None  # inherit bucket
+    sse_key_hash: SSECustomerKeyMD5 | None
     checksum_algorithm: ChecksumAlgorithm
     checksum_value: str
     checksum_type: ChecksumType
-    lock_mode: Optional[ObjectLockMode | ObjectLockRetentionMode]
-    lock_legal_status: Optional[ObjectLockLegalHoldStatus]
-    lock_until: Optional[datetime]
-    website_redirect_location: Optional[WebsiteRedirectLocation]
-    acl: Optional[AccessControlPolicy]
+    lock_mode: ObjectLockMode | ObjectLockRetentionMode | None
+    lock_legal_status: ObjectLockLegalHoldStatus | None
+    lock_until: datetime | None
+    website_redirect_location: WebsiteRedirectLocation | None
+    acl: AccessControlPolicy | None
     is_current: bool
-    parts: Optional[dict[int, InternalObjectPart]]
-    restore: Optional[Restore]
+    parts: dict[int, InternalObjectPart] | None
+    restore: Restore | None
     internal_last_modified: int
 
     def __init__(
         self,
         key: ObjectKey,
-        etag: Optional[ETag] = None,
-        size: Optional[int] = None,
-        version_id: Optional[ObjectVersionId] = None,
-        user_metadata: Optional[Metadata] = None,
-        system_metadata: Optional[Metadata] = None,
+        etag: ETag | None = None,
+        size: int | None = None,
+        version_id: ObjectVersionId | None = None,
+        user_metadata: Metadata | None = None,
+        system_metadata: Metadata | None = None,
         storage_class: StorageClass = StorageClass.STANDARD,
-        expires: Optional[datetime] = None,
-        expiration: Optional[Expiration] = None,
-        checksum_algorithm: Optional[ChecksumAlgorithm] = None,
-        checksum_value: Optional[str] = None,
-        checksum_type: Optional[ChecksumType] = ChecksumType.FULL_OBJECT,
-        encryption: Optional[ServerSideEncryption] = None,
-        kms_key_id: Optional[SSEKMSKeyId] = None,
-        sse_key_hash: Optional[SSECustomerKeyMD5] = None,
+        expires: datetime | None = None,
+        expiration: Expiration | None = None,
+        checksum_algorithm: ChecksumAlgorithm | None = None,
+        checksum_value: str | None = None,
+        checksum_type: ChecksumType | None = ChecksumType.FULL_OBJECT,
+        encryption: ServerSideEncryption | None = None,
+        kms_key_id: SSEKMSKeyId | None = None,
+        sse_key_hash: SSECustomerKeyMD5 | None = None,
         bucket_key_enabled: bool = False,
-        lock_mode: Optional[ObjectLockMode | ObjectLockRetentionMode] = None,
-        lock_legal_status: Optional[ObjectLockLegalHoldStatus] = None,
-        lock_until: Optional[datetime] = None,
-        website_redirect_location: Optional[WebsiteRedirectLocation] = None,
-        acl: Optional[AccessControlPolicy] = None,  # TODO
-        owner: Optional[Owner] = None,
+        lock_mode: ObjectLockMode | ObjectLockRetentionMode | None = None,
+        lock_legal_status: ObjectLockLegalHoldStatus | None = None,
+        lock_until: datetime | None = None,
+        website_redirect_location: WebsiteRedirectLocation | None = None,
+        acl: AccessControlPolicy | None = None,  # TODO
+        owner: Owner | None = None,
     ):
         self.key = key
         self.user_metadata = (
@@ -406,19 +406,19 @@ class S3DeleteMarker:
 # TODO: could use dataclass, validate after models are set
 class S3Part:
     part_number: PartNumber
-    etag: Optional[ETag]
+    etag: ETag | None
     last_modified: datetime
-    size: Optional[int]
-    checksum_algorithm: Optional[ChecksumAlgorithm]
-    checksum_value: Optional[str]
+    size: int | None
+    checksum_algorithm: ChecksumAlgorithm | None
+    checksum_value: str | None
 
     def __init__(
         self,
         part_number: PartNumber,
         size: int = None,
         etag: ETag = None,
-        checksum_algorithm: Optional[ChecksumAlgorithm] = None,
-        checksum_value: Optional[str] = None,
+        checksum_algorithm: ChecksumAlgorithm | None = None,
+        checksum_value: str | None = None,
     ):
         self.last_modified = datetime.now(tz=_gmt_zone_info)
         self.part_number = part_number
@@ -436,8 +436,8 @@ class S3Multipart:
     parts: dict[PartNumber, S3Part]
     object: S3Object
     upload_id: MultipartUploadId
-    checksum_value: Optional[str]
-    checksum_type: Optional[ChecksumType]
+    checksum_value: str | None
+    checksum_type: ChecksumType | None
     checksum_algorithm: ChecksumAlgorithm
     initiated: datetime
     precondition: bool
@@ -446,25 +446,25 @@ class S3Multipart:
         self,
         key: ObjectKey,
         storage_class: StorageClass | ObjectStorageClass = StorageClass.STANDARD,
-        expires: Optional[datetime] = None,
-        expiration: Optional[datetime] = None,  # come from lifecycle
-        checksum_algorithm: Optional[ChecksumAlgorithm] = None,
-        checksum_type: Optional[ChecksumType] = None,
-        encryption: Optional[ServerSideEncryption] = None,  # inherit bucket
-        kms_key_id: Optional[SSEKMSKeyId] = None,  # inherit bucket
+        expires: datetime | None = None,
+        expiration: datetime | None = None,  # come from lifecycle
+        checksum_algorithm: ChecksumAlgorithm | None = None,
+        checksum_type: ChecksumType | None = None,
+        encryption: ServerSideEncryption | None = None,  # inherit bucket
+        kms_key_id: SSEKMSKeyId | None = None,  # inherit bucket
         bucket_key_enabled: bool = False,  # inherit bucket
-        sse_key_hash: Optional[SSECustomerKeyMD5] = None,
-        lock_mode: Optional[ObjectLockMode] = None,
-        lock_legal_status: Optional[ObjectLockLegalHoldStatus] = None,
-        lock_until: Optional[datetime] = None,
-        website_redirect_location: Optional[WebsiteRedirectLocation] = None,
-        acl: Optional[AccessControlPolicy] = None,  # TODO
-        user_metadata: Optional[Metadata] = None,
-        system_metadata: Optional[Metadata] = None,
-        initiator: Optional[Owner] = None,
-        tagging: Optional[dict[str, str]] = None,
-        owner: Optional[Owner] = None,
-        precondition: Optional[bool] = None,
+        sse_key_hash: SSECustomerKeyMD5 | None = None,
+        lock_mode: ObjectLockMode | None = None,
+        lock_legal_status: ObjectLockLegalHoldStatus | None = None,
+        lock_until: datetime | None = None,
+        website_redirect_location: WebsiteRedirectLocation | None = None,
+        acl: AccessControlPolicy | None = None,  # TODO
+        user_metadata: Metadata | None = None,
+        system_metadata: Metadata | None = None,
+        initiator: Owner | None = None,
+        tagging: dict[str, str] | None = None,
+        owner: Owner | None = None,
+        precondition: bool | None = None,
     ):
         self.id = token_urlsafe(96)  # MultipartUploadId is 128 characters long
         self.initiated = datetime.now(tz=_gmt_zone_info)
@@ -638,7 +638,7 @@ class KeyStore:
 
     def values(self, *_, **__) -> list[S3Object | S3DeleteMarker]:
         # we create a shallow copy with dict to avoid size changed during iteration
-        return [value for value in dict(self._store).values()]
+        return list(dict(self._store).values())
 
     def is_empty(self) -> bool:
         return not self._store

localstack/services/s3/notifications.py

@@ -6,7 +6,7 @@ import logging
 import re
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Tuple, TypedDict, Union
+from typing import TypedDict
 from urllib.parse import quote
 
 from botocore.exceptions import ClientError
@@ -21,6 +21,7 @@ from localstack.aws.api.s3 import (
     Event,
     EventBridgeConfiguration,
     EventList,
+    InvalidArgument,
     LambdaFunctionArn,
     LambdaFunctionConfiguration,
     NotificationConfiguration,
@@ -34,8 +35,8 @@ from localstack.aws.api.s3 import (
     TopicConfiguration,
 )
 from localstack.aws.connect import connect_to
+from localstack.services.s3.exceptions import MalformedXML
 from localstack.services.s3.models import S3Bucket, S3DeleteMarker, S3Object
-from localstack.services.s3.utils import _create_invalid_argument_exc
 from localstack.utils.aws import arns
 from localstack.utils.aws.arns import ARN_PARTITION_REGEX, get_partition, parse_arn, s3_bucket_arn
 from localstack.utils.aws.client_types import ServicePrincipal
@@ -64,8 +65,8 @@ HEADER_AMZN_XRAY = "X-Amzn-Trace-Id"
 class S3NotificationContent(TypedDict):
     s3SchemaVersion: str
     configurationId: NotificationId
-    bucket: Dict[str, str]  # todo
-    object: Dict[str, Union[str, int]]  # todo
+    bucket: dict[str, str]  # todo
+    object: dict[str, str | int]  # todo
 
 
 class EventRecord(TypedDict):
@@ -74,14 +75,14 @@ class EventRecord(TypedDict):
     awsRegion: str
     eventTime: str
     eventName: str
-    userIdentity: Dict[str, str]
-    requestParameters: Dict[str, str]
-    responseElements: Dict[str, str]
+    userIdentity: dict[str, str]
+    requestParameters: dict[str, str]
+    responseElements: dict[str, str]
     s3: S3NotificationContent
 
 
 class Notification(TypedDict):
-    Records: List[EventRecord]
+    Records: list[EventRecord]
 
 
 @dataclass
@@ -101,15 +102,15 @@ class S3EventNotificationContext:
     key_etag: str
     key_version_id: str
     key_expiry: datetime.datetime
-    key_storage_class: Optional[StorageClass]
+    key_storage_class: StorageClass | None
 
     @classmethod
-    def from_request_context_native(
+    def from_request_context(
         cls,
         request_context: RequestContext,
         s3_bucket: S3Bucket,
         s3_object: S3Object | S3DeleteMarker,
-    ) -> "S3EventNotificationContext":
+    ) -> S3EventNotificationContext:
         """
         Create an S3EventNotificationContext from a RequestContext.
         The key is not always present in the request context depending on the event type. In that case, we can use
@@ -165,7 +166,7 @@ class BucketVerificationContext:
     request_id: str
     bucket_name: str
     region: str
-    configuration: Dict
+    configuration: dict
     skip_destination_validation: bool
 
 
@@ -185,7 +186,7 @@ def _matching_event(events: EventList, event_name: str) -> bool:
 
 
 def _matching_filter(
-    notification_filter: Optional[NotificationConfigurationFilter], key_name: str
+    notification_filter: NotificationConfigurationFilter | None, key_name: str
 ) -> bool:
     """
     See: https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-filtering.html
@@ -213,11 +214,11 @@ def _matching_filter(
 class BaseNotifier:
     service_name: str
 
-    def notify(self, ctx: S3EventNotificationContext, config: Dict):
+    def notify(self, ctx: S3EventNotificationContext, config: dict):
         raise NotImplementedError
 
     @staticmethod
-    def should_notify(ctx: S3EventNotificationContext, config: Dict) -> bool:
+    def should_notify(ctx: S3EventNotificationContext, config: dict) -> bool:
         """
         Helper method checking if the event should be notified to the configured notifiers from the configuration
         :param ctx: S3EventNotificationContext
@@ -229,12 +230,12 @@ class BaseNotifier:
         )
 
     @staticmethod
-    def _get_arn_value_and_name(notifier_configuration: Dict) -> Tuple[str, str]:
+    def _get_arn_value_and_name(notifier_configuration: dict) -> tuple[str, str]:
         raise NotImplementedError
 
     def validate_configuration_for_notifier(
         self,
-        configurations: List[Dict],
+        configurations: list[dict],
         skip_destination_validation: bool,
         context: RequestContext,
         bucket_name: str,
@@ -272,26 +273,29 @@ class BaseNotifier:
         arn, argument_name = self._get_arn_value_and_name(configuration)
 
         if not re.match(f"{ARN_PARTITION_REGEX}:{self.service_name}:", arn):
-            raise _create_invalid_argument_exc(
-                "The ARN could not be parsed", name=argument_name, value=arn
+            raise InvalidArgument(
+                "The ARN could not be parsed",
+                ArgumentName=argument_name,
+                ArgumentValue=arn,
             )
+
         if not verification_ctx.skip_destination_validation:
             self._verify_target(arn, verification_ctx)
 
         if filter_rules := configuration.get("Filter", {}).get("Key", {}).get("FilterRules"):
             for rule in filter_rules:
-                rule["Name"] = rule["Name"].capitalize()
-                if rule["Name"] not in ["Suffix", "Prefix"]:
-                    raise _create_invalid_argument_exc(
+                if "Name" not in rule or "Value" not in rule:
+                    raise MalformedXML()
+
+                if rule["Name"].lower() not in ["suffix", "prefix"]:
+                    raise InvalidArgument(
                         "filter rule name must be either prefix or suffix",
-                        rule["Name"],
-                        rule["Value"],
-                    )
-                if not rule["Value"]:
-                    raise _create_invalid_argument_exc(
-                        "filter value cannot be empty", rule["Name"], rule["Value"]
+                        ArgumentName="FilterRule.Name",
+                        ArgumentValue=rule["Name"],
                     )
 
+                rule["Name"] = rule["Name"].capitalize()
+
     @staticmethod
     def _get_test_payload(verification_ctx: BucketVerificationContext):
         return {
@@ -381,8 +385,8 @@ class SqsNotifier(BaseNotifier):
     service_name = "sqs"
 
     @staticmethod
-    def _get_arn_value_and_name(queue_configuration: QueueConfiguration) -> Tuple[QueueArn, str]:
-        return queue_configuration.get("QueueArn", ""), "QueueArn"
+    def _get_arn_value_and_name(queue_configuration: QueueConfiguration) -> tuple[QueueArn, str]:
+        return queue_configuration.get("QueueArn", ""), "Queue"
 
     def _verify_target(self, target_arn: str, verification_ctx: BucketVerificationContext) -> None:
         if not is_api_enabled("sqs"):
@@ -402,13 +406,20 @@ class SqsNotifier(BaseNotifier):
             queue_url = sqs_client.get_queue_url(
                 QueueName=arn_data["resource"], QueueOwnerAWSAccountId=arn_data["account"]
             )["QueueUrl"]
-        except ClientError:
-            LOG.exception("Could not validate the notification destination %s", target_arn)
-            raise _create_invalid_argument_exc(
+        except ClientError as e:
+            code = e.response["Error"]["Code"]
+            LOG.error(
+                "Could not validate the notification destination %s: %s",
+                target_arn,
+                code,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
+            )
+            raise InvalidArgument(
                 "Unable to validate the following destination configurations",
-                name=target_arn,
-                value="The destination queue does not exist",
+                ArgumentName=target_arn,
+                ArgumentValue="The destination queue does not exist",
             )
+
         # send test event with the request metadata for permissions
         # https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-event-types-and-destinations.html#supported-notification-event-types
         sqs_client = connect_to(region_name=arn_data["region"]).sqs.request_metadata(
@@ -424,10 +435,10 @@ class SqsNotifier(BaseNotifier):
                 verification_ctx.bucket_name,
                 target_arn,
             )
-            raise _create_invalid_argument_exc(
+            raise InvalidArgument(
                 "Unable to validate the following destination configurations",
-                name=target_arn,
-                value="Permissions on the destination queue do not allow S3 to publish notifications from this bucket",
+                ArgumentName=target_arn,
+                ArgumentValue="Permissions on the destination queue do not allow S3 to publish notifications from this bucket",
             ) from e
 
     def notify(self, ctx: S3EventNotificationContext, config: QueueConfiguration):
@@ -454,10 +465,11 @@ class SqsNotifier(BaseNotifier):
                 MessageSystemAttributes=system_attributes,
             )
         except Exception:
-            LOG.exception(
+            LOG.error(
                 'Unable to send notification for S3 bucket "%s" to SQS queue "%s"',
                 ctx.bucket_name,
                 parsed_arn["resource"],
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
 
 
@@ -483,10 +495,10 @@ class SnsNotifier(BaseNotifier):
         try:
             sns_client.get_topic_attributes(TopicArn=target_arn)
         except ClientError:
-            raise _create_invalid_argument_exc(
+            raise InvalidArgument(
                 "Unable to validate the following destination configurations",
-                name=target_arn,
-                value="The destination topic does not exist",
+                ArgumentName=target_arn,
+                ArgumentValue="The destination topic does not exist",
             )
 
         sns_client = connect_to(region_name=arn_data["region"]).sns.request_metadata(
@@ -506,10 +518,10 @@ class SnsNotifier(BaseNotifier):
                 verification_ctx.bucket_name,
                 target_arn,
             )
-            raise _create_invalid_argument_exc(
+            raise InvalidArgument(
                 "Unable to validate the following destination configurations",
-                name=target_arn,
-                value="Permissions on the destination topic do not allow S3 to publish notifications from this bucket",
+                ArgumentName=target_arn,
+                ArgumentValue="Permissions on the destination topic do not allow S3 to publish notifications from this bucket",
             ) from e
 
     def notify(self, ctx: S3EventNotificationContext, config: TopicConfiguration):
@@ -536,10 +548,11 @@ class SnsNotifier(BaseNotifier):
                 Subject="Amazon S3 Notification",
             )
         except Exception:
-            LOG.exception(
+            LOG.error(
                 'Unable to send notification for S3 bucket "%s" to SNS topic "%s"',
                 ctx.bucket_name,
                 topic_arn,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
 
 
@@ -549,7 +562,7 @@ class LambdaNotifier(BaseNotifier):
     @staticmethod
     def _get_arn_value_and_name(
         lambda_configuration: LambdaFunctionConfiguration,
-    ) -> Tuple[LambdaFunctionArn, str]:
+    ) -> tuple[LambdaFunctionArn, str]:
         return lambda_configuration.get("LambdaFunctionArn", ""), "LambdaFunctionArn"
 
     def _verify_target(self, target_arn: str, verification_ctx: BucketVerificationContext) -> None:
@@ -567,10 +580,10 @@ class LambdaNotifier(BaseNotifier):
         try:
             lambda_client.get_function(FunctionName=target_arn)
         except ClientError:
-            raise _create_invalid_argument_exc(
+            raise InvalidArgument(
                 "Unable to validate the following destination configurations",
-                name=target_arn,
-                value="The destination Lambda does not exist",
+                ArgumentName=target_arn,
+                ArgumentValue="The destination Lambda does not exist",
             )
         lambda_client = connect_to(region_name=arn_data["region"]).lambda_.request_metadata(
             source_arn=s3_bucket_arn(verification_ctx.bucket_name, region=verification_ctx.region),
@@ -579,10 +592,10 @@ class LambdaNotifier(BaseNotifier):
         try:
             lambda_client.invoke(FunctionName=target_arn, InvocationType=InvocationType.DryRun)
         except ClientError as e:
-            raise _create_invalid_argument_exc(
+            raise InvalidArgument(
                 "Unable to validate the following destination configurations",
-                name=f"{target_arn}, null",
-                value=f"Not authorized to invoke function [{target_arn}]",
+                ArgumentName=f"{target_arn}, null",
+                ArgumentValue=f"Not authorized to invoke function [{target_arn}]",
             ) from e
 
     def notify(self, ctx: S3EventNotificationContext, config: LambdaFunctionConfiguration):
@@ -604,10 +617,11 @@ class LambdaNotifier(BaseNotifier):
                 Payload=payload,
             )
         except Exception:
-            LOG.exception(
+            LOG.error(
                 'Unable to send notification for S3 bucket "%s" to Lambda function "%s".',
                 ctx.bucket_name,
                 lambda_arn,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
 
 
@@ -698,14 +712,14 @@ class EventBridgeNotifier(BaseNotifier):
         return entry
 
     @staticmethod
-    def should_notify(ctx: S3EventNotificationContext, config: Dict) -> bool:
+    def should_notify(ctx: S3EventNotificationContext, config: dict) -> bool:
         # Events are always passed to EventBridge, you can route the event in EventBridge
         # See https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventBridge.html
         return True
 
     def validate_configuration_for_notifier(
         self,
-        configurations: List[Dict],
+        configurations: list[dict],
         skip_destination_validation: bool,
         context: RequestContext,
         bucket_name: str,
@@ -729,8 +743,10 @@ class EventBridgeNotifier(BaseNotifier):
         try:
             events_client.put_events(Entries=[entry])
         except Exception:
-            LOG.exception(
-                'Unable to send notification for S3 bucket "%s" to EventBridge', ctx.bucket_name
+            LOG.error(
+                'Unable to send notification for S3 bucket "%s" to EventBridge',
+                ctx.bucket_name,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )