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

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

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

rclone_api-1.0.18/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.2
+Name: rclone_api
+Version: 1.0.18
+Summary: rclone api in python
+Home-page: https://github.com/zackees/rclone-api
+Maintainer: Zachary Vorhies
+License: BSD 3-Clause License
+Keywords: template-python-cmd
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: home-page
+Dynamic: maintainer
+
+# rclone-api
+
+[![Linting](https://github.com/zackees/rclone-api/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/lint.yml)
+[![MacOS_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml)
+[![Ubuntu_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml)
+[![Win_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml)
+
+Api version of rclone. It's well tested. It's a pretty low level api without the bells and whistles of other apis, but it will get the job done.
+
+You will need to have rclone installed and on your path.
+
+One of the benefits of this api is that it does not use `shell=True`, which can keep `rclone` running in some instances even when try to kill the process.
+
+# Install
+
+`pip install rclone-api`
+
+
+# Examples
+
+You can use env variables or use a `.env` file to store your secrets.
+
+
+# Rclone API Usage Examples
+
+This script demonstrates how to interact with DigitalOcean Spaces using `rclone_api`. 
+
+## Setup & Usage
+
+Ensure you have set the required environment variables:
+
+- `BUCKET_NAME`
+- `BUCKET_KEY_PUBLIC`
+- `BUCKET_KEY_SECRET`
+- `BUCKET_URL`
+
+Then, run the following Python script:
+
+```python
+import os
+from rclone_api import Config, DirListing, File, Rclone, Remote
+
+# Load environment variables
+BUCKET_NAME = os.getenv("BUCKET_NAME")
+BUCKET_KEY_PUBLIC = os.getenv("BUCKET_KEY_PUBLIC")
+BUCKET_KEY_SECRET = os.getenv("BUCKET_KEY_SECRET")
+BUCKET_URL = "sfo3.digitaloceanspaces.com"
+
+# Generate Rclone Configuration
+def generate_rclone_config() -> Config:
+    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)
+
+rclone = Rclone(generate_rclone_config())
+
+# List Available Remotes
+print("\n=== Available Remotes ===")
+remotes = rclone.listremotes()
+for remote in remotes:
+    print(remote)
+
+# List Contents of the Root Bucket
+print("\n=== Listing Root Bucket ===")
+listing = rclone.ls(f"dst:{BUCKET_NAME}", max_depth=-1)
+
+print("\nDirectories:")
+for dir in listing.dirs:
+    print(dir)
+
+print("\nFiles:")
+for file in listing.files:
+    print(file)
+
+# List a Specific Subdirectory
+print("\n=== Listing 'zachs_video' Subdirectory ===")
+path = f"dst:{BUCKET_NAME}/zachs_video"
+listing = rclone.ls(path)
+print(listing)
+
+# List PNG Files in a Subdirectory
+print("\n=== Listing PNG Files ===")
+listing = rclone.ls(path, glob="*.png")
+
+if listing.files:
+    for file in listing.files:
+        print(file)
+
+# Copy a File
+print("\n=== Copying a File ===")
+if listing.files:
+    file = listing.files[0]
+    new_path = f"dst:{BUCKET_NAME}/zachs_video/{file.name}_copy"
+    rclone.copyfile(file, new_path)
+    print(f"Copied {file.name} to {new_path}")
+
+# Copy Multiple Files
+print("\n=== Copying Multiple Files ===")
+if listing.files:
+    file_mapping = {file.name: file.name + "_copy" for file in listing.files[:2]}
+    rclone.copyfiles(file_mapping)
+    print(f"Copied files: {file_mapping}")
+
+# Delete a File
+print("\n=== Deleting a File ===")
+file_to_delete = f"dst:{BUCKET_NAME}/zachs_video/sample.png_copy"
+rclone.deletefiles([file_to_delete])
+print(f"Deleted {file_to_delete}")
+
+# Walk Through a Directory
+print("\n=== Walking Through a Directory ===")
+for dirlisting in rclone.walk(f"dst:{BUCKET_NAME}", max_depth=1):
+    print(dirlisting)
+
+print("Done.")
+```
+
+
+To develop software, run `. ./activate`
+
+# Windows
+
+This environment requires you to use `git-bash`.
+
+# Linting
+
+Run `./lint`

rclone_api-1.0.18/README.md

@@ -0,0 +1,133 @@
+# rclone-api
+
+[![Linting](https://github.com/zackees/rclone-api/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/lint.yml)
+[![MacOS_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml)
+[![Ubuntu_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml)
+[![Win_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml)
+
+Api version of rclone. It's well tested. It's a pretty low level api without the bells and whistles of other apis, but it will get the job done.
+
+You will need to have rclone installed and on your path.
+
+One of the benefits of this api is that it does not use `shell=True`, which can keep `rclone` running in some instances even when try to kill the process.
+
+# Install
+
+`pip install rclone-api`
+
+
+# Examples
+
+You can use env variables or use a `.env` file to store your secrets.
+
+
+# Rclone API Usage Examples
+
+This script demonstrates how to interact with DigitalOcean Spaces using `rclone_api`. 
+
+## Setup & Usage
+
+Ensure you have set the required environment variables:
+
+- `BUCKET_NAME`
+- `BUCKET_KEY_PUBLIC`
+- `BUCKET_KEY_SECRET`
+- `BUCKET_URL`
+
+Then, run the following Python script:
+
+```python
+import os
+from rclone_api import Config, DirListing, File, Rclone, Remote
+
+# Load environment variables
+BUCKET_NAME = os.getenv("BUCKET_NAME")
+BUCKET_KEY_PUBLIC = os.getenv("BUCKET_KEY_PUBLIC")
+BUCKET_KEY_SECRET = os.getenv("BUCKET_KEY_SECRET")
+BUCKET_URL = "sfo3.digitaloceanspaces.com"
+
+# Generate Rclone Configuration
+def generate_rclone_config() -> Config:
+    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)
+
+rclone = Rclone(generate_rclone_config())
+
+# List Available Remotes
+print("\n=== Available Remotes ===")
+remotes = rclone.listremotes()
+for remote in remotes:
+    print(remote)
+
+# List Contents of the Root Bucket
+print("\n=== Listing Root Bucket ===")
+listing = rclone.ls(f"dst:{BUCKET_NAME}", max_depth=-1)
+
+print("\nDirectories:")
+for dir in listing.dirs:
+    print(dir)
+
+print("\nFiles:")
+for file in listing.files:
+    print(file)
+
+# List a Specific Subdirectory
+print("\n=== Listing 'zachs_video' Subdirectory ===")
+path = f"dst:{BUCKET_NAME}/zachs_video"
+listing = rclone.ls(path)
+print(listing)
+
+# List PNG Files in a Subdirectory
+print("\n=== Listing PNG Files ===")
+listing = rclone.ls(path, glob="*.png")
+
+if listing.files:
+    for file in listing.files:
+        print(file)
+
+# Copy a File
+print("\n=== Copying a File ===")
+if listing.files:
+    file = listing.files[0]
+    new_path = f"dst:{BUCKET_NAME}/zachs_video/{file.name}_copy"
+    rclone.copyfile(file, new_path)
+    print(f"Copied {file.name} to {new_path}")
+
+# Copy Multiple Files
+print("\n=== Copying Multiple Files ===")
+if listing.files:
+    file_mapping = {file.name: file.name + "_copy" for file in listing.files[:2]}
+    rclone.copyfiles(file_mapping)
+    print(f"Copied files: {file_mapping}")
+
+# Delete a File
+print("\n=== Deleting a File ===")
+file_to_delete = f"dst:{BUCKET_NAME}/zachs_video/sample.png_copy"
+rclone.deletefiles([file_to_delete])
+print(f"Deleted {file_to_delete}")
+
+# Walk Through a Directory
+print("\n=== Walking Through a Directory ===")
+for dirlisting in rclone.walk(f"dst:{BUCKET_NAME}", max_depth=1):
+    print(dirlisting)
+
+print("Done.")
+```
+
+
+To develop software, run `. ./activate`
+
+# Windows
+
+This environment requires you to use `git-bash`.
+
+# Linting
+
+Run `./lint`

{rclone_api-1.0.15 → 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.15"
+version = "1.0.18"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

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

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

{rclone_api-1.0.15 → rclone_api-1.0.18}/src/rclone_api/__init__.py

@@ -3,6 +3,7 @@ from .dir import Dir
 from .dir_listing import DirListing
 from .file import File
 from .filelist import FileList
+from .process import Process
 from .rclone import Rclone
 from .remote import Remote
 from .rpath import RPath
@@ -16,4 +17,5 @@ __all__ = [
     "RPath",
     "DirListing",
     "FileList",
+    "Process",
 ]

{rclone_api-1.0.15 → rclone_api-1.0.18}/src/rclone_api/exec.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from rclone_api.config import Config
+from rclone_api.process import Process, ProcessArgs
 
 
 @dataclass
@@ -17,3 +18,15 @@ class RcloneExec:
         from rclone_api.util import rclone_execute
 
         return rclone_execute(cmd, self.rclone_config, self.rclone_exe, check=check)
+
+    def launch_process(self, cmd: list[str]) -> Process:
+        """Launch rclone process."""
+
+        args: ProcessArgs = ProcessArgs(
+            cmd=cmd,
+            rclone_conf=self.rclone_config,
+            rclone_exe=self.rclone_exe,
+            cmd_list=cmd,
+        )
+        process = Process(args)
+        return process

rclone_api-1.0.18/src/rclone_api/process.py

@@ -0,0 +1,126 @@
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from typing import Any
+
+from rclone_api.config import Config
+from rclone_api.util import get_verbose
+
+# def rclone_launch_process(
+#     cmd: list[str],
+#     rclone_conf: Path | Config,
+#     rclone_exe: Path,
+#     verbose: bool | None = None,
+# ) -> subprocess.Popen:
+#     tempdir: TemporaryDirectory | None = None
+#     verbose = _get_verbose(verbose)
+#     assert verbose is not None
+
+#     try:
+#         if isinstance(rclone_conf, Config):
+#             tempdir = TemporaryDirectory()
+#             tmpfile = Path(tempdir.name) / "rclone.conf"
+#             tmpfile.write_text(rclone_conf.text, encoding="utf-8")
+#             rclone_conf = tmpfile
+#         cmd = (
+#             [str(rclone_exe.resolve())] + ["--config", str(rclone_conf.resolve())] + cmd
+#         )
+#         if verbose:
+#             cmd_str = subprocess.list2cmdline(cmd)
+#             print(f"Running: {cmd_str}")
+#         cp = subprocess.Popen(
+#             cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False
+#         )
+#         return cp
+#     finally:
+#         if tempdir:
+#             try:
+#                 tempdir.cleanup()
+#             except Exception as e:
+#                 print(f"Error cleaning up tempdir: {e}")
+
+
+def _get_verbose(verbose: bool | None) -> bool:
+    if verbose is not None:
+        return verbose
+    # get it from the environment
+    return bool(int(os.getenv("RCLONE_API_VERBOSE", "0")))
+
+
+@dataclass
+class ProcessArgs:
+    cmd: list[str]
+    rclone_conf: Path | Config
+    rclone_exe: Path
+    cmd_list: list[str]
+    verbose: bool | None = None
+
+
+class Process:
+    def __init__(self, args: ProcessArgs) -> None:
+        assert args.rclone_exe.exists()
+        self.args = args
+        self.tempdir: TemporaryDirectory | None = None
+        verbose = get_verbose(args.verbose)
+        if isinstance(args.rclone_conf, Config):
+            self.tempdir = TemporaryDirectory()
+            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()
+
+        self.cmd = (
+            [str(args.rclone_exe.resolve())]
+            + ["--config", str(rclone_conf.resolve())]
+            + args.cmd
+        )
+        if verbose:
+            cmd_str = subprocess.list2cmdline(self.cmd)
+            print(f"Running: {cmd_str}")
+        self.process = subprocess.Popen(self.cmd, shell=False)
+
+    def cleanup(self) -> None:
+        if self.tempdir and self.needs_cleanup:
+            try:
+                self.tempdir.cleanup()
+            except Exception as e:
+                print(f"Error cleaning up tempdir: {e}")
+
+    def __del__(self) -> None:
+        self.cleanup()
+
+    def kill(self) -> None:
+        self.cleanup()
+        return self.process.kill()
+
+    def terminate(self) -> None:
+        self.cleanup()
+        return self.process.terminate()
+
+    @property
+    def returncode(self) -> int | None:
+        return self.process.returncode
+
+    @property
+    def stdout(self) -> Any:
+        return self.process.stdout
+
+    @property
+    def stderr(self) -> Any:
+        return self.process.stderr
+
+    def poll(self) -> int | None:
+        return self.process.poll()
+
+    def wait(self) -> int:
+        return self.process.wait()
+
+    def send_signal(self, signal: int) -> None:
+        return self.process.send_signal(signal)

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

@@ -3,6 +3,7 @@ Unit test file.
 """
 
 import subprocess
+import time
 from concurrent.futures import ThreadPoolExecutor
 from fnmatch import fnmatch
 from pathlib import Path
@@ -15,6 +16,7 @@ from rclone_api.dir_listing import DirListing
 from rclone_api.exec import RcloneExec
 from rclone_api.file import File
 from rclone_api.filelist import FileList
+from rclone_api.process import Process
 from rclone_api.remote import Remote
 from rclone_api.rpath import RPath
 from rclone_api.util import get_rclone_exe, to_path
@@ -33,6 +35,9 @@ class Rclone:
     def _run(self, cmd: list[str], check: bool = True) -> subprocess.CompletedProcess:
         return self._exec.execute(cmd, check=check)
 
+    def _launch_process(self, cmd: list[str]) -> Process:
+        return self._exec.launch_process(cmd)
+
     def ls(
         self,
         path: Dir | Remote | str,
@@ -232,3 +237,120 @@ class Rclone:
         if args is not None:
             cmd_list += args
         return self._run(cmd_list)
+
+    def mount(
+        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.
+
+        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 = convert_to_str(src)
+        cmd_list: list[str] = ["mount", src_str, str(outdir)]
+        if not allow_writes:
+            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.15 → rclone_api-1.0.18}/src/rclone_api/util.py

@@ -54,7 +54,7 @@ def to_path(item: Dir | Remote | str, rclone: Any) -> RPath:
         raise ValueError(f"Invalid type for item: {type(item)}")
 
 
-def _get_verbose(verbose: bool | None) -> bool:
+def get_verbose(verbose: bool | None) -> bool:
     if verbose is not None:
         return verbose
     # get it from the environment
@@ -79,7 +79,7 @@ def rclone_execute(
     verbose: bool | None = None,
 ) -> subprocess.CompletedProcess:
     tempdir: TemporaryDirectory | None = None
-    verbose = _get_verbose(verbose)
+    verbose = get_verbose(verbose)
     assert verbose is not None
 
     try:

rclone_api-1.0.18/src/rclone_api.egg-info/PKG-INFO

@@ -0,0 +1,149 @@
+Metadata-Version: 2.2
+Name: rclone_api
+Version: 1.0.18
+Summary: rclone api in python
+Home-page: https://github.com/zackees/rclone-api
+Maintainer: Zachary Vorhies
+License: BSD 3-Clause License
+Keywords: template-python-cmd
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: home-page
+Dynamic: maintainer
+
+# rclone-api
+
+[![Linting](https://github.com/zackees/rclone-api/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/lint.yml)
+[![MacOS_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml)
+[![Ubuntu_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml)
+[![Win_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml)
+
+Api version of rclone. It's well tested. It's a pretty low level api without the bells and whistles of other apis, but it will get the job done.
+
+You will need to have rclone installed and on your path.
+
+One of the benefits of this api is that it does not use `shell=True`, which can keep `rclone` running in some instances even when try to kill the process.
+
+# Install
+
+`pip install rclone-api`
+
+
+# Examples
+
+You can use env variables or use a `.env` file to store your secrets.
+
+
+# Rclone API Usage Examples
+
+This script demonstrates how to interact with DigitalOcean Spaces using `rclone_api`. 
+
+## Setup & Usage
+
+Ensure you have set the required environment variables:
+
+- `BUCKET_NAME`
+- `BUCKET_KEY_PUBLIC`
+- `BUCKET_KEY_SECRET`
+- `BUCKET_URL`
+
+Then, run the following Python script:
+
+```python
+import os
+from rclone_api import Config, DirListing, File, Rclone, Remote
+
+# Load environment variables
+BUCKET_NAME = os.getenv("BUCKET_NAME")
+BUCKET_KEY_PUBLIC = os.getenv("BUCKET_KEY_PUBLIC")
+BUCKET_KEY_SECRET = os.getenv("BUCKET_KEY_SECRET")
+BUCKET_URL = "sfo3.digitaloceanspaces.com"
+
+# Generate Rclone Configuration
+def generate_rclone_config() -> Config:
+    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)
+
+rclone = Rclone(generate_rclone_config())
+
+# List Available Remotes
+print("\n=== Available Remotes ===")
+remotes = rclone.listremotes()
+for remote in remotes:
+    print(remote)
+
+# List Contents of the Root Bucket
+print("\n=== Listing Root Bucket ===")
+listing = rclone.ls(f"dst:{BUCKET_NAME}", max_depth=-1)
+
+print("\nDirectories:")
+for dir in listing.dirs:
+    print(dir)
+
+print("\nFiles:")
+for file in listing.files:
+    print(file)
+
+# List a Specific Subdirectory
+print("\n=== Listing 'zachs_video' Subdirectory ===")
+path = f"dst:{BUCKET_NAME}/zachs_video"
+listing = rclone.ls(path)
+print(listing)
+
+# List PNG Files in a Subdirectory
+print("\n=== Listing PNG Files ===")
+listing = rclone.ls(path, glob="*.png")
+
+if listing.files:
+    for file in listing.files:
+        print(file)
+
+# Copy a File
+print("\n=== Copying a File ===")
+if listing.files:
+    file = listing.files[0]
+    new_path = f"dst:{BUCKET_NAME}/zachs_video/{file.name}_copy"
+    rclone.copyfile(file, new_path)
+    print(f"Copied {file.name} to {new_path}")
+
+# Copy Multiple Files
+print("\n=== Copying Multiple Files ===")
+if listing.files:
+    file_mapping = {file.name: file.name + "_copy" for file in listing.files[:2]}
+    rclone.copyfiles(file_mapping)
+    print(f"Copied files: {file_mapping}")
+
+# Delete a File
+print("\n=== Deleting a File ===")
+file_to_delete = f"dst:{BUCKET_NAME}/zachs_video/sample.png_copy"
+rclone.deletefiles([file_to_delete])
+print(f"Deleted {file_to_delete}")
+
+# Walk Through a Directory
+print("\n=== Walking Through a Directory ===")
+for dirlisting in rclone.walk(f"dst:{BUCKET_NAME}", max_depth=1):
+    print(dirlisting)
+
+print("Done.")
+```
+
+
+To develop software, run `. ./activate`
+
+# Windows
+
+This environment requires you to use `git-bash`.
+
+# Linting
+
+Run `./lint`

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

@@ -29,6 +29,7 @@ src/rclone_api/dir_listing.py
 src/rclone_api/exec.py
 src/rclone_api/file.py
 src/rclone_api/filelist.py
+src/rclone_api/process.py
 src/rclone_api/rclone.py
 src/rclone_api/remote.py
 src/rclone_api/rpath.py
@@ -43,5 +44,7 @@ src/rclone_api/assets/example.txt
 tests/test_copy.py
 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.15 → 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.15 → 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_mount.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 RcloneMountTests(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(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()

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()

rclone_api-1.0.15/PKG-INFO

@@ -1,34 +0,0 @@
-Metadata-Version: 2.2
-Name: rclone_api
-Version: 1.0.15
-Summary: rclone api in python
-Home-page: https://github.com/zackees/rclone-api
-Maintainer: Zachary Vorhies
-License: BSD 3-Clause License
-Keywords: template-python-cmd
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: python-dotenv>=1.0.0
-Dynamic: home-page
-Dynamic: maintainer
-
-# rclone-api
-
-[![Linting](https://github.com/zackees/rclone-api/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/lint.yml)
-[![MacOS_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml)
-[![Ubuntu_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml)
-[![Win_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml)
-
-Api version of rclone. It's well tested. It's just released so this readme is a little to be desired.
-
-To develop software, run `. ./activate`
-
-# Windows
-
-This environment requires you to use `git-bash`.
-
-# Linting
-
-Run `./lint`

rclone_api-1.0.15/README.md

@@ -1,18 +0,0 @@
-# rclone-api
-
-[![Linting](https://github.com/zackees/rclone-api/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/lint.yml)
-[![MacOS_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml)
-[![Ubuntu_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml)
-[![Win_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml)
-
-Api version of rclone. It's well tested. It's just released so this readme is a little to be desired.
-
-To develop software, run `. ./activate`
-
-# Windows
-
-This environment requires you to use `git-bash`.
-
-# Linting
-
-Run `./lint`

rclone_api-1.0.15/src/rclone_api.egg-info/PKG-INFO

@@ -1,34 +0,0 @@
-Metadata-Version: 2.2
-Name: rclone_api
-Version: 1.0.15
-Summary: rclone api in python
-Home-page: https://github.com/zackees/rclone-api
-Maintainer: Zachary Vorhies
-License: BSD 3-Clause License
-Keywords: template-python-cmd
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: python-dotenv>=1.0.0
-Dynamic: home-page
-Dynamic: maintainer
-
-# rclone-api
-
-[![Linting](https://github.com/zackees/rclone-api/actions/workflows/lint.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/lint.yml)
-[![MacOS_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_macos.yml)
-[![Ubuntu_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_ubuntu.yml)
-[![Win_Tests](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml/badge.svg)](https://github.com/zackees/rclone-api/actions/workflows/push_win.yml)
-
-Api version of rclone. It's well tested. It's just released so this readme is a little to be desired.
-
-To develop software, run `. ./activate`
-
-# Windows
-
-This environment requires you to use `git-bash`.
-
-# Linting
-
-Run `./lint`