shelltastic 0.4.0__tar.gz → 0.4.1__tar.gz

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

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

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

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

{shelltastic-0.4.0 → shelltastic-0.4.1}/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.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.0 → shelltastic-0.4.1}/src/shelltastic/backend/base.py

@@ -1,26 +1,12 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
 from pathlib import Path
 
 from shelltastic.display import IODisplay
 from shelltastic.enum import CaptureMode, DisplayMode
-from shelltastic.exception import ShellException
 from shelltastic.host import Host
-
-
-@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.result import ShellResult
 
 
 class ShellBackend(ABC):
@@ -43,6 +29,15 @@ class ShellBackend(ABC):
         raise NotImplementedError()
 
 
+class LocalShellBackend(ShellBackend):
+    __slots__ = ()
+
+    @staticmethod
+    @abstractmethod
+    def local() -> LocalShellBackend:
+        raise NotImplementedError()
+
+
 class RemoteShellBackend(ShellBackend):
     __slots__ = ()
 

shelltastic-0.4.0/src/shelltastic/backend/__init__.py → shelltastic-0.4.1/src/shelltastic/backend/default/common.py

@@ -8,10 +8,9 @@ from multiprocessing.pool import ThreadPool
 from typing import IO, Literal
 
 from shelltastic import display
-from shelltastic.backend.base import RemoteShellBackend, ShellBackend, ShellResult
+from shelltastic.backend.base import ShellBackend
 from shelltastic.enum import CaptureMode, DisplayMode
-from shelltastic.exception import SSHConnectionError
-from shelltastic.host import Host
+from shelltastic.result import ShellResult
 
 LOGGER = logging.getLogger(__name__)
 
@@ -87,7 +86,7 @@ def _determine_subprocess_output_mode(
         return subprocess.PIPE
 
 
-class LocalShellBackend(ShellBackend):
+class CommonDefaultBackend(ShellBackend):
     __slots__ = ()
 
     def run(
@@ -195,55 +194,3 @@ class LocalShellBackend(ShellBackend):
             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

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.0 → shelltastic-0.4.1}/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,7 +57,7 @@ class GitFrontend:
             stdout=CaptureMode.PIPE,
             stderr=CaptureMode.PIPE,
         )
-        assert(result.stdout is not None)
+        assert result.stdout is not None
         configs = [i.strip() for i in result.stdout.decode().split("\n") if i.strip()]
         return configs
 
@@ -90,7 +90,7 @@ class GitFrontend:
         if response.returncode != 0:
             return []
         else:
-            assert(response.stdout is not None)
+            assert response.stdout is not None
             gitcredentials = response.stdout.decode()
 
         return gitcredentials.splitlines()
@@ -100,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)
 
 
@@ -108,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.4.0 → shelltastic-0.4.1}/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.1}/src/shelltastic/frontend/shell.py

@@ -3,12 +3,13 @@ from __future__ import annotations
 import shutil
 from pathlib import Path
 
-from shelltastic.backend import LocalShellBackend, SSHShellBackend
-from shelltastic.backend.base import ShellBackend, ShellResult
+from shelltastic import backend
+from shelltastic.backend.base import ShellBackend
 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:
@@ -91,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)
 
 
@@ -99,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)