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

localstack/utils/aws/dead_letter_queue.py

@@ -59,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)

localstack/utils/aws/message_forwarding.py

@@ -3,7 +3,6 @@ import json
 import logging
 import re
 import uuid
-from typing import Optional
 
 from moto.events.models import events_backends
 
@@ -214,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"""
 

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 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]

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

@@ -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,
         )

localstack/utils/batch_policy.py

@@ -1,6 +1,6 @@
 import copy
 import time
-from typing import Generic, Optional, TypeVar, overload
+from typing import Generic, TypeVar, overload
 
 from pydantic import Field
 from pydantic.dataclasses import dataclass
@@ -47,8 +47,8 @@ class Batcher(Generic[T]):
         assert batcher.flush() == ["item1", "item2", "item3", "item4"]
     """
 
-    max_count: Optional[int] = Field(default=None, description="Maximum number of items", ge=0)
-    max_window: Optional[float] = Field(
+    max_count: int | None = Field(default=None, description="Maximum number of items", ge=0)
+    max_window: float | None = Field(
         default=None, description="Maximum time window in seconds", ge=0
     )
 

localstack/utils/bootstrap.py

@@ -9,9 +9,9 @@ import shlex
 import signal
 import threading
 import time
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from functools import wraps
-from typing import Any, Callable, Optional, Union
+from typing import Any
 
 from localstack import config, constants
 from localstack.config import (
@@ -175,7 +175,7 @@ def get_docker_image_details(image_name: str = None) -> dict[str, str]:
     return result
 
 
-def get_image_environment_variable(env_name: str) -> Optional[str]:
+def get_image_environment_variable(env_name: str) -> str | None:
     image_name = get_docker_image_to_start()
     image_info = DOCKER_CLIENT.inspect_image(image_name)
     image_envs = image_info["Config"]["Env"]
@@ -427,7 +427,7 @@ def validate_localstack_config(name: str):
 
     def port_exposed(port):
         for exposed in docker_ports:
-            if re.match(r"^([0-9]+-)?%s(-[0-9]+)?$" % port, exposed):
+            if re.match(rf"^([0-9]+-)?{port}(-[0-9]+)?$", exposed):
                 return True
 
     if not port_exposed(edge_port):
@@ -455,7 +455,7 @@ def get_docker_image_to_start():
 
 def extract_port_flags(user_flags, port_mappings: PortMappings):
     regex = r"-p\s+([0-9]+)(\-([0-9]+))?:([0-9]+)(\-([0-9]+))?"
-    matches = re.match(".*%s" % regex, user_flags)
+    matches = re.match(f".*{regex}", user_flags)
     if matches:
         for match in re.findall(regex, user_flags):
             start = int(match[0])
@@ -544,7 +544,7 @@ class ContainerConfigurators:
 
     @staticmethod
     def gateway_listen(
-        port: Union[int, Iterable[int], HostAndPort, Iterable[HostAndPort]],
+        port: int | Iterable[int] | HostAndPort | Iterable[HostAndPort],
     ):
         """
         Uses the given ports to configure GATEWAY_LISTEN. For instance, ``gateway_listen([4566, 443])`` would
@@ -1000,7 +1000,7 @@ class RunningContainer:
                     return
                 raise
 
-    def inspect(self) -> dict[str, Union[dict, str]]:
+    def inspect(self) -> dict[str, dict | str]:
         return self.container_client.inspect_container(container_name_or_id=self.id)
 
     def attach(self):
@@ -1028,7 +1028,7 @@ class ContainerLogPrinter:
         self.callback = callback
 
         self._closed = threading.Event()
-        self._stream: Optional[CancellableStream] = None
+        self._stream: CancellableStream | None = None
 
     def _can_start_streaming(self):
         if self._closed.is_set():
@@ -1114,8 +1114,8 @@ class LocalstackContainerServer(Server):
 
     def do_run(self):
         if self.is_container_running():
-            raise ContainerExists(
-                'LocalStack container named "%s" is already running' % self.container.name
+            raise ContainerRunning(
+                f'LocalStack container named "{self.container.name}" is already running'
             )
 
         config.dirs.mkdirs()
@@ -1151,12 +1151,19 @@ class ContainerExists(Exception):
     pass
 
 
+class ContainerRunning(Exception):
+    pass
+
+
 def prepare_docker_start():
     # prepare environment for docker start
     container_name = config.MAIN_CONTAINER_NAME
 
     if DOCKER_CLIENT.is_container_running(container_name):
-        raise ContainerExists('LocalStack container named "%s" is already running' % container_name)
+        raise ContainerRunning(f'LocalStack container named "{container_name}" is already running')
+
+    if container_name in DOCKER_CLIENT.get_all_container_names():
+        raise ContainerExists(f'LocalStack container named "{container_name}" already exists')
 
     config.dirs.mkdirs()
 
@@ -1308,7 +1315,8 @@ def start_infra_in_docker_detached(console, cli_params: dict[str, Any] = None):
     console.log("preparing environment")
     try:
         prepare_docker_start()
-    except ContainerExists as e:
+    except ContainerRunning as e:
+        # starting in detached mode is idempotent, return if container is already running
         console.print(str(e))
         return
 
@@ -1330,7 +1338,7 @@ def start_infra_in_docker_detached(console, cli_params: dict[str, Any] = None):
     console.log("detaching")
 
 
-def wait_container_is_ready(timeout: Optional[float] = None):
+def wait_container_is_ready(timeout: float | None = None):
     """Blocks until the localstack main container is running and the ready marker has been printed."""
     container_name = config.MAIN_CONTAINER_NAME
     started = time.time()

localstack/utils/catalog/catalog.py

@@ -0,0 +1,139 @@
+import logging
+from abc import abstractmethod
+
+from plux import Plugin
+
+from localstack.services.cloudformation.resource_provider import (
+    plugin_manager as cfn_plugin_manager,
+)
+from localstack.utils.catalog.catalog_loader import RemoteCatalogLoader
+from localstack.utils.catalog.common import (
+    AwsServiceOperationsSupportInLatest,
+    AwsServicesSupportInLatest,
+    AwsServiceSupportAtRuntime,
+    CloudFormationResourcesSupportAtRuntime,
+    CloudFormationResourcesSupportInLatest,
+    LocalstackEmulatorType,
+)
+
+ServiceName = str
+ServiceOperations = set[str]
+ProviderName = str
+CfnResourceName = str
+CfnResourceMethodName = str
+AwsServicesSupportStatus = (
+    AwsServiceSupportAtRuntime | AwsServicesSupportInLatest | AwsServiceOperationsSupportInLatest
+)
+CfnResourceSupportStatus = (
+    CloudFormationResourcesSupportInLatest | CloudFormationResourcesSupportAtRuntime
+)
+CfnResourceCatalog = dict[LocalstackEmulatorType, dict[CfnResourceName, set[CfnResourceMethodName]]]
+
+LOG = logging.getLogger(__name__)
+
+
+class CatalogPlugin(Plugin):
+    namespace = "localstack.utils.catalog"
+
+    @staticmethod
+    def _get_cfn_resources_catalog(cloudformation_resources: dict) -> CfnResourceCatalog:
+        cfn_resources_catalog = {}
+        for emulator_type, resources in cloudformation_resources.items():
+            cfn_resources_catalog[emulator_type] = {}
+            for resource_name, resource in resources.items():
+                cfn_resources_catalog[emulator_type][resource_name] = set(resource.methods)
+        return cfn_resources_catalog
+
+    @staticmethod
+    def _get_services_at_runtime() -> set[ServiceName]:
+        from localstack.services.plugins import SERVICE_PLUGINS
+
+        return set(SERVICE_PLUGINS.list_available())
+
+    @staticmethod
+    def _get_cfn_resources_available_at_runtime() -> set[CfnResourceName]:
+        return set(cfn_plugin_manager.list_names())
+
+    @abstractmethod
+    def get_aws_service_status(
+        self, service_name: str, operation_name: str | None = None
+    ) -> AwsServicesSupportStatus | None:
+        pass
+
+    @abstractmethod
+    def get_cloudformation_resource_status(
+        self, resource_name: str, service_name: str, is_pro_resource: bool = False
+    ) -> CfnResourceSupportStatus | AwsServicesSupportInLatest | None:
+        pass
+
+
+class AwsCatalogRuntimePlugin(CatalogPlugin):
+    name = "aws-catalog-runtime-only"
+
+    def get_aws_service_status(
+        self, service_name: str, operation_name: str | None = None
+    ) -> AwsServicesSupportStatus | None:
+        return None
+
+    def get_cloudformation_resource_status(
+        self, resource_name: str, service_name: str, is_pro_resource: bool = False
+    ) -> CfnResourceSupportStatus | AwsServicesSupportInLatest | None:
+        return None
+
+
+class AwsCatalogRemoteStatePlugin(CatalogPlugin):
+    name = "aws-catalog-remote-state"
+    current_emulator_type: LocalstackEmulatorType = LocalstackEmulatorType.COMMUNITY
+    services_in_latest: dict[ServiceName, dict[LocalstackEmulatorType, ServiceOperations]] = {}
+    services_at_runtime: set[ServiceName] = set()
+    cfn_resources_in_latest: CfnResourceCatalog = {}
+    cfn_resources_at_runtime: set[CfnResourceName] = set()
+
+    def __init__(self, remote_catalog_loader: RemoteCatalogLoader | None = None) -> None:
+        catalog_loader = remote_catalog_loader or RemoteCatalogLoader()
+        remote_catalog = catalog_loader.get_remote_catalog()
+        for service_name, emulators in remote_catalog.services.items():
+            for emulator_type, service_provider in emulators.items():
+                self.services_in_latest.setdefault(service_name, {})[emulator_type] = set(
+                    service_provider.operations
+                )
+
+        self.cfn_resources_in_latest = self._get_cfn_resources_catalog(
+            remote_catalog.cloudformation_resources
+        )
+        self.cfn_resources_at_runtime = self._get_cfn_resources_available_at_runtime()
+        self.services_at_runtime = self._get_services_at_runtime()
+
+    def get_aws_service_status(
+        self, service_name: str, operation_name: str | None = None
+    ) -> AwsServicesSupportStatus | None:
+        if not self.services_in_latest:
+            return None
+        if service_name not in self.services_in_latest:
+            return AwsServicesSupportInLatest.NOT_SUPPORTED
+        if self.current_emulator_type not in self.services_in_latest[service_name]:
+            return AwsServicesSupportInLatest.SUPPORTED_WITH_LICENSE_UPGRADE
+        if not operation_name:
+            return AwsServicesSupportInLatest.SUPPORTED
+        if operation_name in self.services_in_latest[service_name][self.current_emulator_type]:
+            return AwsServiceOperationsSupportInLatest.SUPPORTED
+        for emulator_type in self.services_in_latest[service_name]:
+            if emulator_type is self.current_emulator_type:
+                continue
+            if operation_name in self.services_in_latest[service_name][emulator_type]:
+                return AwsServiceOperationsSupportInLatest.SUPPORTED_WITH_LICENSE_UPGRADE
+        return AwsServiceOperationsSupportInLatest.NOT_SUPPORTED
+
+    def get_cloudformation_resource_status(
+        self, resource_name: str, service_name: str, is_pro_resource: bool = False
+    ) -> CfnResourceSupportStatus | AwsServicesSupportInLatest | None:
+        if resource_name in self.cfn_resources_at_runtime:
+            return CloudFormationResourcesSupportAtRuntime.AVAILABLE
+        if service_name in self.services_at_runtime:
+            if resource_name in self.cfn_resources_in_latest[self.current_emulator_type]:
+                return CloudFormationResourcesSupportInLatest.SUPPORTED
+            else:
+                return CloudFormationResourcesSupportInLatest.NOT_SUPPORTED
+        if service_name in self.services_in_latest:
+            return self.get_aws_service_status(service_name, operation_name=None)
+        return AwsServicesSupportInLatest.NOT_SUPPORTED

localstack/utils/catalog/catalog_loader.py

@@ -0,0 +1,119 @@
+import json
+import logging
+from json import JSONDecodeError
+from pathlib import Path
+
+import requests
+from pydantic import BaseModel
+
+from localstack import config, constants
+from localstack.utils.catalog.common import AwsRemoteCatalog
+from localstack.utils.http import get_proxies
+from localstack.utils.json import FileMappedDocument
+
+LOG = logging.getLogger(__name__)
+
+AWS_CATALOG_FILE_NAME = "aws_catalog.json"
+
+
+class RemoteCatalogVersionResponse(BaseModel):
+    emulator_type: str
+    version: str
+
+
+class AwsCatalogLoaderException(Exception):
+    def __init__(self, msg: str, *args):
+        super().__init__(msg, *args)
+
+
+class RemoteCatalogLoader:
+    supported_schema_version = "v1"
+    api_endpoint_catalog = f"{constants.API_ENDPOINT}/license/catalog"
+    catalog_file_path = Path(config.dirs.cache) / AWS_CATALOG_FILE_NAME
+
+    def get_remote_catalog(self) -> AwsRemoteCatalog:
+        catalog_doc = FileMappedDocument(self.catalog_file_path)
+        cached_catalog = AwsRemoteCatalog(**catalog_doc) if catalog_doc else None
+        if cached_catalog:
+            cached_catalog_version = cached_catalog.localstack.version
+            if not self._should_update_cached_catalog(cached_catalog_version):
+                return cached_catalog
+        catalog = self._get_catalog_from_platform()
+        self._save_catalog_to_cache(catalog_doc, catalog)
+        return catalog
+
+    def _get_latest_localstack_version(self) -> str:
+        try:
+            proxies = get_proxies()
+            response = requests.get(
+                f"{self.api_endpoint_catalog}/aws/version",
+                verify=not config.is_env_true("SSL_NO_VERIFY"),
+                proxies=proxies,
+            )
+            if response.ok:
+                return RemoteCatalogVersionResponse.model_validate(response.content).version
+            self._raise_server_error(response)
+        except requests.exceptions.RequestException as e:
+            raise AwsCatalogLoaderException(
+                f"An unexpected network error occurred when trying to fetch latest localstack version: {e}"
+            ) from e
+
+    def _should_update_cached_catalog(self, current_catalog_version: str) -> bool:
+        try:
+            latest_version = self._get_latest_localstack_version()
+            return latest_version != current_catalog_version
+        except Exception as e:
+            LOG.warning(
+                "Failed to retrieve the latest catalog version, cached catalog update skipped: %s",
+                e,
+            )
+            return False
+
+    def _save_catalog_to_cache(self, catalog_doc: FileMappedDocument, catalog: AwsRemoteCatalog):
+        catalog_doc.clear()
+        catalog_doc.update(catalog.model_dump())
+        catalog_doc.save()
+
+    def _get_catalog_from_platform(self) -> AwsRemoteCatalog:
+        try:
+            proxies = get_proxies()
+            response = requests.post(
+                self.api_endpoint_catalog,
+                verify=not config.is_env_true("SSL_NO_VERIFY"),
+                proxies=proxies,
+            )
+
+            if response.ok:
+                return self._parse_catalog(response.content)
+            self._raise_server_error(response)
+        except requests.exceptions.RequestException as e:
+            raise AwsCatalogLoaderException(
+                f"An unexpected network error occurred when trying to fetch remote catalog: {e}"
+            ) from e
+
+    def _parse_catalog(self, document: bytes) -> AwsRemoteCatalog | None:
+        try:
+            catalog_json = json.loads(document)
+        except JSONDecodeError as e:
+            raise AwsCatalogLoaderException(f"Could not de-serialize json catalog: {e}") from e
+        remote_catalog = AwsRemoteCatalog.model_validate(catalog_json)
+        if remote_catalog.schema_version != self.supported_schema_version:
+            raise AwsCatalogLoaderException(
+                f"Unsupported schema version: '{remote_catalog.schema_version}'. Only '{self.supported_schema_version}' is supported"
+            )
+        return remote_catalog
+
+    def _raise_server_error(self, response: requests.Response):
+        try:
+            server_error = response.json()
+            if error_message := server_error.get("message"):
+                raise AwsCatalogLoaderException(
+                    f"Unexpected AWS catalog server error: {response.text}"
+                )
+            raise AwsCatalogLoaderException(
+                f"A server error occurred while calling remote catalog API (HTTP {response.status_code}): {error_message}"
+            )
+        except Exception:
+            raise AwsCatalogLoaderException(
+                f"An unexpected server error occurred while calling remote catalog API (HTTP {response.status_code}): {response.text}"
+            )

localstack/utils/catalog/common.py

@@ -0,0 +1,58 @@
+from enum import StrEnum
+
+from pydantic import BaseModel
+
+
+class CloudFormationResource(BaseModel):
+    methods: list[str]
+
+
+class AwsServiceCatalog(BaseModel):
+    provider: str
+    operations: list[str]
+    plans: list[str]
+
+
+class LocalStackMetadata(BaseModel):
+    version: str
+
+
+class AwsRemoteCatalog(BaseModel):
+    schema_version: str
+    localstack: LocalStackMetadata
+    services: dict[str, dict[str, AwsServiceCatalog]]
+    cloudformation_resources: dict[str, dict[str, CloudFormationResource]]
+
+
+class LocalstackEmulatorType(StrEnum):
+    COMMUNITY = "community"
+    PRO = "pro"
+
+
+class AwsServiceSupportAtRuntime(StrEnum):
+    AVAILABLE = "AVAILABLE"
+    AVAILABLE_WITH_LICENSE_UPGRADE = "AVAILABLE_WITH_LICENSE_UPGRADE"
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED"
+
+
+class AwsServicesSupportInLatest(StrEnum):
+    SUPPORTED = "SUPPORTED"
+    SUPPORTED_WITH_LICENSE_UPGRADE = "SUPPORTED_WITH_LICENSE_UPGRADE"
+    NOT_SUPPORTED = "NOT_SUPPORTED"
+    NON_DEFAULT_PROVIDER = "NON_DEFAULT_PROVIDER"
+
+
+class AwsServiceOperationsSupportInLatest(StrEnum):
+    SUPPORTED = "SUPPORTED"
+    SUPPORTED_WITH_LICENSE_UPGRADE = "SUPPORTED_WITH_LICENSE_UPGRADE"
+    NOT_SUPPORTED = "NOT_SUPPORTED"
+
+
+class CloudFormationResourcesSupportInLatest(StrEnum):
+    SUPPORTED = "SUPPORTED"
+    NOT_SUPPORTED = "NOT_SUPPORTED"
+
+
+class CloudFormationResourcesSupportAtRuntime(StrEnum):
+    AVAILABLE = "AVAILABLE"
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED"

localstack/utils/catalog/plugins.py

@@ -0,0 +1,28 @@
+import logging
+
+from plux import PluginManager
+
+from localstack.utils.catalog.catalog import CatalogPlugin
+from localstack.utils.objects import singleton_factory
+
+LOG = logging.getLogger(__name__)
+
+
+@singleton_factory
+def get_aws_catalog() -> CatalogPlugin:
+    plugin_manager = PluginManager(CatalogPlugin.namespace)
+    try:
+        plugin_name = "aws-catalog-remote-state-with-license"
+        if not plugin_manager.exists(plugin_name):
+            plugin_name = "aws-catalog-remote-state"
+        return plugin_manager.load(plugin_name)
+    except Exception as e:
+        LOG.debug(
+            "Failed to load catalog plugin with the latest LocalStack services support data, falling back to catalog without remote state: %s",
+            e,
+        )
+        # Try to load runtime catalog from pro version first
+        fallback_plugin_name = "aws-catalog-runtime-only-with-license"
+        if not plugin_manager.exists(fallback_plugin_name):
+            fallback_plugin_name = "aws-catalog-runtime-only"
+        return plugin_manager.load(fallback_plugin_name)

localstack/utils/cloudwatch/cloudwatch_util.py

@@ -2,7 +2,7 @@ import logging
 import time
 from datetime import datetime, timezone
 from itertools import islice
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 from werkzeug import Response as WerkzeugResponse
 
@@ -20,8 +20,8 @@ LOG = logging.getLogger(__name__)
 class SqsMetricBatchData(TypedDict, total=False):
     MetricName: str
     QueueName: str
-    Value: Optional[int]
-    Unit: Optional[str]
+    Value: int | None
+    Unit: str | None
 
 
 def dimension_lambda(kwargs):
@@ -30,7 +30,7 @@ def dimension_lambda(kwargs):
 
 
 def publish_lambda_metric(
-    metric, value, kwargs, account_id: Optional[str] = None, region_name: Optional[str] = None
+    metric, value, kwargs, account_id: str | None = None, region_name: str | None = None
 ):
     # publish metric only if CloudWatch service is available
     if not is_api_enabled("cloudwatch"):
@@ -155,7 +155,7 @@ def store_cloudwatch_logs(
     log_stream_name,
     log_output,
     start_time=None,
-    auto_create_group: Optional[bool] = True,
+    auto_create_group: bool | None = True,
 ):
     if not is_api_enabled("logs"):
         return

localstack/utils/collections.py

@@ -5,10 +5,9 @@ and manipulate python collection (dicts, list, sets).
 
 import logging
 import re
-from collections.abc import Iterable, Iterator, Mapping, Sized
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sized
 from typing import (
     Any,
-    Callable,
     Optional,
     TypedDict,
     TypeVar,
@@ -116,7 +115,7 @@ class PaginatedList(list[_ListType]):
         next_token: str = None,
         page_size: int = None,
         filter_function: Callable[[_ListType], bool] = None,
-    ) -> tuple[list[_ListType], Optional[str]]:
+    ) -> tuple[list[_ListType], str | None]:
         if filter_function is not None:
             result_list = list(filter(filter_function, self))
         else:
@@ -148,7 +147,7 @@ class PaginatedList(list[_ListType]):
 class CustomExpiryTTLCache(cachetools.TTLCache):
     """TTLCache that allows to set custom expiry times for individual keys."""
 
-    def set_expiry(self, key: Any, ttl: Union[float, int]) -> float:
+    def set_expiry(self, key: Any, ttl: float | int) -> float:
         """Set the expiry of the given key in a TTLCache to (<current_time> + <ttl>)"""
         with self.timer as time:
             # note: need to access the internal dunder API here
@@ -315,7 +314,7 @@ def is_list_or_tuple(obj) -> bool:
     return isinstance(obj, (list, tuple))
 
 
-def ensure_list(obj: Any, wrap_none=False) -> Optional[list]:
+def ensure_list(obj: Any, wrap_none=False) -> list | None:
     """Wrap the given object in a list, or return the object itself if it already is a list."""
     if obj is None and not wrap_none:
         return obj
@@ -414,7 +413,7 @@ def items_equivalent(list1, list2, comparator):
     return True
 
 
-def is_none_or_empty(obj: Union[Optional[str], Optional[list]]) -> bool:
+def is_none_or_empty(obj: str | None | list | None) -> bool:
     return (
         obj is None
         or (isinstance(obj, str) and obj.strip() == "")
@@ -475,7 +474,7 @@ def convert_to_typed_dict(typed_dict: type[T], obj: dict, strict: bool = False)
     return result
 
 
-def dict_multi_values(elements: Union[list, dict]) -> dict[str, list[Any]]:
+def dict_multi_values(elements: list | dict) -> dict[str, list[Any]]:
     """
     Return a dictionary with the original keys from the list of dictionary and the
     values are the list of values of the original dictionary.
@@ -516,7 +515,7 @@ def split_list_by(
     return truthy, falsy
 
 
-def is_comma_delimited_list(string: str, item_regex: Optional[str] = None) -> bool:
+def is_comma_delimited_list(string: str, item_regex: str | None = None) -> bool:
     """
     Checks if the given string is a comma-delimited list of items.
     The optional `item_regex` parameter specifies the regex pattern for each item in the list.