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

localstack/utils/http.py

@@ -2,7 +2,6 @@ import logging
 import math
 import os
 import re
-from typing import Dict, 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
 
@@ -76,7 +75,7 @@ def add_path_parameters_to_url(uri: str, path_params: list):
     return urlunparse(url._replace(path=new_path))
 
 
-def add_query_params_to_url(uri: str, query_params: Dict) -> str:
+def add_query_params_to_url(uri: str, query_params: dict) -> str:
     """
     Add query parameters to the uri.
     :param uri: the base uri it can contains path arguments and query parameters
@@ -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
@@ -141,7 +140,7 @@ class _RequestsSafe:
 safe_requests = _RequestsSafe()
 
 
-def parse_request_data(method: str, path: str, data=None, headers=None) -> Dict:
+def parse_request_data(method: str, path: str, data=None, headers=None) -> dict:
     """Extract request data either from query string as well as request body (e.g., for POST)."""
     result = {}
     headers = headers or {}
@@ -165,7 +164,7 @@ def parse_request_data(method: str, path: str, data=None, headers=None) -> Dict:
     return result
 
 
-def get_proxies() -> Dict[str, str]:
+def get_proxies() -> dict[str, str]:
     proxy_map = {}
     if config.OUTBOUND_HTTP_PROXY:
         proxy_map["http"] = config.OUTBOUND_HTTP_PROXY
@@ -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/iputils.py

@@ -6,7 +6,8 @@ some of its functionality.
 import ipaddress
 import json
 import subprocess as sp
-from typing import Any, Generator, TypedDict
+from collections.abc import Generator
+from typing import Any, TypedDict
 
 from cachetools import TTLCache, cached
 

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
@@ -78,7 +78,7 @@ class FileMappedDocument(dict):
         if os.path.isdir(self.path):
             raise IsADirectoryError
 
-        with open(self.path, "r") as fd:
+        with open(self.path) as fd:
             self.update(json.load(fd))
 
     def save(self):
@@ -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

@@ -3,8 +3,9 @@ import random
 import re
 import socket
 import threading
+from collections.abc import MutableMapping
 from contextlib import closing
-from typing import Any, List, MutableMapping, NamedTuple, Optional, Union
+from typing import Any, NamedTuple
 from urllib.parse import urlparse
 
 import dns.resolver
@@ -49,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
@@ -92,11 +93,16 @@ def is_port_open(
                         answers = resolver.query("google.com", "A")
                         assert len(answers) > 0
                     else:
-                        sock.sendto(bytes(), (host, port))
+                        sock.sendto(b"", (host, port))
                         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))
@@ -158,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)
@@ -190,7 +197,7 @@ def port_can_be_bound(port: IntOrPort, address: str = "") -> bool:
         return False
 
 
-def get_free_udp_port(blocklist: List[int] = None) -> int:
+def get_free_udp_port(blocklist: list[int] = None) -> int:
     blocklist = blocklist or []
     for i in range(10):
         udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -202,7 +209,7 @@ def get_free_udp_port(blocklist: List[int] = None) -> int:
     raise Exception(f"Unable to determine free UDP port with blocklist {blocklist}")
 
 
-def get_free_tcp_port(blocklist: List[int] = None) -> int:
+def get_free_tcp_port(blocklist: list[int] = None) -> int:
     """
     Tries to bind a socket to port 0 and returns the port that was assigned by the system. If the port is
     in the given ``blocklist``, or the port is marked as reserved in ``dynamic_port_range``, the procedure
@@ -268,11 +275,11 @@ 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)
-    except socket.error:
+    except OSError:
         return None
 
 
@@ -280,7 +287,7 @@ def is_ip_address(addr: str) -> bool:
     try:
         socket.inet_aton(addr)
         return True
-    except socket.error:
+    except OSError:
         return False
 
 
@@ -341,7 +348,8 @@ class PortRange:
         if end > self.end:
             raise ValueError(f"end not in range ({end} < {self.end})")
 
-        port_range = PortRange(start, end)
+        # ensures that we return an instance of a subclass
+        port_range = type(self)(start, end)
         port_range._ports_cache = self._ports_cache
         port_range._ports_lock = self._ports_lock
         return port_range
@@ -354,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
@@ -468,9 +476,9 @@ def get_docker_host_from_container() -> str:
         if config.is_in_docker:
             try:
                 result = socket.gethostbyname("host.docker.internal")
-            except socket.error:
+            except OSError:
                 result = socket.gethostbyname("host.containers.internal")
-    except socket.error:
+    except OSError:
         # TODO if neither host resolves, we might be in linux. We could just use the default gateway then
         pass
     return result

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, Dict, Generic, List, Optional, Set, Type, 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):
@@ -83,7 +84,7 @@ class SubtypesInstanceManager:
     """Simple instance manager base class that scans the subclasses of a base type for concrete named
     implementations, and lazily creates and returns (singleton) instances on demand."""
 
-    _instances: Dict[str, "SubtypesInstanceManager"]
+    _instances: dict[str, "SubtypesInstanceManager"]
 
     @classmethod
     def get(cls, subtype_name: str, raise_if_missing: bool = True):
@@ -104,7 +105,7 @@ class SubtypesInstanceManager:
         return instance
 
     @classmethod
-    def instances(cls) -> Dict[str, "SubtypesInstanceManager"]:
+    def instances(cls) -> dict[str, "SubtypesInstanceManager"]:
         base_type = cls.get_base_type()
         if not hasattr(base_type, "_instances"):
             base_type._instances = {}
@@ -116,13 +117,13 @@ class SubtypesInstanceManager:
         raise NotImplementedError
 
     @classmethod
-    def get_base_type(cls) -> Type:
+    def get_base_type(cls) -> type:
         """Get the base class for which instances are being managed - can be customized by subtypes."""
         return cls
 
 
 # this requires that all subclasses have been imported before(!)
-def get_all_subclasses(clazz: Type) -> Set[Type]:
+def get_all_subclasses(clazz: type) -> set[type]:
     """Recursively get all subclasses of the given class."""
     result = set()
     subs = clazz.__subclasses__()
@@ -132,11 +133,11 @@ def get_all_subclasses(clazz: Type) -> Set[Type]:
     return result
 
 
-def fully_qualified_class_name(klass: Type) -> str:
+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
 
@@ -156,14 +157,14 @@ def recurse_object(obj: ComplexType, func: Callable, path: str = "") -> ComplexT
 
 
 def keys_to(
-    obj: ComplexType, op: Callable[[str], str], skip_children_of: List[str] = None
+    obj: ComplexType, op: Callable[[str], str], skip_children_of: list[str] = None
 ) -> ComplexType:
     """Recursively changes all dict keys to apply op. Skip children
     of any elements whose names are contained in skip_children_of (e.g., ['Tags'])"""
     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():
@@ -175,11 +176,11 @@ def keys_to(
     return result
 
 
-def keys_to_lower(obj: ComplexType, skip_children_of: List[str] = None) -> ComplexType:
+def keys_to_lower(obj: ComplexType, skip_children_of: list[str] = None) -> ComplexType:
     return keys_to(obj, first_char_to_lower, skip_children_of)
 
 
-def keys_to_upper(obj: ComplexType, skip_children_of: List[str] = None) -> ComplexType:
+def keys_to_upper(obj: ComplexType, skip_children_of: list[str] = None) -> ComplexType:
     return keys_to(obj, first_char_to_upper, skip_children_of)
 
 

localstack/utils/patch.py

@@ -1,7 +1,8 @@
 import functools
 import inspect
 import types
-from typing import Any, Callable, List, Type
+from collections.abc import Callable
+from typing import Any
 
 
 def get_defining_object(method):
@@ -71,7 +72,7 @@ def create_patch_proxy(target: Callable, new: Callable):
 
 
 class Patch:
-    applied_patches: List["Patch"] = []
+    applied_patches: list["Patch"] = []
     """Bookkeeping for patches that are applied. You can use this to debug patches. For instance,
     you could write something like::
 
@@ -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()
@@ -120,7 +127,7 @@ class Patch:
         return self
 
     @staticmethod
-    def extend_class(target: Type, fn: Callable):
+    def extend_class(target: type, fn: Callable):
         def _getattr(obj, name):
             if name != fn.__name__:
                 raise AttributeError(f"`{target.__name__}` object has no attribute `{name}`")
@@ -164,9 +171,9 @@ class Patch:
 
 
 class Patches:
-    patches: List[Patch]
+    patches: list[Patch]
 
-    def __init__(self, patches: List[Patch] = None) -> None:
+    def __init__(self, patches: list[Patch] = None) -> None:
         super().__init__()
 
         self.patches = []

localstack/utils/platform.py

@@ -14,14 +14,14 @@ def is_windows() -> bool:
     return "windows" == platform.system().lower()
 
 
-@lru_cache()
+@lru_cache
 def is_debian() -> bool:
     from localstack.utils.files import load_file
 
     return "Debian" in load_file("/etc/issue", "")
 
 
-@lru_cache()
+@lru_cache
 def is_redhat() -> bool:
     from localstack.utils.files import load_file
 

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, Dict, List, 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:
@@ -114,7 +115,7 @@ def run(
         return process
     except subprocess.CalledProcessError as e:
         if print_error:
-            print("ERROR: '%s': exit code %s; output: %s" % (cmd, e.returncode, e.output))
+            print(f"ERROR: '{cmd}': exit code {e.returncode}; output: {e.output}")
             sys.stdout.flush()
         raise e
 
@@ -151,7 +152,7 @@ def run_for_max_seconds(max_secs, _function, *args, **kwargs):
         time.sleep(0.5)
 
 
-def run_interactive(command: List[str]):
+def run_interactive(command: list[str]):
     """
     Run an interactive command in a subprocess. This blocks the current thread and attaches sys.stdin to
     the process. Copied from https://stackoverflow.com/a/43012138/804840
@@ -196,13 +197,13 @@ def is_root() -> bool:
     return get_os_user() == "root"
 
 
-@lru_cache()
+@lru_cache
 def get_os_user() -> str:
     # using getpass.getuser() seems to be reporting a different/invalid user in Docker/macOS
     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,10 +212,10 @@ class ShellCommandThread(FuncThread):
 
     def __init__(
         self,
-        cmd: Union[str, List[str]],
+        cmd: str | list[str],
         params: Any = None,
-        outfile: Union[str, int] = None,
-        env_vars: Dict[str, str] = None,
+        outfile: str | int = None,
+        env_vars: dict[str, str] = None,
         stdin: bool = False,
         auto_restart: bool = False,
         quiet: bool = True,
@@ -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 {}
@@ -268,7 +269,7 @@ class ShellCommandThread(FuncThread):
             if self.strip_color:
                 # strip color codes
                 line = re.sub(r"\x1b(\[.*?[@-~]|\].*?(\x07|\x1b\\))", "", line)
-            return "%s\r\n" % line.strip()
+            return f"{line.strip()}\r\n"
 
         def filter_line(line):
             """Return True if this line should be filtered, i.e., not printed"""