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

localstack/utils/archives.py

@@ -8,7 +8,7 @@ import tempfile
 import time
 import zipfile
 from subprocess import Popen
-from typing import IO, Literal, Optional, Union
+from typing import IO, Literal
 
 from localstack.constants import MAVEN_REPO_URL
 from localstack.utils.files import load_file, mkdir, new_tmp_file, rm_rf, save_file
@@ -22,7 +22,7 @@ from .strings import truncate
 LOG = logging.getLogger(__name__)
 
 
-StrPath = Union[str, os.PathLike]
+StrPath = str | os.PathLike
 
 
 def is_zip_file(content):
@@ -30,13 +30,13 @@ def is_zip_file(content):
     return zipfile.is_zipfile(stream)
 
 
-def get_unzipped_size(zip_file: Union[str, IO[bytes]]):
+def get_unzipped_size(zip_file: str | IO[bytes]):
     """Returns the size of the unzipped file."""
     with zipfile.ZipFile(zip_file, "r") as zip_ref:
         return sum(f.file_size for f in zip_ref.infolist())
 
 
-def unzip(path: str, target_dir: str, overwrite: bool = True) -> Optional[Union[str, Popen]]:
+def unzip(path: str, target_dir: str, overwrite: bool = True) -> str | Popen | None:
     from localstack.utils.platform import is_debian
 
     use_native_cmd = is_debian() or is_command_available("unzip")
@@ -99,7 +99,7 @@ def create_zip_file_python(
     base_dir: StrPath,
     zip_file: StrPath,
     mode: Literal["r", "w", "x", "a"] = "w",
-    content_root: Optional[str] = None,
+    content_root: str | None = None,
 ):
     with zipfile.ZipFile(zip_file, mode) as zip_file:
         for root, dirs, files in os.walk(base_dir):
@@ -122,7 +122,7 @@ def add_file_to_jar(class_file, class_url, target_jar, base_dir=None):
 
 
 def update_jar_manifest(
-    jar_file_name: str, parent_dir: str, search: Union[str, re.Pattern], replace: str
+    jar_file_name: str, parent_dir: str, search: str | re.Pattern, replace: str
 ):
     manifest_file_path = "META-INF/MANIFEST.MF"
     jar_path = os.path.join(parent_dir, jar_file_name)
@@ -174,10 +174,10 @@ def upgrade_jar_file(base_dir: str, file_glob: str, maven_asset: str):
 def download_and_extract(
     archive_url: str,
     target_dir: str,
-    retries: Optional[int] = 0,
-    sleep: Optional[int] = 3,
-    tmp_archive: Optional[str] = None,
-    checksum_url: Optional[str] = None,
+    retries: int | None = 0,
+    sleep: int | None = 3,
+    tmp_archive: str | None = None,
+    checksum_url: str | None = None,
 ) -> None:
     """
     Download and extract an archive to a target directory with optional checksum verification.
@@ -233,7 +233,7 @@ def download_and_extract(
             rm_rf(tmp_archive)
             raise e
 
-    if ext == ".zip":
+    if ext in (".zip", ".whl"):
         unzip(tmp_archive, target_dir)
     elif ext in (
         ".bz2",
@@ -250,7 +250,7 @@ def download_and_extract_with_retry(
     archive_url,
     tmp_archive,
     target_dir,
-    checksum_url: Optional[str] = None,
+    checksum_url: str | None = None,
 ):
     try:
         download_and_extract(

localstack/utils/asyncio.py

@@ -40,12 +40,12 @@ class AdaptiveThreadPool(DaemonAwareThreadPool):
 
     def __init__(self, core_size=None):
         self.core_size = core_size or self.DEFAULT_CORE_POOL_SIZE
-        super(AdaptiveThreadPool, self).__init__(max_workers=self.core_size)
+        super().__init__(max_workers=self.core_size)
 
     def submit(self, fn, *args, **kwargs):
         # if idle threads are available, don't spin new threads
         if self.has_idle_threads():
-            return super(AdaptiveThreadPool, self).submit(fn, *args, **kwargs)
+            return super().submit(fn, *args, **kwargs)
 
         def _run(*tmpargs):
             return fn(*args, **kwargs)

localstack/utils/aws/arns.py

@@ -1,7 +1,7 @@
 import logging
 import re
 from functools import cache
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 from botocore.utils import ArnParser, InvalidArnException
 
@@ -27,7 +27,7 @@ PARTITION_NAMES = list(REGION_PREFIX_TO_PARTITION.values()) + [DEFAULT_PARTITION
 ARN_PARTITION_REGEX = r"^arn:(" + "|".join(sorted(PARTITION_NAMES)) + ")"
 
 
-def get_partition(region: Optional[str]) -> str:
+def get_partition(region: str | None) -> str:
     if not region:
         return DEFAULT_PARTITION
     if region in PARTITION_NAMES:
@@ -65,28 +65,28 @@ def parse_arn(arn: str) -> ArnData:
     return _arn_parser.parse_arn(arn)
 
 
-def extract_account_id_from_arn(arn: str) -> Optional[str]:
+def extract_account_id_from_arn(arn: str) -> str | None:
     try:
         return parse_arn(arn).get("account")
     except InvalidArnException:
         return None
 
 
-def extract_region_from_arn(arn: str) -> Optional[str]:
+def extract_region_from_arn(arn: str) -> str | None:
     try:
         return parse_arn(arn).get("region")
     except InvalidArnException:
         return None
 
 
-def extract_service_from_arn(arn: str) -> Optional[str]:
+def extract_service_from_arn(arn: str) -> str | None:
     try:
         return parse_arn(arn).get("service")
     except InvalidArnException:
         return None
 
 
-def extract_resource_from_arn(arn: str) -> Optional[str]:
+def extract_resource_from_arn(arn: str) -> str | None:
     try:
         return parse_arn(arn).get("resource")
     except InvalidArnException:
@@ -98,8 +98,10 @@ def extract_resource_from_arn(arn: str) -> Optional[str]:
 #
 
 
-def _resource_arn(name: str, pattern: str, account_id: str, region_name: str) -> str:
-    if ":" in name:
+def _resource_arn(
+    name: str, pattern: str, account_id: str, region_name: str, allow_colons=False
+) -> str:
+    if ":" in name and not allow_colons:
         return name
     if len(pattern.split("%s")) == 4:
         return pattern % (get_partition(region_name), account_id, name)
@@ -120,7 +122,7 @@ def iam_role_arn(role_name: str, account_id: str, region_name: str) -> str:
         return role_name
     if re.match(f"{ARN_PARTITION_REGEX}:iam::", role_name):
         return role_name
-    return "arn:%s:iam::%s:role/%s" % (get_partition(region_name), account_id, role_name)
+    return f"arn:{get_partition(region_name)}:iam::{account_id}:role/{role_name}"
 
 
 def iam_resource_arn(resource: str, account_id: str, role: str = None) -> str:
@@ -155,14 +157,14 @@ def secretsmanager_secret_arn(
 def cloudformation_stack_arn(
     stack_name: str, stack_id: str, account_id: str, region_name: str
 ) -> str:
-    pattern = "arn:%s:cloudformation:%s:%s:stack/%s/{stack_id}".format(stack_id=stack_id)
+    pattern = f"arn:%s:cloudformation:%s:%s:stack/%s/{stack_id}"
     return _resource_arn(stack_name, pattern, account_id=account_id, region_name=region_name)
 
 
 def cloudformation_change_set_arn(
     change_set_name: str, change_set_id: str, account_id: str, region_name: str
 ) -> str:
-    pattern = "arn:%s:cloudformation:%s:%s:changeSet/%s/{cs_id}".format(cs_id=change_set_id)
+    pattern = f"arn:%s:cloudformation:%s:%s:changeSet/%s/{change_set_id}"
     return _resource_arn(change_set_name, pattern, account_id=account_id, region_name=region_name)
 
 
@@ -180,13 +182,7 @@ def dynamodb_table_arn(table_name: str, account_id: str, region_name: str) -> st
 def dynamodb_stream_arn(
     table_name: str, latest_stream_label: str, account_id: str, region_name: str
 ) -> str:
-    return "arn:%s:dynamodb:%s:%s:table/%s/stream/%s" % (
-        get_partition(region_name),
-        region_name,
-        account_id,
-        table_name,
-        latest_stream_label,
-    )
+    return f"arn:{get_partition(region_name)}:dynamodb:{region_name}:{account_id}:table/{table_name}/stream/{latest_stream_label}"
 
 
 #
@@ -291,7 +287,7 @@ def lambda_event_source_mapping_arn(uuid: str, account_id: str, region_name: str
 def lambda_function_or_layer_arn(
     type: str,
     entity_name: str,
-    version: Optional[str],
+    version: str | None,
     account_id: str,
     region_name: str,
 ) -> str:
@@ -453,7 +449,7 @@ def s3_bucket_arn(bucket_name_or_arn: str, region="us-east-1") -> str:
 
 def sqs_queue_arn(queue_name: str, account_id: str, region_name: str) -> str:
     queue_name = queue_name.split("/")[-1]
-    return "arn:%s:sqs:%s:%s:%s" % (get_partition(region_name), region_name, account_id, queue_name)
+    return f"arn:{get_partition(region_name)}:sqs:{region_name}:{account_id}:{queue_name}"
 
 
 #
@@ -462,20 +458,13 @@ def sqs_queue_arn(queue_name: str, account_id: str, region_name: str) -> str:
 
 
 def apigateway_restapi_arn(api_id: str, account_id: str, region_name: str) -> str:
-    return "arn:%s:apigateway:%s:%s:/restapis/%s" % (
-        get_partition(region_name),
-        region_name,
-        account_id,
-        api_id,
+    return (
+        f"arn:{get_partition(region_name)}:apigateway:{region_name}:{account_id}:/restapis/{api_id}"
     )
 
 
 def apigateway_invocations_arn(lambda_uri: str, region_name: str) -> str:
-    return "arn:%s:apigateway:%s:lambda:path/2015-03-31/functions/%s/invocations" % (
-        get_partition(region_name),
-        region_name,
-        lambda_uri,
-    )
+    return f"arn:{get_partition(region_name)}:apigateway:{region_name}:lambda:path/2015-03-31/functions/{lambda_uri}/invocations"
 
 
 #
@@ -487,6 +476,12 @@ def sns_topic_arn(topic_name: str, account_id: str, region_name: str) -> str:
     return f"arn:{get_partition(region_name)}:sns:{region_name}:{account_id}:{topic_name}"
 
 
+def sns_platform_application_arn(
+    platform_application_name: str, platform: str, account_id: str, region_name: str
+) -> str:
+    return f"arn:{get_partition(region_name)}:sns:{region_name}:{account_id}:app/{platform}/{platform_application_name}"
+
+
 #
 # ECR
 #
@@ -555,7 +550,7 @@ def lambda_function_name(name_or_arn: str) -> str:
     if ":" in name_or_arn:
         arn = parse_arn(name_or_arn)
         if arn["service"] != "lambda":
-            raise ValueError("arn is not a lambda arn %s" % name_or_arn)
+            raise ValueError(f"arn is not a lambda arn {name_or_arn}")
 
         return parse_arn(name_or_arn)["resource"].split(":")[1]
     else:

localstack/utils/aws/aws_responses.py

@@ -3,7 +3,7 @@ import datetime
 import json
 import re
 from binascii import crc32
-from typing import Any, Dict, Optional, Union
+from typing import Any
 from urllib.parse import parse_qs
 
 import xmltodict
@@ -36,21 +36,19 @@ def requests_error_response_json(message, code=500, error_type="InternalFailure"
 
 def requests_error_response_xml(
     message: str,
-    code: Optional[int] = 400,
-    code_string: Optional[str] = "InvalidParameter",
-    service: Optional[str] = None,
-    xmlns: Optional[str] = None,
+    code: int | None = 400,
+    code_string: str | None = "InvalidParameter",
+    service: str | None = None,
+    xmlns: str | None = None,
 ):
     response = RequestsResponse()
-    xmlns = xmlns or "http://%s.amazonaws.com/doc/2010-03-31/" % service
-    response._content = """<ErrorResponse xmlns="{xmlns}"><Error>
+    xmlns = xmlns or f"http://{service}.amazonaws.com/doc/2010-03-31/"
+    response._content = f"""<ErrorResponse xmlns="{xmlns}"><Error>
         <Type>Sender</Type>
         <Code>{code_string}</Code>
         <Message>{message}</Message>
-        </Error><RequestId>{req_id}</RequestId>
-        </ErrorResponse>""".format(
-        xmlns=xmlns, message=message, code_string=code_string, req_id=short_uid()
-    )
+        </Error><RequestId>{short_uid()}</RequestId>
+        </ErrorResponse>"""
     response.status_code = code
     return response
 
@@ -65,18 +63,13 @@ def requests_error_response_xml_signature_calculation(
     aws_access_token="temp",
 ):
     response = RequestsResponse()
-    response_template = """<?xml version="1.0" encoding="UTF-8"?>
+    response_template = f"""<?xml version="1.0" encoding="UTF-8"?>
         <Error>
             <Code>{code_string}</Code>
             <Message>{message}</Message>
-            <RequestId>{req_id}</RequestId>
-            <HostId>{host_id}</HostId>
-        </Error>""".format(
-        message=message,
-        code_string=code_string,
-        req_id=short_uid(),
-        host_id=short_uid(),
-    )
+            <RequestId>{short_uid()}</RequestId>
+            <HostId>{short_uid()}</HostId>
+        </Error>"""
 
     parsed_response = xmltodict.parse(response_template)
     response.status_code = code
@@ -94,8 +87,8 @@ def requests_error_response_xml_signature_calculation(
         server_time = datetime.datetime.utcnow().isoformat()[:-4]
         expires_isoformat = datetime.datetime.fromtimestamp(int(expires)).isoformat()[:-4]
         parsed_response["Error"]["Code"] = code_string
-        parsed_response["Error"]["Expires"] = "{}Z".format(expires_isoformat)
-        parsed_response["Error"]["ServerTime"] = "{}Z".format(server_time)
+        parsed_response["Error"]["Expires"] = f"{expires_isoformat}Z"
+        parsed_response["Error"]["ServerTime"] = f"{server_time}Z"
         set_response_content(response, xmltodict.unparse(parsed_response))
 
     if not signature and not expires and code_string == "AccessDenied":
@@ -106,8 +99,8 @@ def requests_error_response_xml_signature_calculation(
 
 
 def requests_error_response(
-    req_headers: Dict,
-    message: Union[str, bytes],
+    req_headers: dict,
+    message: str | bytes,
     code: int = 500,
     error_type: str = "InternalFailure",
     service: str = None,
@@ -121,7 +114,7 @@ def requests_error_response(
     )
 
 
-def is_json_request(req_headers: Dict) -> bool:
+def is_json_request(req_headers: dict) -> bool:
     ctype = req_headers.get("Content-Type", "")
     accept = req_headers.get("Accept", "")
     return "json" in ctype or "json" in accept
@@ -186,7 +179,7 @@ def set_response_content(response, content, headers=None):
     response.headers["Content-Length"] = str(len(response._content))
 
 
-def create_sqs_system_attributes(headers: Dict[str, str]) -> Dict[str, Any]:
+def create_sqs_system_attributes(headers: dict[str, str]) -> dict[str, Any]:
     system_attributes = {}
     if "X-Amzn-Trace-Id" in headers:
         system_attributes["AWSTraceHeader"] = {
@@ -196,7 +189,7 @@ def create_sqs_system_attributes(headers: Dict[str, str]) -> Dict[str, Any]:
     return system_attributes
 
 
-def parse_query_string(url_or_qs: str, multi_values=False) -> Dict[str, str]:
+def parse_query_string(url_or_qs: str, multi_values=False) -> dict[str, str]:
     url_or_qs = str(url_or_qs or "").strip()
     # we match if the `url_or_qs` passed is maybe a URL
     if regex_url_start.match(url_or_qs) and "?" not in url_or_qs:
@@ -208,7 +201,7 @@ def parse_query_string(url_or_qs: str, multi_values=False) -> Dict[str, str]:
     return result
 
 
-def calculate_crc32(content: Union[str, bytes]) -> int:
+def calculate_crc32(content: str | bytes) -> int:
     return crc32(to_bytes(content)) & 0xFFFFFFFF
 
 

localstack/utils/aws/aws_stack.py

@@ -2,7 +2,6 @@ import logging
 import re
 import socket
 from functools import lru_cache
-from typing import List, Union
 
 import boto3
 
@@ -20,7 +19,7 @@ LOG = logging.getLogger(__name__)
 CACHE_S3_HOSTNAME_DNS_STATUS = None
 
 
-@lru_cache()
+@lru_cache
 def get_valid_regions():
     session = boto3.Session()
     valid_regions = set()
@@ -32,7 +31,7 @@ def get_valid_regions():
 
 # FIXME: AWS recommends use of SSM parameter store to determine per region availability
 # https://github.com/aws/aws-sdk/issues/206#issuecomment-1471354853
-@lru_cache()
+@lru_cache
 def get_valid_regions_for_service(service_name):
     session = boto3.Session()
     regions = list(session.get_available_regions(service_name))
@@ -46,7 +45,7 @@ def get_boto3_region() -> str:
     return boto3.session.Session().region_name
 
 
-def get_local_service_url(service_name_or_port: Union[str, int]) -> str:
+def get_local_service_url(service_name_or_port: str | int) -> str:
     """Return the local service URL for the given service name or port."""
     # TODO(srw): we don't need to differentiate on service name any more, so remove the argument
     if isinstance(service_name_or_port, int):
@@ -60,7 +59,7 @@ def get_s3_hostname():
         try:
             assert socket.gethostbyname(S3_VIRTUAL_HOSTNAME)
             CACHE_S3_HOSTNAME_DNS_STATUS = True
-        except socket.error:
+        except OSError:
             CACHE_S3_HOSTNAME_DNS_STATUS = False
     if CACHE_S3_HOSTNAME_DNS_STATUS:
         return S3_VIRTUAL_HOSTNAME
@@ -68,7 +67,7 @@ def get_s3_hostname():
 
 
 def fix_account_id_in_arns(
-    response, replacement: str, colon_delimiter: str = ":", existing: Union[str, List[str]] = None
+    response, replacement: str, colon_delimiter: str = ":", existing: str | list[str] = None
 ):
     """Fix the account ID in the ARNs returned in the given Flask response or string"""
     from moto.core import DEFAULT_ACCOUNT_ID
@@ -78,13 +77,9 @@ def fix_account_id_in_arns(
     is_str_obj = is_string_or_bytes(response)
     content = to_str(response if is_str_obj else response._content)
 
-    replacement = r"arn{col}aws{col}\1{col}\2{col}{acc}{col}".format(
-        col=colon_delimiter, acc=replacement
-    )
+    replacement = rf"arn{colon_delimiter}aws{colon_delimiter}\1{colon_delimiter}\2{colon_delimiter}{replacement}{colon_delimiter}"
     for acc_id in existing:
-        regex = r"arn{col}aws{col}([^:%]+){col}([^:%]*){col}{acc}{col}".format(
-            col=colon_delimiter, acc=acc_id
-        )
+        regex = rf"arn{colon_delimiter}aws{colon_delimiter}([^:%]+){colon_delimiter}([^:%]*){colon_delimiter}{acc_id}{colon_delimiter}"
         content = re.sub(regex, replacement, content)
 
     if not is_str_obj:

localstack/utils/aws/dead_letter_queue.py

@@ -1,7 +1,6 @@
 import json
 import logging
 import uuid
-from typing import Dict, List
 
 from localstack.aws.connect import connect_to
 from localstack.utils.aws import arns
@@ -34,7 +33,7 @@ def sns_error_to_dead_letter_queue(
     return _send_to_dead_letter_queue(sns_subscriber["SubscriptionArn"], target_arn, event, error)
 
 
-def _send_to_dead_letter_queue(source_arn: str, dlq_arn: str, event: Dict, error, role: str = None):
+def _send_to_dead_letter_queue(source_arn: str, dlq_arn: str, event: dict, error, role: str = None):
     if not dlq_arn:
         return
     LOG.info("Sending failed execution %s to dead letter queue %s", source_arn, dlq_arn)
@@ -60,11 +59,7 @@ def _send_to_dead_letter_queue(source_arn: str, dlq_arn: str, event: Dict, error
         except Exception as e:
             error = e
         if error or not result_code or result_code >= 400:
-            msg = "Unable to send message to dead letter queue %s (code %s): %s" % (
-                queue_url,
-                result_code,
-                error,
-            )
+            msg = f"Unable to send message to dead letter queue {queue_url} (code {result_code}): {error}"
             if "InvalidMessageContents" in str(error):
                 msg += f" - messages: {messages}"
             LOG.info(msg)
@@ -84,7 +79,7 @@ def _send_to_dead_letter_queue(source_arn: str, dlq_arn: str, event: Dict, error
     return dlq_arn
 
 
-def _prepare_messages_to_dlq(source_arn: str, event: Dict, error) -> List[Dict]:
+def _prepare_messages_to_dlq(source_arn: str, event: dict, error) -> list[dict]:
     messages = []
     custom_attrs = {
         "RequestID": {"DataType": "String", "StringValue": str(uuid.uuid4())},
@@ -136,7 +131,7 @@ def _prepare_messages_to_dlq(source_arn: str, event: Dict, error) -> List[Dict]:
     return messages
 
 
-def message_attributes_to_upper(message_attrs: Dict) -> Dict:
+def message_attributes_to_upper(message_attrs: dict) -> dict:
     """Convert message attribute details (first characters) to upper case (e.g., StringValue, DataType)."""
     message_attrs = message_attrs or {}
     for _, attr in message_attrs.items():

localstack/utils/aws/message_forwarding.py

@@ -3,7 +3,6 @@ import json
 import logging
 import re
 import uuid
-from typing import Dict, Optional
 
 from moto.events.models import events_backends
 
@@ -31,10 +30,10 @@ AUTH_OAUTH = "OAUTH_CLIENT_CREDENTIALS"
 # TODO: refactor/split this. too much here is service specific
 def send_event_to_target(
     target_arn: str,
-    event: Dict,
-    target_attributes: Dict = None,
+    event: dict,
+    target_attributes: dict = None,
     asynchronous: bool = True,
-    target: Dict = None,
+    target: dict = None,
     role: str = None,
     source_arn: str = None,
     source_service: str = None,
@@ -155,7 +154,7 @@ def send_event_to_target(
         LOG.warning('Unsupported Events rule target ARN: "%s"', target_arn)
 
 
-def auth_keys_from_connection(connection: Dict):
+def auth_keys_from_connection(connection: dict):
     headers = {}
 
     auth_type = connection.get("AuthorizationType").upper()
@@ -164,9 +163,7 @@ def auth_keys_from_connection(connection: Dict):
         basic_auth_parameters = auth_parameters.get("BasicAuthParameters", {})
         username = basic_auth_parameters.get("Username", "")
         password = basic_auth_parameters.get("Password", "")
-        auth = "Basic " + to_str(
-            base64.b64encode("{}:{}".format(username, password).encode("ascii"))
-        )
+        auth = "Basic " + to_str(base64.b64encode(f"{username}:{password}".encode("ascii")))
         headers.update({"authorization": auth})
 
     if auth_type == AUTH_API_KEY:
@@ -206,7 +203,7 @@ def auth_keys_from_connection(connection: Dict):
 
         token_type = oauth_data.get("token_type", "")
         access_token = oauth_data.get("access_token", "")
-        auth_header = "{} {}".format(token_type, access_token)
+        auth_header = f"{token_type} {access_token}"
         headers.update({"authorization": auth_header})
 
     return headers
@@ -216,7 +213,7 @@ def list_of_parameters_to_object(items):
     return {item.get("Key"): item.get("Value") for item in items}
 
 
-def send_event_to_api_destination(target_arn, event, http_parameters: Optional[Dict] = None):
+def send_event_to_api_destination(target_arn, event, http_parameters: dict | None = None):
     """Send an event to an EventBridge API destination
     See https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-api-destinations.html"""
 
@@ -291,7 +288,7 @@ def add_api_destination_authorization(destination, headers, event):
     return endpoint
 
 
-def add_target_http_parameters(http_parameters: Dict, endpoint: str, headers: Dict, body):
+def add_target_http_parameters(http_parameters: dict, endpoint: str, headers: dict, body):
     endpoint = add_path_parameters_to_url(endpoint, http_parameters.get("PathParameterValues", []))
 
     # The request should prioritze connection header/query parameters over target params if there is an overlap

localstack/utils/aws/request_context.py

@@ -4,7 +4,6 @@ This module has utilities relating to creating/parsing AWS requests.
 
 import logging
 import re
-from typing import Dict, Optional
 
 from rolo import Request as RoloRequest
 
@@ -30,7 +29,7 @@ def get_account_id_from_request(request: RoloRequest) -> str:
     return get_account_id_from_access_key_id(access_key_id)
 
 
-def extract_region_from_auth_header(headers) -> Optional[str]:
+def extract_region_from_auth_header(headers) -> str | None:
     auth = headers.get("Authorization") or ""
     region = re.sub(r".*Credential=[^/]+/[^/]+/([^/]+)/.*", r"\1", auth)
     if region == auth:
@@ -38,12 +37,12 @@ def extract_region_from_auth_header(headers) -> Optional[str]:
     return region
 
 
-def extract_account_id_from_auth_header(headers) -> Optional[str]:
+def extract_account_id_from_auth_header(headers) -> str | None:
     if access_key_id := extract_access_key_id_from_auth_header(headers):
         return get_account_id_from_access_key_id(access_key_id)
 
 
-def extract_access_key_id_from_auth_header(headers: Dict[str, str]) -> Optional[str]:
+def extract_access_key_id_from_auth_header(headers: dict[str, str]) -> str | None:
     auth = headers.get("Authorization") or ""
 
     if auth.startswith("AWS4-"):
@@ -67,7 +66,7 @@ def extract_region_from_headers(headers) -> str:
     return extract_region_from_auth_header(headers) or AWS_REGION_US_EAST_1
 
 
-def extract_service_name_from_auth_header(headers: Dict) -> Optional[str]:
+def extract_service_name_from_auth_header(headers: dict) -> str | None:
     try:
         auth_header = headers.get("authorization", "")
         credential_scope = auth_header.split(",")[0].split()[1]
@@ -79,7 +78,7 @@ def extract_service_name_from_auth_header(headers: Dict) -> Optional[str]:
 
 def mock_aws_request_headers(
     service: str, aws_access_key_id: str, region_name: str, internal: bool = False
-) -> Dict[str, str]:
+) -> dict[str, str]:
     """
     Returns a mock set of headers that resemble SigV4 signing method.
     """

localstack/utils/aws/resources.py

@@ -86,7 +86,7 @@ def create_api_gateway(
     resources = resources or []
     stage_name = stage_name or "testing"
     usage_plan_name = usage_plan_name or "Basic Usage"
-    description = description or 'Test description for API "%s"' % name
+    description = description or f'Test description for API "{name}"'
 
     LOG.info('Creating API resources under API Gateway "%s".', name)
     api = client.create_rest_api(name=name, description=description)

localstack/utils/aws/templating.py

@@ -1,6 +1,6 @@
 import json
 import re
-from typing import Any, Dict
+from typing import Any
 
 import airspeed
 
@@ -44,7 +44,7 @@ class VelocityUtil:
 class VtlTemplate:
     """Utility class for rendering Velocity templates"""
 
-    def render_vtl(self, template: str, variables: Dict, as_json=False) -> str | dict:
+    def render_vtl(self, template: str, variables: dict, as_json=False) -> str | dict:
         """
         Render the given VTL template against the dict of variables. Note that this is a
         potentially mutating operation which may change the values of `variables` in-place.
@@ -66,7 +66,7 @@ class VtlTemplate:
         empty_placeholder = " __pLaCe-HoLdEr__ "
         template = re.sub(
             r"([^\s]+)#\$({)?(.*)",
-            r"\1#%s$\2\3" % empty_placeholder,
+            rf"\1#{empty_placeholder}$\2\3",
             template,
             count=re.MULTILINE,
         )
@@ -125,7 +125,7 @@ class VtlTemplate:
             rendered_template = json.loads(rendered_template)
         return rendered_template
 
-    def prepare_namespace(self, variables: Dict[str, Any], source: str = "") -> Dict:
+    def prepare_namespace(self, variables: dict[str, Any], source: str = "") -> dict:
         namespace = dict(variables or {})
         namespace.setdefault("context", {})
         if not namespace.get("util"):