shelltastic 0.4.0__tar.gz → 0.4.2__tar.gz

{shelltastic-0.4.0 → shelltastic-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shelltastic
-Version: 0.4.0
+Version: 0.4.2
 Summary: A fantastic shell command runner for python
 Author: Bearmine
 License-Expression: MPL-2.0

shelltastic-0.4.2/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "shelltastic"
+version = "0.4.2"
+description = "A fantastic shell command runner for python"
+readme = "README.md"
+authors = [
+    { name = "Bearmine" }
+]
+license = "MPL-2.0"
+license-files = [
+    "LICENSE"
+]
+requires-python = ">=3.12"
+dependencies = []
+
+[project.urls]
+Repository = "https://forge.bearmine.com/bearmine/shelltastic"
+
+[build-system]
+requires = ["uv_build>=0.11.18,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.ruff.lint]
+extend-select = [
+    "F",        # Pyflakes rules
+    "W",        # PyCodeStyle warnings
+    "E",        # PyCodeStyle errors
+    "I",        # Sort imports properly
+    "UP",       # Warn if certain things can changed due to newer Python versions
+    "C4",       # Catch incorrect use of comprehensions, dict, list, etc
+    "FA",       # Enforce from __future__ import annotations
+    "ISC",      # Good use of string concatenation
+    "ICN",      # Use common import conventions
+    "RET",      # Good return practices
+    "SIM",      # Common simplification rules
+    "TID",      # Some good import practices
+    "TC",       # Enforce importing certain types in a TYPE_CHECKING block
+    "PTH",      # Use pathlib instead of os.path
+    "TD",       # Be diligent with TODO comments
+    "NPY",      # Some numpy-specific things
+    "FURB",     # Suggest more idiomatic Python patterns
+]
+
+[tool.ruff.lint.pycodestyle]
+max-line-length = 100

{shelltastic-0.4.0 → shelltastic-0.4.2}/src/shelltastic/__init__.py

@@ -3,6 +3,7 @@ from shelltastic.frontend.git import LocalGitFrontend
 from shelltastic.frontend.scp import SCP
 from shelltastic.frontend.shell import LocalShellFrontend
 from shelltastic.host import Host
+from shelltastic.result import ShellResult
 
 __all__ = [
     "shell",
@@ -12,6 +13,7 @@ __all__ = [
     "CaptureMode",
     "SystemType",
     "Host",
+    "ShellResult",
 ]
 
 shell = LocalShellFrontend()

shelltastic-0.4.2/src/shelltastic/backend/__init__.py

@@ -0,0 +1,33 @@
+from shelltastic.backend.base import LocalShellBackend, RemoteShellBackend
+from shelltastic.backend.default.local import DefaultLocalBackend
+from shelltastic.backend.default.remote import DefaultRemoteBackend
+from shelltastic.host import Host
+
+_default_local_backend: type[LocalShellBackend] = DefaultLocalBackend
+_default_remote_backend: type[RemoteShellBackend] = DefaultRemoteBackend
+
+
+def register_default_local_backend(backend: type[LocalShellBackend]):
+    global _default_local_backend
+    _default_local_backend = backend
+
+
+def register_default_remote_backend(backend: type[RemoteShellBackend]):
+    global _default_remote_backend
+    _default_remote_backend = backend
+
+
+def get_local_backend(
+    *, backend: type[LocalShellBackend] | None = None
+) -> LocalShellBackend:
+    if backend:
+        return backend.local()
+    return _default_local_backend.local()
+
+
+def get_remote_backend(
+    host: Host, *, backend: type[RemoteShellBackend] | None = None
+) -> RemoteShellBackend:
+    if backend:
+        return backend.for_host(host)
+    return _default_remote_backend.for_host(host)

{shelltastic-0.4.0 → shelltastic-0.4.2}/src/shelltastic/backend/base.py

@@ -1,26 +1,15 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from pathlib import Path
+from typing import TYPE_CHECKING
 
-from shelltastic.display import IODisplay
-from shelltastic.enum import CaptureMode, DisplayMode
-from shelltastic.exception import ShellException
-from shelltastic.host import Host
+if TYPE_CHECKING:
+    from pathlib import Path
 
-
-@dataclass
-class ShellResult:
-    cmd: str | list[str]
-    returncode: int
-    stdout: bytes | None
-    stderr: bytes | None
-
-    def check_returncode(self):
-        """If returncode is not 0, raise ShellException"""
-        if self.returncode != 0:
-            raise ShellException(self.cmd, self.returncode, self.stdout, self.stderr)
+    from shelltastic.display import IODisplay
+    from shelltastic.enum import CaptureMode, DisplayMode
+    from shelltastic.host import Host
+    from shelltastic.result import ShellResult
 
 
 class ShellBackend(ABC):
@@ -43,6 +32,15 @@ class ShellBackend(ABC):
         raise NotImplementedError()
 
 
+class LocalShellBackend(ShellBackend):
+    __slots__ = ()
+
+    @staticmethod
+    @abstractmethod
+    def local() -> LocalShellBackend:
+        raise NotImplementedError()
+
+
 class RemoteShellBackend(ShellBackend):
     __slots__ = ()
 

shelltastic-0.4.2/src/shelltastic/backend/default/common.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import logging
+import shlex
+import subprocess
+from multiprocessing.pool import ThreadPool
+from typing import IO, TYPE_CHECKING, Literal
+
+from shelltastic import display
+from shelltastic.backend.base import ShellBackend
+from shelltastic.enum import CaptureMode, DisplayMode
+from shelltastic.result import ShellResult
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _output_and_collect(
+    io: IO[bytes] | None, display: display.IODisplay | None, collect: bool = True
+) -> bytes | None:
+    if io is None:
+        return None
+
+    if collect:
+        if display:
+            return_bytes: bytes = b""
+            for line in io:
+                return_bytes += line
+                display.printbytes(line)
+            return return_bytes
+        return io.read()
+
+    if display:
+        for line in io:
+            display.printbytes(line)
+
+    return None
+
+
+def _determine_subprocess_output_mode(
+    capture_mode: CaptureMode | None,
+    display_mode: DisplayMode | display.IODisplay | None,
+    output_name: Literal["stdout", "stderr"],
+) -> int:
+    # If DisplayMode is None, we act like subprocess does
+    if display_mode is None:
+        if capture_mode == CaptureMode.PIPE:
+            return subprocess.PIPE
+        if capture_mode == CaptureMode.STDOUT:
+            return subprocess.STDOUT
+        if capture_mode == CaptureMode.DEVNULL:
+            return subprocess.DEVNULL
+        return subprocess.PIPE
+
+    # Don't print
+    if display_mode == DisplayMode.DEVNULL:
+        if capture_mode == CaptureMode.PIPE:
+            return subprocess.PIPE
+        if capture_mode == CaptureMode.STDOUT:
+            if output_name == "stdout":
+                # stdout
+                return subprocess.PIPE
+            # stderr
+            return subprocess.STDOUT
+        if capture_mode == CaptureMode.DEVNULL:
+            return subprocess.DEVNULL
+        assert capture_mode is None
+        return subprocess.DEVNULL
+
+    # Print Output
+    # display_mode == STDOUT, STDERR, LOG, or is an IODisplay
+    if capture_mode == CaptureMode.PIPE:
+        return subprocess.PIPE
+    if capture_mode == CaptureMode.STDOUT:
+        return subprocess.STDOUT
+    if capture_mode == CaptureMode.DEVNULL:
+        # We need to PIPE to be able to print the output
+        return subprocess.PIPE
+    assert capture_mode is None
+    # We need to PIPE to be able to print the output
+    return subprocess.PIPE
+
+
+class CommonDefaultBackend(ShellBackend):
+    __slots__ = ()
+
+    def run(
+        self,
+        cmd: str | list[str],
+        *,
+        check: bool = True,
+        stdout: CaptureMode | None = None,
+        stderr: CaptureMode | None = None,
+        stdout_display: DisplayMode | display.IODisplay | None = None,
+        stderr_display: DisplayMode | display.IODisplay | None = None,
+        cwd: str | Path | None = None,
+        echo_cmd: DisplayMode | display.IODisplay | bool | None = None,
+        **kwargs,
+    ) -> ShellResult:
+        if kwargs:
+            raise TypeError(f"Uknown argument/s {list(kwargs.keys())}")
+
+        # If cmd is a str, run as shell
+        shell = isinstance(cmd, str)
+
+        # Echo command based on setting
+        # Defaults to DEBUG_LOG
+        # False to disable
+        if isinstance(echo_cmd, bool):
+            echo_cmd = DisplayMode.STDOUT if echo_cmd else DisplayMode.DEVNULL
+
+        if echo_cmd is None:
+            echo_cmd = DisplayMode.DEBUG_LOG
+
+        if isinstance(echo_cmd, display.IODisplay):
+            echo_display = echo_cmd
+        else:
+            echo_display = display.from_mode(echo_cmd)
+
+        if isinstance(cmd, str):
+            echo_display.printline("%s> %s", cwd or "", cmd)
+        else:
+            echo_display.printline("%s> %s", cwd or "", shlex.join(cmd))
+
+        # Determine PIPE mode for stdout
+        stdout_sub_mode = _determine_subprocess_output_mode(
+            stdout, stdout_display, "stdout"
+        )
+
+        # Determine PIPE mode for stderr
+        stderr_sub_mode = _determine_subprocess_output_mode(
+            stderr, stderr_display, "stderr"
+        )
+
+        if stdout_display is None:
+            stdout_display = (
+                DisplayMode.STDOUT if stdout is None else DisplayMode.DEVNULL
+            )
+
+        if stderr_display is None:
+            stderr_display = (
+                DisplayMode.STDERR if stderr is None else DisplayMode.DEVNULL
+            )
+
+        # Run subprocess command
+        with (
+            subprocess.Popen(
+                cmd,
+                shell=shell,
+                stdout=stdout_sub_mode,
+                stderr=stderr_sub_mode,
+                cwd=cwd,
+            ) as popen,
+            ThreadPool(2) as display_pool,
+        ):
+            # Print out and capture stdout
+            stdout_result = display_pool.apply_async(
+                _output_and_collect,
+                args=[
+                    popen.stdout,
+                    (
+                        stdout_display
+                        if isinstance(stdout_display, display.IODisplay)
+                        else display.from_mode(stdout_display)
+                    ),
+                    stdout is not None and stdout != CaptureMode.DEVNULL,
+                ],
+            )
+
+            # Print out and capture stderr
+            stderr_result = display_pool.apply_async(
+                _output_and_collect,
+                args=[
+                    popen.stderr,
+                    (
+                        stderr_display
+                        if isinstance(stderr_display, display.IODisplay)
+                        else display.from_mode(stderr_display)
+                    ),
+                    stderr is not None and stderr != CaptureMode.DEVNULL,
+                ],
+            )
+
+            # Wait on command completion
+            returncode = popen.wait()
+
+            # Build our result
+            result = ShellResult(
+                cmd=cmd,
+                stdout=stdout_result.get(),
+                stderr=stderr_result.get(),
+                returncode=returncode,
+            )
+
+        # If check is True, raise exception if returncode is not 0
+        if check:
+            result.check_returncode()
+
+        return result

shelltastic-0.4.2/src/shelltastic/backend/default/local.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import logging
+
+from shelltastic.backend.base import LocalShellBackend
+from shelltastic.backend.default.common import CommonDefaultBackend
+
+LOGGER = logging.getLogger(__name__)
+
+
+class DefaultLocalBackend(CommonDefaultBackend, LocalShellBackend):
+    @staticmethod
+    def local() -> LocalShellBackend:
+        return DefaultLocalBackend()

shelltastic-0.4.2/src/shelltastic/backend/default/remote.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import logging
+import shlex
+from typing import TYPE_CHECKING
+
+from shelltastic.backend.base import RemoteShellBackend
+from shelltastic.backend.default.common import CommonDefaultBackend
+from shelltastic.exception import ShellException, SSHConnectionError
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from shelltastic.host import Host
+    from shelltastic.result import ShellResult
+
+LOGGER = logging.getLogger(__name__)
+
+
+class DefaultRemoteBackend(CommonDefaultBackend, RemoteShellBackend):
+    def __init__(self, host: Host) -> None:
+        super().__init__()
+        self.host: Host = host
+
+    @staticmethod
+    def for_host(host: Host) -> RemoteShellBackend:
+        return DefaultRemoteBackend(host)
+
+    def run(
+        self,
+        cmd: str | list[str],
+        *,
+        subshell: bool = True,
+        cwd: str | Path | None = None,
+        **kwargs,
+    ) -> ShellResult:
+        """
+        Execute a remote command using SSH.
+        """
+        if isinstance(cmd, list):
+            cmd = shlex.join(cmd)
+
+        # Wrap user command in sh -c call
+        if subshell:
+            cmd = shlex.join(["bash", "-c", cmd])
+
+        # cd into cwd first if cwd is set
+        if cwd:
+            cmd = shlex.join(["cd", str(cwd)]) + " && " + cmd
+
+        port_flag = ["-p", str(self.host.port)] if self.host.port else []
+
+        try:
+            result = super().run(
+                ["ssh", *port_flag, self.host.host_specifier(), cmd], **kwargs
+            )
+            if (
+                result.returncode == 255
+            ):  # 255 is what ssh returns if it has an error with ssh itself
+                raise SSHConnectionError(
+                    self.host.hostname, result.returncode, result.stdout, result.stderr
+                )
+            return result
+        except ShellException as ex:
+            if ex.returncode == 255:
+                raise SSHConnectionError(
+                    self.host.hostname, ex.returncode, ex.stdout, ex.stderr
+                ) from ex
+            raise

{shelltastic-0.4.0 → shelltastic-0.4.2}/src/shelltastic/frontend/common.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generic, TypeVar, overload
+from typing import overload
 
 from shelltastic.host import Host
 
@@ -12,10 +12,8 @@ class RemoteFrontend(ABC):
         return self._host
 
 
-T = TypeVar("T", bound=RemoteFrontend)
 
-
-class RemoteFrontendFactory(Generic[T], ABC):
+class RemoteFrontendFactory[T: RemoteFrontend](ABC):
     __slots__ = ()
 
     @overload

{shelltastic-0.4.0 → shelltastic-0.4.2}/src/shelltastic/frontend/git.py

@@ -2,7 +2,7 @@ import logging
 from pathlib import Path
 from typing import overload
 
-from shelltastic.backend import LocalShellBackend, SSHShellBackend
+from shelltastic import backend
 from shelltastic.backend.base import ShellBackend
 from shelltastic.enum import CaptureMode
 from shelltastic.frontend.common import RemoteFrontend, RemoteFrontendFactory
@@ -29,7 +29,7 @@ class GitFrontend:
             stdout=CaptureMode.PIPE,
             cwd=repo_path,
         )
-        assert(result.stdout is not None)
+        assert result.stdout is not None
         return result.stdout.decode().strip()
 
     def set_remote_url(
@@ -57,9 +57,8 @@ class GitFrontend:
             stdout=CaptureMode.PIPE,
             stderr=CaptureMode.PIPE,
         )
-        assert(result.stdout is not None)
-        configs = [i.strip() for i in result.stdout.decode().split("\n") if i.strip()]
-        return configs
+        assert result.stdout is not None
+        return [i.strip() for i in result.stdout.decode().split("\n") if i.strip()]
 
     def set_global_config(self, key: str, value: str | list[str]):
         LOGGER.info(
@@ -89,10 +88,9 @@ class GitFrontend:
         )
         if response.returncode != 0:
             return []
-        else:
-            assert(response.stdout is not None)
-            gitcredentials = response.stdout.decode()
 
+        assert response.stdout is not None
+        gitcredentials = response.stdout.decode()
         return gitcredentials.splitlines()
 
 
@@ -100,7 +98,7 @@ class RemoteGitFrontend(GitFrontend, RemoteFrontend):
     __slots__ = ()
 
     def __init__(self, host: Host) -> None:
-        super().__init__(SSHShellBackend.for_host(host))
+        super().__init__(backend.get_remote_backend(host))
         super(GitFrontend, self).__init__(host)
 
 
@@ -108,7 +106,7 @@ class LocalGitFrontend(GitFrontend, RemoteFrontendFactory[RemoteGitFrontend]):
     __slots__ = ()
 
     def __init__(self) -> None:
-        super().__init__(LocalShellBackend())
+        super().__init__(backend.get_local_backend())
 
     def _create_remote_frontend(self, host: Host) -> RemoteGitFrontend:
         return RemoteGitFrontend(host)

{shelltastic-0.4.0 → shelltastic-0.4.2}/src/shelltastic/frontend/scp.py

@@ -1,7 +1,7 @@
 import logging
 from pathlib import Path
 
-from shelltastic.backend import LocalShellBackend, SSHShellBackend
+from shelltastic import backend
 from shelltastic.enum import CaptureMode
 from shelltastic.frontend.common import RemoteFrontend, RemoteFrontendFactory
 from shelltastic.host import Host
@@ -12,8 +12,8 @@ LOGGER = logging.getLogger(__name__)
 class SCPFrontend(RemoteFrontend):
     def __init__(self, host: Host) -> None:
         super().__init__(host)
-        self._local_backend = LocalShellBackend()
-        self._remote_backend = SSHShellBackend(host)
+        self._local_backend = backend.get_local_backend()
+        self._remote_backend = backend.get_remote_backend(host)
 
     def _scp_flags(self, recursive) -> list[str]:
         # Set Port

{shelltastic-0.4.0 → shelltastic-0.4.2}/src/shelltastic/frontend/shell.py

@@ -2,13 +2,17 @@ from __future__ import annotations
 
 import shutil
 from pathlib import Path
+from typing import TYPE_CHECKING
 
-from shelltastic.backend import LocalShellBackend, SSHShellBackend
-from shelltastic.backend.base import ShellBackend, ShellResult
-from shelltastic.display import IODisplay
+from shelltastic import backend
 from shelltastic.enum import CaptureMode, DisplayMode, SystemType
 from shelltastic.frontend.common import RemoteFrontend, RemoteFrontendFactory
-from shelltastic.host import Host
+
+if TYPE_CHECKING:
+    from shelltastic.backend.base import ShellBackend
+    from shelltastic.display import IODisplay
+    from shelltastic.host import Host
+    from shelltastic.result import ShellResult
 
 
 class ShellFrontend:
@@ -34,9 +38,7 @@ class ShellFrontend:
             stdout=CaptureMode.DEVNULL,
             stderr=CaptureMode.DEVNULL,
         )
-        if result.returncode == 0:
-            return True
-        return False
+        return result.returncode == 0
 
     def home_dir(self) -> Path:
         """Return the path to the current user's home directory"""
@@ -91,7 +93,7 @@ class RemoteShellFrontend(ShellFrontend, RemoteFrontend):
     __slots__ = ()
 
     def __init__(self, host: Host) -> None:
-        super().__init__(SSHShellBackend.for_host(host))
+        super().__init__(backend.get_remote_backend(host))
         super(ShellFrontend, self).__init__(host)
 
 
@@ -99,7 +101,7 @@ class LocalShellFrontend(ShellFrontend, RemoteFrontendFactory[RemoteShellFronten
     __slots__ = ()
 
     def __init__(self) -> None:
-        super().__init__(LocalShellBackend())
+        super().__init__(backend.get_local_backend())
 
     def _create_remote_frontend(self, host: Host) -> RemoteShellFrontend:
         return RemoteShellFrontend(host)

{shelltastic-0.4.0 → shelltastic-0.4.2}/src/shelltastic/host.py

@@ -10,5 +10,4 @@ class Host:
     def host_specifier(self):
         if self.username:
             return f"{self.username}@{self.hostname}"
-        else:
-            return self.hostname
+        return self.hostname

shelltastic-0.4.2/src/shelltastic/result.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+from shelltastic.exception import ShellException
+
+
+@dataclass
+class ShellResult:
+    cmd: str | list[str]
+    returncode: int
+    stdout: bytes | None
+    stderr: bytes | None
+
+    def check_returncode(self):
+        """If returncode is not 0, raise ShellException"""
+        if self.returncode != 0:
+            raise ShellException(self.cmd, self.returncode, self.stdout, self.stderr)

shelltastic-0.4.0/pyproject.toml

@@ -1,21 +0,0 @@
-[project]
-name = "shelltastic"
-version = "0.4.0"
-description = "A fantastic shell command runner for python"
-readme = "README.md"
-authors = [
-    { name = "Bearmine" }
-]
-license = "MPL-2.0"
-license-files = [
-    "LICENSE"
-]
-requires-python = ">=3.12"
-dependencies = []
-
-[project.urls]
-Repository = "https://forge.bearmine.com/bearmine/shelltastic"
-
-[build-system]
-requires = ["uv_build>=0.11.18,<0.12.0"]
-build-backend = "uv_build"

shelltastic-0.4.0/src/shelltastic/backend/__init__.py

@@ -1,249 +0,0 @@
-from __future__ import annotations
-
-import logging
-import pathlib
-import shlex
-import subprocess
-from multiprocessing.pool import ThreadPool
-from typing import IO, Literal
-
-from shelltastic import display
-from shelltastic.backend.base import RemoteShellBackend, ShellBackend, ShellResult
-from shelltastic.enum import CaptureMode, DisplayMode
-from shelltastic.exception import SSHConnectionError
-from shelltastic.host import Host
-
-LOGGER = logging.getLogger(__name__)
-
-
-def _output_and_collect(
-    io: IO[bytes] | None, display: display.IODisplay | None, collect: bool = True
-) -> bytes | None:
-    if io is None:
-        return None
-
-    if collect:
-        if display:
-            return_bytes = bytes()
-            for line in io:
-                return_bytes += line
-                display.printbytes(line)
-            return return_bytes
-        else:
-            return io.read()
-    else:
-        if display:
-            for line in io:
-                display.printbytes(line)
-        return None
-
-
-def _determine_subprocess_output_mode(
-    capture_mode: CaptureMode | None,
-    display_mode: DisplayMode | display.IODisplay | None,
-    output_name: Literal["stdout", "stderr"],
-) -> int | None:
-    # If DisplayMode is None, we act like subpress does
-    if display_mode is None:
-        if capture_mode == CaptureMode.PIPE:
-            return subprocess.PIPE
-        elif capture_mode == CaptureMode.STDOUT:
-            return subprocess.STDOUT
-        elif capture_mode == CaptureMode.DEVNULL:
-            return subprocess.DEVNULL
-        else:
-            assert capture_mode is None
-            return None
-
-    # Don't print
-    if display_mode == DisplayMode.DEVNULL:
-        if capture_mode == CaptureMode.PIPE:
-            return subprocess.PIPE
-        elif capture_mode == CaptureMode.STDOUT:
-            if output_name == "stdout":
-                # stdout
-                return subprocess.PIPE
-            else:
-                # stderr
-                return subprocess.STDOUT
-        elif capture_mode == CaptureMode.DEVNULL:
-            return subprocess.DEVNULL
-        else:
-            assert capture_mode is None
-            return subprocess.DEVNULL
-
-    # Print Output
-    # display_mode == STDOUT, STDERR, LOG, or is an IODisplay
-    if capture_mode == CaptureMode.PIPE:
-        return subprocess.PIPE
-    elif capture_mode == CaptureMode.STDOUT:
-        return subprocess.STDOUT
-    elif capture_mode == CaptureMode.DEVNULL:
-        # We need to PIPE to be able to print the output
-        return subprocess.PIPE
-    else:
-        assert capture_mode is None
-        # We need to PIPE to be able to print the output
-        return subprocess.PIPE
-
-
-class LocalShellBackend(ShellBackend):
-    __slots__ = ()
-
-    def run(
-        self,
-        cmd: str | list[str],
-        *,
-        check: bool = True,
-        stdout: CaptureMode | None = None,
-        stderr: CaptureMode | None = None,
-        stdout_display: DisplayMode | display.IODisplay | None = None,
-        stderr_display: DisplayMode | display.IODisplay | None = None,
-        cwd: str | pathlib.Path | None = None,
-        echo_cmd: DisplayMode | display.IODisplay | bool | None = None,
-        **kwargs,
-    ) -> ShellResult:
-        if kwargs:
-            raise TypeError(f"Uknown argument/s {list(kwargs.keys())}")
-
-        # If cmd is a str, run as shell
-        if isinstance(cmd, str):
-            shell = True
-        else:
-            shell = False
-
-        # Echo command based on setting
-        # Defaults to DEBUG_LOG
-        # False to disable
-        if isinstance(echo_cmd, bool):
-            if echo_cmd:
-                echo_cmd = DisplayMode.STDOUT
-            else:
-                echo_cmd = DisplayMode.DEVNULL
-
-        if echo_cmd is None:
-            echo_cmd = DisplayMode.DEBUG_LOG
-
-        if isinstance(echo_cmd, display.IODisplay):
-            echo_display = echo_cmd
-        else:
-            echo_display = display.from_mode(echo_cmd)
-
-        if isinstance(cmd, str):
-            echo_display.printline("%s> %s", cwd if cwd else "", cmd)
-        else:
-            echo_display.printline("%s> %s", cwd if cwd else "", shlex.join(cmd))
-
-        # Determine PIPE mode for stdout
-        stdout_sub_mode = _determine_subprocess_output_mode(
-            stdout, stdout_display, "stdout"
-        )
-
-        # Determine PIPE mode for stderr
-        stderr_sub_mode = _determine_subprocess_output_mode(
-            stderr, stderr_display, "stderr"
-        )
-
-        # Run subprocess command
-        with subprocess.Popen(
-            cmd, shell=shell, stdout=stdout_sub_mode, stderr=stderr_sub_mode, cwd=cwd
-        ) as popen:
-            with ThreadPool(2) as display_pool:
-                # Print out and capture stdout
-                stdout_result = display_pool.apply_async(
-                    _output_and_collect,
-                    args=[
-                        popen.stdout,
-                        (
-                            stdout_display
-                            if stdout_display is None
-                            or isinstance(stdout_display, display.IODisplay)
-                            else display.from_mode(stdout_display)
-                        ),
-                        False if stdout == CaptureMode.DEVNULL else True,
-                    ],
-                )
-
-                # Print out and capture stderr
-                stderr_result = display_pool.apply_async(
-                    _output_and_collect,
-                    args=[
-                        popen.stderr,
-                        (
-                            stderr_display
-                            if stderr_display is None
-                            or isinstance(stderr_display, display.IODisplay)
-                            else display.from_mode(stderr_display)
-                        ),
-                        False if stderr == CaptureMode.DEVNULL else True,
-                    ],
-                )
-
-                # Wait on command completion
-                returncode = popen.wait()
-
-                # Build our result
-                result = ShellResult(
-                    cmd=cmd,
-                    stdout=stdout_result.get(),
-                    stderr=stderr_result.get(),
-                    returncode=returncode,
-                )
-
-        # If check is True, raise exception if returncode is not 0
-        if check:
-            result.check_returncode()
-
-        return result
-
-
-class SSHShellBackend(LocalShellBackend, RemoteShellBackend):
-    def __init__(self, host: Host) -> None:
-        super().__init__()
-        self.host: Host = host
-
-    @staticmethod
-    def for_host(host: Host) -> RemoteShellBackend:
-        return SSHShellBackend(host)
-
-    def run(
-        self,
-        cmd: str | list[str],
-        *,
-        subshell: bool = True,
-        cwd: str | pathlib.Path | None = None,
-        **kwargs,
-    ) -> ShellResult:
-        """
-        Execute a remote command using SSH.
-        """
-        if isinstance(cmd, list):
-            cmd = shlex.join(cmd)
-
-        # Wrap user command in sh -c call
-        if subshell:
-            cmd = shlex.join(["bash", "-c", cmd])
-
-        # cd into cwd first if cwd is set
-        if cwd:
-            cmd = shlex.join(["cd", str(cwd)]) + " && " + cmd
-
-        port_flag = ["-p", str(self.host.port)] if self.host.port else []
-
-        try:
-            result = super().run(
-                ["ssh", *port_flag, self.host.host_specifier(), cmd], **kwargs
-            )
-            if (
-                result.returncode == 255
-            ):  # 255 is what ssh returns if it has an error with ssh itself
-                raise SSHConnectionError(
-                    self.host.hostname, result.returncode, result.stdout, result.stderr
-                )
-            return result
-        except subprocess.CalledProcessError as ex:
-            if ex.returncode == 255:
-                raise SSHConnectionError(
-                    self.host.hostname, ex.returncode, ex.stdout, ex.stderr
-                ) from ex
-            raise