rclone-api 1.0.46__tar.gz → 1.0.48__tar.gz

{rclone_api-1.0.46 → rclone_api-1.0.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.0.46
+Version: 1.0.48
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 Maintainer: Zachary Vorhies

{rclone_api-1.0.46 → rclone_api-1.0.48}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
     "python-dotenv>=1.0.0",
 ]
 # Change this with the version number bump.
-version = "1.0.46"
+version = "1.0.48"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

rclone_api-1.0.48/src/rclone_api/completed_process.py

@@ -0,0 +1,49 @@
+import subprocess
+from dataclasses import dataclass
+
+
+@dataclass
+class CompletedProcess:
+    completed: list[subprocess.CompletedProcess]
+
+    @property
+    def ok(self) -> bool:
+        return all([p.returncode == 0 for p in self.completed])
+
+    @staticmethod
+    def from_subprocess(process: subprocess.CompletedProcess) -> "CompletedProcess":
+        return CompletedProcess(completed=[process])
+
+    def failed(self) -> list[subprocess.CompletedProcess]:
+        return [p for p in self.completed if p.returncode != 0]
+
+    def successes(self) -> list[subprocess.CompletedProcess]:
+        return [p for p in self.completed if p.returncode == 0]
+
+    @property
+    def stdout(self) -> str:
+        tmp: list[str] = []
+        for cp in self.completed:
+            stdout = cp.stdout
+            if stdout is not None:
+                tmp.append(stdout)
+        return "\n".join(tmp)
+
+    @property
+    def stderr(self) -> str:
+        tmp: list[str] = []
+        for cp in self.completed:
+            stderr = cp.stderr
+            if stderr is not None:
+                tmp.append(stderr)
+        return "\n".join(tmp)
+
+    @property
+    def returncode(self) -> int | None:
+        for cp in self.completed:
+            rtn = cp.returncode
+            if rtn is None:
+                return None
+            if rtn != 0:
+                return rtn
+        return 0

{rclone_api-1.0.46 → rclone_api-1.0.48}/src/rclone_api/exec.py

@@ -13,11 +13,15 @@ class RcloneExec:
     rclone_config: Path | Config
     rclone_exe: Path
 
-    def execute(self, cmd: list[str], check: bool) -> subprocess.CompletedProcess:
+    def execute(
+        self, cmd: list[str], check: bool, capture: bool | None = None
+    ) -> subprocess.CompletedProcess:
         """Execute rclone command."""
         from rclone_api.util import rclone_execute
 
-        return rclone_execute(cmd, self.rclone_config, self.rclone_exe, check=check)
+        return rclone_execute(
+            cmd, self.rclone_config, self.rclone_exe, check=check, capture=capture
+        )
 
     def launch_process(self, cmd: list[str], capture: bool | None) -> Process:
         """Launch rclone process."""

{rclone_api-1.0.46 → rclone_api-1.0.48}/src/rclone_api/rclone.py

@@ -57,8 +57,10 @@ class Rclone:
                 raise ValueError(f"Rclone config file not found: {rclone_conf}")
         self._exec = RcloneExec(rclone_conf, get_rclone_exe(rclone_exe))
 
-    def _run(self, cmd: list[str], check: bool = True) -> subprocess.CompletedProcess:
-        return self._exec.execute(cmd, check=check)
+    def _run(
+        self, cmd: list[str], check: bool = True, capture: bool | None = None
+    ) -> subprocess.CompletedProcess:
+        return self._exec.execute(cmd, check=check, capture=capture)
 
     def _launch_process(self, cmd: list[str], capture: bool | None = None) -> Process:
         return self._exec.launch_process(cmd, capture=capture)
@@ -70,6 +72,47 @@ class Rclone:
             cmd += other_args
         return self._launch_process(cmd, capture=False)
 
+    def launch_server(
+        self,
+        addr: str | None = None,
+        user: str | None = None,
+        password: str | None = None,
+        other_args: list[str] | None = None,
+    ) -> Process:
+        """Launch the Rclone server so it can receive commands"""
+        cmd = ["rcd"]
+        if addr is not None:
+            cmd += ["--rc-addr", addr]
+        if user is not None:
+            cmd += ["--rc-user", user]
+        if password is not None:
+            cmd += ["--rc-pass", password]
+        if other_args:
+            cmd += other_args
+        out = self._launch_process(cmd, capture=False)
+        time.sleep(1)  # Give it some time to launch
+        return out
+
+    def remote_control(
+        self,
+        addr: str,
+        user: str | None = None,
+        password: str | None = None,
+        capture: bool | None = None,
+        other_args: list[str] | None = None,
+    ) -> CompletedProcess:
+        cmd = ["rc"]
+        if addr:
+            cmd += ["--rc-addr", addr]
+        if user is not None:
+            cmd += ["--rc-user", user]
+        if password is not None:
+            cmd += ["--rc-pass", password]
+        if other_args:
+            cmd += other_args
+        cp = self._run(cmd, capture=capture)
+        return CompletedProcess.from_subprocess(cp)
+
     def obscure(self, password: str) -> str:
         """Obscure a password for use in rclone config files."""
         cmd_list: list[str] = ["obscure", password]
@@ -218,7 +261,13 @@ class Rclone:
         cmd_list: list[str] = ["copyto", src, dst]
         self._run(cmd_list)
 
-    def copy_to(self, src: File | str, dst: File | str) -> None:
+    def copy_to(
+        self,
+        src: File | str,
+        dst: File | str,
+        check=True,
+        other_args: list[str] | None = None,
+    ) -> None:
         """Copy multiple files from source to destination.
 
         Warning - slow.
@@ -229,9 +278,16 @@ class Rclone:
         src = str(src)
         dst = str(dst)
         cmd_list: list[str] = ["copyto", src, dst]
-        self._run(cmd_list)
+        if other_args is not None:
+            cmd_list += other_args
+        self._run(cmd_list, check=check)
 
-    def copyfiles(self, files: str | File | list[str] | list[File], check=True) -> None:
+    def copyfiles(
+        self,
+        files: str | File | list[str] | list[File],
+        check=True,
+        other_args: list[str] | None = None,
+    ) -> list[CompletedProcess]:
         """Copy multiple files from source to destination.
 
         Warning - slow.
@@ -241,10 +297,11 @@ class Rclone:
         """
         payload: list[str] = convert_to_filestr_list(files)
         if len(payload) == 0:
-            return
+            return []
 
         datalists: dict[str, list[str]] = group_files(payload)
-        out: subprocess.CompletedProcess | None = None
+        # out: subprocess.CompletedProcess | None = None
+        out: list[CompletedProcess] = []
 
         futures: list[Future] = []
 
@@ -257,7 +314,7 @@ class Rclone:
 
                     # print(include_files_txt)
                     cmd_list: list[str] = [
-                        "delete",
+                        "copy",
                         remote,
                         "--files-from",
                         str(include_files_txt),
@@ -266,19 +323,23 @@ class Rclone:
                         "--transfers",
                         "1000",
                     ]
+                    if other_args is not None:
+                        cmd_list += other_args
                     out = self._run(cmd_list)
                     return out
 
             fut: Future = EXECUTOR.submit(_task)
             futures.append(fut)
         for fut in futures:
-            out = fut.result()
-            assert out is not None
-            if out.returncode != 0:
+            cp: subprocess.CompletedProcess = fut.result()
+            assert cp is not None
+            out.append(CompletedProcess.from_subprocess(cp))
+            if cp.returncode != 0:
                 if check:
-                    raise ValueError(f"Error deleting files: {out.stderr}")
+                    raise ValueError(f"Error deleting files: {cp.stderr}")
                 else:
-                    warnings.warn(f"Error deleting files: {out.stderr}")
+                    warnings.warn(f"Error deleting files: {cp.stderr}")
+        return out
 
     def copy(self, src: Dir | str, dst: Dir | str) -> CompletedProcess:
         """Copy files from source to destination.

{rclone_api-1.0.46 → rclone_api-1.0.48}/src/rclone_api/util.py

@@ -78,10 +78,12 @@ def rclone_execute(
     rclone_conf: Path | Config,
     rclone_exe: Path,
     check: bool,
+    capture: bool | None = None,
     verbose: bool | None = None,
 ) -> subprocess.CompletedProcess:
     tempdir: TemporaryDirectory | None = None
     verbose = get_verbose(verbose)
+    capture = capture if isinstance(capture, bool) else True
     assert verbose is not None
 
     try:
@@ -97,7 +99,7 @@ def rclone_execute(
             cmd_str = subprocess.list2cmdline(cmd)
             print(f"Running: {cmd_str}")
         cp = subprocess.run(
-            cmd, capture_output=True, encoding="utf-8", check=False, shell=False
+            cmd, capture_output=capture, encoding="utf-8", check=False, shell=False
         )
         if cp.returncode != 0:
             cmd_str = subprocess.list2cmdline(cmd)

{rclone_api-1.0.46 → rclone_api-1.0.48}/src/rclone_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.0.46
+Version: 1.0.48
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 Maintainer: Zachary Vorhies

{rclone_api-1.0.46 → rclone_api-1.0.48}/src/rclone_api.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ tests/test_mount.py
 tests/test_mount_s3.py
 tests/test_mount_webdav.py
 tests/test_obscure.py
+tests/test_remote_control.py
 tests/test_remotes.py
 tests/test_serve_webdav.py
 tests/test_walk.py

rclone_api-1.0.48/tests/test_remote_control.py

@@ -0,0 +1,82 @@
+"""
+Unit test file.
+"""
+
+import os
+import unittest
+
+from dotenv import load_dotenv
+
+from rclone_api import Config, Rclone
+
+load_dotenv()
+
+BUCKET_NAME = os.getenv("BUCKET_NAME")  # Default if not in .env
+
+
+def _generate_rclone_config() -> Config:
+
+    # BUCKET_NAME = os.getenv("BUCKET_NAME", "TorrentBooks")  # Default if not in .env
+
+    # Load additional environment variables
+    BUCKET_KEY_SECRET = os.getenv("BUCKET_KEY_SECRET")
+    BUCKET_KEY_PUBLIC = os.getenv("BUCKET_KEY_PUBLIC")
+    # BUCKET_URL = os.getenv("BUCKET_URL")
+    BUCKET_URL = "sfo3.digitaloceanspaces.com"
+
+    config_text = f"""
+[dst]
+type = s3
+provider = DigitalOcean
+access_key_id = {BUCKET_KEY_PUBLIC}
+secret_access_key = {BUCKET_KEY_SECRET}
+endpoint = {BUCKET_URL}
+bucket = {BUCKET_NAME}
+"""
+
+    out = Config(config_text)
+    return out
+
+
+class RcloneRemoteControlTests(unittest.TestCase):
+    """Test rclone functionality."""
+
+    def setUp(self) -> None:
+        """Check if all required environment variables are set before running tests."""
+        required_vars = [
+            "BUCKET_NAME",
+            "BUCKET_KEY_SECRET",
+            "BUCKET_KEY_PUBLIC",
+            "BUCKET_URL",
+        ]
+        missing = [var for var in required_vars if not os.getenv(var)]
+        if missing:
+            self.skipTest(
+                f"Missing required environment variables: {', '.join(missing)}"
+            )
+        os.environ["RCLONE_API_VERBOSE"] = "1"
+
+    def test_server_launch(self) -> None:
+        rclone = Rclone(_generate_rclone_config())
+        proc = rclone.launch_server(addr="localhost:8888")
+        try:
+            self.assertTrue(proc.returncode is None)
+        finally:
+            proc.kill()
+
+    def test_launch_server_and_control_it(self) -> None:
+        rclone = Rclone(_generate_rclone_config())
+        proc = rclone.launch_server(addr="localhost:8889")
+        try:
+            self.assertTrue(proc.returncode is None)
+            # test the server
+            cp = rclone.remote_control(addr="localhost:8889")
+            # print(cp)
+            print(cp.stdout)
+            print("done")
+        finally:
+            proc.kill()
+
+
+if __name__ == "__main__":
+    unittest.main()

rclone_api-1.0.46/src/rclone_api/completed_process.py

@@ -1,21 +0,0 @@
-import subprocess
-from dataclasses import dataclass
-
-
-@dataclass
-class CompletedProcess:
-    completed: list[subprocess.CompletedProcess]
-
-    @property
-    def ok(self) -> bool:
-        return all([p.returncode == 0 for p in self.completed])
-
-    @staticmethod
-    def from_subprocess(process: subprocess.CompletedProcess) -> "CompletedProcess":
-        return CompletedProcess(completed=[process])
-
-    def failed(self) -> list[subprocess.CompletedProcess]:
-        return [p for p in self.completed if p.returncode != 0]
-
-    def successes(self) -> list[subprocess.CompletedProcess]:
-        return [p for p in self.completed if p.returncode == 0]