shelltastic 0.2.2__tar.gz → 0.3.0__tar.gz

{shelltastic-0.2.2 → shelltastic-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shelltastic
-Version: 0.2.2
+Version: 0.3.0
 Summary: A fantastic shell command runner for python
 Author: Bearmine
 License-Expression: MPL-2.0
@@ -43,3 +43,20 @@ shell.host("example.com").run("echo Hello World!")
 # Specifying Username and Port
 shell.host("example.com", username="root", port=22).run("echo Hello World!")
 ```
+
+To copy files to/from hosts use the scp frontend:
+
+```python
+from shelltastic import scp
+
+scp.host("example.com").send(...)
+scp.host("example.com").receive(...)
+```
+
+To interact with git, there's a git frontend:
+
+```python
+from shelltastic import git
+
+git.clone(...)
+```

{shelltastic-0.2.2 → shelltastic-0.3.0}/README.md

@@ -32,3 +32,20 @@ shell.host("example.com").run("echo Hello World!")
 # Specifying Username and Port
 shell.host("example.com", username="root", port=22).run("echo Hello World!")
 ```
+
+To copy files to/from hosts use the scp frontend:
+
+```python
+from shelltastic import scp
+
+scp.host("example.com").send(...)
+scp.host("example.com").receive(...)
+```
+
+To interact with git, there's a git frontend:
+
+```python
+from shelltastic import git
+
+git.clone(...)
+```

{shelltastic-0.2.2 → shelltastic-0.3.0}/pyproject.toml

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

{shelltastic-0.2.2 → shelltastic-0.3.0}/src/shelltastic/__init__.py

@@ -1,7 +1,9 @@
+from shelltastic.frontend.git import LocalGitFrontend
 from shelltastic.frontend.scp import SCP
 from shelltastic.frontend.shell import LocalShellFrontend
 
-__all__ = ["shell", "scp"]
+__all__ = ["shell", "scp", "git"]
 
 shell = LocalShellFrontend()
 scp = SCP()
+git = LocalGitFrontend()

{shelltastic-0.2.2 → shelltastic-0.3.0}/src/shelltastic/backend/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import logging
 import pathlib
 import shlex
@@ -13,6 +14,8 @@ LOGGER = logging.getLogger(__name__)
 
 
 class LocalShellBackend(ShellBackend):
+    __slots__ = ()
+
     def run(
         self,
         cmd: str | list[str],
@@ -78,10 +81,7 @@ class SSHConnectionError(Exception):
 
 
 class SSHShellBackend(LocalShellBackend, RemoteShellBackend):
-    def __init__(
-        self,
-        host: Host
-    ) -> None:
+    def __init__(self, host: Host) -> None:
         super().__init__()
         self.host: Host = host
 
@@ -89,8 +89,6 @@ class SSHShellBackend(LocalShellBackend, RemoteShellBackend):
     def for_host(host: Host) -> RemoteShellBackend:
         return SSHShellBackend(host)
 
-
-
     def run(
         self,
         cmd: str | list[str],

shelltastic-0.3.0/src/shelltastic/frontend/common.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar, overload
+
+from shelltastic.host import Host
+
+
+class RemoteFrontend(ABC):
+    def __init__(self, host: Host) -> None:
+        self._host = host
+
+    def host(self) -> Host:
+        return self._host
+
+
+T = TypeVar("T", bound=RemoteFrontend)
+
+
+class RemoteFrontendFactory(Generic[T], ABC):
+    __slots__ = ()
+
+    @overload
+    def host(self, host_or_hostname: Host) -> T: ...
+    @overload
+    def host(
+        self,
+        host_or_hostname: str,
+        *,
+        username: str | None = None,
+        port: int | None = None,
+    ) -> T: ...
+    def host(
+        self,
+        host_or_hostname: str | Host,
+        *,
+        username: str | None = None,
+        port: int | None = None,
+    ) -> T:
+        if isinstance(host_or_hostname, Host):
+            host = host_or_hostname
+        else:
+            host = Host(host_or_hostname, port, username)
+        return self._create_remote_frontend(host)
+
+    @abstractmethod
+    def _create_remote_frontend(self, host: Host) -> T:
+        raise NotImplementedError()

shelltastic-0.3.0/src/shelltastic/frontend/git.py

@@ -0,0 +1,111 @@
+import logging
+from pathlib import Path
+from typing import overload
+
+from shelltastic.backend import LocalShellBackend, SSHShellBackend
+from shelltastic.backend.base import ShellBackend
+from shelltastic.enum import OutputMode
+from shelltastic.frontend.common import RemoteFrontend, RemoteFrontendFactory
+from shelltastic.host import Host
+
+LOGGER = logging.getLogger(__name__)
+
+
+class GitFrontend:
+    def __init__(self, backend: ShellBackend) -> None:
+        self._backend = backend
+
+    def clone(self, repo_url: str, target_location: str | Path):
+        LOGGER.info("Cloning %s into directory %s", repo_url, target_location)
+        self._backend.run(["git", "clone", repo_url, str(target_location)])
+
+    def pull(self, repo_path: str | Path, remote: str = "origin"):
+        LOGGER.info("Pulling %s for repo %s", remote, repo_path)
+        self._backend.run(["git", "pull", remote], cwd=repo_path)
+
+    def get_remote_url(self, repo_path: str | Path, remote: str = "origin") -> str:
+        result = self._backend.run(
+            ["git", "remote", "get-url", remote],
+            stdout=OutputMode.CAPTURE,
+            cwd=repo_path,
+        )
+        return result.stdout.decode().strip()
+
+    def set_remote_url(
+        self, repo_path: str | Path, repo_url: str, remote: str = "origin"
+    ):
+        self._backend.run(
+            ["git", "remote", "set-url", remote, repo_url],
+            cwd=repo_path,
+        )
+
+    @overload
+    def global_config(self, key: str) -> list[str]: ...
+    @overload
+    def global_config(self, key: str, value: str | list[str]) -> None: ...
+    def global_config(self, key: str, value: str | list[str] | None = None):
+        if value is not None:
+            return self.set_global_config(key, value)
+        return self.get_global_config(key)
+
+    def get_global_config(self, key: str) -> list[str]:
+        LOGGER.info("Getting git config %s", key)
+        result = self._backend.run(
+            ["git", "config", "--global", "--get-all", key],
+            check=False,
+            stdout=OutputMode.CAPTURE,
+            stderr=OutputMode.CAPTURE,
+        )
+        configs = [i.strip() for i in result.stdout.decode().split("\n") if i.strip()]
+        return configs
+
+    def set_global_config(self, key: str, value: str | list[str]):
+        LOGGER.info(
+            "Setting git config %s to %s",
+            key,
+            value,
+        )
+        self._backend.run(
+            ["git", "config", "unset", "--global", "--all", key],
+            check=False,
+            stdout=OutputMode.CAPTURE,
+            stderr=OutputMode.CAPTURE,
+        )
+        if isinstance(value, str):
+            value = [value]
+        for v in value:
+            self._backend.run(
+                ["git", "config", "set", "--global", "--append", key, v], check=True
+            )
+
+    def git_credentials(self) -> list[str]:
+        response = self._backend.run(
+            "cat ~/.git-credentials",
+            check=False,
+            stdout=OutputMode.CAPTURE,
+            stderr=OutputMode.DEVNULL,
+        )
+        if response.returncode != 0:
+            return []
+        else:
+            gitcredentials = response.stdout.decode()
+
+        return gitcredentials.splitlines()
+
+
+class RemoteGitFrontend(GitFrontend, RemoteFrontend):
+    __slots__ = ()
+
+    def __init__(self, host: Host) -> None:
+        super().__init__(SSHShellBackend.for_host(host))
+        super(GitFrontend, self).__init__(host)
+
+
+class LocalGitFrontend(GitFrontend, RemoteFrontendFactory[RemoteGitFrontend]):
+    __slots__ = ()
+
+    def __init__(self) -> None:
+        super().__init__(LocalShellBackend())
+
+    def _create_remote_frontend(self, host: Host) -> RemoteGitFrontend:
+        return RemoteGitFrontend(host)

{shelltastic-0.2.2 → shelltastic-0.3.0}/src/shelltastic/frontend/scp.py

@@ -3,18 +3,17 @@ from pathlib import Path
 
 from shelltastic.backend import LocalShellBackend, SSHShellBackend
 from shelltastic.enum import OutputMode
+from shelltastic.frontend.common import RemoteFrontend, RemoteFrontendFactory
 from shelltastic.host import Host
 
 LOGGER = logging.getLogger(__name__)
 
-class SCPFrontend:
+
+class SCPFrontend(RemoteFrontend):
     def __init__(self, host: Host) -> None:
+        super().__init__(host)
         self._local_backend = LocalShellBackend()
         self._remote_backend = SSHShellBackend(host)
-        self._host = host
-
-    def host(self) -> Host:
-        return self._host
 
     def _scp_flags(self, recursive) -> list[str]:
         # Set Port
@@ -26,7 +25,7 @@ class SCPFrontend:
 
         return flags
 
-    def scp_send(
+    def send(
         self,
         source_path: str,
         destination_path: str,
@@ -67,7 +66,7 @@ class SCPFrontend:
             LOGGER.info("chmod %s to %s", dest, mode)
             self._remote_backend.run(["chmod", mode, destination_path])
 
-    def scp_receive(
+    def receive(
         self,
         source_path: str,
         destination_path: str,
@@ -100,16 +99,9 @@ class SCPFrontend:
             LOGGER.info("chmod %s to %s", destination_path, mode)
             self._remote_backend.run(["chmod", mode, destination_path])
 
-class SCP():
-    def host(
-        self,
-        host_or_hostname: str | Host,
-        *,
-        username: str | None = None,
-        port: int | None = None,
-    ) -> SCPFrontend:
-        if isinstance(host_or_hostname, Host):
-            host = host_or_hostname
-        else:
-            host = Host(host_or_hostname, port, username)
-        return SCPFrontend(host)
+
+class SCP(RemoteFrontendFactory[SCPFrontend]):
+    __slots__ = ()
+
+    def _create_remote_frontend(self, host: Host) -> SCPFrontend:
+        return SCPFrontend(host)

{shelltastic-0.2.2 → shelltastic-0.3.0}/src/shelltastic/frontend/shell.py

@@ -7,6 +7,7 @@ from subprocess import CompletedProcess
 from shelltastic.backend import LocalShellBackend, SSHShellBackend
 from shelltastic.backend.base import ShellBackend
 from shelltastic.enum import OutputMode, SystemType
+from shelltastic.frontend.common import RemoteFrontend, RemoteFrontendFactory
 from shelltastic.host import Host
 
 
@@ -79,21 +80,21 @@ class ShellFrontend:
         )
 
 
-class LocalShellFrontend(ShellFrontend):
+class RemoteShellFrontend(ShellFrontend, RemoteFrontend):
+    __slots__ = ()
+
+    def __init__(self, host: Host) -> None:
+        super().__init__(SSHShellBackend.for_host(host))
+        super(ShellFrontend, self).__init__(host)
+
+
+class LocalShellFrontend(ShellFrontend, RemoteFrontendFactory[RemoteShellFrontend]):
+    __slots__ = ()
+
     def __init__(self) -> None:
         super().__init__(LocalShellBackend())
 
-    def host(
-        self,
-        host_or_hostname: str | Host,
-        *,
-        username: str | None = None,
-        port: int | None = None,
-    ) -> RemoteShellFrontend:
-        if isinstance(host_or_hostname, Host):
-            host = host_or_hostname
-        else:
-            host = Host(host_or_hostname, port, username)
+    def _create_remote_frontend(self, host: Host) -> RemoteShellFrontend:
         return RemoteShellFrontend(host)
 
     def which(self, command: str) -> Path | None:
@@ -101,12 +102,3 @@ class LocalShellFrontend(ShellFrontend):
         if result:
             return Path(result)
         return None
-
-
-class RemoteShellFrontend(ShellFrontend):
-    def __init__(self, host: Host) -> None:
-        super().__init__(SSHShellBackend.for_host(host))
-        self._host = host
-
-    def host(self) -> Host:
-        return self._host

{shelltastic-0.2.2 → shelltastic-0.3.0}/src/shelltastic/host.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 
 
-@dataclass
+@dataclass(slots=True)
 class Host:
     hostname: str
     port: int | None