shelltastic 0.4.1__tar.gz → 0.4.2__tar.gz

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

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

shelltastic-0.4.2/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "shelltastic"
+version = "0.4.2"
+description = "A fantastic shell command runner for python"
+readme = "README.md"
+authors = [
+    { name = "Bearmine" }
+]
+license = "MPL-2.0"
+license-files = [
+    "LICENSE"
+]
+requires-python = ">=3.12"
+dependencies = []
+
+[project.urls]
+Repository = "https://forge.bearmine.com/bearmine/shelltastic"
+
+[build-system]
+requires = ["uv_build>=0.11.18,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.ruff.lint]
+extend-select = [
+    "F",        # Pyflakes rules
+    "W",        # PyCodeStyle warnings
+    "E",        # PyCodeStyle errors
+    "I",        # Sort imports properly
+    "UP",       # Warn if certain things can changed due to newer Python versions
+    "C4",       # Catch incorrect use of comprehensions, dict, list, etc
+    "FA",       # Enforce from __future__ import annotations
+    "ISC",      # Good use of string concatenation
+    "ICN",      # Use common import conventions
+    "RET",      # Good return practices
+    "SIM",      # Common simplification rules
+    "TID",      # Some good import practices
+    "TC",       # Enforce importing certain types in a TYPE_CHECKING block
+    "PTH",      # Use pathlib instead of os.path
+    "TD",       # Be diligent with TODO comments
+    "NPY",      # Some numpy-specific things
+    "FURB",     # Suggest more idiomatic Python patterns
+]
+
+[tool.ruff.lint.pycodestyle]
+max-line-length = 100

{shelltastic-0.4.1 → shelltastic-0.4.2}/src/shelltastic/backend/__init__.py

@@ -1,26 +1,24 @@
-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
+_default_local_backend: type[LocalShellBackend] = DefaultLocalBackend
+_default_remote_backend: type[RemoteShellBackend] = DefaultRemoteBackend
 
 
-def register_default_local_backend(backend: Type[LocalShellBackend]):
+def register_default_local_backend(backend: type[LocalShellBackend]):
     global _default_local_backend
     _default_local_backend = backend
 
 
-def register_default_remote_backend(backend: Type[RemoteShellBackend]):
+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
+    *, backend: type[LocalShellBackend] | None = None
 ) -> LocalShellBackend:
     if backend:
         return backend.local()
@@ -28,7 +26,7 @@ def get_local_backend(
 
 
 def get_remote_backend(
-    host: Host, *, backend: Type[RemoteShellBackend] | None = None
+    host: Host, *, backend: type[RemoteShellBackend] | None = None
 ) -> RemoteShellBackend:
     if backend:
         return backend.for_host(host)

{shelltastic-0.4.1 → shelltastic-0.4.2}/src/shelltastic/backend/base.py

@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from pathlib import Path
+from typing import TYPE_CHECKING
 
-from shelltastic.display import IODisplay
-from shelltastic.enum import CaptureMode, DisplayMode
-from shelltastic.host import Host
-from shelltastic.result import ShellResult
+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):

{shelltastic-0.4.1 → shelltastic-0.4.2}/src/shelltastic/backend/default/common.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
 import logging
-import pathlib
 import shlex
 import subprocess
 from multiprocessing.pool import ThreadPool
-from typing import IO, Literal
+from typing import IO, TYPE_CHECKING, Literal
 
 from shelltastic import display
 from shelltastic.backend.base import ShellBackend
 from shelltastic.enum import CaptureMode, DisplayMode
 from shelltastic.result import ShellResult
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 LOGGER = logging.getLogger(__name__)
 
 
@@ -23,67 +25,62 @@ def _output_and_collect(
 
     if collect:
         if display:
-            return_bytes = bytes()
+            return_bytes: bytes = b""
             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
+        return io.read()
+
+    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
+) -> int:
+    # If DisplayMode is None, we act like subprocess does
     if display_mode is None:
         if capture_mode == CaptureMode.PIPE:
             return subprocess.PIPE
-        elif capture_mode == CaptureMode.STDOUT:
+        if capture_mode == CaptureMode.STDOUT:
             return subprocess.STDOUT
-        elif capture_mode == CaptureMode.DEVNULL:
+        if capture_mode == CaptureMode.DEVNULL:
             return subprocess.DEVNULL
-        else:
-            assert capture_mode is None
-            return None
+        return subprocess.PIPE
 
     # Don't print
     if display_mode == DisplayMode.DEVNULL:
         if capture_mode == CaptureMode.PIPE:
             return subprocess.PIPE
-        elif capture_mode == CaptureMode.STDOUT:
+        if 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
+            # stderr
+            return subprocess.STDOUT
+        if capture_mode == CaptureMode.DEVNULL:
             return subprocess.DEVNULL
+        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:
+    if 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
+    if capture_mode == CaptureMode.DEVNULL:
         # We need to PIPE to be able to print the output
         return subprocess.PIPE
+    assert capture_mode is None
+    # We need to PIPE to be able to print the output
+    return subprocess.PIPE
 
 
 class CommonDefaultBackend(ShellBackend):
@@ -98,7 +95,7 @@ class CommonDefaultBackend(ShellBackend):
         stderr: CaptureMode | None = None,
         stdout_display: DisplayMode | display.IODisplay | None = None,
         stderr_display: DisplayMode | display.IODisplay | None = None,
-        cwd: str | pathlib.Path | None = None,
+        cwd: str | Path | None = None,
         echo_cmd: DisplayMode | display.IODisplay | bool | None = None,
         **kwargs,
     ) -> ShellResult:
@@ -106,19 +103,13 @@ class CommonDefaultBackend(ShellBackend):
             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
+        shell = isinstance(cmd, str)
 
         # 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
+            echo_cmd = DisplayMode.STDOUT if echo_cmd else DisplayMode.DEVNULL
 
         if echo_cmd is None:
             echo_cmd = DisplayMode.DEBUG_LOG
@@ -129,9 +120,9 @@ class CommonDefaultBackend(ShellBackend):
             echo_display = display.from_mode(echo_cmd)
 
         if isinstance(cmd, str):
-            echo_display.printline("%s> %s", cwd if cwd else "", cmd)
+            echo_display.printline("%s> %s", cwd or "", cmd)
         else:
-            echo_display.printline("%s> %s", cwd if cwd else "", shlex.join(cmd))
+            echo_display.printline("%s> %s", cwd or "", shlex.join(cmd))
 
         # Determine PIPE mode for stdout
         stdout_sub_mode = _determine_subprocess_output_mode(
@@ -143,51 +134,65 @@ class CommonDefaultBackend(ShellBackend):
             stderr, stderr_display, "stderr"
         )
 
+        if stdout_display is None:
+            stdout_display = (
+                DisplayMode.STDOUT if stdout is None else DisplayMode.DEVNULL
+            )
+
+        if stderr_display is None:
+            stderr_display = (
+                DisplayMode.STDERR if stderr is None else DisplayMode.DEVNULL
+            )
+
         # 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,
-                )
+        with (
+            subprocess.Popen(
+                cmd,
+                shell=shell,
+                stdout=stdout_sub_mode,
+                stderr=stderr_sub_mode,
+                cwd=cwd,
+            ) as popen,
+            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 isinstance(stdout_display, display.IODisplay)
+                        else display.from_mode(stdout_display)
+                    ),
+                    stdout is not None and stdout != CaptureMode.DEVNULL,
+                ],
+            )
+
+            # Print out and capture stderr
+            stderr_result = display_pool.apply_async(
+                _output_and_collect,
+                args=[
+                    popen.stderr,
+                    (
+                        stderr_display
+                        if isinstance(stderr_display, display.IODisplay)
+                        else display.from_mode(stderr_display)
+                    ),
+                    stderr is not None and stderr != CaptureMode.DEVNULL,
+                ],
+            )
+
+            # 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:

{shelltastic-0.4.1 → shelltastic-0.4.2}/src/shelltastic/backend/default/remote.py

@@ -1,14 +1,18 @@
 from __future__ import annotations
 
 import logging
-import pathlib
 import shlex
+from typing import TYPE_CHECKING
 
 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
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from shelltastic.host import Host
+    from shelltastic.result import ShellResult
 
 LOGGER = logging.getLogger(__name__)
 
@@ -27,7 +31,7 @@ class DefaultRemoteBackend(CommonDefaultBackend, RemoteShellBackend):
         cmd: str | list[str],
         *,
         subshell: bool = True,
-        cwd: str | pathlib.Path | None = None,
+        cwd: str | Path | None = None,
         **kwargs,
     ) -> ShellResult:
         """

{shelltastic-0.4.1 → shelltastic-0.4.2}/src/shelltastic/frontend/common.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generic, TypeVar, overload
+from typing import overload
 
 from shelltastic.host import Host
 
@@ -12,10 +12,8 @@ class RemoteFrontend(ABC):
         return self._host
 
 
-T = TypeVar("T", bound=RemoteFrontend)
 
-
-class RemoteFrontendFactory(Generic[T], ABC):
+class RemoteFrontendFactory[T: RemoteFrontend](ABC):
     __slots__ = ()
 
     @overload

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

@@ -58,8 +58,7 @@ class GitFrontend:
             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
+        return [i.strip() for i in result.stdout.decode().split("\n") if i.strip()]
 
     def set_global_config(self, key: str, value: str | list[str]):
         LOGGER.info(
@@ -89,10 +88,9 @@ class GitFrontend:
         )
         if response.returncode != 0:
             return []
-        else:
-            assert response.stdout is not None
-            gitcredentials = response.stdout.decode()
 
+        assert response.stdout is not None
+        gitcredentials = response.stdout.decode()
         return gitcredentials.splitlines()
 
 

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

@@ -2,14 +2,17 @@ from __future__ import annotations
 
 import shutil
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 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
+
+if TYPE_CHECKING:
+    from shelltastic.backend.base import ShellBackend
+    from shelltastic.display import IODisplay
+    from shelltastic.host import Host
+    from shelltastic.result import ShellResult
 
 
 class ShellFrontend:
@@ -35,9 +38,7 @@ class ShellFrontend:
             stdout=CaptureMode.DEVNULL,
             stderr=CaptureMode.DEVNULL,
         )
-        if result.returncode == 0:
-            return True
-        return False
+        return result.returncode == 0
 
     def home_dir(self) -> Path:
         """Return the path to the current user's home directory"""

{shelltastic-0.4.1 → shelltastic-0.4.2}/src/shelltastic/host.py

@@ -10,5 +10,4 @@ class Host:
     def host_specifier(self):
         if self.username:
             return f"{self.username}@{self.hostname}"
-        else:
-            return self.hostname
+        return self.hostname

shelltastic-0.4.1/pyproject.toml

@@ -1,21 +0,0 @@
-[project]
-name = "shelltastic"
-version = "0.4.1"
-description = "A fantastic shell command runner for python"
-readme = "README.md"
-authors = [
-    { name = "Bearmine" }
-]
-license = "MPL-2.0"
-license-files = [
-    "LICENSE"
-]
-requires-python = ">=3.12"
-dependencies = []
-
-[project.urls]
-Repository = "https://forge.bearmine.com/bearmine/shelltastic"
-
-[build-system]
-requires = ["uv_build>=0.11.18,<0.12.0"]
-build-backend = "uv_build"