shelltastic 0.3.1__tar.gz → 0.4.1__tar.gz

{shelltastic-0.3.1 → shelltastic-0.4.1}/PKG-INFO

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

{shelltastic-0.3.1 → shelltastic-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shelltastic"
-version = "0.3.1"
+version = "0.4.1"
 description = "A fantastic shell command runner for python"
 readme = "README.md"
 authors = [

shelltastic-0.4.1/src/shelltastic/__init__.py

@@ -0,0 +1,21 @@
+from shelltastic.enum import CaptureMode, DisplayMode, SystemType
+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",
+    "scp",
+    "git",
+    "DisplayMode",
+    "CaptureMode",
+    "SystemType",
+    "Host",
+    "ShellResult",
+]
+
+shell = LocalShellFrontend()
+scp = SCP()
+git = LocalGitFrontend()

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

@@ -0,0 +1,35 @@
+from typing import Type
+
+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.1/src/shelltastic/backend/base.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from shelltastic.display import IODisplay
+from shelltastic.enum import CaptureMode, DisplayMode
+from shelltastic.host import Host
+from shelltastic.result import ShellResult
+
+
+class ShellBackend(ABC):
+    __slots__ = ()
+
+    @abstractmethod
+    def run(
+        self,
+        cmd: str | list[str],
+        *,
+        check: bool = True,
+        stdout: CaptureMode | None = None,
+        stderr: CaptureMode | None = None,
+        stdout_display: DisplayMode | IODisplay | None = None,
+        stderr_display: DisplayMode | IODisplay | None = None,
+        cwd: str | Path | None = None,
+        echo_cmd: DisplayMode | IODisplay | bool | None = None,
+        **kwargs,
+    ) -> ShellResult:
+        raise NotImplementedError()
+
+
+class LocalShellBackend(ShellBackend):
+    __slots__ = ()
+
+    @staticmethod
+    @abstractmethod
+    def local() -> LocalShellBackend:
+        raise NotImplementedError()
+
+
+class RemoteShellBackend(ShellBackend):
+    __slots__ = ()
+
+    @staticmethod
+    @abstractmethod
+    def for_host(host: Host) -> RemoteShellBackend:
+        raise NotImplementedError()

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

@@ -0,0 +1,196 @@
+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 ShellBackend
+from shelltastic.enum import CaptureMode, DisplayMode
+from shelltastic.result import ShellResult
+
+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 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 | 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

shelltastic-0.4.1/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.1/src/shelltastic/backend/default/remote.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import logging
+import pathlib
+import shlex
+
+from shelltastic.backend.base import RemoteShellBackend
+from shelltastic.backend.default.common import CommonDefaultBackend
+from shelltastic.exception import ShellException, SSHConnectionError
+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 | 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 ShellException as ex:
+            if ex.returncode == 255:
+                raise SSHConnectionError(
+                    self.host.hostname, ex.returncode, ex.stdout, ex.stderr
+                ) from ex
+            raise

shelltastic-0.4.1/src/shelltastic/display.py

@@ -0,0 +1,99 @@
+import logging
+import sys
+from abc import ABC, abstractmethod
+
+from shelltastic.enum import DisplayMode
+
+LOGGER = logging.getLogger(__name__)
+
+
+class IODisplay(ABC):
+    @abstractmethod
+    def printbytes(self, line: bytes):
+        raise NotImplementedError
+
+    @abstractmethod
+    def printline(self, msg: object, *args: object):
+        raise NotImplementedError
+
+
+class DevNullDisplay(IODisplay):
+    def printbytes(self, line: bytes):
+        pass
+
+    def printline(self, msg, *args):
+        pass
+
+
+class StdoutDisplay(IODisplay):
+    def printbytes(self, line: bytes):
+        print(line.decode(), end="")
+
+    def printline(self, msg, *args):
+        print(str(msg) % args)
+
+
+class StderrDisplay(IODisplay):
+    def printbytes(self, line: bytes):
+        print(line.decode(), end="", file=sys.stderr)
+
+    def printline(self, msg, *args):
+        print(str(msg) % args, file=sys.stderr)
+
+
+class LogDisplay(IODisplay):
+    def __init__(self, log_level) -> None:
+        super().__init__()
+        self.log_level = log_level
+
+    def printbytes(self, line: bytes):
+        LOGGER.log(self.log_level, line.decode().rstrip(), stacklevel=2)
+
+    def printline(self, msg: object, *args: object):
+        LOGGER.log(self.log_level, msg, *args, stacklevel=2)
+
+
+class CriticalLogDisplay(LogDisplay):
+    def __init__(self) -> None:
+        super().__init__(logging.CRITICAL)
+
+
+class ErrorLogDisplay(LogDisplay):
+    def __init__(self) -> None:
+        super().__init__(logging.ERROR)
+
+
+class WarningLogDisplay(LogDisplay):
+    def __init__(self) -> None:
+        super().__init__(logging.WARNING)
+
+
+class InfoLogDisplay(LogDisplay):
+    def __init__(self) -> None:
+        super().__init__(logging.INFO)
+
+
+class DebugLogDisplay(LogDisplay):
+    def __init__(self) -> None:
+        super().__init__(logging.DEBUG)
+
+
+def from_mode(mode: DisplayMode) -> IODisplay:
+    """Get a IODisplay for the given DisplayMode"""
+    if mode == DisplayMode.DEVNULL:
+        return DevNullDisplay()
+    if mode == DisplayMode.STDOUT:
+        return StdoutDisplay()
+    if mode == DisplayMode.STDERR:
+        return StderrDisplay()
+    if mode == DisplayMode.CRITICAL_LOG:
+        return CriticalLogDisplay()
+    if mode == DisplayMode.ERROR_LOG:
+        return ErrorLogDisplay()
+    if mode == DisplayMode.WARNING_LOG:
+        return WarningLogDisplay()
+    if mode == DisplayMode.INFO_LOG:
+        return InfoLogDisplay()
+    if mode == DisplayMode.DEBUG_LOG:
+        return DebugLogDisplay()
+    raise ValueError(f"Unknown DisplayMode {mode}")

shelltastic-0.4.1/src/shelltastic/enum.py

@@ -0,0 +1,23 @@
+from enum import Enum, auto
+
+
+class SystemType(Enum):
+    DEBIAN_BASED = auto()
+    UNKNOWN = auto()
+
+
+class CaptureMode(Enum):
+    PIPE = auto()
+    STDOUT = auto()
+    DEVNULL = auto()
+
+
+class DisplayMode(Enum):
+    STDOUT = auto()
+    STDERR = auto()
+    DEVNULL = auto()
+    CRITICAL_LOG = auto()
+    ERROR_LOG = auto()
+    WARNING_LOG = auto()
+    INFO_LOG = auto()
+    DEBUG_LOG = auto()

{shelltastic-0.3.1 → shelltastic-0.4.1}/src/shelltastic/exception.py

@@ -10,3 +10,18 @@ class SSHConnectionError(Exception):
         self.returncode = returncode
         self.stdout = stdout
         self.stderr = stderr
+
+
+class ShellException(Exception):
+    def __init__(
+        self,
+        cmd: str | list[str],
+        returncode: int,
+        stdout: bytes | None,
+        stderr: bytes | None,
+    ):
+        super().__init__(f"Shell execution failed with returncode {returncode}")
+        self.cmd = cmd
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr

{shelltastic-0.3.1 → shelltastic-0.4.1}/src/shelltastic/frontend/git.py

@@ -2,9 +2,9 @@ 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 OutputMode
+from shelltastic.enum import CaptureMode
 from shelltastic.frontend.common import RemoteFrontend, RemoteFrontendFactory
 from shelltastic.host import Host
 
@@ -26,9 +26,10 @@ class GitFrontend:
     def get_remote_url(self, repo_path: str | Path, remote: str = "origin") -> str:
         result = self._backend.run(
             ["git", "remote", "get-url", remote],
-            stdout=OutputMode.CAPTURE,
+            stdout=CaptureMode.PIPE,
             cwd=repo_path,
         )
+        assert result.stdout is not None
         return result.stdout.decode().strip()
 
     def set_remote_url(
@@ -53,9 +54,10 @@ class GitFrontend:
         result = self._backend.run(
             ["git", "config", "--global", "--get-all", key],
             check=False,
-            stdout=OutputMode.CAPTURE,
-            stderr=OutputMode.CAPTURE,
+            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
 
@@ -68,8 +70,8 @@ class GitFrontend:
         self._backend.run(
             ["git", "config", "unset", "--global", "--all", key],
             check=False,
-            stdout=OutputMode.CAPTURE,
-            stderr=OutputMode.CAPTURE,
+            stdout=CaptureMode.DEVNULL,
+            stderr=CaptureMode.DEVNULL,
         )
         if isinstance(value, str):
             value = [value]
@@ -82,12 +84,13 @@ class GitFrontend:
         response = self._backend.run(
             "cat ~/.git-credentials",
             check=False,
-            stdout=OutputMode.CAPTURE,
-            stderr=OutputMode.DEVNULL,
+            stdout=CaptureMode.PIPE,
+            stderr=CaptureMode.DEVNULL,
         )
         if response.returncode != 0:
             return []
         else:
+            assert response.stdout is not None
             gitcredentials = response.stdout.decode()
 
         return gitcredentials.splitlines()
@@ -97,7 +100,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)
 
 
@@ -105,7 +108,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.3.1 → shelltastic-0.4.1}/src/shelltastic/frontend/scp.py

@@ -1,8 +1,8 @@
 import logging
 from pathlib import Path
 
-from shelltastic.backend import LocalShellBackend, SSHShellBackend
-from shelltastic.enum import OutputMode
+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
@@ -58,7 +58,7 @@ class SCPFrontend(RemoteFrontend):
                 source_path,
                 dest,
             ],
-            stdout=OutputMode.DEVNULL,
+            stdout=CaptureMode.DEVNULL,
         )
 
         # Set mode if configured
@@ -93,7 +93,7 @@ class SCPFrontend(RemoteFrontend):
                 src,
                 destination_path,
             ],
-            stdout=OutputMode.DEVNULL,
+            stdout=CaptureMode.DEVNULL,
         )
         if mode:
             LOGGER.info("chmod %s to %s", destination_path, mode)

{shelltastic-0.3.1 → shelltastic-0.4.1}/src/shelltastic/frontend/shell.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 import shutil
 from pathlib import Path
-from subprocess import CompletedProcess
 
-from shelltastic.backend import LocalShellBackend, SSHShellBackend
+from shelltastic import backend
 from shelltastic.backend.base import ShellBackend
-from shelltastic.enum import OutputMode, SystemType
+from shelltastic.display import IODisplay
+from shelltastic.enum import CaptureMode, DisplayMode, SystemType
 from shelltastic.frontend.common import RemoteFrontend, RemoteFrontendFactory
 from shelltastic.host import Host
+from shelltastic.result import ShellResult
 
 
 class ShellFrontend:
@@ -17,11 +18,13 @@ class ShellFrontend:
 
     def which(self, command: str) -> Path | None:
         """Return the path to the command or None if the command is not on the path."""
-        result = self.run(["which", command], check=False, stdout=OutputMode.CAPTURE)
+        result = self.run(["which", command], check=False, stdout=CaptureMode.PIPE)
 
         if result.returncode != 0:
             return None
 
+        assert result.stdout is not None
+
         return Path(result.stdout.decode().strip())
 
     def file_exists(self, path: str | Path) -> bool:
@@ -29,8 +32,8 @@ class ShellFrontend:
         result = self.run(
             f'stat "{path}"',
             check=False,
-            stdout=OutputMode.DEVNULL,
-            stderr=OutputMode.DEVNULL,
+            stdout=CaptureMode.DEVNULL,
+            stderr=CaptureMode.DEVNULL,
         )
         if result.returncode == 0:
             return True
@@ -39,8 +42,9 @@ class ShellFrontend:
     def home_dir(self) -> Path:
         """Return the path to the current user's home directory"""
         result = self.run(
-            "echo ${HOME}", stdout=OutputMode.CAPTURE, stderr=OutputMode.DEVNULL
+            "echo ${HOME}", stdout=CaptureMode.PIPE, stderr=CaptureMode.DEVNULL
         )
+        assert result.stdout is not None
         return Path(result.stdout.decode().strip())
 
     def system_type(self) -> SystemType:
@@ -49,8 +53,8 @@ class ShellFrontend:
             self.run(
                 "stat /etc/debian_version",
                 check=False,
-                stdout=OutputMode.DEVNULL,
-                stderr=OutputMode.DEVNULL,
+                stdout=CaptureMode.DEVNULL,
+                stderr=CaptureMode.DEVNULL,
             ).returncode
             == 0
         ):
@@ -62,18 +66,22 @@ class ShellFrontend:
         cmd: str | list[str],
         *,
         check: bool = True,
-        stdout: OutputMode = OutputMode.PRINT,
-        stderr: OutputMode = OutputMode.PRINT,
+        stdout: CaptureMode | None = None,
+        stderr: CaptureMode | None = None,
+        stdout_display: DisplayMode | IODisplay | None = None,
+        stderr_display: DisplayMode | IODisplay | None = None,
         cwd: str | Path | None = None,
-        echo_cmd: bool = False,
+        echo_cmd: DisplayMode | IODisplay | bool | None = None,
         **kwargs,
-    ) -> CompletedProcess[bytes]:
+    ) -> ShellResult:
         """Run a shell command"""
         return self._backend.run(
             cmd,
             check=check,
             stdout=stdout,
             stderr=stderr,
+            stdout_display=stdout_display,
+            stderr_display=stderr_display,
             cwd=cwd,
             echo_cmd=echo_cmd,
             **kwargs,
@@ -84,7 +92,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)
 
 
@@ -92,7 +100,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.1/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.3.1/src/shelltastic/__init__.py

@@ -1,9 +0,0 @@
-from shelltastic.frontend.git import LocalGitFrontend
-from shelltastic.frontend.scp import SCP
-from shelltastic.frontend.shell import LocalShellFrontend
-
-__all__ = ["shell", "scp", "git"]
-
-shell = LocalShellFrontend()
-scp = SCP()
-git = LocalGitFrontend()

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

@@ -1,119 +0,0 @@
-from __future__ import annotations
-
-import logging
-import pathlib
-import shlex
-import subprocess
-import sys
-
-from shelltastic.backend.base import RemoteShellBackend, ShellBackend
-from shelltastic.enum import OutputMode
-from shelltastic.exception import SSHConnectionError
-from shelltastic.host import Host
-
-LOGGER = logging.getLogger(__name__)
-
-
-class LocalShellBackend(ShellBackend):
-    __slots__ = ()
-
-    def run(
-        self,
-        cmd: str | list[str],
-        *,
-        check: bool = True,
-        stdout: OutputMode = OutputMode.PRINT,
-        stderr: OutputMode = OutputMode.PRINT,
-        cwd: str | pathlib.Path | None = None,
-        echo_cmd: bool = False,
-        **kwargs,
-    ) -> subprocess.CompletedProcess[bytes]:
-        if kwargs:
-            raise TypeError(f"Uknown argument/s {list(kwargs.keys())}")
-
-        if isinstance(cmd, str):
-            LOGGER.debug("%s> %s", cwd if cwd else "", cmd)
-        else:
-            LOGGER.debug("%s> %s", cwd if cwd else "", shlex.join(cmd))
-
-        if echo_cmd:
-            print(cmd if isinstance(cmd, str) else shlex.join(cmd))
-
-        cmd_to_run = {}
-        cmd_to_run["args"] = cmd
-        cmd_to_run["check"] = check
-        cmd_to_run["cwd"] = cwd
-
-        if isinstance(cmd, str):
-            cmd_to_run["shell"] = True
-
-        # stdout
-        if stdout == OutputMode.CAPTURE:
-            cmd_to_run["stdout"] = subprocess.PIPE
-        elif stdout == OutputMode.DEVNULL:
-            cmd_to_run["stdout"] = subprocess.DEVNULL
-
-        # stderr
-        if stderr == OutputMode.CAPTURE:
-            cmd_to_run["stderr"] = subprocess.PIPE
-        elif stderr == OutputMode.DEVNULL:
-            cmd_to_run["stderr"] = subprocess.DEVNULL
-
-        # Flush stdout/stderr
-        # This fixes out of order prints between python and commands
-        sys.stdout.flush()
-        sys.stderr.flush()
-
-        return subprocess.run(**cmd_to_run)
-
-
-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,
-    ) -> subprocess.CompletedProcess[bytes]:
-        """
-        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

shelltastic-0.3.1/src/shelltastic/backend/base.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-import pathlib
-import subprocess
-from abc import ABC, abstractmethod
-
-from shelltastic.enum import OutputMode
-from shelltastic.host import Host
-
-
-class ShellBackend(ABC):
-    __slots__ = ()
-
-    @abstractmethod
-    def run(
-        self,
-        cmd: str | list[str],
-        *,
-        check: bool = True,
-        stdout: OutputMode = OutputMode.PRINT,
-        stderr: OutputMode = OutputMode.PRINT,
-        cwd: str | pathlib.Path | None = None,
-        echo_cmd: bool = False,
-        **kwargs,
-    ) -> subprocess.CompletedProcess[bytes]:
-        raise NotImplementedError()
-
-
-class RemoteShellBackend(ShellBackend):
-    __slots__ = ()
-
-    @staticmethod
-    @abstractmethod
-    def for_host(host: Host) -> RemoteShellBackend:
-        raise NotImplementedError()

shelltastic-0.3.1/src/shelltastic/enum.py

@@ -1,12 +0,0 @@
-from enum import Enum, auto
-
-
-class OutputMode(Enum):
-    CAPTURE = auto()
-    DEVNULL = auto()
-    PRINT = auto()
-
-
-class SystemType(Enum):
-    DEBIAN_BASED = auto()
-    UNKNOWN = auto()