rclone-api 1.0.17__tar.gz → 1.0.18__tar.gz

{rclone_api-1.0.17 → rclone_api-1.0.18}/.gitignore

@@ -144,4 +144,4 @@ uv.lock
 !.aider.conf.yml
 !.aiderignore
 
-rclone.conf
+rclone*.conf

{rclone_api-1.0.17 → rclone_api-1.0.18}/PKG-INFO

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

{rclone_api-1.0.17 → rclone_api-1.0.18}/pyproject.toml

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

{rclone_api-1.0.17 → rclone_api-1.0.18}/requirements.testing.txt

@@ -5,3 +5,4 @@ pytest
 tox
 ruff
 pytest-xdist
+httpx

{rclone_api-1.0.17 → rclone_api-1.0.18}/src/rclone_api/process.py

@@ -69,8 +69,10 @@ class Process:
             tmpfile = Path(self.tempdir.name) / "rclone.conf"
             tmpfile.write_text(args.rclone_conf.text, encoding="utf-8")
             rclone_conf = tmpfile
+            self.needs_cleanup = True
         else:
             rclone_conf = args.rclone_conf
+            self.needs_cleanup = False
 
         assert rclone_conf.exists()
 
@@ -85,7 +87,7 @@ class Process:
         self.process = subprocess.Popen(self.cmd, shell=False)
 
     def cleanup(self) -> None:
-        if self.tempdir:
+        if self.tempdir and self.needs_cleanup:
             try:
                 self.tempdir.cleanup()
             except Exception as e:

{rclone_api-1.0.17 → rclone_api-1.0.18}/src/rclone_api/rclone.py

@@ -239,7 +239,13 @@ class Rclone:
         return self._run(cmd_list)
 
     def mount(
-        self, src: Remote | Dir | str, outdir: Path, allow_writes=False, use_links=True
+        self,
+        src: Remote | Dir | str,
+        outdir: Path,
+        allow_writes=False,
+        use_links=True,
+        vfs_cache_mode="full",
+        other_cmds: list[str] | None = None,
     ) -> Process:
         """Mount a remote or directory to a local path.
 
@@ -266,8 +272,85 @@ class Rclone:
             cmd_list.append("--read-only")
         if use_links:
             cmd_list.append("--links")
+        if vfs_cache_mode:
+            cmd_list.append("--vfs-cache-mode")
+            cmd_list.append(vfs_cache_mode)
+        if other_cmds:
+            cmd_list += other_cmds
         proc = self._launch_process(cmd_list)
         time.sleep(2)  # give it a moment to mount
         if proc.poll() is not None:
             raise ValueError("Mount process failed to start")
         return proc
+
+    def mount_webdav(
+        self,
+        url: str,
+        outdir: Path,
+        vfs_cache_mode="full",
+        other_cmds: list[str] | None = None,
+    ) -> Process:
+        """Mount a remote or directory to a local path.
+
+        Args:
+            src: Remote or directory to mount
+            outdir: Local path to mount to
+
+        Returns:
+            CompletedProcess from the mount command execution
+
+        Raises:
+            subprocess.CalledProcessError: If the mount operation fails
+        """
+        if outdir.exists():
+            is_empty = not list(outdir.iterdir())
+            if not is_empty:
+                raise ValueError(
+                    f"Mount directory already exists and is not empty: {outdir}"
+                )
+            outdir.rmdir()
+
+        src_str = url
+        cmd_list: list[str] = ["mount", src_str, str(outdir)]
+        cmd_list.append("--vfs-cache-mode")
+        cmd_list.append(vfs_cache_mode)
+        if other_cmds:
+            cmd_list += other_cmds
+        proc = self._launch_process(cmd_list)
+        # proc = rclone_exec.launch_process(cmd_list)
+        time.sleep(2)
+        if proc.poll() is not None:
+            raise ValueError("Mount process failed to start")
+        return proc
+
+    def serve_webdav(
+        self,
+        src: Remote | Dir | str,
+        user: str,
+        password: str,
+        addr: str = "localhost:2049",
+        allow_other: bool = False,
+    ) -> Process:
+        """Serve a remote or directory via NFS.
+
+        Args:
+            src: Remote or directory to serve
+            addr: Network address and port to serve on (default: localhost:2049)
+            allow_other: Allow other users to access the share
+
+        Returns:
+            Process: The running NFS server process
+
+        Raises:
+            ValueError: If the NFS server fails to start
+        """
+        src_str = convert_to_str(src)
+        cmd_list: list[str] = ["serve", "webdav", "--addr", addr, src_str]
+        cmd_list.extend(["--user", user, "--pass", password])
+        if allow_other:
+            cmd_list.append("--allow-other")
+        proc = self._launch_process(cmd_list)
+        time.sleep(2)  # give it a moment to start
+        if proc.poll() is not None:
+            raise ValueError("NFS serve process failed to start")
+        return proc

{rclone_api-1.0.17 → rclone_api-1.0.18}/src/rclone_api.egg-info/PKG-INFO

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

{rclone_api-1.0.17 → rclone_api-1.0.18}/src/rclone_api.egg-info/SOURCES.txt

@@ -46,4 +46,5 @@ tests/test_is_synced.py
 tests/test_ls.py
 tests/test_mount.py
 tests/test_remotes.py
+tests/test_serve_webdav.py
 tests/test_walk.py

{rclone_api-1.0.17 → rclone_api-1.0.18}/test

@@ -2,4 +2,4 @@
 
 set -e
 echo "Running unittests"
-uv run pytest -n auto tests -v
+uv run pytest tests -v

{rclone_api-1.0.17 → rclone_api-1.0.18}/tests/test_ls.py

@@ -31,6 +31,7 @@ provider = DigitalOcean
 access_key_id = {BUCKET_KEY_PUBLIC}
 secret_access_key = {BUCKET_KEY_SECRET}
 endpoint = {BUCKET_URL}
+bucket = {BUCKET_NAME}
 """
 
     out = Config(config_text)

rclone_api-1.0.18/tests/test_serve_webdav.py

@@ -0,0 +1,158 @@
+"""
+Unit test file.
+"""
+
+import os
+import unittest
+from pathlib import Path
+
+import httpx
+from dotenv import load_dotenv
+
+from rclone_api import Process, Rclone, Remote
+
+load_dotenv()
+
+BUCKET_NAME = os.getenv("BUCKET_NAME")  # Default if not in .env
+
+
+def _generate_rclone_config() -> Path:
+
+    # 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}
+
+
+[webdav]
+type = webdav
+user = guest
+# encrypted password for "1234"
+pass = d4IbQLV9W0JhI2tm5Zp88hpMtEg
+url = http://localhost:8089
+vendor = rclone
+"""
+
+    # out = Config(config_text)
+    out = Path("rclone_nfs.conf")
+    out.write_text(config_text, encoding="utf-8")
+    return out
+
+
+class RcloneNfsServeTest(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"
+        self.config = _generate_rclone_config()
+        self.rclone = Rclone(self.config)
+
+    def tearDown(self):
+        if self.config.exists():
+            self.config.unlink()
+
+    def test_serve_webdav(self) -> None:
+        """Test basic NFS serve functionality."""
+        config = _generate_rclone_config()
+        rclone = Rclone(config)
+
+        # Start NFS server for the remote
+        remote = Remote("dst", rclone=rclone)
+        # serve = Remote("webdav", rclone=rclone)
+        test_addr = "localhost:8089"
+        user = "guest"
+        password = "1234"
+
+        process = rclone.serve_webdav(
+            f"{remote.name}:{BUCKET_NAME}", addr=test_addr, user=user, password=password
+        )
+        mount_proc: Process | None = None
+
+        try:
+            # Verify process is running
+            self.assertIsNone(process.poll())
+            response = httpx.get(f"http://{test_addr}/", auth=(user, password))
+            # Note that windows is kinda broken and returns internal server error
+            is_serving = response.status_code == 200
+            self.assertTrue(is_serving)
+
+        finally:
+            # Clean up
+            process.terminate()
+            process.wait()
+            if mount_proc:
+                mount_proc.terminate()
+                mount_proc.wait()
+
+        # Verify process terminated
+        self.assertIsNotNone(process.poll())
+
+    def test_serve_webdav_and_mount(self) -> None:
+        """Test basic NFS serve functionality."""
+        config = _generate_rclone_config()
+        rclone = Rclone(config)
+
+        # Start NFS server for the remote
+        remote = Remote("dst", rclone=rclone)
+        # serve = Remote("webdav", rclone=rclone)
+        test_addr = "localhost:8089"
+        user = "guest"
+        password = "1234"
+
+        process = rclone.serve_webdav(
+            f"{remote.name}:{BUCKET_NAME}", addr=test_addr, user=user, password=password
+        )
+        mount_proc: Process | None = None
+
+        try:
+            # Verify process is running
+            self.assertIsNone(process.poll())
+            mount_point = Path("test_mount2")
+            mount_proc = rclone.mount_webdav("webdav:", mount_point)
+            # test that the mount point exists
+            self.assertTrue(mount_point.exists())
+            # test the folder is not empty
+            dirs = next(mount_point.iterdir())
+            self.assertTrue(dirs.is_dir())
+
+        finally:
+            # Clean up
+            if mount_proc:
+                mount_proc.terminate()
+                mount_proc.wait()
+            process.terminate()
+            process.wait()
+            if mount_proc:
+                mount_proc.terminate()
+                mount_proc.wait()
+
+        # Verify process terminated
+        self.assertIsNotNone(process.poll())
+
+
+if __name__ == "__main__":
+    unittest.main()