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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.0.18
+Version: 1.0.19
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 Maintainer: Zachary Vorhies
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: pyright>=1.1.393
 Requires-Dist: python-dotenv>=1.0.0
 Dynamic: home-page
 Dynamic: maintainer

{rclone_api-1.0.18 → rclone_api-1.0.19}/lint

@@ -11,5 +11,7 @@ echo Running isort src tests
 uv run isort --profile black src tests
 echo Running mypy src
 uv run mypy src tests
+echo Running pyright src tests
+uv run pyright src tests --threads
 echo Linting complete!
 exit 0

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

@@ -11,10 +11,11 @@ keywords = ["template-python-cmd"]
 license = { text = "BSD 3-Clause License" }
 classifiers = ["Programming Language :: Python :: 3"]
 dependencies = [
-    "python-dotenv>=1.0.0"
+    "pyright>=1.1.393",
+    "python-dotenv>=1.0.0",
 ]
 # Change this with the version number bump.
-version = "1.0.18"
+version = "1.0.19"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

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

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

{rclone_api-1.0.18 → rclone_api-1.0.19}/src/rclone_api/dir.py

@@ -47,12 +47,14 @@ class Dir:
         dir = Dir(self.path)
         return self.path.rclone.ls(dir, max_depth=max_depth)
 
-    def walk(self, max_depth: int = -1) -> Generator[DirListing, None, None]:
+    def walk(
+        self, breadth_first: bool, max_depth: int = -1
+    ) -> Generator[DirListing, None, None]:
         """List files and directories in the given path."""
         from rclone_api.walk import walk
 
         assert self.path.rclone is not None
-        return walk(self, max_depth=max_depth)
+        return walk(self, breadth_first=breadth_first, max_depth=max_depth)
 
     def to_json(self) -> dict:
         """Convert the Dir to a JSON serializable dictionary."""

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

@@ -38,6 +38,12 @@ class Rclone:
     def _launch_process(self, cmd: list[str]) -> Process:
         return self._exec.launch_process(cmd)
 
+    def obscure(self, password: str) -> str:
+        """Obscure a password for use in rclone config files."""
+        cmd_list: list[str] = ["obscure", password]
+        cp = self._run(cmd_list)
+        return cp.stdout.strip()
+
     def ls(
         self,
         path: Dir | Remote | str,
@@ -61,8 +67,9 @@ class Rclone:
 
         cmd = ["lsjson"]
         if max_depth is not None:
-            cmd.append("--recursive")
-            if max_depth > -1:
+            if max_depth < 0:
+                cmd.append("--recursive")
+            if max_depth > 0:
                 cmd.append("--max-depth")
                 cmd.append(str(max_depth))
         cmd.append(str(path))
@@ -96,7 +103,7 @@ class Rclone:
         return out
 
     def walk(
-        self, path: Dir | Remote | str, max_depth: int = -1
+        self, path: Dir | Remote | str, max_depth: int = -1, breadth_first: bool = True
     ) -> Generator[DirListing, None, None]:
         """Walk through the given path recursively.
 
@@ -107,6 +114,7 @@ class Rclone:
         Yields:
             DirListing: Directory listing for each directory encountered
         """
+        dir_obj: Dir
         if isinstance(path, Dir):
             # Create a Remote object for the path
             remote = path.remote
@@ -126,9 +134,10 @@ class Rclone:
         elif isinstance(path, Remote):
             dir_obj = Dir(path)
         else:
+            dir_obj = Dir(path)  # shut up pyright
             assert f"Invalid type for path: {type(path)}"
 
-        yield from walk(dir_obj, max_depth=max_depth)
+        yield from walk(dir_obj, max_depth=max_depth, breadth_first=breadth_first)
 
     def copyfile(self, src: File | str, dst: File | str) -> None:
         """Copy a single file from source to destination.

{rclone_api-1.0.18 → rclone_api-1.0.19}/src/rclone_api/walk.py

@@ -9,9 +9,11 @@ from rclone_api.remote import Remote
 _MAX_OUT_QUEUE_SIZE = 50
 
 
-def _walk_runner(
-    queue: Queue[Dir], max_depth: int, out_queue: Queue[DirListing | None]
+def _walk_runner_breadth_first(
+    dir: Dir, max_depth: int, out_queue: Queue[DirListing | None]
 ) -> None:
+    queue: Queue[Dir] = Queue()
+    queue.put(dir)
     try:
         while not queue.empty():
             current_dir = queue.get()
@@ -35,7 +37,35 @@ def _walk_runner(
         _thread.interrupt_main()
 
 
-def walk(dir: Dir | Remote, max_depth: int = -1) -> Generator[DirListing, None, None]:
+def _walk_runner_depth_first(
+    dir: Dir, max_depth: int, out_queue: Queue[DirListing | None]
+) -> None:
+    try:
+        stack = [(dir, max_depth)]
+        while stack:
+            current_dir, depth = stack.pop()
+            dirlisting = current_dir.ls()
+            if depth != 0:
+                for subdir in reversed(
+                    dirlisting.dirs
+                ):  # Process deeper directories first
+                    # stack.append((child, depth - 1 if depth > 0 else depth))
+                    next_depth = depth - 1 if depth > 0 else depth
+                    _walk_runner_depth_first(subdir, next_depth, out_queue)
+            out_queue.put(dirlisting)
+        out_queue.put(None)
+    except KeyboardInterrupt:
+        import _thread
+
+        out_queue.put(None)
+        _thread.interrupt_main()
+
+
+def walk(
+    dir: Dir | Remote,
+    breadth_first: bool,
+    max_depth: int = -1,
+) -> Generator[DirListing, None, None]:
     """Walk through the given directory recursively.
 
     Args:
@@ -49,14 +79,17 @@ def walk(dir: Dir | Remote, max_depth: int = -1) -> Generator[DirListing, None,
         # Convert Remote to Dir if needed
         if isinstance(dir, Remote):
             dir = Dir(dir)
-
-        in_queue: Queue[Dir] = Queue()
         out_queue: Queue[DirListing] = Queue(maxsize=_MAX_OUT_QUEUE_SIZE)
-        in_queue.put(dir)
+
+        strategy = (
+            _walk_runner_breadth_first if breadth_first else _walk_runner_depth_first
+        )
 
         # Start worker thread
         worker = Thread(
-            target=_walk_runner, args=(in_queue, max_depth, out_queue), daemon=True
+            target=strategy,
+            args=(dir, max_depth, out_queue),
+            daemon=True,
         )
         worker.start()
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.0.18
+Version: 1.0.19
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 Maintainer: Zachary Vorhies
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: pyright>=1.1.393
 Requires-Dist: python-dotenv>=1.0.0
 Dynamic: home-page
 Dynamic: maintainer

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

@@ -45,6 +45,8 @@ tests/test_copy.py
 tests/test_is_synced.py
 tests/test_ls.py
 tests/test_mount.py
+tests/test_mount_webdav.py
+tests/test_obscure.py
 tests/test_remotes.py
 tests/test_serve_webdav.py
 tests/test_walk.py

{rclone_api-1.0.18 → rclone_api-1.0.19}/src/rclone_api.egg-info/requires.txt

@@ -1 +1,2 @@
+pyright>=1.1.393
 python-dotenv>=1.0.0

{rclone_api-1.0.18 → rclone_api-1.0.19}/test

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

rclone_api-1.0.18/tests/test_serve_webdav.py → rclone_api-1.0.19/tests/test_mount_webdav.py

@@ -6,17 +6,16 @@ import os
 import unittest
 from pathlib import Path
 
-import httpx
 from dotenv import load_dotenv
 
-from rclone_api import Process, Rclone, Remote
+from rclone_api import Config, Process, Rclone, Remote
 
 load_dotenv()
 
 BUCKET_NAME = os.getenv("BUCKET_NAME")  # Default if not in .env
 
 
-def _generate_rclone_config() -> Path:
+def _generate_rclone_config(port: int) -> Config:
 
     # BUCKET_NAME = os.getenv("BUCKET_NAME", "TorrentBooks")  # Default if not in .env
 
@@ -39,19 +38,17 @@ bucket = {BUCKET_NAME}
 [webdav]
 type = webdav
 user = guest
-# encrypted password for "1234"
+# obscured password for "1234", use Rclone.obscure("1234") to generate
 pass = d4IbQLV9W0JhI2tm5Zp88hpMtEg
-url = http://localhost:8089
+url = http://localhost:{port}
 vendor = rclone
 """
 
-    # out = Config(config_text)
-    out = Path("rclone_nfs.conf")
-    out.write_text(config_text, encoding="utf-8")
+    out = Config(config_text)
     return out
 
 
-class RcloneNfsServeTest(unittest.TestCase):
+class RcloneMountWebdavTester(unittest.TestCase):
     """Test rclone functionality."""
 
     def setUp(self) -> None:
@@ -68,58 +65,17 @@ class RcloneNfsServeTest(unittest.TestCase):
                 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()
+        port = 8090
+        config = _generate_rclone_config(port)
         rclone = Rclone(config)
 
         # Start NFS server for the remote
         remote = Remote("dst", rclone=rclone)
         # serve = Remote("webdav", rclone=rclone)
-        test_addr = "localhost:8089"
+        test_addr = f"localhost:{port}"
         user = "guest"
         password = "1234"
 
@@ -136,8 +92,8 @@ class RcloneNfsServeTest(unittest.TestCase):
             # 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())
+            next_path = next(mount_point.iterdir())
+            self.assertIsNotNone(next_path)
 
         finally:
             # Clean up

rclone_api-1.0.18/tests/test_walk.py → rclone_api-1.0.19/tests/test_obscure.py

@@ -7,7 +7,7 @@ import unittest
 
 from dotenv import load_dotenv
 
-from rclone_api import Config, DirListing, Rclone
+from rclone_api import Config, Rclone
 
 load_dotenv()
 
@@ -31,13 +31,14 @@ 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 RcloneWalkTest(unittest.TestCase):
+class RcloneLsTests(unittest.TestCase):
     """Test rclone functionality."""
 
     def setUp(self) -> None:
@@ -55,13 +56,11 @@ class RcloneWalkTest(unittest.TestCase):
             )
         os.environ["RCLONE_API_VERBOSE"] = "1"
 
-    def test_walk(self) -> None:
+    def test_list_remotes(self) -> None:
         rclone = Rclone(_generate_rclone_config())
-        # rclone.walk
-        dirlisting: DirListing
-        for dirlisting in rclone.walk(f"dst:{BUCKET_NAME}", max_depth=1):
-            print(dirlisting)
-        print("done")
+        obscured = rclone.obscure("1234")
+        self.assertNotEqual(obscured, "1234")
+        print()
 
 
 if __name__ == "__main__":

rclone_api-1.0.19/tests/test_serve_webdav.py

@@ -0,0 +1,108 @@
+"""
+Unit test file.
+"""
+
+import os
+import unittest
+
+import httpx
+from dotenv import load_dotenv
+
+from rclone_api import Config, Process, Rclone, Remote
+
+load_dotenv()
+
+BUCKET_NAME = os.getenv("BUCKET_NAME")  # Default if not in .env
+
+
+def _generate_rclone_config(port: int) -> 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}
+
+
+[webdav]
+type = webdav
+user = guest
+# obscured password for "1234", use Rclone.obscure("1234") to generate
+pass = d4IbQLV9W0JhI2tm5Zp88hpMtEg
+url = http://localhost:{port}
+vendor = rclone
+"""
+
+    out = Config(config_text)
+    return out
+
+
+class RcloneServeWebdavTester(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_serve_webdav(self) -> None:
+        """Test basic NFS serve functionality."""
+        port = 8089
+        config = _generate_rclone_config(port)
+        rclone = Rclone(config)
+
+        # Start NFS server for the remote
+        remote = Remote("dst", rclone=rclone)
+        # serve = Remote("webdav", rclone=rclone)
+        test_addr = f"localhost:{port}"
+        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())
+
+
+if __name__ == "__main__":
+    unittest.main()

rclone_api-1.0.19/tests/test_walk.py

@@ -0,0 +1,86 @@
+"""
+Unit test file.
+"""
+
+import os
+import unittest
+
+from dotenv import load_dotenv
+
+from rclone_api import Config, DirListing, 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}
+"""
+
+    out = Config(config_text)
+    return out
+
+
+class RcloneWalkTest(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_walk(self) -> None:
+        rclone = Rclone(_generate_rclone_config())
+        # rclone.walk
+        dirlisting: DirListing
+        is_first = True
+        for dirlisting in rclone.walk(f"dst:{BUCKET_NAME}", max_depth=1):
+            if is_first:
+                # assert just one file
+                # assert len(dirlisting.files) == 1
+                self.assertEqual(len(dirlisting.files), 1)
+                # assert it's first.txt
+                self.assertEqual(dirlisting.files[0].name, "first.txt")
+                is_first = False
+            print(dirlisting)
+        print("done")
+
+    def test_walk_depth_first(self) -> None:
+        rclone = Rclone(_generate_rclone_config())
+        # rclone.walk
+        dirlisting: DirListing
+        for dirlisting in rclone.walk(
+            f"dst:{BUCKET_NAME}", max_depth=1, breadth_first=False
+        ):
+            print(dirlisting)
+        print("done")
+
+
+if __name__ == "__main__":
+    unittest.main()