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

localstack/utils/container_utils/docker_sdk_client.py

@@ -6,9 +6,10 @@ import queue
 import re
 import socket
 import threading
-from functools import lru_cache
+from collections.abc import Callable
+from functools import cache
 from time import sleep
-from typing import Callable, Dict, List, Optional, Tuple, Union, cast
+from typing import cast
 from urllib.parse import quote
 
 import docker
@@ -56,7 +57,7 @@ class SdkDockerClient(ContainerClient):
     is doing some of the heavy lifting for us to support both target platforms.
     """
 
-    docker_client: Optional[DockerClient]
+    docker_client: DockerClient | None
 
     def __init__(self):
         try:
@@ -264,21 +265,23 @@ class SdkDockerClient(ContainerClient):
         except APIError as e:
             raise ContainerException() from e
 
-    def remove_container(self, container_name: str, force=True, check_existence=False) -> None:
-        LOG.debug("Removing container: %s", container_name)
-        if check_existence and container_name not in self.get_running_container_names():
+    def remove_container(
+        self, container_name: str, force=True, check_existence=False, volumes=False
+    ) -> None:
+        LOG.debug("Removing container: %s, with volumes: %s", container_name, volumes)
+        if check_existence and container_name not in self.get_all_container_names():
             LOG.debug("Aborting removing due to check_existence check")
             return
         try:
             container = self.client().containers.get(container_name)
-            container.remove(force=force)
+            container.remove(force=force, v=volumes)
         except NotFound:
             if not force:
                 raise NoSuchContainer(container_name)
         except APIError as e:
             raise ContainerException() from e
 
-    def list_containers(self, filter: Union[List[str], str, None] = None, all=True) -> List[dict]:
+    def list_containers(self, filter: list[str] | str | None = None, all=True) -> list[dict]:
         if filter:
             filter = [filter] if isinstance(filter, str) else filter
             filter = dict([f.split("=", 1) for f in filter])
@@ -337,14 +340,14 @@ class SdkDockerClient(ContainerClient):
     def pull_image(
         self,
         docker_image: str,
-        platform: Optional[DockerPlatform] = None,
-        log_handler: Optional[Callable[[str], None]] = None,
+        platform: DockerPlatform | None = None,
+        log_handler: Callable[[str], None] | None = None,
     ) -> None:
         LOG.debug("Pulling Docker image: %s", docker_image)
         # some path in the docker image string indicates a custom repository
 
         docker_image = self.registry_resolver_strategy.resolve(docker_image)
-        kwargs: Dict[str, Union[str, bool]] = {"platform": platform}
+        kwargs: dict[str, str | bool] = {"platform": platform}
         try:
             if log_handler:
                 # Use a lower-level API, as the 'stream' argument is not available in the higher-level `pull`-API
@@ -389,7 +392,7 @@ class SdkDockerClient(ContainerClient):
         dockerfile_path: str,
         image_name: str,
         context_path: str = None,
-        platform: Optional[DockerPlatform] = None,
+        platform: DockerPlatform | None = None,
     ):
         try:
             dockerfile_path = Util.resolve_dockerfile_path(dockerfile_path)
@@ -466,7 +469,7 @@ class SdkDockerClient(ContainerClient):
         except APIError as e:
             raise ContainerException() from e
 
-    def inspect_container(self, container_name_or_id: str) -> Dict[str, Union[Dict, str]]:
+    def inspect_container(self, container_name_or_id: str) -> dict[str, dict | str]:
         try:
             return self.client().containers.get(container_name_or_id).attrs
         except NotFound:
@@ -479,7 +482,7 @@ class SdkDockerClient(ContainerClient):
         image_name: str,
         pull: bool = True,
         strip_wellknown_repo_prefixes: bool = True,
-    ) -> Dict[str, Union[dict, list, str]]:
+    ) -> dict[str, dict | list | str]:
         image_name = self.registry_resolver_strategy.resolve(image_name)
         try:
             result = self.client().images.get(image_name).attrs
@@ -513,7 +516,7 @@ class SdkDockerClient(ContainerClient):
         except APIError as e:
             raise ContainerException() from e
 
-    def inspect_network(self, network_name: str) -> Dict[str, Union[Dict, str]]:
+    def inspect_network(self, network_name: str) -> dict[str, dict | str]:
         try:
             return self.client().networks.get(network_name).attrs
         except NotFound:
@@ -525,8 +528,8 @@ class SdkDockerClient(ContainerClient):
         self,
         network_name: str,
         container_name_or_id: str,
-        aliases: Optional[List] = None,
-        link_local_ips: List[str] = None,
+        aliases: list | None = None,
+        link_local_ips: list[str] = None,
     ) -> None:
         LOG.debug(
             "Connecting container '%s' to network '%s' with aliases '%s'",
@@ -574,7 +577,7 @@ class SdkDockerClient(ContainerClient):
             LOG.info("Container has more than one assigned network. Picking the first one...")
         return networks[network_names[0]]["IPAddress"]
 
-    @lru_cache(maxsize=None)
+    @cache
     def has_docker(self) -> bool:
         try:
             if not self.docker_client:
@@ -619,8 +622,8 @@ class SdkDockerClient(ContainerClient):
         stdin=None,
         interactive: bool = False,
         attach: bool = False,
-        flags: Optional[str] = None,
-    ) -> Tuple[bytes, bytes]:
+        flags: str | None = None,
+    ) -> tuple[bytes, bytes]:
         LOG.debug("Starting container %s", container_name_or_id)
         try:
             container = self.client().containers.get(container_name_or_id)
@@ -668,7 +671,7 @@ class SdkDockerClient(ContainerClient):
                         sock.sendall(to_bytes(stdin))
                         sock.shutdown(socket.SHUT_WR)
                     stdout, stderr = self._read_from_sock(sock, False)
-                except socket.timeout:
+                except TimeoutError:
                     LOG.debug(
                         "Socket timeout when talking to the I/O streams of Docker container '%s'",
                         container_name_or_id,
@@ -701,31 +704,31 @@ class SdkDockerClient(ContainerClient):
         self,
         image_name: str,
         *,
-        name: Optional[str] = None,
-        entrypoint: Optional[Union[List[str], str]] = None,
+        name: str | None = None,
+        entrypoint: list[str] | str | None = None,
         remove: bool = False,
         interactive: bool = False,
         tty: bool = False,
         detach: bool = False,
-        command: Optional[Union[List[str], str]] = None,
-        volumes: Optional[List[SimpleVolumeBind]] = None,
-        ports: Optional[PortMappings] = None,
-        exposed_ports: Optional[List[str]] = None,
-        env_vars: Optional[Dict[str, str]] = None,
-        user: Optional[str] = None,
-        cap_add: Optional[List[str]] = None,
-        cap_drop: Optional[List[str]] = None,
-        security_opt: Optional[List[str]] = None,
-        network: Optional[str] = None,
-        dns: Optional[Union[str, List[str]]] = None,
-        additional_flags: Optional[str] = None,
-        workdir: Optional[str] = None,
-        privileged: Optional[bool] = None,
-        labels: Optional[Dict[str, str]] = None,
-        platform: Optional[DockerPlatform] = None,
-        ulimits: Optional[List[Ulimit]] = None,
-        init: Optional[bool] = None,
-        log_config: Optional[LogConfig] = None,
+        command: list[str] | str | None = None,
+        volumes: list[SimpleVolumeBind] | None = None,
+        ports: PortMappings | None = None,
+        exposed_ports: list[str] | None = None,
+        env_vars: dict[str, str] | None = None,
+        user: str | None = None,
+        cap_add: list[str] | None = None,
+        cap_drop: list[str] | None = None,
+        security_opt: list[str] | None = None,
+        network: str | None = None,
+        dns: str | list[str] | None = None,
+        additional_flags: str | None = None,
+        workdir: str | None = None,
+        privileged: bool | None = None,
+        labels: dict[str, str] | None = None,
+        platform: DockerPlatform | None = None,
+        ulimits: list[Ulimit] | None = None,
+        init: bool | None = None,
+        log_config: LogConfig | None = None,
     ) -> str:
         LOG.debug("Creating container with attributes: %s", locals())
         extra_hosts = None
@@ -832,32 +835,32 @@ class SdkDockerClient(ContainerClient):
         image_name: str,
         stdin=None,
         *,
-        name: Optional[str] = None,
-        entrypoint: Optional[str] = None,
+        name: str | None = None,
+        entrypoint: str | None = None,
         remove: bool = False,
         interactive: bool = False,
         tty: bool = False,
         detach: bool = False,
-        command: Optional[Union[List[str], str]] = None,
-        volumes: Optional[List[SimpleVolumeBind]] = None,
-        ports: Optional[PortMappings] = None,
-        exposed_ports: Optional[List[str]] = None,
-        env_vars: Optional[Dict[str, str]] = None,
-        user: Optional[str] = None,
-        cap_add: Optional[List[str]] = None,
-        cap_drop: Optional[List[str]] = None,
-        security_opt: Optional[List[str]] = None,
-        network: Optional[str] = None,
-        dns: Optional[str] = None,
-        additional_flags: Optional[str] = None,
-        workdir: Optional[str] = None,
-        labels: Optional[Dict[str, str]] = None,
-        platform: Optional[DockerPlatform] = None,
-        privileged: Optional[bool] = None,
-        ulimits: Optional[List[Ulimit]] = None,
-        init: Optional[bool] = None,
-        log_config: Optional[LogConfig] = None,
-    ) -> Tuple[bytes, bytes]:
+        command: list[str] | str | None = None,
+        volumes: list[SimpleVolumeBind] | None = None,
+        ports: PortMappings | None = None,
+        exposed_ports: list[str] | None = None,
+        env_vars: dict[str, str] | None = None,
+        user: str | None = None,
+        cap_add: list[str] | None = None,
+        cap_drop: list[str] | None = None,
+        security_opt: list[str] | None = None,
+        network: str | None = None,
+        dns: str | None = None,
+        additional_flags: str | None = None,
+        workdir: str | None = None,
+        labels: dict[str, str] | None = None,
+        platform: DockerPlatform | None = None,
+        privileged: bool | None = None,
+        ulimits: list[Ulimit] | None = None,
+        init: bool | None = None,
+        log_config: LogConfig | None = None,
+    ) -> tuple[bytes, bytes]:
         LOG.debug("Running container with image: %s", image_name)
         container = None
         try:
@@ -903,14 +906,14 @@ class SdkDockerClient(ContainerClient):
     def exec_in_container(
         self,
         container_name_or_id: str,
-        command: Union[List[str], str],
+        command: list[str] | str,
         interactive=False,
         detach=False,
-        env_vars: Optional[Dict[str, Optional[str]]] = None,
-        stdin: Optional[bytes] = None,
-        user: Optional[str] = None,
-        workdir: Optional[str] = None,
-    ) -> Tuple[bytes, bytes]:
+        env_vars: dict[str, str | None] | None = None,
+        stdin: bytes | None = None,
+        user: str | None = None,
+        workdir: str | None = None,
+    ) -> tuple[bytes, bytes]:
         LOG.debug("Executing command in container %s: %s", container_name_or_id, command)
         try:
             container: Container = self.client().containers.get(container_name_or_id)
@@ -936,7 +939,7 @@ class SdkDockerClient(ContainerClient):
                         sock.shutdown(socket.SHUT_WR)
                         stdout, stderr = self._read_from_sock(sock, tty)
                         return stdout, stderr
-                    except socket.timeout:
+                    except TimeoutError:
                         pass
             else:
                 if detach:
@@ -957,7 +960,7 @@ class SdkDockerClient(ContainerClient):
         except APIError as e:
             raise ContainerException() from e
 
-    def login(self, username: str, password: str, registry: Optional[str] = None) -> None:
+    def login(self, username: str, password: str, registry: str | None = None) -> None:
         LOG.debug("Docker login for %s", username)
         try:
             self.client().login(username, password=password, registry=registry, reauth=True)

localstack/utils/crypto.py

@@ -3,7 +3,6 @@ import logging
 import os
 import re
 import threading
-from typing import Tuple
 
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
@@ -44,8 +43,8 @@ def generate_ssl_cert(
         return all(os.path.exists(f) for f in files)
 
     def store_cert_key_files(base_filename):
-        key_file_name = "%s.key" % base_filename
-        cert_file_name = "%s.crt" % base_filename
+        key_file_name = f"{base_filename}.key"
+        cert_file_name = f"{base_filename}.crt"
         # TODO: Cleaner code to load the cert dynamically
         # extract key and cert from target_file and store into separate files
         content = load_file(target_file)
@@ -75,9 +74,9 @@ def generate_ssl_cert(
             return target_file, cert_file_name, key_file_name
     if random and target_file:
         if "." in target_file:
-            target_file = target_file.replace(".", ".%s." % short_uid(), 1)
+            target_file = target_file.replace(".", f".{short_uid()}.", 1)
         else:
-            target_file = "%s.%s" % (target_file, short_uid())
+            target_file = f"{target_file}.{short_uid()}"
 
     # create a key pair
     k = crypto.PKey()
@@ -105,7 +104,7 @@ def generate_ssl_cert(
     cert.set_pubkey(k)
     alt_names = (
         f"DNS:localhost,DNS:test.localhost.atlassian.io,DNS:localhost.localstack.cloud,DNS:{host_definition.host}IP:127.0.0.1"
-    ).encode("utf8")
+    ).encode()
     cert.add_extensions(
         [
             crypto.X509Extension(b"subjectAltName", False, alt_names),
@@ -124,10 +123,10 @@ def generate_ssl_cert(
     key_file.write(to_str(crypto.dump_privatekey(crypto.FILETYPE_PEM, k)))
     cert_file_content = cert_file.getvalue().strip()
     key_file_content = key_file.getvalue().strip()
-    file_content = "%s\n%s" % (key_file_content, cert_file_content)
+    file_content = f"{key_file_content}\n{cert_file_content}"
     if target_file:
-        key_file_name = "%s.key" % target_file
-        cert_file_name = "%s.crt" % target_file
+        key_file_name = f"{target_file}.key"
+        cert_file_name = f"{target_file}.crt"
         # check existence to avoid permission denied issues:
         # https://github.com/localstack/localstack/issues/1607
         if not all_exist(target_file, key_file_name, cert_file_name):
@@ -146,9 +145,9 @@ def generate_ssl_cert(
                         e,
                     )
                     # Fix for https://github.com/localstack/localstack/issues/1743
-                    target_file = "%s.pem" % new_tmp_file()
-                    key_file_name = "%s.key" % target_file
-                    cert_file_name = "%s.crt" % target_file
+                    target_file = f"{new_tmp_file()}.pem"
+                    key_file_name = f"{target_file}.key"
+                    cert_file_name = f"{target_file}.crt"
             TMP_FILES.append(target_file)
             TMP_FILES.append(key_file_name)
             TMP_FILES.append(cert_file_name)
@@ -165,7 +164,7 @@ def unpad(s: bytes) -> bytes:
     return s[0 : -s[-1]]
 
 
-def encrypt(key: bytes, message: bytes, iv: bytes = None, aad: bytes = None) -> Tuple[bytes, bytes]:
+def encrypt(key: bytes, message: bytes, iv: bytes = None, aad: bytes = None) -> tuple[bytes, bytes]:
     iv = iv or b"0" * BLOCK_SIZE
     cipher = Cipher(algorithms.AES(key), modes.GCM(iv), backend=default_backend())
     encryptor = cipher.encryptor()

localstack/utils/diagnose.py

@@ -3,7 +3,6 @@
 import inspect
 import os
 import socket
-from typing import Dict, List, Optional, Union
 
 from localstack import config
 from localstack.constants import DEFAULT_VOLUME_DIR
@@ -41,7 +40,7 @@ ENDPOINT_RESOLVE_LIST = ["localhost.localstack.cloud", "api.localstack.cloud"]
 INSPECT_DIRECTORIES = [DEFAULT_VOLUME_DIR, "/tmp"]
 
 
-def get_localstack_logs() -> Dict:
+def get_localstack_logs() -> dict:
     try:
         result = DOCKER_CLIENT.get_container_logs(get_main_container_name())
     except Exception as e:
@@ -50,7 +49,7 @@ def get_localstack_logs() -> Dict:
     return {"docker": result}
 
 
-def get_localstack_config() -> Dict:
+def get_localstack_config() -> dict:
     result = {}
     for k, v in inspect.getmembers(config):
         if k in EXCLUDE_CONFIG_KEYS:
@@ -77,14 +76,14 @@ def get_localstack_config() -> Dict:
     return result
 
 
-def inspect_main_container() -> Union[str, Dict]:
+def inspect_main_container() -> str | dict:
     try:
         return DOCKER_CLIENT.inspect_container(get_main_container_name())
     except Exception as e:
         return f"inspect failed: {e}"
 
 
-def get_localstack_version() -> Dict[str, Optional[str]]:
+def get_localstack_version() -> dict[str, str | None]:
     return {
         "build-date": os.environ.get("LOCALSTACK_BUILD_DATE"),
         "build-git-hash": os.environ.get("LOCALSTACK_BUILD_GIT_HASH"),
@@ -92,7 +91,7 @@ def get_localstack_version() -> Dict[str, Optional[str]]:
     }
 
 
-def resolve_endpoints() -> Dict[str, str]:
+def resolve_endpoints() -> dict[str, str]:
     result = {}
     for endpoint in ENDPOINT_RESOLVE_LIST:
         try:
@@ -103,7 +102,7 @@ def resolve_endpoints() -> Dict[str, str]:
     return result
 
 
-def get_important_image_hashes() -> Dict[str, str]:
+def get_important_image_hashes() -> dict[str, str]:
     result = {}
     for image in DIAGNOSE_IMAGES:
         try:
@@ -116,17 +115,17 @@ def get_important_image_hashes() -> Dict[str, str]:
     return result
 
 
-def get_service_stats() -> Dict[str, str]:
+def get_service_stats() -> dict[str, str]:
     from localstack.services.plugins import SERVICE_PLUGINS
 
     return {service: state.value for service, state in SERVICE_PLUGINS.get_states().items()}
 
 
-def get_file_tree() -> Dict[str, List[str]]:
+def get_file_tree() -> dict[str, list[str]]:
     return {d: traverse_file_tree(d) for d in INSPECT_DIRECTORIES}
 
 
-def traverse_file_tree(root: str) -> List[str]:
+def traverse_file_tree(root: str) -> list[str]:
     try:
         result = []
         if config.in_docker():
@@ -134,10 +133,10 @@ def traverse_file_tree(root: str) -> List[str]:
                 result.append(dirpath)
         return result
     except Exception as e:
-        return ["traversing files failed %s" % e]
+        return [f"traversing files failed {e}"]
 
 
-def get_docker_image_details() -> Dict[str, str]:
+def get_docker_image_details() -> dict[str, str]:
     try:
         image = DOCKER_CLIENT.inspect_container(get_main_container_name())["Config"]["Image"]
     except ContainerException:

localstack/utils/docker_utils.py

@@ -2,13 +2,13 @@ import functools
 import logging
 import platform
 import random
-from typing import List, Optional, Union
 
 from localstack import config
 from localstack.constants import DEFAULT_VOLUME_DIR, DOCKER_IMAGE_NAME
 from localstack.utils.collections import ensure_list
 from localstack.utils.container_utils.container_client import (
     ContainerClient,
+    DockerNotAvailable,
     PortMappings,
     VolumeInfo,
 )
@@ -74,12 +74,12 @@ def get_current_container_id() -> str:
     return container_id
 
 
-def inspect_current_container_mounts() -> List[VolumeInfo]:
+def inspect_current_container_mounts() -> list[VolumeInfo]:
     return DOCKER_CLIENT.inspect_container_volumes(get_current_container_id())
 
 
-@functools.lru_cache()
-def get_default_volume_dir_mount() -> Optional[VolumeInfo]:
+@functools.lru_cache
+def get_default_volume_dir_mount() -> VolumeInfo | None:
     """
     Returns the volume information of LocalStack's DEFAULT_VOLUME_DIR (/var/lib/localstack), if mounted,
     else it returns None. If we're not currently in docker a VauleError is raised. in a container, a ValueError is
@@ -132,8 +132,8 @@ def get_host_path_for_path_in_docker(path):
 
 
 def container_ports_can_be_bound(
-    ports: Union[IntOrPort, List[IntOrPort]],
-    address: Optional[str] = None,
+    ports: IntOrPort | list[IntOrPort],
+    address: str | None = None,
 ) -> bool:
     """Determine whether a given list of ports can be bound by Docker containers
 
@@ -153,10 +153,14 @@ def container_ports_can_be_bound(
             ports=port_mappings,
             remove=True,
         )
+    except DockerNotAvailable as e:
+        LOG.warning("Cannot perform port check because Docker is not available.")
+        raise e
     except Exception as e:
         if "port is already allocated" not in str(e) and "address already in use" not in str(e):
             LOG.warning(
-                "Unexpected error when attempting to determine container port status", exc_info=e
+                "Unexpected error when attempting to determine container port status",
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
         return False
     # TODO(srw): sometimes the command output from the docker container is "None", particularly when this function is

localstack/utils/files.py

@@ -6,13 +6,12 @@ import shutil
 import stat
 import tempfile
 from pathlib import Path
-from typing import Dict
 
 LOG = logging.getLogger(__name__)
 TMP_FILES = []
 
 
-def parse_config_file(file_or_str: str, single_section: bool = True) -> Dict:
+def parse_config_file(file_or_str: str, single_section: bool = True) -> dict:
     """Parse the given properties config file/string and return a dict of section->key->value.
     If the config contains a single section, and 'single_section' is True, returns"""
 
@@ -81,9 +80,26 @@ def save_file(file, content, append=False, permissions=None):
         f.flush()
 
 
-def load_file(file_path: str, default=None, mode=None):
+def load_file(
+    file_path: str | os.PathLike,
+    default: str | bytes | None = None,
+    mode: str | None = None,
+    strict: bool = False,
+) -> str | bytes | None:
+    """
+    Return file contents
+
+    :param file_path: path of the file
+    :param default: if strict=False then return this value if the file does not exist
+    :param mode: mode to open the file with (e.g. `r`, `rw`)
+    :param strict: raise an error if the file path is not a file
+    :return: the file contents
+    """
     if not os.path.isfile(file_path):
-        return default
+        if strict:
+            raise FileNotFoundError(file_path)
+        else:
+            return default
     if not mode:
         mode = "r"
     with open(file_path, mode) as f:
@@ -202,7 +218,7 @@ def rm_rf(path: str):
     # Running the native command can be an order of magnitude faster in Alpine on Travis-CI
     if is_debian():
         try:
-            return run('rm -rf "%s"' % path)
+            return run(f'rm -rf "{path}"')
         except Exception:
             pass
     # Make sure all files are writeable and dirs executable to remove
@@ -248,11 +264,7 @@ def cp_r(src: str, dst: str, rm_dest_on_conflict=False, ignore_copystat_errors=F
     except Exception as e:
 
         def _info(_path):
-            return "%s (file=%s, symlink=%s)" % (
-                _path,
-                os.path.isfile(_path),
-                os.path.islink(_path),
-            )
+            return f"{_path} (file={os.path.isfile(_path)}, symlink={os.path.islink(_path)})"
 
         LOG.debug("Error copying files from %s to %s: %s", _info(src), _info(dst), e)
         raise
@@ -293,7 +305,7 @@ def cleanup_tmp_files():
     del TMP_FILES[:]
 
 
-def new_tmp_file(suffix: str = None, dir: str = None) -> str:
+def new_tmp_file(suffix: str | None = None, dir: str | None = None) -> str:
     """Return a path to a new temporary file."""
     tmp_file, tmp_path = tempfile.mkstemp(suffix=suffix, dir=dir)
     os.close(tmp_file)
@@ -301,8 +313,15 @@ def new_tmp_file(suffix: str = None, dir: str = None) -> str:
     return tmp_path
 
 
-def new_tmp_dir(dir: str = None):
-    folder = new_tmp_file(dir=dir)
-    rm_rf(folder)
-    mkdir(folder)
+def new_tmp_dir(dir: str | None = None, mode: int = 0o777) -> str:
+    """
+    Create a new temporary directory with the specified permissions. The directory is added to the tracked temporary
+    files.
+    :param dir: parent directory for the temporary directory to be created. Systems's default otherwise.
+    :param mode: file permission for the directory (default: 0o777)
+    :return: the absolute path of the created directory
+    """
+    folder = tempfile.mkdtemp(dir=dir)
+    TMP_FILES.append(folder)
+    idempotent_chmod(folder, mode=mode)
     return folder

localstack/utils/functions.py

@@ -3,7 +3,8 @@
 import functools
 import inspect
 import logging
-from typing import Any, Callable, Dict, Optional, Tuple
+from collections.abc import Callable
+from typing import Any
 
 LOG = logging.getLogger(__name__)
 
@@ -19,8 +20,8 @@ def run_safe(_python_lambda, *args, _default=None, **kwargs):
 
 
 def call_safe(
-    func: Callable, args: Tuple = None, kwargs: Dict = None, exception_message: str = None
-) -> Optional[Any]:
+    func: Callable, args: tuple = None, kwargs: dict = None, exception_message: str = None
+) -> Any | None:
     """
     Call the given function with the given arguments, and if it fails, log the given exception_message.
     If logging.DEBUG is set for the logger, then we also log the traceback.
@@ -32,7 +33,7 @@ def call_safe(
     :return: whatever the func returns
     """
     if exception_message is None:
-        exception_message = "error calling function %s" % func.__name__
+        exception_message = f"error calling function {func.__name__}"
     if args is None:
         args = ()
     if kwargs is None: