shelltastic 0.8.0__tar.gz → 0.8.2__tar.gz

{shelltastic-0.8.0 → shelltastic-0.8.2}/PKG-INFO

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

{shelltastic-0.8.0 → shelltastic-0.8.2}/pyproject.toml

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

{shelltastic-0.8.0 → shelltastic-0.8.2}/src/shelltastic/backend/__init__.py

@@ -4,6 +4,7 @@ from shelltastic.backend.base import (
     RemoteShellBackend,
     ShellBackend,
     add_shim,
+    clear_shims,
 )
 from shelltastic.backend.default.local import DefaultLocalBackend
 from shelltastic.backend.default.remote import DefaultRemoteBackend
@@ -17,6 +18,7 @@ __all__ = [
     "register_default_local_backend",
     "register_default_remote_backend",
     "add_shim",
+    "clear_shims",
     "get_local_backend",
     "get_remote_backend",
 ]

{shelltastic-0.8.0 → shelltastic-0.8.2}/src/shelltastic/backend/base.py

@@ -90,6 +90,10 @@ class BackendShim(ABC):
 
 _backend_shims: list[BackendShim] = []
 
+def clear_shims():
+    """Clear all shims"""
+    global _backend_shims
+    _backend_shims.clear()
 
 def add_shim(shim: BackendShim):
     """Add a shim to manipulate `ShellBackend` params before any `ShellBackend` runs"""
@@ -103,7 +107,19 @@ def _shim_run(f, backend_type: type):
         result: BackendShimResult = BackendShimResult(*args, **kwargs)
         for shim in _backend_shims:
             result = shim.run_shim(
-                backend_type, f.__name__, *result.args, **result.kwargs
+                backend_type, *result.args, **result.kwargs
+            )
+        return f(*result.args, **result.kwargs)
+
+    return wrapper
+
+def _shim_run_async(f, backend_type: type):
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        result: BackendShimResult = BackendShimResult(*args, **kwargs)
+        for shim in _backend_shims:
+            result = shim.run_async_shim(
+                backend_type, *result.args, **result.kwargs
             )
         return f(*result.args, **result.kwargs)
 
@@ -114,7 +130,7 @@ class _InstallShims(ABCMeta):
     def __call__(self, *args: Any, **kwds: Any) -> Any:
         instance = super().__call__(*args, **kwds)
         instance.run = _shim_run(instance.run, instance.__class__)
-        instance.run_async = _shim_run(instance.run_async, instance.__class__)
+        instance.run_async = _shim_run_async(instance.run_async, instance.__class__)
         return instance
 
 

{shelltastic-0.8.0 → shelltastic-0.8.2}/src/shelltastic/backend/default/common.py

@@ -6,13 +6,14 @@ import time
 from io import RawIOBase
 from multiprocessing import Pipe
 from multiprocessing.connection import Connection
-from multiprocessing.pool import ThreadPool
 from pathlib import Path
+from threading import Thread
 from typing import IO, Literal
 
 from shelltastic import display
 from shelltastic.backend.base import ShellBackend
 from shelltastic.enum import CaptureMode, DisplayMode
+from shelltastic.exception import ShellClosedException
 from shelltastic.io import PipeReader
 from shelltastic.result import ShellResult, ShellResultAsync
 
@@ -90,24 +91,20 @@ class IOTimeoutStream:
 def _output_and_pipe(
     io: IO[bytes] | None, display: display.IODisplay | None, pipe: Connection | None
 ) -> None:
-    try:
-        if io is None:
-            return
-
-        if pipe:
-            if display:
-                for line in IOTimeoutStream(io):
-                    pipe.send_bytes(line)
-                    display.printbytes(line)
-            for line in IOTimeoutStream(io):
-                pipe.send_bytes(line)
+    if io is None:
+        return
 
+    if pipe:
         if display:
             for line in IOTimeoutStream(io):
+                pipe.send_bytes(line)
                 display.printbytes(line)
-    finally:
-        if pipe:
-            pipe.close()
+        for line in IOTimeoutStream(io):
+            pipe.send_bytes(line)
+
+    if display:
+        for line in IOTimeoutStream(io):
+            display.printbytes(line)
 
 
 def _determine_subprocess_output_mode(
@@ -168,7 +165,7 @@ class CommonShellAsyncResult(ShellResultAsync[RawIOBase | None, RawIOBase | None
         stderr_display: display.IODisplay | None,
         check: bool,
     ) -> None:
-        _display_pool = None
+        super().__init__(cmd)
         _stdout_async_result = None
         _stderr_async_result = None
 
@@ -176,66 +173,77 @@ class CommonShellAsyncResult(ShellResultAsync[RawIOBase | None, RawIOBase | None
             # If stdout is PIPE, then setup reader
             if stdout_capture == CaptureMode.PIPE:
                 stdout_rcv, stdout_snd = Pipe(False)
-                stdout = PipeReader(stdout_rcv)
+                self._stdout = PipeReader(stdout_rcv)
             else:
                 stdout_snd = None
-                stdout = None
+                self._stdout = None
 
             if stdout_snd or stdout_display:
-                if _display_pool is None:
-                    _display_pool = ThreadPool(2)
-
-                _stdout_async_result = _display_pool.apply_async(
-                    _output_and_pipe,
+                _stdout_async_result = Thread(
+                    target=_output_and_pipe,
                     args=[
                         popen.stdout,
                         stdout_display,
                         stdout_snd,
                     ],
                 )
+                _stdout_async_result.start()
         else:
-            stdout = None
+            self._stdout = None
 
         if popen.stderr:
             if stderr_capture == CaptureMode.PIPE:
                 stderr_rcv, stderr_snd = Pipe(False)
-                stderr = PipeReader(stderr_rcv)
+                self._stderr = PipeReader(stderr_rcv)
             else:
                 stderr_snd = None
-                stderr = None
+                self._stderr = None
 
             if stderr_snd or stderr_display:
-                if _display_pool is None:
-                    _display_pool = ThreadPool(2)
-
-                _stderr_async_result = _display_pool.apply_async(
-                    _output_and_pipe,
+                _stderr_async_result = Thread(
+                    target=_output_and_pipe,
                     args=[
                         popen.stderr,
                         stderr_display,
                         stderr_snd,
                     ],
                 )
+                _stderr_async_result.start()
         else:
-            stderr = None
-
-        super().__init__(cmd, stdout, stderr)
+            self._stderr = None
 
-        self._display_pool = _display_pool
         self._stdout_async_result = _stdout_async_result
         self._stderr_async_result = _stderr_async_result
         self._popen = popen
         self._check = check
+        self._closed = False
+
+    @property
+    def stdout(self) -> RawIOBase | None:
+        if self._closed:
+            raise ShellClosedException(f"{self} is closed")
+
+        return self._stdout
+
+    @property
+    def stderr(self) -> RawIOBase | None:
+        if self._closed:
+            raise ShellClosedException(f"{self} is closed")
+
+        return self._stderr
 
     def __exit__(self, exc_type, exc, tb):
-        # Wait for command to finish before closing everything
-        self.wait()
+        self.close()
+
+    def close(self) -> None:
+        if self._closed:
+            return
 
-        # Close popen
-        self._popen.__exit__(exc_type, exc, tb)
+        # Terminate popen
+        self._popen.terminate()
 
-        if self._display_pool:
-            self._display_pool.__exit__(exc_type, exc, tb)
+        # Wait for command to finish before closing everything
+        self.wait()
 
         # Close stdout and stderr
         if self.stdout is not None:
@@ -243,14 +251,19 @@ class CommonShellAsyncResult(ShellResultAsync[RawIOBase | None, RawIOBase | None
         if self.stderr is not None:
             self.stderr.close()
 
-    def close(self) -> None:
-        self.__exit__(None, None, None)
+        self._closed = True
 
     def terminate(self) -> None:
+        if self._closed:
+            raise ShellClosedException(f"{self} is closed")
+
         self._popen.terminate()
         self.close()
 
     def result(self) -> ShellResult[RawIOBase | None, RawIOBase | None]:
+        if self._closed:
+            raise ShellClosedException(f"{self} is closed")
+
         # Get result
         result = ShellResult(
             cmd=self.cmd,
@@ -261,10 +274,10 @@ class CommonShellAsyncResult(ShellResultAsync[RawIOBase | None, RawIOBase | None
 
         # Wait for our async readers to be complete
         if self._stdout_async_result:
-            self._stdout_async_result.wait()
+            self._stdout_async_result.join()
 
         if self._stderr_async_result:
-            self._stderr_async_result.wait()
+            self._stderr_async_result.join()
 
         # Check if set
         if self._check:

{shelltastic-0.8.0 → shelltastic-0.8.2}/src/shelltastic/exception.py

@@ -25,3 +25,7 @@ class ShellException(Exception):
         self.returncode = returncode
         self.stdout = stdout
         self.stderr = stderr
+
+
+class ShellClosedException(Exception):
+    pass

{shelltastic-0.8.0 → shelltastic-0.8.2}/src/shelltastic/result.py

@@ -18,12 +18,18 @@ class ShellResult[SO: RawIOBase | bytes | None, SE: RawIOBase | bytes | None]:
         """If returncode is not 0, raise ShellException"""
         if self.returncode != 0:
             result = self.to_result_bytes()
-            raise ShellException(self.cmd, self.returncode, result.stdout, result.stderr)
+            raise ShellException(
+                self.cmd, self.returncode, result.stdout, result.stderr
+            )
 
     def to_result_bytes(self) -> ShellResult[bytes | None, bytes | None]:
-        stdout = self.stdout.readall() if isinstance(self.stdout, RawIOBase) else self.stdout
+        stdout = (
+            self.stdout.readall() if isinstance(self.stdout, RawIOBase) else self.stdout
+        )
 
-        stderr = self.stderr.readall() if isinstance(self.stderr, RawIOBase) else self.stderr
+        stderr = (
+            self.stderr.readall() if isinstance(self.stderr, RawIOBase) else self.stderr
+        )
 
         return ShellResult(self.cmd, self.returncode, stdout, stderr)
 
@@ -39,15 +45,24 @@ class ShellResultAsync[SO: RawIOBase | None, SE: RawIOBase | None](ABC):
     stderr: Bytes stream for stderr
     """
 
-    def __init__(self, cmd: str | list[str], stdout: SO, stderr: SE) -> None:
+    def __init__(self, cmd: str | list[str]) -> None:
         self.cmd = cmd
         """The running command"""
 
-        self.stdout = stdout
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}({self.cmd})"
+
+    @property
+    @abstractmethod
+    def stdout(self) -> SO:
         """Byte based IO stream for stdout"""
+        raise NotImplementedError()
 
-        self.stderr = stderr
+    @property
+    @abstractmethod
+    def stderr(self) -> SE:
         """Byte based IO stream for stderr"""
+        raise NotImplementedError()
 
     def __enter__(self):
         return self