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

localstack/utils/crypto.py

@@ -43,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)
@@ -74,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()
@@ -123,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):
@@ -145,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)

localstack/utils/diagnose.py

@@ -3,7 +3,6 @@
 import inspect
 import os
 import socket
-from typing import Optional, Union
 
 from localstack import config
 from localstack.constants import DEFAULT_VOLUME_DIR
@@ -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"),
@@ -134,7 +133,7 @@ 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]:

localstack/utils/docker_utils.py

@@ -2,13 +2,13 @@ import functools
 import logging
 import platform
 import random
-from typing import 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,
 )
@@ -79,7 +79,7 @@ def inspect_current_container_mounts() -> list[VolumeInfo]:
 
 
 @functools.lru_cache
-def get_default_volume_dir_mount() -> Optional[VolumeInfo]:
+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

@@ -80,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:
@@ -201,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
@@ -247,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
@@ -292,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)
@@ -300,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, Optional
+from collections.abc import Callable
+from typing import Any
 
 LOG = logging.getLogger(__name__)
 
@@ -20,7 +21,7 @@ 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]:
+) -> 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:

localstack/utils/http.py

@@ -2,7 +2,6 @@ import logging
 import math
 import os
 import re
-from typing import Optional, Union
 from urllib.parse import parse_qs, parse_qsl, urlencode, urlparse, urlunparse
 
 import requests
@@ -43,18 +42,18 @@ def create_chunked_data(data, chunk_size: int = 80):
     dl = len(data)
     ret = ""
     for i in range(dl // chunk_size):
-        ret += "%s\r\n" % (hex(chunk_size)[2:])
-        ret += "%s\r\n\r\n" % (data[i * chunk_size : (i + 1) * chunk_size])
+        ret += f"{hex(chunk_size)[2:]}\r\n"
+        ret += f"{data[i * chunk_size : (i + 1) * chunk_size]}\r\n\r\n"
 
     if len(data) % chunk_size != 0:
-        ret += "%s\r\n" % (hex(len(data) % chunk_size)[2:])
-        ret += "%s\r\n" % (data[-(len(data) % chunk_size) :])
+        ret += f"{hex(len(data) % chunk_size)[2:]}\r\n"
+        ret += f"{data[-(len(data) % chunk_size) :]}\r\n"
 
     ret += "0\r\n\r\n"
     return ret
 
 
-def canonicalize_headers(headers: Union[dict, CaseInsensitiveDict]) -> dict:
+def canonicalize_headers(headers: dict | CaseInsensitiveDict) -> dict:
     if not headers:
         return headers
 
@@ -103,7 +102,7 @@ def add_query_params_to_url(uri: str, query_params: dict) -> str:
 
 
 def make_http_request(
-    url: str, data: Union[bytes, str] = None, headers: dict[str, str] = None, method: str = "GET"
+    url: str, data: bytes | str = None, headers: dict[str, str] = None, method: str = "GET"
 ) -> Response:
     return requests.request(
         url=url, method=method, headers=headers, data=data, auth=NetrcBypassAuth(), verify=False
@@ -179,7 +178,7 @@ def download(
     path: str,
     verify_ssl: bool = True,
     timeout: float = None,
-    request_headers: Optional[dict] = None,
+    request_headers: dict | None = None,
     quiet: bool = False,
 ) -> None:
     """Downloads file at url to the given path. Raises TimeoutError if the optional timeout (in secs) is reached.
@@ -202,7 +201,7 @@ def download(
         r = s.get(url, stream=True, verify=_verify, timeout=timeout, headers=request_headers)
         # check status code before attempting to read body
         if not r.ok:
-            raise Exception("Failed to download %s, response code %s" % (url, r.status_code))
+            raise Exception(f"Failed to download {url}, response code {r.status_code}")
 
         total_size = 0
         if r.headers.get("Content-Length"):
@@ -291,18 +290,19 @@ def download_github_artifact(url: str, target_file: str, timeout: int = None):
     Optionally allows to define a timeout in seconds."""
 
     def do_download(
-        download_url: str, request_headers: Optional[dict] = None, print_error: bool = False
+        download_url: str, request_headers: dict | None = None, print_error: bool = False
     ):
         try:
             download(download_url, target_file, timeout=timeout, request_headers=request_headers)
             return True
         except Exception as e:
             if print_error:
-                LOG.exception(
+                LOG.error(
                     "Unable to download Github artifact from %s to %s: %s %s",
                     url,
                     target_file,
                     e,
+                    exc_info=LOG.isEnabledFor(logging.DEBUG),
                 )
 
     # if a GitHub API token is set, use it to avoid rate limiting issues

localstack/utils/json.py

@@ -5,7 +5,7 @@ import logging
 import os
 from datetime import date, datetime
 from json import JSONDecodeError
-from typing import Any, Union
+from typing import Any
 
 from localstack.config import HostAndPort
 
@@ -42,7 +42,7 @@ class CustomEncoder(json.JSONEncoder):
         try:
             if isinstance(o, bytes):
                 return to_str(o)
-            return super(CustomEncoder, self).default(o)
+            return super().default(o)
         except Exception:
             return None
 
@@ -63,9 +63,9 @@ class FileMappedDocument(dict):
     concurrent writes, run load(). To save and overwrite the current document on disk, run save().
     """
 
-    path: Union[str, os.PathLike]
+    path: str | os.PathLike
 
-    def __init__(self, path: Union[str, os.PathLike], mode=0o664):
+    def __init__(self, path: str | os.PathLike, mode=0o664):
         super().__init__()
         self.path = path
         self.mode = mode
@@ -169,10 +169,24 @@ def extract_jsonpath(value, path):
     return result
 
 
-def assign_to_path(target, path: str, value, delimiter: str = "."):
+def assign_to_path(target: dict, path: str, value: any, delimiter: str = ".") -> dict:
+    """Assign the given value to a dict. If the path doesn't exist in the target dict, it will be created.
+    The delimiter can be used to provide a path with a different delimiter.
+
+    Examples:
+     - assign_to_path({}, "a", "b") => {"a": "b"}
+     - assign_to_path({}, "a.b.c", "d") => {"a": {"b": {"c": "d"}}}
+     - assign_to_path({}, "a.b/c", "d", delimiter="/") => {"a.b": {"c": "d"}}
+
+    """
     parts = path.strip(delimiter).split(delimiter)
+
+    if len(parts) == 1:
+        target[parts[0]] = value
+        return target
+
     path_to_parent = delimiter.join(parts[:-1])
-    parent = extract_from_jsonpointer_path(target, path_to_parent, auto_create=True)
+    parent = extract_from_jsonpointer_path(target, path_to_parent, delimiter, auto_create=True)
     if not isinstance(parent, dict):
         LOG.debug(
             'Unable to find parent (type %s) for path "%s" in object: %s',

localstack/utils/kinesis/kinesis_connector.py

@@ -6,7 +6,8 @@ import re
 import socket
 import tempfile
 import threading
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 from amazon_kclpy import kcl
 from amazon_kclpy.v2 import processor

localstack/utils/net.py

@@ -5,7 +5,7 @@ import socket
 import threading
 from collections.abc import MutableMapping
 from contextlib import closing
-from typing import Any, NamedTuple, Optional, Union
+from typing import Any, NamedTuple
 from urllib.parse import urlparse
 
 import dns.resolver
@@ -50,14 +50,14 @@ class Port(NamedTuple):
 
 
 # simple helper type to encapsulate int/Port argument types
-IntOrPort = Union[int, Port]
+IntOrPort = int | Port
 
 
 def is_port_open(
-    port_or_url: Union[int, str],
+    port_or_url: int | str,
     http_path: str = None,
     expect_success: bool = True,
-    protocols: Optional[Union[str, list[str]]] = None,
+    protocols: str | list[str] | None = None,
     quiet: bool = True,
 ):
     from localstack.utils.http import safe_requests
@@ -97,7 +97,12 @@ def is_port_open(
                         sock.recvfrom(1024)
                 except Exception:
                     if not quiet:
-                        LOG.exception("Error connecting to UDP port %s:%s", host, port)
+                        LOG.error(
+                            "Error connecting to UDP port %s:%s",
+                            host,
+                            port,
+                            exc_info=LOG.isEnabledFor(logging.DEBUG),
+                        )
                     return False
             elif nw_protocol == socket.SOCK_STREAM:
                 result = sock.connect_ex((host, port))
@@ -159,8 +164,9 @@ def wait_for_port_status(
         status = is_port_open(port, http_path=http_path, expect_success=expect_success)
         if bool(status) != (not expect_closed):
             raise Exception(
-                "Port %s (path: %s) was not %s"
-                % (port, http_path, "closed" if expect_closed else "open")
+                "Port {} (path: {}) was not {}".format(
+                    port, http_path, "closed" if expect_closed else "open"
+                )
             )
 
     return retry(check, sleep=sleep_time, retries=retries)
@@ -269,7 +275,7 @@ def get_free_tcp_port_range(num_ports: int, max_attempts: int = 50) -> "PortRang
     raise PortNotAvailableException("reached max_attempts when trying to find port range")
 
 
-def resolve_hostname(hostname: str) -> Optional[str]:
+def resolve_hostname(hostname: str) -> str | None:
     """Resolve the given hostname and return its IP address, or None if it cannot be resolved."""
     try:
         return socket.gethostbyname(hostname)
@@ -356,7 +362,7 @@ class PortRange:
         """
         return range(self.start, self.end + 1)
 
-    def reserve_port(self, port: Optional[IntOrPort] = None, duration: Optional[int] = None) -> int:
+    def reserve_port(self, port: IntOrPort | None = None, duration: int | None = None) -> int:
         """
         Reserves the given port (if it is still free). If the given port is None, it reserves a free port from the
         configured port range for external services. If a port is given, it has to be within the configured

localstack/utils/no_exit_argument_parser.py

@@ -1,6 +1,6 @@
 import argparse
 import logging
-from typing import NoReturn, Optional
+from typing import NoReturn
 
 LOG = logging.getLogger(__name__)
 
@@ -12,7 +12,7 @@ class NoExitArgumentParser(argparse.ArgumentParser):
     * ArgumentParser subclassing example: https://stackoverflow.com/a/59072378/6875981
     """
 
-    def exit(self, status: int = ..., message: Optional[str] = ...) -> NoReturn:
+    def exit(self, status: int = ..., message: str | None = ...) -> NoReturn:
         LOG.warning("Error in argument parser but preventing exit: %s", message)
 
     def error(self, message: str) -> NoReturn:

localstack/utils/numbers.py

@@ -1,4 +1,4 @@
-from typing import Any, Union
+from typing import Any
 
 
 def format_number(number: float, decimals: int = 2):
@@ -11,6 +11,13 @@ def format_number(number: float, decimals: int = 2):
 
 
 def is_number(s: Any) -> bool:
+    # booleans inherit from int
+    #
+    # >>> a.__class__.__mro__
+    # (<class 'bool'>, <class 'int'>, <class 'object'>)
+    if s is False or s is True:
+        return False
+
     try:
         float(s)  # for int, long and float
         return True
@@ -18,7 +25,7 @@ def is_number(s: Any) -> bool:
         return False
 
 
-def to_number(s: Any) -> Union[int, float]:
+def to_number(s: Any) -> int | float:
     """Cast the string representation of the given object to a number (int or float), or raise ValueError."""
     try:
         return int(str(s))

localstack/utils/objects.py

@@ -1,12 +1,13 @@
 import functools
 import re
 import threading
-from typing import Any, Callable, Generic, Optional, TypeVar, Union
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
 
 from .collections import ensure_list
 from .strings import first_char_to_lower, first_char_to_upper
 
-ComplexType = Union[list, dict, object]
+ComplexType = list | dict | object
 
 _T = TypeVar("_T")
 
@@ -16,7 +17,7 @@ class Value(Generic[_T]):
     Simple value container.
     """
 
-    value: Optional[_T]
+    value: _T | None
 
     def __init__(self, value: _T = None) -> None:
         self.value = value
@@ -30,7 +31,7 @@ class Value(Generic[_T]):
     def is_set(self) -> bool:
         return self.value is not None
 
-    def get(self) -> Optional[_T]:
+    def get(self) -> _T | None:
         return self.value
 
     def __bool__(self):
@@ -136,7 +137,7 @@ def fully_qualified_class_name(klass: type) -> str:
     return f"{klass.__module__}.{klass.__name__}"
 
 
-def not_none_or(value: Optional[Any], alternative: Any) -> Any:
+def not_none_or(value: Any | None, alternative: Any) -> Any:
     """Return 'value' if it is not None, or 'alternative' otherwise."""
     return value if value is not None else alternative
 
@@ -163,7 +164,7 @@ def keys_to(
     skip_children_of = ensure_list(skip_children_of or [])
 
     def fix_keys(o, path="", **kwargs):
-        if any(re.match(r"(^|.*\.)%s($|[.\[].*)" % k, path) for k in skip_children_of):
+        if any(re.match(rf"(^|.*\.){k}($|[.\[].*)", path) for k in skip_children_of):
             return o
         if isinstance(o, dict):
             for k, v in dict(o).items():

localstack/utils/patch.py

@@ -1,7 +1,8 @@
 import functools
 import inspect
 import types
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 
 def get_defining_object(method):
@@ -97,19 +98,25 @@ class Patch:
         self.is_applied = False
 
     def apply(self):
+        if self.is_applied:
+            return
+
         if self.old and self.name == "__getattr__":
             raise Exception("You can't patch class types implementing __getattr__")
         if not self.old and self.name != "__getattr__":
             raise AttributeError(f"`{self.obj.__name__}` object has no attribute `{self.name}`")
         setattr(self.obj, self.name, self.new)
-        self.is_applied = True
         Patch.applied_patches.append(self)
+        self.is_applied = True
 
     def undo(self):
+        if not self.is_applied:
+            return
+
         # If we added a method to a class type, we don't have a self.old. We just delete __getattr__
         setattr(self.obj, self.name, self.old) if self.old else delattr(self.obj, self.name)
-        self.is_applied = False
         Patch.applied_patches.remove(self)
+        self.is_applied = False
 
     def __enter__(self):
         self.apply()