localstack-core 4.7.1.dev49__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/testing/pytest/marking.py

@@ -3,7 +3,8 @@ Custom pytest mark typings
 """
 
 import os
-from typing import TYPE_CHECKING, Callable, Optional
+from collections.abc import Callable
+from typing import TYPE_CHECKING
 
 import pytest
 from _pytest.config import PytestPluginManager
@@ -36,13 +37,13 @@ class SkipSnapshotVerifyMarker:
     def __call__(
         self,
         *,
-        paths: "Optional[list[str]]" = None,
-        condition: "Optional[Callable[[...], bool]]" = None,
+        paths: "list[str] | None" = None,
+        condition: "Callable[[...], bool] | None" = None,
     ): ...
 
 
 class MultiRuntimeMarker:
-    def __call__(self, *, scenario: str, runtimes: Optional[list[str]] = None): ...
+    def __call__(self, *, scenario: str, runtimes: list[str] | None = None): ...
 
 
 class SnapshotMarkers:
@@ -58,13 +59,27 @@ class Markers:
 
     # test selection
     acceptance_test = pytest.mark.acceptance_test
+    """This test is an acceptance test"""
     skip_offline = pytest.mark.skip_offline
+    """Test is skipped if offline, as it requires some sort of internet connection to run"""
     only_on_amd64 = pytest.mark.only_on_amd64
+    """Test requires ability of the system to execute amd64 binaries"""
     only_on_arm64 = pytest.mark.only_on_arm64
+    """Test requires ability of the system to execute arm64 binaries"""
     resource_heavy = pytest.mark.resource_heavy
-    only_in_docker = pytest.mark.only_in_docker
-    # Tests to execute when updating snapshots for a new Lambda runtime
+    """Test is very resource heavy, and might be skipped in CI"""
+    requires_in_container = pytest.mark.requires_in_container
+    """Test requires LocalStack to run inside a container"""
+    requires_in_process = pytest.mark.requires_in_process
+    """The test and the LS instance have to be run in the same process"""
+    requires_docker = pytest.mark.requires_docker
+    """The test requires docker or a compatible container engine - will not work on kubernetes"""
     lambda_runtime_update = pytest.mark.lambda_runtime_update
+    """Tests to execute when updating snapshots for a new Lambda runtime"""
+    k8s_always_run = pytest.mark.k8s_always_run
+    """This tests will always run against k8s environment"""
+    skip_k8s = pytest.mark.skip_k8s
+    """This test will be skipped in k8s environment"""
 
 
 # pytest plugin
@@ -131,8 +146,8 @@ def filter_by_markers(config: "Config", items: list[pytest.Item]):
         "Add network connectivity and remove the --offline option when running "
         "the test."
     )
-    only_in_docker = pytest.mark.skip(
-        reason="Test requires execution inside Docker (e.g., to install system packages)"
+    requires_in_container = pytest.mark.skip(
+        reason="Test requires execution inside a container (e.g., to install system packages)"
     )
     only_on_amd64 = pytest.mark.skip(
         reason="Test uses features that are currently only supported for AMD64. Skipping in CI."
@@ -144,8 +159,8 @@ def filter_by_markers(config: "Config", items: list[pytest.Item]):
     for item in items:
         if is_offline and "skip_offline" in item.keywords:
             item.add_marker(skip_offline)
-        if not is_in_docker and "only_in_docker" in item.keywords:
-            item.add_marker(only_in_docker)
+        if not is_in_docker and "requires_in_container" in item.keywords:
+            item.add_marker(requires_in_container)
         if is_in_ci and not is_amd64 and "only_on_amd64" in item.keywords:
             item.add_marker(only_on_amd64)
         if is_in_ci and not is_arm64 and "only_on_arm64" in item.keywords:
@@ -177,7 +192,7 @@ def pytest_configure(config):
     )
     config.addinivalue_line(
         "markers",
-        "only_in_docker: mark the test as running only in Docker (e.g., requires installation of system packages)",
+        "requires_in_container: mark the test as running only in a container (e.g., requires installation of system packages)",
     )
     config.addinivalue_line(
         "markers",
@@ -208,3 +223,15 @@ def pytest_configure(config):
         "markers",
         "multiruntime: parametrize test against multiple Lambda runtimes",
     )
+    config.addinivalue_line(
+        "markers",
+        "requires_docker: mark the test as requiring docker (or a compatible container engine) - will not work on kubernetes.",
+    )
+    config.addinivalue_line(
+        "markers",
+        "requires_in_process: mark the test as requiring the test to run inside the same process as LocalStack - will not work if tests are run against a running LS container.",
+    )
+    config.addinivalue_line(
+        "markers",
+        "k8s_always_run: mark the test to always run in k8s environment. This allows us to run tests that would otherwise be skipped, such as localstack_only tests.",
+    )

localstack/testing/pytest/stepfunctions/utils.py

@@ -1,6 +1,7 @@
 import json
 import logging
-from typing import Callable, Final, Optional
+from collections.abc import Callable
+from typing import Final
 
 from botocore.exceptions import ClientError
 from jsonpath_ng.ext import parse
@@ -402,8 +403,8 @@ def create_state_machine_with_iam_role(
     create_state_machine,
     snapshot,
     definition: Definition,
-    logging_configuration: Optional[LoggingConfiguration] = None,
-    state_machine_name: Optional[str] = None,
+    logging_configuration: LoggingConfiguration | None = None,
+    state_machine_name: str | None = None,
     state_machine_type: StateMachineType = StateMachineType.STANDARD,
 ):
     snf_role_arn = create_state_machine_iam_role(target_aws_client=target_aws_client)

localstack/testing/pytest/util.py

@@ -1,7 +1,7 @@
 import os
 import pwd
+from collections.abc import Callable
 from multiprocessing import Process, ProcessError
-from typing import Callable
 
 
 def run_as_os_user(target: Callable, uid: str | int, gid: str | int = None):

localstack/testing/pytest/validation_tracking.py

@@ -9,7 +9,6 @@ import datetime
 import json
 import os
 from pathlib import Path
-from typing import Optional
 
 import pytest
 from pluggy import Result
@@ -28,7 +27,7 @@ Stores information from call execution phase about whether the test failed.
 """
 
 
-def find_validation_data_for_item(item: pytest.Item) -> Optional[dict]:
+def find_validation_data_for_item(item: pytest.Item) -> dict | None:
     base_path = os.path.join(item.fspath.dirname, item.fspath.purebasename)
     snapshot_path = f"{base_path}.validation.json"
 

localstack/testing/snapshots/transformer_utility.py

@@ -45,6 +45,10 @@ PATTERN_KEY_ARN = re.compile(
     r"arn:(aws[a-zA-Z-]*)?:([a-zA-Z0-9-_.]+)?:([^:]+)?:(\d{12})?:key/[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}"
 )
 
+PATTERN_MRK_KEY_ARN = re.compile(
+    r"arn:(aws[a-zA-Z-]*)?:([a-zA-Z0-9-_.]+)?:([^:]+)?:(\d{12})?:key/mrk-[a-fA-F0-9]{32}"
+)
+
 
 # TODO: split into generic/aws and put into lib
 class TransformerUtility:
@@ -500,7 +504,7 @@ class TransformerUtility:
                 replacement="<stream-name>",
             ),
             TransformerUtility.key_value(
-                "ContinuationSequenceNumber", "<continuation_sequence_number>"
+                "ContinuationSequenceNumber", "continuation_sequence_number"
             ),
         ]
 
@@ -573,6 +577,7 @@ class TransformerUtility:
             TransformerUtility.key_value("CiphertextBlob", reference_replacement=False),
             TransformerUtility.key_value("Plaintext", reference_replacement=False),
             RegexTransformer(PATTERN_KEY_ARN, replacement="<key-arn>"),
+            RegexTransformer(PATTERN_MRK_KEY_ARN, replacement="<mrk-key-arn>"),
         ]
 
     @staticmethod

localstack/utils/analytics/events.py

@@ -1,8 +1,8 @@
 import abc
 import dataclasses
-from typing import Any, Union
+from typing import Any
 
-EventPayload = Union[dict[str, Any], Any]  # FIXME: better typing
+EventPayload = dict[str, Any] | Any  # FIXME: better typing
 
 
 @dataclasses.dataclass

localstack/utils/analytics/metadata.py

@@ -2,7 +2,6 @@ import dataclasses
 import logging
 import os
 import platform
-from typing import Optional
 
 from localstack import config
 from localstack.constants import VERSION
@@ -41,7 +40,7 @@ class ClientMetadata:
             k = "*" * len(k)
         d["api_key"] = k
 
-        return "ClientMetadata(%s)" % d
+        return f"ClientMetadata({d})"
 
 
 def get_version_string() -> str:
@@ -148,7 +147,10 @@ def is_license_activated() -> bool:
 
         return licensingv2.get_licensed_environment().activated
     except Exception:
-        LOG.exception("Could not determine license activation status")
+        LOG.error(
+            "Could not determine license activation status",
+            exc_info=LOG.isEnabledFor(logging.DEBUG),
+        )
         return False
 
 
@@ -198,7 +200,7 @@ def _generate_machine_id() -> str:
     return f"gen_{long_uid()[:12]}"
 
 
-def get_api_key_or_auth_token() -> Optional[str]:
+def get_api_key_or_auth_token() -> str | None:
     # TODO: this is duplicated code from ext, but should probably migrate that to localstack
     auth_token = os.environ.get("LOCALSTACK_AUTH_TOKEN", "").strip("'\" ")
     if auth_token:

localstack/utils/analytics/metrics/counter.py

@@ -1,7 +1,7 @@
 import threading
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Any, Optional, Union
+from typing import Any
 
 from localstack import config
 
@@ -38,7 +38,7 @@ class LabeledCounterPayload:
     value: int
     type: str
     schema_version: int
-    labels: dict[str, Union[str, float]]
+    labels: dict[str, str | float]
 
     def as_dict(self) -> dict[str, Any]:
         payload_dict = {
@@ -66,7 +66,7 @@ class ThreadSafeCounter:
     _count: int
 
     def __init__(self):
-        super(ThreadSafeCounter, self).__init__()
+        super().__init__()
         self._mutex = threading.Lock()
         self._count = 0
 
@@ -140,15 +140,11 @@ class LabeledCounter(Metric):
 
     _type: str
     _labels: list[str]
-    _label_values: tuple[Optional[Union[str, float]], ...]
-    _counters_by_label_values: defaultdict[
-        tuple[Optional[Union[str, float]], ...], ThreadSafeCounter
-    ]
+    _label_values: tuple[str | float | None, ...]
+    _counters_by_label_values: defaultdict[tuple[str | float | None, ...], ThreadSafeCounter]
 
     def __init__(self, namespace: str, name: str, labels: list[str], schema_version: int = 1):
-        super(LabeledCounter, self).__init__(
-            namespace=namespace, name=name, schema_version=schema_version
-        )
+        super().__init__(namespace=namespace, name=name, schema_version=schema_version)
 
         if not labels:
             raise ValueError("At least one label is required; the labels list cannot be empty.")
@@ -164,7 +160,7 @@ class LabeledCounter(Metric):
         self._counters_by_label_values = defaultdict(ThreadSafeCounter)
         MetricRegistry().register(self)
 
-    def labels(self, **kwargs: Union[str, float, None]) -> ThreadSafeCounter:
+    def labels(self, **kwargs: str | float | None) -> ThreadSafeCounter:
         """
         Create a scoped counter instance with specific label values.
 
@@ -200,10 +196,7 @@ class LabeledCounter(Metric):
                 )
 
             # Create labels dictionary
-            labels_dict = {
-                label_name: label_value
-                for label_name, label_value in zip(self._labels, label_values)
-            }
+            labels_dict = dict(zip(self._labels, label_values, strict=False))
 
             payload.append(
                 LabeledCounterPayload(

localstack/utils/analytics/publisher.py

@@ -4,7 +4,6 @@ import logging
 import threading
 import time
 from queue import Full, Queue
-from typing import Optional
 
 from localstack import config
 from localstack.utils.threads import start_thread, start_worker_thread
@@ -93,7 +92,7 @@ class PublisherBuffer(EventHandler):
         self._stopping.set()
         self._command_queue.put(self._cmd_stop)
 
-    def close_sync(self, timeout: Optional[float] = None):
+    def close_sync(self, timeout: float | None = None):
         self.close()
         return self._stopped.wait(timeout)
 

localstack/utils/analytics/service_providers.py

@@ -0,0 +1,19 @@
+from localstack.runtime import hooks
+
+
+@hooks.on_runtime_ready()
+def publish_provider_assignment():
+    """
+    Publishes the service provider assignment to the analytics service.
+    """
+
+    from localstack.config import SERVICE_PROVIDER_CONFIG
+    from localstack.services.plugins import SERVICE_PLUGINS
+    from localstack.utils.analytics import log
+
+    provider_assignment = {
+        service: f"localstack.aws.provider/{service}:{SERVICE_PROVIDER_CONFIG[service]}"
+        for service in SERVICE_PLUGINS.list_available()
+    }
+
+    log.event("ls_service_provider_assignment", provider_assignment)

localstack/utils/analytics/service_request_aggregator.py

@@ -2,7 +2,7 @@ import datetime
 import logging
 import threading
 from collections import Counter
-from typing import NamedTuple, Optional
+from typing import NamedTuple
 
 from localstack import config
 from localstack.runtime.shutdown import SHUTDOWN_HANDLERS
@@ -20,7 +20,7 @@ class ServiceRequestInfo(NamedTuple):
     service: str
     operation: str
     status_code: int
-    err_type: Optional[str] = None
+    err_type: str | None = None
 
 
 class ServiceRequestAggregator:

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.
@@ -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:
@@ -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, Optional, Union
+from typing import Any
 from urllib.parse import parse_qs
 
 import xmltodict
@@ -36,13 +36,13 @@ 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
+    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>
@@ -100,7 +100,7 @@ def requests_error_response_xml_signature_calculation(
 
 def requests_error_response(
     req_headers: dict,
-    message: Union[str, bytes],
+    message: str | bytes,
     code: int = 500,
     error_type: str = "InternalFailure",
     service: str = None,
@@ -201,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 Union
 
 import boto3
 
@@ -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):
@@ -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