localstack-core 4.7.1.dev139__py3-none-any.whl → 4.10.1.dev42__py3-none-any.whl

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:
@@ -288,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)
@@ -296,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.

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
@@ -54,7 +53,7 @@ def create_chunked_data(data, chunk_size: int = 80):
     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.
@@ -291,7 +290,7 @@ 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)

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

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):

localstack/utils/run.py

@@ -7,9 +7,10 @@ import subprocess
 import sys
 import threading
 import time
+from collections.abc import Callable
 from functools import lru_cache
 from queue import Queue
-from typing import Any, AnyStr, Callable, Optional, Union
+from typing import Any, AnyStr
 
 from localstack import config
 
@@ -23,19 +24,19 @@ LOG = logging.getLogger(__name__)
 
 
 def run(
-    cmd: Union[str, list[str]],
+    cmd: str | list[str],
     print_error=True,
     asynchronous=False,
     stdin=False,
     stderr=subprocess.STDOUT,
     outfile=None,
-    env_vars: Optional[dict[AnyStr, AnyStr]] = None,
+    env_vars: dict[AnyStr, AnyStr] | None = None,
     inherit_cwd=False,
     inherit_env=True,
     tty=False,
     shell=True,
     cwd: str = None,
-) -> Union[str, subprocess.Popen]:
+) -> str | subprocess.Popen:
     LOG.debug("Executing command: %s", cmd)
     env_dict = os.environ.copy() if inherit_env else {}
     if env_vars:
@@ -202,7 +203,7 @@ def get_os_user() -> str:
     return run("whoami").strip()
 
 
-def to_str(obj: Union[str, bytes], errors="strict"):
+def to_str(obj: str | bytes, errors="strict"):
     return obj.decode(config.DEFAULT_ENCODING, errors) if isinstance(obj, bytes) else obj
 
 
@@ -211,9 +212,9 @@ class ShellCommandThread(FuncThread):
 
     def __init__(
         self,
-        cmd: Union[str, list[str]],
+        cmd: str | list[str],
         params: Any = None,
-        outfile: Union[str, int] = None,
+        outfile: str | int = None,
         env_vars: dict[str, str] = None,
         stdin: bool = False,
         auto_restart: bool = False,
@@ -223,8 +224,8 @@ class ShellCommandThread(FuncThread):
         log_listener: Callable = None,
         stop_listener: Callable = None,
         strip_color: bool = False,
-        name: Optional[str] = None,
-        cwd: Optional[str] = None,
+        name: str | None = None,
+        cwd: str | None = None,
     ):
         params = params if params is not None else {}
         env_vars = env_vars if env_vars is not None else {}

localstack/utils/scheduler.py

@@ -1,9 +1,9 @@
 import queue
 import threading
 import time
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from concurrent.futures import Executor
-from typing import Any, Callable, Optional, Union
+from typing import Any
 
 
 class ScheduledTask:
@@ -14,12 +14,12 @@ class ScheduledTask:
     def __init__(
         self,
         task: Callable,
-        period: Optional[float] = None,
+        period: float | None = None,
         fixed_rate: bool = True,
-        start: Optional[float] = None,
+        start: float | None = None,
         on_error: Callable[[Exception], None] = None,
-        args: Optional[Union[tuple, list]] = None,
-        kwargs: Optional[Mapping[str, Any]] = None,
+        args: tuple | list | None = None,
+        kwargs: Mapping[str, Any] | None = None,
     ) -> None:
         super().__init__()
         self.task = task
@@ -76,7 +76,7 @@ class Scheduler:
 
     POISON = (-1, "__POISON__")
 
-    def __init__(self, executor: Optional[Executor] = None) -> None:
+    def __init__(self, executor: Executor | None = None) -> None:
         """
         Creates a new Scheduler. If an executor is passed, then that executor will be used to run the scheduled tasks
         asynchronously, otherwise they will be executed synchronously inside the event loop. Running tasks
@@ -94,12 +94,12 @@ class Scheduler:
     def schedule(
         self,
         func: Callable,
-        period: Optional[float] = None,
+        period: float | None = None,
         fixed_rate: bool = True,
-        start: Optional[float] = None,
+        start: float | None = None,
         on_error: Callable[[Exception], None] = None,
-        args: Optional[Union[tuple, list[Any]]] = None,
-        kwargs: Optional[Mapping[str, Any]] = None,
+        args: tuple | list[Any] | None = None,
+        kwargs: Mapping[str, Any] | None = None,
     ) -> ScheduledTask:
         """
         Schedules a given task (function call).

localstack/utils/server/tcp_proxy.py

@@ -1,8 +1,8 @@
 import logging
 import select
 import socket
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
-from typing import Callable
 
 from localstack.utils.serving import Server
 
@@ -93,7 +93,7 @@ class TCPProxy(Server):
                 try:
                     src_socket, _ = self._server_socket.accept()
                     self._thread_pool.submit(self._handle_request, src_socket)
-                except socket.timeout:
+                except TimeoutError:
                     pass
                 except OSError as e:
                     # avoid creating an error message if OSError is thrown due to socket closing

localstack/utils/serving.py

@@ -1,7 +1,6 @@
 import abc
 import logging
 import threading
-from typing import Optional
 
 from localstack.utils.net import is_port_open
 from localstack.utils.sync import poll_condition
@@ -21,7 +20,7 @@ class Server(abc.ABC):
 
     def __init__(self, port: int, host: str = "localhost") -> None:
         super().__init__()
-        self._thread: Optional[FuncThread] = None
+        self._thread: FuncThread | None = None
 
         self._lifecycle_lock = threading.RLock()
         self._stopped = threading.Event()
@@ -46,7 +45,7 @@ class Server(abc.ABC):
     def url(self):
         return f"{self.protocol}://{self.host}:{self.port}"
 
-    def get_error(self) -> Optional[Exception]:
+    def get_error(self) -> Exception | None:
         """
         If the thread running the server returned with an Exception, then this function will return that exception.
         """

localstack/utils/strings.py

@@ -7,7 +7,6 @@ import re
 import string
 import uuid
 import zlib
-from typing import Union
 
 from localstack.config import DEFAULT_ENCODING
 
@@ -28,13 +27,13 @@ REGEX_UNPRINTABLE_CHARS = re.compile(
 )
 
 
-def to_str(obj: Union[str, bytes], encoding: str = DEFAULT_ENCODING, errors="strict") -> str:
+def to_str(obj: str | bytes, encoding: str = DEFAULT_ENCODING, errors="strict") -> str:
     """If ``obj`` is an instance of ``binary_type``, return
     ``obj.decode(encoding, errors)``, otherwise return ``obj``"""
     return obj.decode(encoding, errors) if isinstance(obj, bytes) else obj
 
 
-def to_bytes(obj: Union[str, bytes], encoding: str = DEFAULT_ENCODING, errors="strict") -> bytes:
+def to_bytes(obj: str | bytes, encoding: str = DEFAULT_ENCODING, errors="strict") -> bytes:
     """If ``obj`` is an instance of ``text_type``, return
     ``obj.encode(encoding, errors)``, otherwise return ``obj``"""
     return obj.encode(encoding, errors) if isinstance(obj, str) else obj
@@ -86,7 +85,7 @@ def canonicalize_bool_to_str(val: bool) -> str:
     return "true" if str(val).lower() == "true" else "false"
 
 
-def convert_to_printable_chars(value: Union[list, dict, str]) -> str:
+def convert_to_printable_chars(value: list | dict | str) -> str:
     """Removes all unprintable characters from the given string."""
     from localstack.utils.objects import recurse_object
 
@@ -148,19 +147,19 @@ def long_uid() -> str:
     return str(uuid.uuid4())
 
 
-def md5(string: Union[str, bytes]) -> str:
+def md5(string: str | bytes) -> str:
     m = hashlib.md5()
     m.update(to_bytes(string))
     return m.hexdigest()
 
 
-def checksum_crc32(string: Union[str, bytes]) -> str:
+def checksum_crc32(string: str | bytes) -> str:
     bytes = to_bytes(string)
     checksum = zlib.crc32(bytes)
     return base64.b64encode(checksum.to_bytes(4, "big")).decode()
 
 
-def checksum_crc32c(string: Union[str, bytes]):
+def checksum_crc32c(string: str | bytes):
     # import botocore locally here to avoid a dependency of the CLI to botocore
     from botocore.httpchecksum import CrtCrc32cChecksum
 
@@ -169,7 +168,7 @@ def checksum_crc32c(string: Union[str, bytes]):
     return base64.b64encode(checksum.digest()).decode()
 
 
-def checksum_crc64nvme(string: Union[str, bytes]):
+def checksum_crc64nvme(string: str | bytes):
     # import botocore locally here to avoid a dependency of the CLI to botocore
     from botocore.httpchecksum import CrtCrc64NvmeChecksum
 
@@ -178,12 +177,12 @@ def checksum_crc64nvme(string: Union[str, bytes]):
     return base64.b64encode(checksum.digest()).decode()
 
 
-def hash_sha1(string: Union[str, bytes]) -> str:
+def hash_sha1(string: str | bytes) -> str:
     digest = hashlib.sha1(to_bytes(string)).digest()
     return base64.b64encode(digest).decode()
 
 
-def hash_sha256(string: Union[str, bytes]) -> str:
+def hash_sha256(string: str | bytes) -> str:
     digest = hashlib.sha256(to_bytes(string)).digest()
     return base64.b64encode(digest).decode()
 
@@ -192,7 +191,7 @@ def base64_to_hex(b64_string: str) -> bytes:
     return binascii.hexlify(base64.b64decode(b64_string))
 
 
-def base64_decode(data: Union[str, bytes]) -> bytes:
+def base64_decode(data: str | bytes) -> bytes:
     """Decode base64 data - with optional padding, and able to handle urlsafe encoding (containing -/_)."""
     data = to_str(data)
     missing_padding = len(data) % 4