shelltastic 0.4.3__tar.gz → 0.4.5__tar.gz

{shelltastic-0.4.3 → shelltastic-0.4.5}/PKG-INFO

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

{shelltastic-0.4.3 → shelltastic-0.4.5}/pyproject.toml

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

{shelltastic-0.4.3 → shelltastic-0.4.5}/src/shelltastic/backend/__init__.py

@@ -1,8 +1,26 @@
-from shelltastic.backend.base import LocalShellBackend, RemoteShellBackend
+from shelltastic.backend.base import (
+    BackendShim,
+    LocalShellBackend,
+    RemoteShellBackend,
+    ShellBackend,
+    add_shim,
+)
 from shelltastic.backend.default.local import DefaultLocalBackend
 from shelltastic.backend.default.remote import DefaultRemoteBackend
 from shelltastic.host import Host
 
+__all__ = [
+    "LocalShellBackend",
+    "RemoteShellBackend",
+    "BackendShim",
+    "ShellBackend",
+    "register_default_local_backend",
+    "register_default_remote_backend",
+    "add_shim",
+    "get_local_backend",
+    "get_remote_backend",
+]
+
 _default_local_backend: type[LocalShellBackend] = DefaultLocalBackend
 _default_remote_backend: type[RemoteShellBackend] = DefaultRemoteBackend
 

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

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from abc import ABC, ABCMeta, abstractmethod
+from functools import wraps
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    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 BackendShimResult:
+    def __init__(self, *args, **kwargs) -> None:
+        self.args = args
+        self.kwargs = kwargs
+
+
+class BackendShim(ABC):
+    @abstractmethod
+    def run_shim(
+        self,
+        backend_type: type,
+        /,
+        *args,
+        **kwargs,
+    ) -> BackendShimResult:
+        """
+        Shim for run() method of `ShellBackend`
+
+        Use `self.run(...)` to create and return a `BackendShimResult`
+
+        ```python
+        return self.run(*args, **kwargs)
+        ```
+        """
+        raise NotImplementedError()
+
+    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,
+    ) -> BackendShimResult:
+        """A helper function to make a BackendShimResult"""
+        return BackendShimResult(
+            cmd,
+            check=check,
+            stdout=stdout,
+            stderr=stderr,
+            stdout_display=stdout_display,
+            stderr_display=stderr_display,
+            cwd=cwd,
+            echo_cmd=echo_cmd,
+            **kwargs,
+        )
+
+
+_backend_shims: list[BackendShim] = []
+
+
+def add_shim(shim: BackendShim):
+    """Add a shim to manipulate `ShellBackend` params before any `ShellBackend` runs"""
+    global _backend_shims
+    _backend_shims.append(shim)
+
+
+def _shim_run(f, backend_type: type):
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        result: BackendShimResult = BackendShimResult(*args, **kwargs)
+        for shim in _backend_shims:
+            result = shim.run_shim(backend_type, *result.args, **result.kwargs)
+        return f(*result.args, **result.kwargs)
+
+    return wrapper
+
+
+class _InstallShims(ABCMeta):
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        instance = super().__call__(*args, **kwds)
+        instance.run = _shim_run(instance.run, instance.__class__)
+        return instance
+
+
+class ShellBackend(metaclass=_InstallShims):
+    __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.3 → shelltastic-0.4.5}/src/shelltastic/backend/default/remote.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 
 from shelltastic.backend.base import RemoteShellBackend
 from shelltastic.backend.default.common import CommonDefaultBackend
+from shelltastic.enum import CaptureMode
 from shelltastic.exception import ShellException, SSHConnectionError
 
 if TYPE_CHECKING:
@@ -44,6 +45,11 @@ class DefaultRemoteBackend(CommonDefaultBackend, RemoteShellBackend):
         if subshell:
             cmd = shlex.join(["bash", "-c", cmd])
 
+        # If we're redirecting stderr to stdout,
+        # add the same redirect inside the ssh command.
+        if kwargs.get("stderr") == CaptureMode.STDOUT:
+            cmd = cmd + " 2>&1"
+
         # cd into cwd first if cwd is set
         if cwd:
             cmd = shlex.join(["cd", str(cwd)]) + " && " + cmd

{shelltastic-0.4.3 → shelltastic-0.4.5}/src/shelltastic/display.py

@@ -1,43 +1,41 @@
 import logging
 import sys
+import threading
 from abc import ABC, abstractmethod
 
 from shelltastic.enum import DisplayMode
 
 LOGGER = logging.getLogger(__name__)
 
+_io_display_lock = threading.RLock()
+
 
 class IODisplay(ABC):
-    @abstractmethod
     def printbytes(self, line: bytes):
-        raise NotImplementedError
+        with _io_display_lock:
+            self._emit_line(line.decode().rstrip())
 
-    @abstractmethod
     def printline(self, msg: object, *args: object):
+        with _io_display_lock:
+            self._emit_line(msg, *args)
+
+    @abstractmethod
+    def _emit_line(self, msg: object, *args: object):
         raise NotImplementedError
 
 
 class DevNullDisplay(IODisplay):
-    def printbytes(self, line: bytes):
-        pass
-
-    def printline(self, msg, *args):
+    def _emit_line(self, msg: object, *args: object):
         pass
 
 
 class StdoutDisplay(IODisplay):
-    def printbytes(self, line: bytes):
-        print(line.decode(), end="", flush=True)
-
-    def printline(self, msg, *args):
+    def _emit_line(self, msg: object, *args: object):
         print(str(msg) % args, flush=True)
 
 
 class StderrDisplay(IODisplay):
-    def printbytes(self, line: bytes):
-        print(line.decode(), end="", file=sys.stderr, flush=True)
-
-    def printline(self, msg, *args):
+    def _emit_line(self, msg: object, *args: object):
         print(str(msg) % args, file=sys.stderr, flush=True)
 
 
@@ -46,10 +44,7 @@ class LogDisplay(IODisplay):
         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):
+    def _emit_line(self, msg: object, *args: object):
         LOGGER.log(self.log_level, msg, *args, stacklevel=2)
 
 

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

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    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()