speedtest-ssh 2.6.0__tar.gz → 2.6.2__tar.gz

{speedtest_ssh-2.6.0/speedtest_ssh.egg-info → speedtest_ssh-2.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: speedtest_ssh
-Version: 2.6.0
+Version: 2.6.2
 Summary: A tool meant to check inter-device speeds via ssh
 License: GPL
 Project-URL: Homepage, https://github.com/zwimer/speedtest_ssh

speedtest_ssh-2.6.2/speedtest_ssh/_version.py

@@ -0,0 +1 @@
+__version__: str = "2.6.2"

{speedtest_ssh-2.6.0 → speedtest_ssh-2.6.2}/speedtest_ssh/data_transfer.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
+from subprocess import CalledProcessError, PIPE
 from typing import TYPE_CHECKING
 from datetime import datetime
 from pathlib import Path
-import subprocess
 import random
 import string
-import shlex
 import re
 import os
 
 from tqdm import tqdm
 
 from .sftp_wrapper import sftp_wrapper
+from .util import find_exe, run_cmd
 from .config import Config
-from .util import find_exe
 
 if TYPE_CHECKING:
     from paramiko import SFTPClient
@@ -52,20 +51,26 @@ class DataTransfer:
         :param config: The Config object the DataTransfer instance should use
         :param verbose: If true, be more verbose
         """
+        self._verbose = verbose
         rand = lambda: random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits)
         self._remote_f: str = f"/tmp/speedtest-ssh_{datetime.now()}_{''.join(rand() for _ in range(8))}.tmp"
         self._remote_f = self._remote_f.replace(":", "-").replace(" ", "_")
         # We promise that _remote_f components match: ^[a-zA-Z\d_.-]+$ (old rsync args suck)
+        if self._verbose:
+            print("Parsing ssh config and loading keys...")
         self._sftp_cm = sftp_wrapper(config)
         self._sftp: SFTPClient  # Defined in __enter__
-        self._verbose = verbose
 
     def __enter__(self) -> DataTransfer:
+        if self._verbose:
+            print("Establishing SFTP connection...")
         self._sftp = self._sftp_cm.__enter__()
         return self
 
     def __exit__(self, *args, **kwargs):
         self.clean_remote()
+        if self._verbose:
+            print("Terminating SFTP connection...")
         self._sftp_cm.__exit__(*args, **kwargs)
 
     def put(self, local: Path) -> None:
@@ -85,6 +90,8 @@ class DataTransfer:
         Removes the remote file
         """
         try:
+            if self._verbose:
+                print(f"Removing remote file (if it exists): {self._remote_f}")
             self._sftp.remove(self._remote_f)
         except FileNotFoundError:
             pass
@@ -120,13 +127,13 @@ class Rsync(DataTransfer):
         self._rsync = find_exe("rsync")
         # Determine rsync version
         try:
-            output: str = self._run(self._rsync, "--version", stdout=subprocess.PIPE, check=True).stdout.decode()
-            output = output.split("version")[1].split("protocol")[0].strip()
+            p = run_cmd(self._rsync, "--version", verbose=self._verbose, stdout=PIPE, check=True)
+            output = p.stdout.decode().split("version")[1].split("protocol")[0].strip()
             version: tuple[int, ...] = tuple(int(i) for i in output.split("."))
             self._old = version <= (3, 1, 0)  # macOS has an old version by default
             if self._old:
                 print("\tOld version of rsync detected. Output will be more verbose.")
-        except (subprocess.CalledProcessError, KeyError) as e:
+        except (CalledProcessError, KeyError) as e:
             raise RuntimeError(f"Could not determine rsync version from {self._rsync}") from e
         # Determine rsync command
         self._flags: list[str | Path] = []
@@ -143,21 +150,14 @@ class Rsync(DataTransfer):
         # Determine host info
         self._target: str = ("" if config.user is None else f"{config.user}@") + f"{config.host}:{self._remote_f}"
 
-    def _run(self, cmd: Path, *args: str | Path, **kwargs) -> subprocess.CompletedProcess:
-        full = (cmd, *args)
-        if self._verbose:
-            msg = f"{'*'*30} Running Command: {cmd.name} {'*'*30}"
-            print(f"{msg}\n{' '.join(shlex.quote(str(i)) for i in full)}\n{'*'*len(msg)}")
-        return subprocess.run(full, **kwargs)
-
     def _transfer(self, src: str | Path, dst: str | Path) -> None:
         """
         :param src: The file to rsync to dst
         :param dst: The location to rsync src to
         """
         try:
-            _ = self._run(self._rsync, *self._flags, src, dst, env=self._env, check=True)
-        except subprocess.CalledProcessError as e:
+            _ = run_cmd(self._rsync, *self._flags, src, dst, verbose=self._verbose, env=self._env, check=True)
+        except CalledProcessError as e:
             raise RuntimeError("Failed to transfer data during speed test") from e
 
     def put(self, local: Path) -> None:

speedtest_ssh-2.6.2/speedtest_ssh/ping.py

@@ -0,0 +1,38 @@
+from subprocess import CalledProcessError, PIPE
+from sys import platform
+
+from .util import find_exe, run_cmd
+
+
+__all__ = ("PingFailed", "ping")
+
+
+class PingFailed(RuntimeError):
+    """
+    Raise on ping failure
+    """
+
+
+def ping(host: str, verbose: bool, n_pings: int = 10, max_wait: int = 3) -> float:
+    """
+    :param host: The host to ping
+    :return: The number Ping host
+    """
+    # We use subprocess b/c ping is suid and we don't want to require root
+    print("Pinging...")
+    exe = find_exe("ping")
+    try:
+        wait: str = ("-W" if platform == "darwin" else "-w") + str(max_wait)
+        q = [] if verbose else ["-q"]
+        p = run_cmd(exe, "-i.1", f"-c{n_pings}", wait, *q, host, verbose=verbose, stdout=PIPE)
+        if p.returncode:
+            raise PingFailed(f"{exe} exit code: {p.returncode}")
+        output: str = p.stdout.decode().strip()
+    except CalledProcessError as e:
+        raise PingFailed("Unkown error") from e
+    if verbose:
+        print(output)
+    try:
+        return float(output.split("/")[-3])
+    except IndexError as e:
+        raise PingFailed("Bad output", output) from e

{speedtest_ssh-2.6.0 → speedtest_ssh-2.6.2}/speedtest_ssh/util.py

@@ -1,8 +1,13 @@
 from pathlib import Path
 from shutil import which
+import subprocess
+import shlex
 import os
 
 
+__all__ = ("find_exe", "run_cmd")
+
+
 def find_exe(name: str) -> Path:
     """
     :param name: The name of the executable to find
@@ -15,3 +20,11 @@ def find_exe(name: str) -> Path:
     if not os.access(exe, os.X_OK):
         raise RuntimeError(f"Cannot find valid {name} executable")
     return exe
+
+
+def run_cmd(cmd: Path, *args: str | Path, verbose: bool, **kwargs) -> subprocess.CompletedProcess:
+    full = (cmd, *args)
+    if verbose:
+        msg = f"{'*'*30} Running Command: {cmd.name} {'*'*30}"
+        print(f"{msg}\n{' '.join(shlex.quote(str(i)) for i in full)}\n{'*'*len(msg)}")
+    return subprocess.run(full, **kwargs)

{speedtest_ssh-2.6.0 → speedtest_ssh-2.6.2/speedtest_ssh.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: speedtest_ssh
-Version: 2.6.0
+Version: 2.6.2
 Summary: A tool meant to check inter-device speeds via ssh
 License: GPL
 Project-URL: Homepage, https://github.com/zwimer/speedtest_ssh

speedtest_ssh-2.6.0/speedtest_ssh/_version.py

@@ -1 +0,0 @@
-__version__: str = "2.6.0"

speedtest_ssh-2.6.0/speedtest_ssh/ping.py

@@ -1,41 +0,0 @@
-from typing import TYPE_CHECKING
-from sys import platform
-import subprocess
-
-from .util import find_exe
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-class PingFailed(RuntimeError):
-    """
-    Raise on ping failure
-    """
-
-
-def ping(host: str, verbose: bool, n_pings: int = 10, max_wait: int = 3) -> float:
-    """
-    :param host: The host to ping
-    :return: The number Ping host
-    """
-    # We use subprocess b/c ping is suid and we don't want to require root
-    print("Pinging...")
-    cmd: tuple[Path | str, ...] = (
-        find_exe("ping"),
-        "-i.1",
-        f"-c{n_pings}",
-        ("-W" if platform == "darwin" else "-w") + str(max_wait),
-        *([] if verbose else ["-q"]),
-        host,
-    )
-    try:
-        output: str = subprocess.check_output(cmd).decode().strip()
-    except subprocess.CalledProcessError as e:
-        raise PingFailed("Non-zero exit code") from e
-    if verbose:
-        print(output)
-    try:
-        return float(output.split("/")[-3])
-    except IndexError as e:
-        raise PingFailed("Bad output", output) from e