shelltastic 0.8.1__tar.gz → 0.9.0__tar.gz

{shelltastic-0.8.1 → shelltastic-0.9.0}/PKG-INFO

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

shelltastic-0.9.0/pyproject.toml

@@ -0,0 +1,59 @@
+[project]
+name = "shelltastic"
+version = "0.9.0"
+description = "A fantastic shell command runner for python"
+readme = "README.md"
+license = "MPL-2.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = []
+
+[[project.authors]]
+name = "Bearmine"
+
+[project.urls]
+Repository = "https://forge.bearmine.com/bearmine/shelltastic"
+
+[dependency-groups]
+lint = ["ruff"]
+test = [
+    "pytest",
+    "pytest-cov>=7.1.0",
+]
+
+[[dependency-groups.dev]]
+include-group = "lint"
+
+[[dependency-groups.dev]]
+include-group = "test"
+
+[build-system]
+requires = ["uv_build>=0.11.18,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.ruff.lint]
+extend-select = [
+    "F",
+    "W",
+    "E",
+    "I",
+    "UP",
+    "C4",
+    "FA",
+    "ISC",
+    "ICN",
+    "RET",
+    "SIM",
+    "TID",
+    "TC",
+    "PTH",
+    "TD",
+    "NPY",
+    "FURB",
+]
+
+[tool.ruff.lint.pycodestyle]
+max-line-length = 100
+
+[tool.pytest.ini_options]
+addopts = "--cov=shelltastic --cov-report html"

shelltastic-0.8.1/pyproject.toml → shelltastic-0.9.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "shelltastic"
-version = "0.8.1"
+version = "0.9.0"
 description = "A fantastic shell command runner for python"
 readme = "README.md"
 authors = [
@@ -13,6 +13,19 @@ license-files = [
 requires-python = ">=3.12"
 dependencies = []
 
+[dependency-groups]
+dev = [
+  {include-group = "lint"},
+  {include-group = "test"},
+]
+lint = [
+  "ruff"
+]
+test = [
+  "pytest",
+  "pytest-cov>=7.1.0"
+]
+
 [project.urls]
 Repository = "https://forge.bearmine.com/bearmine/shelltastic"
 
@@ -44,14 +57,5 @@ extend-select = [
 [tool.ruff.lint.pycodestyle]
 max-line-length = 100
 
-[dependency-groups]
-dev = [
-  {include-group = "lint"},
-  {include-group = "test"}
-]
-lint = [
-  "ruff"
-]
-test = [
-  "pytest"
-]
+[tool.pytest.ini_options]
+addopts = "--cov=shelltastic --cov-report html"

{shelltastic-0.8.1 → shelltastic-0.9.0}/src/shelltastic/backend/default/common.py

@@ -1,3 +1,4 @@
+import contextlib
 import logging
 import os
 import shlex
@@ -6,13 +7,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 +92,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 +166,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,81 +174,100 @@ 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
 
-    def __exit__(self, exc_type, exc, tb):
-        # Wait for command to finish before closing everything
-        self.wait()
+    @property
+    def stdout(self) -> RawIOBase | None:
+        if self._closed:
+            raise ShellClosedException(f"{self} is closed")
 
-        # Close popen
-        self._popen.__exit__(exc_type, exc, tb)
+        return self._stdout
 
-        if self._display_pool:
-            self._display_pool.__exit__(exc_type, exc, tb)
+    @property
+    def stderr(self) -> RawIOBase | None:
+        if self._closed:
+            raise ShellClosedException(f"{self} is closed")
 
-        # Close stdout and stderr
-        if self.stdout is not None:
-            self.stdout.close()
-        if self.stderr is not None:
-            self.stderr.close()
+        return self._stderr
 
-    def close(self) -> None:
-        self.__exit__(None, None, None)
+    def __exit__(self, exc_type, exc, tb):
+        with contextlib.suppress(KeyboardInterrupt, subprocess.TimeoutExpired):
+            self.close()
+
+    def close(self, timeout: float | None = None) -> None:
+        if self._closed:
+            return
+
+        # Wait for command to finish before closing everything
+        try:
+            self._popen.wait(timeout)
+        except (KeyboardInterrupt, subprocess.TimeoutExpired):
+            # Kill the process and then reraise
+            self._popen.kill()
+            LOGGER.error("pid %s killed", self._popen.pid)
+            raise
+        finally:
+            # Close stdout and stderr
+            if self.stdout is not None:
+                self.stdout.close()
+            if self.stderr is not None:
+                self.stderr.close()
+
+            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 +278,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.1 → shelltastic-0.9.0}/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.1 → shelltastic-0.9.0}/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