exec-helpers 8.2.0__tar.gz → 8.2.1__tar.gz

{exec_helpers-8.2.0 → exec_helpers-8.2.1}/.pre-commit-config.yaml

@@ -10,7 +10,7 @@ repos:
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.15.13
+    rev: v0.17.3
     hooks:
       # Run the linter.
       - id: ruff-check
@@ -29,6 +29,6 @@ repos:
   - repo: https://github.com/tox-dev/pyproject-fmt
     # Use the sha / tag you want to point at
     # or use `pre-commit autoupdate` to get the latest version
-    rev: "v2.21.2"
+    rev: "v2.30.3"
     hooks:
       - id: pyproject-fmt

{exec_helpers-8.2.0 → exec_helpers-8.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exec-helpers
-Version: 8.2.0
+Version: 8.2.1
 Summary: Execution helpers for simplified usage of subprocess and ssh.
 Author-email: Aleksei Stepanov <penguinolog@gmail.com>
 Maintainer-email: Aleksei Stepanov <penguinolog@gmail.com>, Antonio Esposito <esposito.cloud@gmail.com>, Dennis Dmitriev <dis-xcom@gmail.com>
@@ -445,7 +445,11 @@ Keyword arguments:
 - cwd - working directory.
 - env - environment variables dict.
 
-.. note:: `shell=true` is always set.
+.. note:: The command is executed by the shell by default.
+   `Subprocess(shell=False)` (and `async_api.Subprocess(shell=False)`) executes it directly instead:
+   the command must be a list of arguments (a string raises `TypeError`),
+   and no shell syntax, expansion or `sh -c` inside a chroot is involved.
+   `SSHClient` can not do this: the remote side always passes the command to a shell.
 
 async_api.Subprocess specific
 -----------------------------

{exec_helpers-8.2.0 → exec_helpers-8.2.1}/README.rst

@@ -403,7 +403,11 @@ Keyword arguments:
 - cwd - working directory.
 - env - environment variables dict.
 
-.. note:: `shell=true` is always set.
+.. note:: The command is executed by the shell by default.
+   `Subprocess(shell=False)` (and `async_api.Subprocess(shell=False)`) executes it directly instead:
+   the command must be a list of arguments (a string raises `TypeError`),
+   and no shell syntax, expansion or `sh -c` inside a chroot is involved.
+   `SSHClient` can not do this: the remote side always passes the command to a shell.
 
 async_api.Subprocess specific
 -----------------------------

{exec_helpers-8.2.0 → exec_helpers-8.2.1}/exec_helpers/__init__.py

@@ -16,14 +16,13 @@
 
 from __future__ import annotations
 
+import contextlib
 import importlib
 import typing
 import warnings
 
-try:  # noqa: SIM105,S314,RUF100
+with contextlib.suppress(ImportError):
     from ._version import version as __version__  # noqa: F401
-except ImportError:
-    pass
 
 if typing.TYPE_CHECKING:
     from collections.abc import Sequence

{exec_helpers-8.2.0 → exec_helpers-8.2.1}/exec_helpers/_helpers.py

@@ -9,6 +9,7 @@ import typing
 
 if typing.TYPE_CHECKING:
     from collections.abc import Iterable
+    from collections.abc import Mapping
 
 
 def string_bytes_bytearray_as_bytes(src: str | bytes | bytearray) -> bytes:
@@ -96,3 +97,42 @@ def chroot_command(command: str, chroot_path: str | None = None, chroot_exe: str
         quoted_command = shlex.quote(command)
         return f"{chroot_exe} {chroot_dst} sh -c {shlex.quote(f'eval {quoted_command}')}"
     return command
+
+
+def chroot_argv_command(command: str, chroot_path: str | None = None, chroot_exe: str | None = None) -> str:
+    """Prepare command for chroot execution without a shell, only the arguments are joined.
+
+    :param command: Original command, a result of `shlex.join`.
+    :type command: str
+    :param chroot_path: chroot path.
+    :type chroot_path: str | None
+    :param chroot_exe: chroot executable, may carry its own arguments.
+    :type chroot_exe: str | None
+    :return: Command to be executed with chroot rules if applicable.
+    :rtype: str
+    """
+    if chroot_path and chroot_path != "/":
+        return shlex.join([*shlex.split(chroot_exe or "chroot"), chroot_path.strip(), *shlex.split(command)])
+    return command
+
+
+def repr_stdin(stdin: bytes | None) -> str:
+    """Describe STDIN data for a debug string without exposing it.
+
+    :param stdin: Data for STDIN.
+    :type stdin: bytes | None
+    :return: Size of the data, as the content can hold secrets.
+    :rtype: str
+    """
+    return "None" if stdin is None else f"<{len(stdin)} bytes>"
+
+
+def repr_env(env: Mapping[str, str] | None) -> str:
+    """Describe an environment for a debug string without exposing the values.
+
+    :param env: Process environment.
+    :type env: Mapping[str, str] | None
+    :return: Variable names only, as the values can hold secrets.
+    :rtype: str
+    """
+    return "None" if env is None else f"<names: {sorted(env, key=repr)}>"

{exec_helpers-8.2.0 → exec_helpers-8.2.1}/exec_helpers/_ssh_base.py

@@ -21,7 +21,7 @@ from __future__ import annotations
 import concurrent.futures
 import contextlib
 import copy
-import datetime
+import datetime as dt
 import getpass
 import logging
 import pathlib
@@ -94,6 +94,7 @@ class SshExecuteAsyncResult(api.ExecuteAsyncResult):
     __slots__ = ()
 
     @property
+    # pyrefly: ignore[bad-override]  # the property narrows the NamedTuple field type
     def interface(self) -> paramiko.Channel:
         """Override original NamedTuple with proper typing.
 
@@ -103,6 +104,7 @@ class SshExecuteAsyncResult(api.ExecuteAsyncResult):
         return super().interface  # type: ignore[no-any-return]
 
     @property
+    # pyrefly: ignore[bad-override]  # the property narrows the NamedTuple field type
     def stdin(self) -> paramiko.channel.ChannelStdinFile:
         """Override original NamedTuple with proper typing.
 
@@ -117,6 +119,7 @@ class SshExecuteAsyncResult(api.ExecuteAsyncResult):
         return super().stdin  # type: ignore[return-value]
 
     @property
+    # pyrefly: ignore[bad-override]  # the property narrows the NamedTuple field type
     def stderr(self) -> paramiko.channel.ChannelStderrFile | None:
         """Override original NamedTuple with proper typing.
 
@@ -126,6 +129,7 @@ class SshExecuteAsyncResult(api.ExecuteAsyncResult):
         return super().stderr
 
     @property
+    # pyrefly: ignore[bad-override]  # the property narrows the NamedTuple field type
     def stdout(self) -> paramiko.channel.ChannelFile | None:
         """Override original NamedTuple with proper typing.
 
@@ -135,7 +139,7 @@ class SshExecuteAsyncResult(api.ExecuteAsyncResult):
         return super().stdout
 
 
-class _SSHExecuteContext(api.ExecuteContext, contextlib.AbstractContextManager[SshExecuteAsyncResult]):
+class _SSHExecuteContext(api.ExecuteContext):
     """SSH Execute context."""
 
     __slots__ = (
@@ -222,8 +226,8 @@ class _SSHExecuteContext(api.ExecuteContext, contextlib.AbstractContextManager[S
         """
         return (
             f"<SSHClient().open_execute_context("
-            f"command={self.command!r}, "
-            f"stdin={self.stdin!r}, "
+            f"command={self._masked_command!r}, "
+            f"stdin={_helpers.repr_stdin(self.stdin)}, "
             f"open_stdout={self.open_stdout!r}, "
             f"open_stderr={self.open_stderr!r}, "
             f"get_pty={self.__get_pty!r}, "
@@ -308,7 +312,7 @@ class _SSHExecuteContext(api.ExecuteContext, contextlib.AbstractContextManager[S
             stderr = None
         _stdin: paramiko.channel.ChannelFile
         with chan.makefile("wb") as _stdin:
-            started = datetime.datetime.now(tz=datetime.UTC)
+            started = dt.datetime.now(tz=dt.UTC)
             if self.__sudo_mode:
                 chan.exec_command(self.command)  # nosec  # Sanitize on caller side
                 if not stdout.channel.closed:
@@ -333,13 +337,8 @@ class _SSHExecuteContext(api.ExecuteContext, contextlib.AbstractContextManager[S
             res_stdout = None
 
         # noinspection PyArgumentList
-        return SshExecuteAsyncResult(
-            interface=chan,
-            stdin=_stdin,
-            stderr=stderr,
-            stdout=res_stdout,
-            started=started,
-        )
+        # The fields are typed by properties of the subclass, which type checkers do not accept as constructor arguments
+        return SshExecuteAsyncResult._make((chan, _stdin, stderr, res_stdout, started))
 
     def __exit__(
         self,
@@ -458,6 +457,13 @@ class SSHClientBase(api.ExecHelper):
     :type allow_ssh_agent: bool
     :param missing_host_key_policy: Missing host key policy class. See paramiko.MissingHostKeyPolicy for details.
     :type missing_host_key_policy: type[paramiko.MissingHostKeyPolicy]
+    :param connect_timeout: Timeout in seconds for the TCP connection, the SSH banner, the key exchange and the
+        authentication of every connection step, including hosts reached through `proxy_to`.
+        An authentication timeout is reported as an authentication failure. By default: None
+        (paramiko defaults: no TCP and key exchange limit, banner 15 s, authentication 30 s). A connection attempt
+        is retried 3 times with a 3 s pause, so a hung host takes up to 3 times the timeout plus 6 s to report.
+    :type connect_timeout: float | None
+    :raises ValueError: connect_timeout is not positive.
 
     .. note:: auth has priority over username/password/private_keys.
     .. note::
@@ -477,12 +483,16 @@ class SSHClientBase(api.ExecHelper):
     .. versionchanged:: 7.4.0 Return of keepalive_mode to prevent mix with a keepalive period. Default is `False`.
     .. versionchanged:: 8.0.0 Expose SSH Agent usage override.
     .. versionchanged:: 8.1.4 Allow specifying missing_host_key_policy.
+    .. versionchanged:: 8.2.1 Added connect_timeout.
+    .. versionchanged:: 8.2.1 Direct connection to the local host accepts the host keys of this machine without
+        the unknown host key warning; a key of another server is handled by the missing host key policy as before.
     """
 
     __slots__ = (
         "__allow_agent",
         "__auth_mapping",
         "__conn_chain",
+        "__connect_timeout",
         "__hostname",
         "__keepalive_mode",
         "__keepalive_period",
@@ -519,14 +529,18 @@ class SSHClientBase(api.ExecHelper):
         keepalive: KeepAlivePeriodT = 1,
         allow_ssh_agent: bool = True,
         missing_host_key_policy: type[paramiko.MissingHostKeyPolicy] = paramiko.WarningPolicy,
+        connect_timeout: float | None = None,
     ) -> None:
-        """Main SSH Client helper."""
+        """Initialize the SSH client helper."""
         self.__sudo_mode = False
         self.__keepalive_period: int = int(keepalive)
         self.__keepalive_mode = False
         self.__verbose: bool = verbose
         self.__sock = sock
         self._missing_host_key_policy = missing_host_key_policy
+        if connect_timeout is not None and connect_timeout <= 0:
+            raise ValueError(f"connect_timeout should be positive, got {connect_timeout!r}")
+        self.__connect_timeout = connect_timeout
 
         self.__ssh: paramiko.SSHClient
         self.__sftp: paramiko.SFTPClient | None = None
@@ -749,14 +763,30 @@ class SSHClientBase(api.ExecHelper):
         """
         return self.__ssh
 
+    def __connect(self) -> None:
+        """Open the connection, with retries unless a socket was supplied.
+
+        A failed attempt closes the supplied socket, so there is nothing to retry on:
+        the next attempt would only fail on the closed socket and hide the original error.
+        """
+        with self.lock:
+            if self.__sock is None:
+                self.__connect_with_retries()
+            else:
+                self.__connect_once()
+
     @tenacity.retry(
         retry=RetryOnExceptions(retry_on=paramiko.SSHException, reraise=paramiko.AuthenticationException),
         stop=tenacity.stop.stop_after_attempt(3),
         wait=tenacity.wait.wait_fixed(3),
         reraise=True,
     )
-    def __connect(self) -> None:
-        """Main method for connection open."""
+    def __connect_with_retries(self) -> None:
+        """Open the connection, retry on the connection errors."""
+        self.__connect_once()
+
+    def __connect_once(self) -> None:
+        """Open the connection, one attempt."""
         with self.lock:
             if self.__sock is not None:
                 self.__ssh = paramiko.SSHClient()
@@ -769,6 +799,7 @@ class SSHClientBase(api.ExecHelper):
                     log=self.__verbose,
                     sock=self.__sock,
                     allow_ssh_agent=self.allow_ssh_agent,
+                    timeout=self.__connect_timeout,
                 )
             else:
                 self.__ssh = self.__get_client()
@@ -776,6 +807,27 @@ class SSHClientBase(api.ExecHelper):
             transport: paramiko.Transport = self._ssh_transport
             transport.set_keepalive(1 if self.__keepalive_period else 0)  # send keepalive packets
 
+    def __host_key_policy(self, hostname: str) -> paramiko.MissingHostKeyPolicy | type[paramiko.MissingHostKeyPolicy]:
+        """Select the missing host key policy for a host which is connected to directly.
+
+        :param hostname: Host to connect to, without a proxy or a jump host.
+        :type hostname: str
+        :return: Configured policy; for the local host a policy, which accepts the keys of this machine first.
+        :rtype: paramiko.MissingHostKeyPolicy | type[paramiko.MissingHostKeyPolicy]
+
+        The local host is normally absent from `known_hosts`, so its own keys are the reference. A key of another
+        server (any local address can be a container, a tunnel or another server) goes to the configured policy as
+        before, so nothing which worked fails because of it. Without readable keys the configured policy decides.
+        The own key is accepted without asking the configured policy, so that policy does not see it.
+        """
+        try:
+            keys = _ssh_helpers.local_host_keys() if _ssh_helpers.is_local_host(hostname) else ()
+        except OSError:  # the answer only silences a warning, so a failure of the lookup must not fail the connection
+            keys = ()
+        if keys:
+            return _ssh_helpers.LocalHostKeyPolicy(keys, fallback=self._missing_host_key_policy)
+        return self._missing_host_key_policy
+
     def __get_client(self) -> paramiko.SSHClient:
         """Connect using connection chain information.
 
@@ -785,12 +837,33 @@ class SSHClientBase(api.ExecHelper):
         :raises RuntimeError: Unexpected state.
         :raises ConnectionError: Cannot get SSH transport.
         """
+        opened: list[paramiko.SSHClient] = []
+        try:
+            return self.__connect_chain(opened)
+        except BaseException:
+            for client in reversed(opened):  # paramiko leaves the transports of a failed connect running
+                client.close()
+            raise
+
+    def __connect_chain(self, opened: list[paramiko.SSHClient]) -> paramiko.SSHClient:
+        """Connect the hosts of the connection chain one by one.
+
+        :param opened: Every client created here is added to the list at once, for the cleanup on failure.
+        :type opened: list[paramiko.SSHClient]
+        :return: Paramiko ssh connection object of the last host.
+        :rtype: paramiko.SSHClient
+        :raises ValueError: ProxyCommand found in a connection chain after the first host reached an.
+        :raises RuntimeError: Unexpected state.
+        :raises ConnectionError: Cannot get SSH transport.
+        """
+        config, auth = self.__conn_chain[0]
 
         last_ssh_client: paramiko.SSHClient = paramiko.SSHClient()
+        opened.append(last_ssh_client)
         last_ssh_client.load_system_host_keys()
-        last_ssh_client.set_missing_host_key_policy(self._missing_host_key_policy)
-
-        config, auth = self.__conn_chain[0]
+        last_ssh_client.set_missing_host_key_policy(
+            self._missing_host_key_policy if config.proxycommand else self.__host_key_policy(config.hostname)
+        )
 
         auth.connect(
             last_ssh_client,
@@ -798,10 +871,12 @@ class SSHClientBase(api.ExecHelper):
             port=config.port or 22,
             sock=paramiko.ProxyCommand(config.proxycommand) if config.proxycommand else None,
             allow_ssh_agent=self.allow_ssh_agent,
+            timeout=self.__connect_timeout,
         )
 
         for config, auth in self.__conn_chain[1:]:  # start has another logic, so do it out of cycle
             ssh = paramiko.SSHClient()
+            opened.append(ssh)
             ssh.load_system_host_keys()
             ssh.set_missing_host_key_policy(self._missing_host_key_policy)
 
@@ -820,6 +895,7 @@ class SSHClientBase(api.ExecHelper):
                     port=config.port or 22,
                     sock=sock,
                     allow_ssh_agent=self.allow_ssh_agent,
+                    timeout=self.__connect_timeout,
                 )
                 last_ssh_client = ssh
                 continue
@@ -831,10 +907,11 @@ class SSHClientBase(api.ExecHelper):
         return last_ssh_client
 
     def __connect_sftp(self) -> None:
-        """SFTP connection opener."""
+        """Open the SFTP channel, reconnecting the SSH session first if it was closed."""
         with self.lock:
+            transport = self._ssh_transport  # a failed reconnect is not "SFTP unavailable": let it propagate
             try:
-                self.__sftp = self.__ssh.open_sftp()
+                self.__sftp = transport.open_sftp_client()
             except paramiko.SSHException:
                 self.logger.warning("SFTP enable failed! SSH only is accessible.")
 
@@ -844,6 +921,11 @@ class SSHClientBase(api.ExecHelper):
 
         :rtype: paramiko.sftp_client.SFTPClient
         :raises paramiko.SSHException: SFTP connection failed.
+        :raises ConnectionError: SSH session was closed and the reconnect failed.
+        :raises paramiko.SSHException: SSH session was closed and the reconnect failed (the original exception).
+
+        .. versionchanged:: 8.2.1 The SFTP channel is opened through the reconnecting transport getter,
+            so a closed SSH session is restored instead of failing with `AttributeError`.
         """
         if self.__sftp is not None:
             return self.__sftp
@@ -877,7 +959,7 @@ class SSHClientBase(api.ExecHelper):
         """
         try:
             self.__ssh.close()
-        except BaseException as e:  # pragma: no cover  # NOSONAR
+        except BaseException as e:  # noqa: BLE001  # pragma: no cover  # NOSONAR
             with contextlib.suppress(AttributeError):
                 self.logger.debug(f"Exception in {self!s} destructor call: {e}")
         self.__sftp = None
@@ -908,7 +990,7 @@ class SSHClientBase(api.ExecHelper):
 
     @sudo_mode.setter
     def sudo_mode(self, mode: bool) -> None:
-        """Persistent sudo mode change for connection object.
+        """Change the persistent sudo mode of the connection object.
 
         :param mode: Sudo status: enabled | disabled.
         :type mode: bool
@@ -1061,7 +1143,7 @@ class SSHClientBase(api.ExecHelper):
                 result.read_stderr(src=async_result.stderr, log=self.logger if log_stderr else None, verbose=verbose)
 
         def poll_pipes() -> None:
-            """Polling task for FIFO buffers."""
+            """Poll FIFO buffers."""
             while not async_result.interface.status_event.is_set():
                 time.sleep(0.1)
                 if async_result.stdout or async_result.stderr:
@@ -1155,6 +1237,7 @@ class SSHClientBase(api.ExecHelper):
             sudo_mode=self.sudo_mode,
             auth=self.auth,
             logger=self.logger,
+            log_mask_re=self.log_mask_re,
             **kwargs,
         )
 
@@ -1564,6 +1647,7 @@ class SSHClientBase(api.ExecHelper):
             sock=sock,
             ssh_auth_map=ssh_auth_map if ssh_auth_map is not None else self.__auth_mapping,
             keepalive=int(keepalive),
+            connect_timeout=self.__connect_timeout,
         )
 
     def execute_through_host(
@@ -1787,7 +1871,7 @@ class SSHClientBase(api.ExecHelper):
                 results[remote.hostname, remote.port] = result
                 if result.exit_code not in prep_expected:
                     errors[remote.hostname, remote.port] = result
-            except Exception as e:
+            except Exception as e:  # noqa: BLE001  # stored and reported to the caller
                 raised_exceptions[remote.hostname, remote.port] = e
 
         if raised_exceptions:  # always raise

{exec_helpers-8.2.0 → exec_helpers-8.2.1}/exec_helpers/_ssh_helpers.py

@@ -3,16 +3,23 @@
 from __future__ import annotations
 
 import functools
+import ipaddress
 import pathlib
+import socket
 import typing
 from collections.abc import Collection
+from collections.abc import Iterable
 
 import paramiko
+import psutil
 
 if typing.TYPE_CHECKING:
     # noinspection PyPackageRequirements
     import logwrap
 
+LOCAL_HOST_KEYS_PATTERN = "ssh_host_*_key.pub"
+LOCAL_HOST_KEYS_DIR = pathlib.Path("/etc/ssh")
+
 SSHConfigDictLikeT = dict[str, str | int | bool | Collection[str]]
 SSHConfigsDictT = dict[str, SSHConfigDictLikeT]
 
@@ -38,12 +45,100 @@ def _parse_ssh_config_file(file_path: pathlib.Path) -> paramiko.SSHConfig | None
         config = paramiko.SSHConfig()
         with file_path.open() as f_obj:
             config.parse(f_obj)
-    except Exception:
+    except Exception:  # noqa: BLE001  # any parse failure means no usable config
         config = None
 
     return config
 
 
+def is_local_host(hostname: str) -> bool:
+    """Check if the hostname points to the machine we are running on.
+
+    :param hostname: Host name or IP address from the connection parameters.
+    :type hostname: str
+    :return: Loopback address, `localhost`, own host name or an address of a local interface.
+    :rtype: bool
+
+    No name resolution is done: a name is local only if it is the own host name or its short form.
+    A link-local address without a scope id is ambiguous (any link has such addresses), so it is not local.
+    """
+    name = hostname.strip("[]").lower()
+    try:
+        address = ipaddress.ip_address(name.partition("%")[0])
+    except ValueError:
+        own_name = socket.gethostname().lower()
+        return name in {"localhost", own_name, own_name.partition(".")[0]}
+
+    if address.is_loopback:
+        return True
+    if address.is_link_local and "%" not in name:
+        return False
+    try:
+        return any(
+            address == ipaddress.ip_address(addr.address.partition("%")[0])
+            for addrs in psutil.net_if_addrs().values()
+            for addr in addrs
+            if addr.family in {socket.AF_INET, socket.AF_INET6}
+        )
+    except (OSError, ValueError):  # the answer only silences a warning: no verdict means "not local"
+        return False
+
+
+def local_host_keys() -> tuple[paramiko.PKey, ...]:
+    """Read the public host keys of the SSH server of this machine.
+
+    :return: Parsed keys, empty if there are none or they are not readable.
+    :rtype: tuple[paramiko.PKey, ...]
+
+    The files are read on every call: a key rotation must not leave stale keys, and the read costs less than
+    the connection itself.
+    """
+    keys: list[paramiko.PKey] = []
+    for key_file in sorted(LOCAL_HOST_KEYS_DIR.glob(LOCAL_HOST_KEYS_PATTERN)):
+        try:
+            # known_hosts line format: "<names> <type> <base64 key>"
+            entry = paramiko.hostkeys.HostKeyEntry.from_line(f"local {key_file.read_text(encoding='ascii')}")
+        except (OSError, ValueError, paramiko.SSHException, paramiko.hostkeys.InvalidHostKey):
+            continue
+        if entry is not None and entry.key is not None:
+            keys.append(entry.key)
+    return tuple(keys)
+
+
+class LocalHostKeyPolicy(paramiko.MissingHostKeyPolicy):
+    """Missing host key policy for the local host: accept the host keys of this machine, ask the fallback otherwise.
+
+    :param keys: Public host keys of the SSH server of this machine.
+    :type keys: collections.abc.Iterable[paramiko.PKey]
+    :param fallback: Policy for any other key, so a server which is not this machine is treated as it was before.
+    :type fallback: paramiko.MissingHostKeyPolicy | type[paramiko.MissingHostKeyPolicy]
+    """
+
+    __slots__ = ("__fallback", "__keys")
+
+    def __init__(
+        self,
+        keys: Iterable[paramiko.PKey],
+        fallback: paramiko.MissingHostKeyPolicy | type[paramiko.MissingHostKeyPolicy],
+    ) -> None:
+        """Remember the keys and the fallback policy."""
+        self.__keys = frozenset(key.asbytes() for key in keys)
+        self.__fallback = fallback() if isinstance(fallback, type) else fallback
+
+    def missing_host_key(self, client: paramiko.SSHClient, hostname: str, key: paramiko.PKey) -> None:
+        """Accept the key of this machine, ask the fallback policy about any other key.
+
+        :param client: SSH client (low level).
+        :type client: paramiko.SSHClient
+        :param hostname: Name of the host in `known_hosts` format.
+        :type hostname: str
+        :param key: Key offered by the server.
+        :type key: paramiko.PKey
+        """
+        if key.asbytes() not in self.__keys:
+            self.__fallback.missing_host_key(client, hostname, key)
+
+
 class SSHConfig:
     """Parsed SSH Config for creation connection."""
 

{exec_helpers-8.2.0 → exec_helpers-8.2.1}/exec_helpers/_subprocess_helpers.py

@@ -51,10 +51,10 @@ def kill_proc_tree(pid: int, including_parent: bool = True) -> None:  # pragma:
 
     try:
         parent = psutil.Process(pid)
+        children: list[psutil.Process] = parent.children(recursive=True)
     except psutil.NoSuchProcess:
         # The process is already closed
         return
-    children: list[psutil.Process] = parent.children(recursive=True)
     child: psutil.Process
     for child in children:
         safe_stop(child)  # SIGTERM to allow cleanup
@@ -66,7 +66,8 @@ def kill_proc_tree(pid: int, including_parent: bool = True) -> None:  # pragma:
         _, alive = psutil.wait_procs((parent,), timeout=1)
         if alive:
             safe_stop(parent, kill=True)  # 2nd shot: SIGKILL
-        parent.wait(5)
+        with contextlib.suppress(psutil.NoSuchProcess):
+            parent.wait(5)
 
 
 # Subprocess extra arguments.

{exec_helpers-8.2.0 → exec_helpers-8.2.1}/exec_helpers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '8.2.0'
-__version_tuple__ = version_tuple = (8, 2, 0)
+__version__ = version = '8.2.1'
+__version_tuple__ = version_tuple = (8, 2, 1)
 
-__commit_id__ = commit_id = 'g9b1f831aa'
+__commit_id__ = commit_id = 'gc72db6b6f'