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

localstack/services/sqs/provider.py

@@ -1,21 +1,17 @@
-import copy
-import hashlib
 import json
 import logging
 import re
 import threading
 import time
+from collections.abc import Iterable
 from concurrent.futures.thread import ThreadPoolExecutor
 from itertools import islice
-from typing import Dict, Iterable, List, Literal, Optional, Tuple
 
 from botocore.utils import InvalidArnException
-from moto.sqs.models import BINARY_TYPE_FIELD_INDEX, STRING_TYPE_FIELD_INDEX
-from moto.sqs.models import Message as MotoMessage
 from werkzeug import Request as WerkzeugRequest
 
 from localstack import config
-from localstack.aws.api import CommonServiceException, RequestContext, ServiceException
+from localstack.aws.api import RequestContext, ServiceException
 from localstack.aws.api.sqs import (
     ActionNameList,
     AttributeNameList,
@@ -69,11 +65,8 @@ from localstack.aws.api.sqs import (
     Token,
     TooManyEntriesInBatchRequest,
 )
-from localstack.aws.protocol.parser import create_parser
-from localstack.aws.protocol.serializer import aws_response_serializer
 from localstack.aws.spec import load_service
 from localstack.config import SQS_DISABLE_MAX_NUMBER_OF_MESSAGE_LIMIT
-from localstack.http import Request, route
 from localstack.services.edge import ROUTER
 from localstack.services.plugins import ServiceLifecycleHook
 from localstack.services.sqs import constants as sqs_constants
@@ -83,6 +76,7 @@ from localstack.services.sqs.constants import (
     HEADER_LOCALSTACK_SQS_OVERRIDE_WAIT_TIME_SECONDS,
     MAX_RESULT_LIMIT,
 )
+from localstack.services.sqs.developer_api import SqsDeveloperApi
 from localstack.services.sqs.exceptions import (
     InvalidParameterValueException,
     MissingRequiredParameterException,
@@ -96,8 +90,10 @@ from localstack.services.sqs.models import (
     SqsStore,
     StandardQueue,
     sqs_stores,
+    to_sqs_api_message,
 )
 from localstack.services.sqs.utils import (
+    create_message_attribute_hash,
     decode_move_task_handle,
     generate_message_id,
     is_fifo_queue,
@@ -106,7 +102,6 @@ from localstack.services.sqs.utils import (
 )
 from localstack.services.stores import AccountRegionBundle
 from localstack.utils.aws.arns import parse_arn
-from localstack.utils.aws.request_context import extract_region_from_headers
 from localstack.utils.bootstrap import is_api_enabled
 from localstack.utils.cloudwatch.cloudwatch_util import (
     SqsMetricBatchData,
@@ -126,13 +121,6 @@ MAX_NUMBER_OF_MESSAGES = 10
 _STORE_LOCK = threading.RLock()
 
 
-class InvalidAddress(ServiceException):
-    code = "InvalidAddress"
-    message = "The address https://queue.amazonaws.com/ is not valid for this endpoint."
-    sender_fault = True
-    status_code = 404
-
-
 def assert_queue_name(queue_name: str, fifo: bool = False):
     if queue_name.endswith(".fifo"):
         if not fifo:
@@ -310,7 +298,7 @@ class CloudwatchPublishWorker:
     def __init__(self) -> None:
         super().__init__()
         self.scheduler = Scheduler()
-        self.thread: Optional[FuncThread] = None
+        self.thread: FuncThread | None = None
 
     def publish_approximate_cloudwatch_metrics(self):
         """Publishes the metrics for ApproximateNumberOfMessagesVisible, ApproximateNumberOfMessagesNotVisible
@@ -391,31 +379,39 @@ class QueueUpdateWorker:
     def __init__(self) -> None:
         super().__init__()
         self.scheduler = Scheduler()
-        self.thread: Optional[FuncThread] = None
+        self.thread: FuncThread | None = None
         self.mutex = threading.RLock()
 
     def iter_queues(self) -> Iterable[SqsQueue]:
         for account_id, region, store in sqs_stores.iter_stores():
-            for queue in store.queues.values():
-                yield queue
+            yield from store.queues.values()
 
     def do_update_all_queues(self):
         for queue in self.iter_queues():
             try:
                 queue.requeue_inflight_messages()
             except Exception:
-                LOG.exception("error re-queueing inflight messages")
+                LOG.error(
+                    "error re-queueing inflight messages",
+                    exc_info=LOG.isEnabledFor(logging.DEBUG),
+                )
 
             try:
                 queue.enqueue_delayed_messages()
             except Exception:
-                LOG.exception("error enqueueing delayed messages")
+                LOG.error(
+                    "error enqueueing delayed messages",
+                    exc_info=LOG.isEnabledFor(logging.DEBUG),
+                )
 
             if config.SQS_ENABLE_MESSAGE_RETENTION_PERIOD:
                 try:
                     queue.remove_expired_messages()
                 except Exception:
-                    LOG.exception("error removing expired messages")
+                    LOG.error(
+                        "error removing expired messages",
+                        exc_info=LOG.isEnabledFor(logging.DEBUG),
+                    )
 
     def start(self):
         with self.mutex:
@@ -460,7 +456,7 @@ class MessageMoveTaskManager:
     def __init__(self, stores: AccountRegionBundle[SqsStore] = None) -> None:
         self.stores = stores or sqs_stores
         self.mutex = threading.RLock()
-        self.move_tasks: dict[str, MessageMoveTask] = dict()
+        self.move_tasks: dict[str, MessageMoveTask] = {}
         self.executor = ThreadPoolExecutor(max_workers=100, thread_name_prefix="sqs-move-message")
 
     def submit(self, move_task: MessageMoveTask):
@@ -621,177 +617,16 @@ def check_attributes(message_attributes: MessageBodyAttributeMap):
                 raise InvalidParameterValueException(e.args[0])
 
 
-def check_fifo_id(fifo_id, parameter):
-    if not fifo_id:
+def check_fifo_id(fifo_id: str | None, parameter: str):
+    if fifo_id is None:
         return
-    if len(fifo_id) > 128:
-        raise InvalidParameterValueException(
-            f"Value {fifo_id} for parameter {parameter} is invalid. Reason: {parameter} can only include alphanumeric and punctuation characters. 1 to 128 in length."
-        )
     if not re.match(sqs_constants.FIFO_MSG_REGEX, fifo_id):
         raise InvalidParameterValueException(
-            "Invalid characters found. Deduplication ID and group ID can only contain"
-            "alphanumeric characters as well as TODO"
+            f"Value {fifo_id} for parameter {parameter} is invalid. "
+            f"Reason: {parameter} can only include alphanumeric and punctuation characters. 1 to 128 in length."
         )
 
 
-def get_sqs_protocol(request: Request) -> Literal["query", "json"]:
-    content_type = request.headers.get("Content-Type")
-    return "json" if content_type == "application/x-amz-json-1.0" else "query"
-
-
-def sqs_auto_protocol_aws_response_serializer(service_name: str, operation: str):
-    def _decorate(fn):
-        def _proxy(*args, **kwargs):
-            # extract request from function invocation (decorator can be used for methods as well as for functions).
-            if len(args) > 0 and isinstance(args[0], WerkzeugRequest):
-                # function
-                request = args[0]
-            elif len(args) > 1 and isinstance(args[1], WerkzeugRequest):
-                # method (arg[0] == self)
-                request = args[1]
-            elif "request" in kwargs:
-                request = kwargs["request"]
-            else:
-                raise ValueError(f"could not find Request in signature of function {fn}")
-
-            protocol = get_sqs_protocol(request)
-            return aws_response_serializer(service_name, operation, protocol)(fn)(*args, **kwargs)
-
-        return _proxy
-
-    return _decorate
-
-
-class SqsDeveloperEndpoints:
-    """
-    A set of SQS developer tool endpoints:
-
-    - ``/_aws/sqs/messages``: list SQS messages without side effects, compatible with ``ReceiveMessage``.
-    """
-
-    def __init__(self, stores=None):
-        self.stores = stores or sqs_stores
-
-    @route("/_aws/sqs/messages", methods=["GET", "POST"])
-    @sqs_auto_protocol_aws_response_serializer("sqs", "ReceiveMessage")
-    def list_messages(self, request: Request) -> ReceiveMessageResult:
-        """
-        This endpoint expects a ``QueueUrl`` request parameter (either as query arg or form parameter), similar to
-        the ``ReceiveMessage`` operation. It will parse the Queue URL generated by one of the SQS endpoint strategies.
-        """
-
-        if "x-amz-" in request.mimetype or "x-www-form-urlencoded" in request.mimetype:
-            # only parse the request using a parser if it comes from an AWS client
-            protocol = get_sqs_protocol(request)
-            operation, service_request = create_parser(
-                load_service("sqs", protocol=protocol)
-            ).parse(request)
-            if operation.name != "ReceiveMessage":
-                raise CommonServiceException(
-                    "InvalidRequest", "This endpoint only accepts ReceiveMessage calls"
-                )
-        else:
-            service_request = dict(request.values)
-
-        if not service_request.get("QueueUrl"):
-            raise QueueDoesNotExist()
-
-        try:
-            account_id, region, queue_name = parse_queue_url(service_request.get("QueueUrl"))
-        except ValueError:
-            LOG.exception(
-                "Error while parsing Queue URL from request values: %s", service_request.get
-            )
-            raise InvalidAddress()
-
-        if not region:
-            region = extract_region_from_headers(request.headers)
-
-        return self._get_and_serialize_messages(request, region, account_id, queue_name)
-
-    @route("/_aws/sqs/messages/<region>/<account_id>/<queue_name>")
-    @sqs_auto_protocol_aws_response_serializer("sqs", "ReceiveMessage")
-    def list_messages_for_queue_url(
-        self, request: Request, region: str, account_id: str, queue_name: str
-    ) -> ReceiveMessageResult:
-        """
-        This endpoint extracts the region, account_id, and queue_name directly from the URL rather than requiring the
-        QueueUrl as parameter.
-        """
-        return self._get_and_serialize_messages(request, region, account_id, queue_name)
-
-    def _get_and_serialize_messages(
-        self,
-        request: Request,
-        region: str,
-        account_id: str,
-        queue_name: str,
-    ) -> ReceiveMessageResult:
-        show_invisible = request.values.get("ShowInvisible", "").lower() in ["true", "1"]
-        show_delayed = request.values.get("ShowDelayed", "").lower() in ["true", "1"]
-
-        try:
-            store = SqsProvider.get_store(account_id, region)
-            queue = store.queues[queue_name]
-        except KeyError:
-            LOG.info(
-                "no queue named %s in region %s and account %s", queue_name, region, account_id
-            )
-            raise QueueDoesNotExist()
-
-        messages = self._collect_messages(
-            queue, show_invisible=show_invisible, show_delayed=show_delayed
-        )
-
-        return ReceiveMessageResult(Messages=messages)
-
-    def _collect_messages(
-        self, queue: SqsQueue, show_invisible: bool = False, show_delayed: bool = False
-    ) -> List[Message]:
-        """
-        Retrieves from a given SqsQueue all visible messages without causing any side effects (not setting any
-        receive timestamps, receive counts, or visibility state).
-
-        :param queue: the queue
-        :param show_invisible: show invisible messages as well
-        :param show_delayed: show delayed messages as well
-        :return: a list of messages
-        """
-        receipt_handle = "SQS/BACKDOOR/ACCESS"  # dummy receipt handle
-
-        sqs_messages: List[SqsMessage] = []
-
-        if show_invisible:
-            sqs_messages.extend(queue.inflight)
-
-        if isinstance(queue, StandardQueue):
-            sqs_messages.extend(queue.visible.queue)
-        elif isinstance(queue, FifoQueue):
-            for message_group in queue.message_groups.values():
-                for sqs_message in message_group.messages:
-                    sqs_messages.append(sqs_message)
-        else:
-            raise ValueError(f"unknown queue type {type(queue)}")
-
-        if show_delayed:
-            sqs_messages.extend(queue.delayed)
-
-        messages = []
-
-        for sqs_message in sqs_messages:
-            message: Message = to_sqs_api_message(sqs_message, [QueueAttributeName.All], ["All"])
-            # these are all non-standard fields so we squelch the linter
-            if show_invisible:
-                message["Attributes"]["IsVisible"] = str(sqs_message.is_visible).lower()  # noqa
-            if show_delayed:
-                message["Attributes"]["IsDelayed"] = str(sqs_message.is_delayed).lower()  # noqa
-            messages.append(message)
-            message["ReceiptHandle"] = receipt_handle
-
-        return messages
-
-
 class SqsProvider(SqsApi, ServiceLifecycleHook):
     """
     LocalStack SQS Provider.
@@ -815,7 +650,7 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
         - UntagQueue
     """
 
-    queues: Dict[str, SqsQueue]
+    queues: dict[str, SqsQueue]
 
     def __init__(self) -> None:
         super().__init__()
@@ -828,9 +663,26 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
     def get_store(account_id: str, region: str) -> SqsStore:
         return sqs_stores[account_id][region]
 
+    def on_after_init(self):
+        # this configuration increases the processing power for Query protocol requests, which are form-encoded and by
+        # default are limited to 500kb payload size by Werkzeug. we make sure we only *increase* the limit if it's
+        # already set, and if it's already set to unlimited we leave it.
+        from rolo import Request as RoloRequest
+
+        # needed for the webserver integration (webservers create Werkzeug request objects)
+        if WerkzeugRequest.max_form_memory_size is not None:
+            WerkzeugRequest.max_form_memory_size = max(
+                WerkzeugRequest.max_form_memory_size, sqs_constants.DEFAULT_MAXIMUM_MESSAGE_SIZE * 2
+            )
+        # needed for internal/proxy requests (which create rolo request objects)
+        if RoloRequest.max_form_memory_size is not None:
+            RoloRequest.max_form_memory_size = max(
+                RoloRequest.max_form_memory_size, sqs_constants.DEFAULT_MAXIMUM_MESSAGE_SIZE * 2
+            )
+
     def on_before_start(self):
         query_api.register(ROUTER)
-        self._router_rules = ROUTER.add(SqsDeveloperEndpoints())
+        self._router_rules = ROUTER.add(SqsDeveloperApi())
         self._queue_update_worker.start()
         self._start_cloudwatch_metrics_reporting()
 
@@ -881,8 +733,8 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
     def _resolve_queue(
         self,
         context: RequestContext,
-        queue_name: Optional[str] = None,
-        queue_url: Optional[str] = None,
+        queue_name: str | None = None,
+        queue_url: str | None = None,
     ) -> SqsQueue:
         """
         Determines the name of the queue from available information (request context, queue URL) to return the respective queue,
@@ -1125,7 +977,7 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
             MD5OfMessageBody=message["MD5OfBody"],
             MD5OfMessageAttributes=message.get("MD5OfMessageAttributes"),
             SequenceNumber=queue_item.sequence_number,
-            MD5OfMessageSystemAttributes=_create_message_attribute_hash(message_system_attributes),
+            MD5OfMessageSystemAttributes=create_message_attribute_hash(message_system_attributes),
         )
 
     def send_message_batch(
@@ -1171,7 +1023,7 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
                             MessageId=message.get("MessageId"),
                             MD5OfMessageBody=message.get("MD5OfBody"),
                             MD5OfMessageAttributes=message.get("MD5OfMessageAttributes"),
-                            MD5OfMessageSystemAttributes=_create_message_attribute_hash(
+                            MD5OfMessageSystemAttributes=create_message_attribute_hash(
                                 message.get("message_system_attributes")
                             ),
                             SequenceNumber=queue_item.sequence_number,
@@ -1225,7 +1077,7 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
             MD5OfBody=md5(message_body),
             Body=message_body,
             Attributes=self._create_message_attributes(context, message_system_attributes),
-            MD5OfMessageAttributes=_create_message_attribute_hash(message_attributes),
+            MD5OfMessageAttributes=create_message_attribute_hash(message_attributes),
             MessageAttributes=message_attributes,
         )
         if self._cloudwatch_dispatcher:
@@ -1674,8 +1526,8 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         message_system_attributes: MessageBodySystemAttributeMap = None,
-    ) -> Dict[MessageSystemAttributeName, str]:
-        result: Dict[MessageSystemAttributeName, str] = {
+    ) -> dict[MessageSystemAttributeName, str]:
+        result: dict[MessageSystemAttributeName, str] = {
             MessageSystemAttributeName.SenderId: context.account_id,  # not the account ID in AWS
             MessageSystemAttributeName.SentTimestamp: str(now(millis=True)),
         }
@@ -1709,7 +1561,7 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
 
     def _assert_batch(
         self,
-        batch: List,
+        batch: list,
         *,
         require_fifo_queue_params: bool = False,
         require_message_deduplication_id: bool = False,
@@ -1745,7 +1597,7 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
             else:
                 visited.add(entry_id)
 
-    def _assert_valid_batch_size(self, batch: List, max_message_size: int):
+    def _assert_valid_batch_size(self, batch: list, max_message_size: int):
         batch_message_size = sum(
             _message_body_size(entry.get("MessageBody"))
             + _message_attributes_size(entry.get("MessageAttributes"))
@@ -1756,7 +1608,7 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
             error += f" You have sent {batch_message_size} bytes."
             raise BatchRequestTooLong(error)
 
-    def _assert_valid_message_ids(self, batch: List):
+    def _assert_valid_message_ids(self, batch: list):
         batch_id_regex = r"^[\w-]{1,80}$"
         for message in batch:
             if not re.match(batch_id_regex, message.get("Id", "")):
@@ -1785,37 +1637,9 @@ class SqsProvider(SqsApi, ServiceLifecycleHook):
             self._cloudwatch_dispatcher.shutdown()
 
 
-# Method from moto's attribute_md5 of moto/sqs/models.py, separated from the Message Object
-def _create_message_attribute_hash(message_attributes) -> Optional[str]:
-    # To avoid the need to check for dict conformity everytime we invoke this function
-    if not isinstance(message_attributes, dict):
-        return
-    hash = hashlib.md5()
-
-    for attrName in sorted(message_attributes.keys()):
-        attr_value = message_attributes[attrName]
-        # Encode name
-        MotoMessage.update_binary_length_and_value(hash, MotoMessage.utf8(attrName))
-        # Encode data type
-        MotoMessage.update_binary_length_and_value(hash, MotoMessage.utf8(attr_value["DataType"]))
-        # Encode transport type and value
-        if attr_value.get("StringValue"):
-            hash.update(bytearray([STRING_TYPE_FIELD_INDEX]))
-            MotoMessage.update_binary_length_and_value(
-                hash, MotoMessage.utf8(attr_value.get("StringValue"))
-            )
-        elif attr_value.get("BinaryValue"):
-            hash.update(bytearray([BINARY_TYPE_FIELD_INDEX]))
-            decoded_binary_value = attr_value.get("BinaryValue")
-            MotoMessage.update_binary_length_and_value(hash, decoded_binary_value)
-        # string_list_value, binary_list_value type is not implemented, reserved for the future use.
-        # See https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_MessageAttributeValue.html
-    return hash.hexdigest()
-
-
 def resolve_queue_location(
-    context: RequestContext, queue_name: Optional[str] = None, queue_url: Optional[str] = None
-) -> Tuple[str, Optional[str], str]:
+    context: RequestContext, queue_name: str | None = None, queue_url: str | None = None
+) -> tuple[str, str | None, str]:
     """
     Resolves a queue location from the given information.
 
@@ -1837,106 +1661,6 @@ def resolve_queue_location(
     return context.account_id, context.region, queue_name
 
 
-def to_sqs_api_message(
-    standard_message: SqsMessage,
-    attribute_names: AttributeNameList = None,
-    message_attribute_names: MessageAttributeNameList = None,
-) -> Message:
-    """
-    Utility function to convert an SQS message from LocalStack's internal representation to the AWS API
-    concept 'Message', which is the format returned by the ``ReceiveMessage`` operation.
-
-    :param standard_message: A LocalStack SQS message
-    :param attribute_names: the attribute name list to filter
-    :param message_attribute_names: the message attribute names to filter
-    :return: a copy of the original Message with updated message attributes and MD5 attribute hash sums
-    """
-    # prepare message for receiver
-    message = copy.deepcopy(standard_message.message)
-
-    # update system attributes of the message copy
-    message["Attributes"][MessageSystemAttributeName.ApproximateFirstReceiveTimestamp] = str(
-        int((standard_message.first_received or 0) * 1000)
-    )
-
-    # filter attributes for receiver
-    message_filter_attributes(message, attribute_names)
-    message_filter_message_attributes(message, message_attribute_names)
-    if message.get("MessageAttributes"):
-        message["MD5OfMessageAttributes"] = _create_message_attribute_hash(
-            message["MessageAttributes"]
-        )
-    else:
-        # delete the value that was computed when creating the message
-        message.pop("MD5OfMessageAttributes", None)
-    return message
-
-
-def message_filter_attributes(message: Message, names: Optional[AttributeNameList]):
-    """
-    Utility function filter from the given message (in-place) the system attributes from the given list. It will
-    apply all rules according to:
-    https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sqs.html#SQS.Client.receive_message.
-
-    :param message: The message to filter (it will be modified)
-    :param names: the attributes names/filters
-    """
-    if "Attributes" not in message:
-        return
-
-    if not names:
-        del message["Attributes"]
-        return
-
-    if QueueAttributeName.All in names:
-        return
-
-    for k in list(message["Attributes"].keys()):
-        if k not in names:
-            del message["Attributes"][k]
-
-
-def message_filter_message_attributes(message: Message, names: Optional[MessageAttributeNameList]):
-    """
-    Utility function filter from the given message (in-place) the message attributes from the given list. It will
-    apply all rules according to:
-    https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sqs.html#SQS.Client.receive_message.
-
-    :param message: The message to filter (it will be modified)
-    :param names: the attributes names/filters (can be 'All', '.*', '*' or prefix filters like 'Foo.*')
-    """
-    if not message.get("MessageAttributes"):
-        return
-
-    if not names:
-        del message["MessageAttributes"]
-        return
-
-    if "All" in names or ".*" in names or "*" in names:
-        return
-
-    attributes = message["MessageAttributes"]
-    matched = []
-
-    keys = [name for name in names if ".*" not in name]
-    prefixes = [name.split(".*")[0] for name in names if ".*" in name]
-
-    # match prefix filters
-    for k in attributes:
-        if k in keys:
-            matched.append(k)
-            continue
-
-        for prefix in prefixes:
-            if k.startswith(prefix):
-                matched.append(k)
-            break
-    if matched:
-        message["MessageAttributes"] = {k: attributes[k] for k in matched}
-    else:
-        message.pop("MessageAttributes")
-
-
 def extract_message_count_from_headers(context: RequestContext) -> int | None:
     if override := context.request.headers.get(
         HEADER_LOCALSTACK_SQS_OVERRIDE_MESSAGE_COUNT, default=None, type=int

localstack/services/sqs/query_api.py

@@ -4,7 +4,6 @@ generic implementation that creates from Query API requests the respective AWS r
 to make the request."""
 
 import logging
-from typing import Dict, Optional, Tuple
 from urllib.parse import urlencode
 
 from botocore.exceptions import ClientError
@@ -36,7 +35,7 @@ LOG = logging.getLogger(__name__)
 
 service = load_service("sqs-query")
 parser = create_parser(service)
-serializer = create_serializer(service)
+serializer = create_serializer(service, "query")
 
 
 @route(
@@ -167,7 +166,11 @@ def handle_request(request: Request, region: str) -> Response:
         op = service.operation_model(service.operation_names[0])
         return serializer.serialize_error_to_response(e, op, request.headers, request_id)
     except Exception as e:
-        LOG.exception("exception")
+        LOG.error(
+            "Internal Server exception while executing SQS Query operation: '%s'",
+            e,
+            exc_info=LOG.isEnabledFor(logging.DEBUG),
+        )
         op = service.operation_model(service.operation_names[0])
         return serializer.serialize_error_to_response(
             CommonServiceException(
@@ -179,7 +182,7 @@ def handle_request(request: Request, region: str) -> Response:
         )
 
 
-def try_call_sqs(request: Request, region: str) -> Tuple[Dict, OperationModel]:
+def try_call_sqs(request: Request, region: str) -> tuple[dict, OperationModel]:
     action = request.values.get("Action")
     if not action:
         raise UnknownOperationException()
@@ -209,7 +212,7 @@ def try_call_sqs(request: Request, region: str) -> Tuple[Dict, OperationModel]:
     # Extract from auth header to allow cross-account operations
     # TODO: permissions encoded in URL as AUTHPARAMS cannot be accounted for in this method, which is not a big
     #  problem yet since we generally don't enforce permissions.
-    account_id: Optional[str] = extract_access_key_id_from_auth_header(headers)
+    account_id: str | None = extract_access_key_id_from_auth_header(headers)
 
     client = connect_to(
         region_name=region,

localstack/services/sqs/resource_providers/aws_sqs_queue.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 import localstack.services.cloudformation.provider_utils as util
 from localstack.services.cloudformation.resource_provider import (
@@ -15,29 +15,29 @@ from localstack.services.cloudformation.resource_provider import (
 
 
 class SQSQueueProperties(TypedDict):
-    Arn: Optional[str]
-    ContentBasedDeduplication: Optional[bool]
-    DeduplicationScope: Optional[str]
-    DelaySeconds: Optional[int]
-    FifoQueue: Optional[bool]
-    FifoThroughputLimit: Optional[str]
-    KmsDataKeyReusePeriodSeconds: Optional[int]
-    KmsMasterKeyId: Optional[str]
-    MaximumMessageSize: Optional[int]
-    MessageRetentionPeriod: Optional[int]
-    QueueName: Optional[str]
-    QueueUrl: Optional[str]
-    ReceiveMessageWaitTimeSeconds: Optional[int]
-    RedriveAllowPolicy: Optional[dict | str]
-    RedrivePolicy: Optional[dict | str]
-    SqsManagedSseEnabled: Optional[bool]
-    Tags: Optional[list[Tag]]
-    VisibilityTimeout: Optional[int]
+    Arn: str | None
+    ContentBasedDeduplication: bool | None
+    DeduplicationScope: str | None
+    DelaySeconds: int | None
+    FifoQueue: bool | None
+    FifoThroughputLimit: str | None
+    KmsDataKeyReusePeriodSeconds: int | None
+    KmsMasterKeyId: str | None
+    MaximumMessageSize: int | None
+    MessageRetentionPeriod: int | None
+    QueueName: str | None
+    QueueUrl: str | None
+    ReceiveMessageWaitTimeSeconds: int | None
+    RedriveAllowPolicy: dict | str | None
+    RedrivePolicy: dict | str | None
+    SqsManagedSseEnabled: bool | None
+    Tags: list[Tag] | None
+    VisibilityTimeout: int | None
 
 
 class Tag(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"