Maintenance: python 3.8+ only, reduce amount of deprecated code

* drop `_execute_async`, which was long time protected and deprecated
* use `datetime.now(tz=timezone.utc)` instead of more naive `datetime.utcnow()`
* remove imports headers

Author: penguinolog

.github/workflows/pythonpackage.yml

@@ -108,7 +108,7 @@ jobs:
       max-parallel: 6
       matrix:
         os: [ubuntu-latest, windows-latest]
-        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
 
     name: "Script based python ${{ matrix.python-version }} on ${{ matrix.os }}"
     steps:

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v4.5.0
     hooks:
     - id: check-yaml
     - id: end-of-file-fixer
@@ -30,7 +30,7 @@ repos:
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.0.285
+    rev: v0.1.5
     hooks:
     - id: ruff
       args: [ --fix, --exit-non-zero-on-fix ]

classifiers.txt

@@ -4,10 +4,10 @@ Topic :: Software Development :: Libraries :: Python Modules
 License :: OSI Approved :: Apache Software License
 Programming Language :: Python :: 3
 Programming Language :: Python :: 3 :: Only
-Programming Language :: Python :: 3.7
 Programming Language :: Python :: 3.8
 Programming Language :: Python :: 3.9
 Programming Language :: Python :: 3.10
 Programming Language :: Python :: 3.11
+Programming Language :: Python :: 3.12
 Programming Language :: Python :: Implementation :: CPython
 Programming Language :: Python :: Implementation :: PyPy

exec_helpers/__init__.py

@@ -16,19 +16,16 @@
 
 from __future__ import annotations
 
-# Standard Library
 import importlib
 import typing
 import warnings
 
 try:  # noqa: SIM105
-    # Local Implementation
     from ._version import version as __version__  # noqa: F401
 except ImportError:
     pass
 
 if typing.TYPE_CHECKING:
-    # Standard Library
     from collections.abc import Sequence
 
 # noinspection PyUnresolvedReferences

exec_helpers/__init__.pyi

@@ -12,10 +12,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-# Standard Library
 import typing
 
-# Local Implementation
 from . import async_api
 from ._helpers import mask_command
 from ._ssh_helpers import HostsSSHConfigs
@@ -36,7 +34,6 @@ from .ssh_auth import SSHAuth
 from .subprocess import Subprocess  # nosec  # Expected
 
 try:  # noqa: SIM105
-    # Local Implementation
     from ._version import version as __version__  # noqa: F401
 except ImportError:
     pass

exec_helpers/_helpers.py

@@ -2,14 +2,12 @@
 
 from __future__ import annotations
 
-# Standard Library
 import functools
 import re
 import shlex
 import typing
 
 if typing.TYPE_CHECKING:
-    # Standard Library
     from collections.abc import Iterable
 
 
@@ -47,8 +45,7 @@ def _mask_command(text: str, rules: str | re.Pattern[str]) -> str:
     for match in re.finditer(rules, text):
         for idx, _ in enumerate(match.groups(), start=1):
             start, end = match.span(idx)
-            masked.append(text[prev:start])
-            masked.append("<*masked*>")
+            masked.extend((text[prev:start], "<*masked*>"))
             prev = end
     masked.append(text[prev:])
 
@@ -78,7 +75,7 @@ def cmd_to_string(command: str | Iterable[str]) -> str:
     """
     if isinstance(command, str):
         return command
-    return " ".join(shlex.quote(elem) for elem in command)
+    return shlex.join(command)
 
 
 def chroot_command(command: str, chroot_path: str | None = None) -> str:

exec_helpers/_ssh_base.py

@@ -18,7 +18,6 @@
 
 from __future__ import annotations
 
-# Standard Library
 import concurrent.futures
 import copy
 import datetime
@@ -31,34 +30,28 @@
 import typing
 import warnings
 
-# External Dependencies
 import paramiko
 import tenacity
 
-# Package Implementation
 from exec_helpers import api
 from exec_helpers import constants
 from exec_helpers import exceptions
 from exec_helpers import exec_result
 from exec_helpers import proc_enums
 from exec_helpers import ssh_auth
 
-# Local Implementation
 from . import _helpers
 from . import _log_templates
 from . import _ssh_helpers
 
 if typing.TYPE_CHECKING:
-    # Standard Library
     import socket
     from collections.abc import Iterable
     from collections.abc import Sequence
     from types import TracebackType
 
-    # External Dependencies
     from typing_extensions import Self
 
-    # Package Implementation
     from exec_helpers.api import CalledProcessErrorSubClassT
     from exec_helpers.api import CommandT
     from exec_helpers.api import ErrorInfoT
@@ -68,7 +61,6 @@
     from exec_helpers.api import OptionalTimeoutT
     from exec_helpers.proc_enums import ExitCodeT
 
-    # Local Implementation
     from ._ssh_helpers import SSHConfigsDictT
 
 __all__ = ("SSHClientBase", "SshExecuteAsyncResult", "SupportPathT")
@@ -316,7 +308,7 @@ def __enter__(self) -> SshExecuteAsyncResult:
             stderr = None
         _stdin: paramiko.channel.ChannelFile
         with chan.makefile("wb") as _stdin:
-            started = datetime.datetime.utcnow()
+            started = datetime.datetime.now(tz=datetime.timezone.utc)
             if self.__sudo_mode:
                 chan.exec_command(self.command)  # nosec  # Sanitize on caller side
                 if not stdout.channel.closed:
@@ -868,7 +860,7 @@ def sudo_mode(self, mode: bool) -> None:
         :param mode: sudo status: enabled | disabled
         :type mode: bool
         """
-        self.__sudo_mode = bool(mode)
+        self.__sudo_mode = mode
 
     @property
     def keepalive_period(self) -> int:
@@ -957,122 +949,14 @@ def _prepare_command(self, cmd: str, chroot_path: str | None = None) -> str:
         if not self.sudo_mode:
             return super()._prepare_command(cmd=cmd, chroot_path=chroot_path)
         quoted_command: str = shlex.quote(cmd)
-        if chroot_path is None and self._chroot_path is None:
+        if chroot_path is self._chroot_path is None:
             return f'sudo -S sh -c {shlex.quote(f"eval {quoted_command}")}'
         if chroot_path is not None:
             target_path: str = shlex.quote(chroot_path)
         else:
             target_path = shlex.quote(self._chroot_path)  # type: ignore[arg-type]
         return f'chroot {target_path} sudo sh -c {shlex.quote(f"eval {quoted_command}")}'
 
-    # noinspection PyMethodOverriding
-    def _execute_async(
-        self,
-        command: str,
-        *,
-        stdin: OptionalStdinT = None,
-        open_stdout: bool = True,
-        open_stderr: bool = True,
-        chroot_path: str | None = None,
-        get_pty: bool = False,
-        width: int = 80,
-        height: int = 24,
-        timeout: OptionalTimeoutT = None,
-        **kwargs: typing.Any,
-    ) -> SshExecuteAsyncResult:
-        """Execute command in async mode and return channel with IO objects.
-
-        :param command: Command for execution
-        :type command: str
-        :param stdin: pass STDIN text to the process
-        :type stdin: bytes | str | bytearray | None
-        :param open_stdout: open STDOUT stream for read
-        :type open_stdout: bool
-        :param open_stderr: open STDERR stream for read
-        :type open_stderr: bool
-        :param chroot_path: chroot path override
-        :type chroot_path: str | None
-        :param get_pty: Get PTY for connection
-        :type get_pty: bool
-        :param width: PTY width
-        :type width: int
-        :param height: PTY height
-        :type height: int
-        :param timeout: timeout before stop execution with TimeoutError (will be set on channel)
-        :type timeout: int | float | None
-        :param kwargs: additional parameters for call.
-        :type kwargs: typing.Any
-        :return: Tuple with control interface and file-like objects for STDIN/STDERR/STDOUT
-        :rtype: typing.NamedTuple(
-                    'SshExecuteAsyncResult',
-                    [
-                        ('interface', paramiko.Channel),
-                        ('stdin', paramiko.ChannelFile),
-                        ('stderr', paramiko.ChannelFile | None),
-                        ('stdout', paramiko.ChannelFile | None),
-                        ("started", datetime.datetime),
-                    ]
-                )
-
-        .. versionchanged:: 1.2.0 open_stdout and open_stderr flags
-        .. versionchanged:: 1.2.0 stdin data
-        .. versionchanged:: 1.2.0 get_pty moved to `**kwargs`
-        .. versionchanged:: 2.1.0 Use typed NamedTuple as result
-        .. versionchanged:: 3.2.0 Expose pty options as optional keyword-only arguments
-        .. versionchanged:: 4.1.0 support chroot
-        """
-        warnings.warn("_execute_async is deprecated and will be removed soon", DeprecationWarning, stacklevel=2)
-        chan: paramiko.Channel = self._ssh_transport.open_session()
-        if timeout is not None:
-            chan.settimeout(timeout)
-
-        if get_pty:
-            # Open PTY
-            chan.get_pty(term="vt100", width=width, height=height, width_pixels=0, height_pixels=0)
-
-        _stdin: paramiko.ChannelFile = chan.makefile("wb")  # type: ignore[name-defined]
-        stdout: paramiko.ChannelFile = chan.makefile("rb")  # type: ignore[name-defined]
-        if open_stderr:
-            stderr: paramiko.ChannelFile | None = chan.makefile_stderr("rb")  # type: ignore[name-defined]
-        else:
-            stderr = None
-
-        cmd = f"{self._prepare_command(cmd=command, chroot_path=chroot_path)}\n"
-
-        started = datetime.datetime.utcnow()
-        if self.sudo_mode:
-            chan.exec_command(cmd)  # nosec  # Sanitize on caller side
-            if not stdout.channel.closed:
-                # noinspection PyTypeChecker
-                self.auth.enter_password(_stdin)
-                _stdin.flush()
-        else:
-            chan.exec_command(cmd)  # nosec  # Sanitize on caller side
-
-        if stdin is not None:
-            if not _stdin.channel.closed:
-                stdin_str: bytes = self._string_bytes_bytearray_as_bytes(stdin)
-
-                _stdin.write(stdin_str)
-                _stdin.flush()
-            else:
-                self.logger.warning("STDIN Send failed: closed channel")
-
-        if open_stdout:
-            res_stdout = stdout
-        else:
-            stdout.close()
-            res_stdout = None
-
-        # noinspection PyArgumentList
-        return SshExecuteAsyncResult(
-            interface=chan,
-            stdin=_stdin,
-            stderr=stderr,
-            stdout=res_stdout,
-            started=started,
-        )
-
     def _exec_command(  # type: ignore[override]
         self,
         command: str,

exec_helpers/_ssh_helpers.py

@@ -2,19 +2,15 @@
 
 from __future__ import annotations
 
-# Standard Library
 import functools
 import pathlib
 import typing
 
-# External Dependencies
 import paramiko
 
 if typing.TYPE_CHECKING:
-    # Standard Library
     from collections.abc import Collection
 
-    # External Dependencies
     # noinspection PyPackageRequirements
     import logwrap
 

exec_helpers/_subprocess_helpers.py

@@ -16,12 +16,10 @@
 
 from __future__ import annotations
 
-# Standard Library
 import contextlib
 import platform
 import typing
 
-# External Dependencies
 import psutil
 
 __all__ = ("kill_proc_tree", "subprocess_kw")