rclone-api 1.0.22__tar.gz → 1.0.24__tar.gz

{rclone_api-1.0.22 → rclone_api-1.0.24}/PKG-INFO

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

{rclone_api-1.0.22 → rclone_api-1.0.24}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
     "python-dotenv>=1.0.0",
 ]
 # Change this with the version number bump.
-version = "1.0.22"
+version = "1.0.24"
 
 [tool.setuptools]
 package-dir = {"" = "src"}
@@ -43,3 +43,6 @@ profile = "black"
 [tool.mypy]
 ignore_missing_imports = true
 disable_error_code = ["import-untyped"]
+
+[project.scripts]
+rclone-api-listfiles = "rclone_api.cmd.list_files:main"

rclone_api-1.0.24/src/rclone_api/cmd/list_files.py

@@ -0,0 +1,27 @@
+import argparse
+from pathlib import Path
+
+from rclone_api import Rclone
+
+
+def list_files(rclone: Rclone, path: str):
+    """List files in a remote path."""
+    for dirlisting in rclone.walk(path):
+        for file in dirlisting.files:
+            print(file.path)
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="List files in a remote path.")
+    parser.add_argument("--config", help="Path to rclone config file", required=True)
+    parser.add_argument("path", help="Remote path to list")
+    return parser.parse_args()
+
+
+def main() -> int:
+    """Main entry point."""
+    args = _parse_args()
+    path = args.path
+    rclone = Rclone(Path(args.config))
+    list_files(rclone, path)
+    return 0

{rclone_api-1.0.22 → rclone_api-1.0.24}/src/rclone_api/rclone.py

@@ -6,6 +6,7 @@ import subprocess
 import time
 import warnings
 from concurrent.futures import ThreadPoolExecutor
+from enum import Enum
 from fnmatch import fnmatch
 from pathlib import Path
 from typing import Generator
@@ -23,6 +24,11 @@ from rclone_api.util import get_rclone_exe, to_path, wait_for_mount
 from rclone_api.walk import walk
 
 
+class ModTimeStrategy(Enum):
+    USE_SERVER_MODTIME = "use-server-modtime"
+    NO_MODTIME = "no-modtime"
+
+
 class Rclone:
     def __init__(
         self, rclone_conf: Path | Config, rclone_exe: Path | None = None
@@ -299,6 +305,7 @@ class Rclone:
         url: str,
         outdir: Path,
         vfs_cache_mode="full",
+        vfs_disk_space_total_size: str | None = "10G",
         other_cmds: list[str] | None = None,
     ) -> Process:
         """Mount a remote or directory to a local path.
@@ -327,10 +334,55 @@ class Rclone:
         cmd_list.append(vfs_cache_mode)
         if other_cmds:
             cmd_list += other_cmds
+        if vfs_disk_space_total_size is not None:
+            cmd_list.append("--vfs-cache-max-size")
+            cmd_list.append(vfs_disk_space_total_size)
         proc = self._launch_process(cmd_list)
         wait_for_mount(outdir, proc)
         return proc
 
+    def mount_s3(
+        self,
+        url: str,
+        outdir: Path,
+        vfs_cache_mode="full",
+        transfers: int | None = 16,
+        modtime_strategy: (
+            ModTimeStrategy | None
+        ) = ModTimeStrategy.USE_SERVER_MODTIME,  # speeds up S3 operations
+        vfs_read_chunk_streams: int | None = 16,
+        vfs_read_chunk_size: str | None = "4M",
+        vfs_fast_fingerprint: bool = True,
+        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
+        """
+        other_cmds = other_cmds or []
+        if modtime_strategy is not None:
+            other_cmds.append(f"--{modtime_strategy.value}")
+        if (vfs_cache_mode == "full" or vfs_cache_mode == "writes") and (
+            transfers is not None
+        ):
+            other_cmds.append("--transfers")
+            other_cmds.append(str(transfers))
+        if vfs_read_chunk_streams:
+            other_cmds.append("--vfs-read-chunk-streams")
+            other_cmds.append(str(vfs_read_chunk_streams))
+        if vfs_read_chunk_size:
+            other_cmds.append("--vfs-read-chunk-size")
+            other_cmds.append(vfs_read_chunk_size)
+        if vfs_fast_fingerprint:
+            other_cmds.append("--vfs-fast-fingerprint")
+
+        other_cmds = other_cmds if other_cmds else None
+        return self.mount(
+            url, outdir, vfs_cache_mode=vfs_cache_mode, other_cmds=other_cmds
+        )
+
     def serve_webdav(
         self,
         src: Remote | Dir | str,

{rclone_api-1.0.22 → rclone_api-1.0.24}/src/rclone_api.egg-info/PKG-INFO

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

{rclone_api-1.0.22 → rclone_api-1.0.24}/src/rclone_api.egg-info/SOURCES.txt

@@ -38,13 +38,17 @@ src/rclone_api/walk.py
 src/rclone_api.egg-info/PKG-INFO
 src/rclone_api.egg-info/SOURCES.txt
 src/rclone_api.egg-info/dependency_links.txt
+src/rclone_api.egg-info/entry_points.txt
 src/rclone_api.egg-info/requires.txt
 src/rclone_api.egg-info/top_level.txt
 src/rclone_api/assets/example.txt
+src/rclone_api/cmd/list_files.py
+tests/test_cmd_list_files.py
 tests/test_copy.py
 tests/test_is_synced.py
 tests/test_ls.py
 tests/test_mount.py
+tests/test_mount_s3.py
 tests/test_mount_webdav.py
 tests/test_obscure.py
 tests/test_remotes.py

rclone_api-1.0.24/src/rclone_api.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rclone-api-listfiles = rclone_api.cmd.list_files:main

rclone_api-1.0.24/tests/test_cmd_list_files.py

@@ -0,0 +1,83 @@
+"""
+Unit test file.
+"""
+
+import os
+import unittest
+
+from dotenv import load_dotenv
+
+from rclone_api import Config, Rclone, Remote
+from rclone_api.cmd.list_files import list_files
+
+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 RcloneLsTests(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_list_remotes(self) -> None:
+        rclone = Rclone(_generate_rclone_config())
+
+        remotes: list[Remote] = rclone.listremotes()
+        self.assertGreater(len(remotes), 0)
+        for remote in remotes:
+            self.assertIsInstance(remote, Remote)
+            print(remote)
+        print("done")
+
+    def test_cmd_list_files(self) -> None:
+        """Test listing the root directory of the bucket.
+
+        Verifies that we can:
+        1. Connect to the bucket
+        2. List its contents
+        3. Get both directories and files as proper types
+        """
+        rclone = Rclone(_generate_rclone_config())
+        list_files(rclone, f"dst:{BUCKET_NAME}")
+
+
+if __name__ == "__main__":
+    unittest.main()

rclone_api-1.0.24/tests/test_mount_s3.py

@@ -0,0 +1,105 @@
+"""
+Unit test file for testing rclone mount functionality.
+"""
+
+import os
+import subprocess
+import unittest
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from rclone_api import Config, Process, Rclone
+
+load_dotenv()
+
+
+def _generate_rclone_config() -> Config:
+    # Load environment variables
+    BUCKET_KEY_SECRET = os.getenv("BUCKET_KEY_SECRET")
+    BUCKET_KEY_PUBLIC = os.getenv("BUCKET_KEY_PUBLIC")
+    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}
+"""
+    return Config(config_text)
+
+
+class RcloneMountS3Tests(unittest.TestCase):
+    """Test rclone mount 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)}"
+            )
+
+        self.bucket_name = os.getenv("BUCKET_NAME")
+        self.mount_point = Path("test_mount")
+        # Create mount point directory if it doesn't exist
+        # self.mount_point.mkdir(exist_ok=True)
+        # make parents
+        parent = self.mount_point.parent
+        if not parent.exists():
+            parent.mkdir(parents=True)
+
+        os.environ["RCLONE_API_VERBOSE"] = "1"
+        self.rclone = Rclone(_generate_rclone_config())
+
+    def test_mount(self) -> None:
+        """Test mounting a remote bucket."""
+        remote_path = f"dst:{self.bucket_name}"
+        process: Process | None = None
+
+        try:
+            # Start the mount process
+            process = self.rclone.mount_s3(remote_path, self.mount_point)
+            self.assertIsNone(
+                process.poll(), "Mount process should still be running after 2 seconds"
+            )
+
+            # Verify mount point exists and is accessible
+            self.assertTrue(self.mount_point.exists())
+            self.assertTrue(self.mount_point.is_dir())
+
+            # Check if we can list contents
+            contents = list(self.mount_point.iterdir())
+            self.assertGreater(
+                len(contents), 0, "Mounted directory should not be empty"
+            )
+
+        except subprocess.CalledProcessError as e:
+            self.fail(f"Mount operation failed: {str(e)}")
+        finally:
+            # Cleanup will happen in tearDown
+            if process:
+                if process.poll() is None:
+                    process.kill()
+                stdout = process.stdout
+                if stdout:
+                    # stdout is a buffered reader
+                    for line in stdout:
+                        print(line)
+                stderr = process.stderr
+                if stderr:
+                    for line in stderr:
+                        print(line)
+                process.kill()
+
+
+if __name__ == "__main__":
+    unittest.main()