rclone-api 1.0.14__py2.py3-none-any.whl → 1.0.17__py2.py3-none-any.whl

rclone_api/__init__.py

@@ -2,8 +2,20 @@ from .config import Config
 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
 
-__all__ = ["Rclone", "File", "Config", "Remote", "Dir", "RPath", "DirListing"]
+__all__ = [
+    "Rclone",
+    "File",
+    "Config",
+    "Remote",
+    "Dir",
+    "RPath",
+    "DirListing",
+    "FileList",
+    "Process",
+]

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
@@ -12,8 +13,20 @@ class RcloneExec:
     rclone_config: Path | Config
     rclone_exe: Path
 
-    def execute(self, cmd: list[str]) -> subprocess.CompletedProcess:
+    def execute(self, cmd: list[str], check: bool) -> subprocess.CompletedProcess:
         """Execute rclone command."""
         from rclone_api.util import rclone_execute
 
-        return rclone_execute(cmd, self.rclone_config, self.rclone_exe)
+        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/file.py

@@ -31,7 +31,7 @@ class File:
         if self.path.is_dir:
             raise RuntimeError("Cannot read a directory as bytes")
 
-        result = self.path.rclone._run(["cat", self.path.path])
+        result = self.path.rclone._run(["cat", self.path.path], check=True)
         return result.stdout
 
     def to_json(self) -> dict:

rclone_api/filelist.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+
+from rclone_api.dir import Dir
+from rclone_api.dir_listing import DirListing
+from rclone_api.file import File
+from rclone_api.rpath import RPath
+
+
+@dataclass
+class FileList:
+    """Remote file dataclass."""
+
+    dirs: list[Dir]
+    files: list[File]
+
+    def _to_dir_list(self) -> list[RPath]:
+        pathlist: list[RPath] = []
+        for d in self.dirs:
+            pathlist.append(d.path)
+        for f in self.files:
+            pathlist.append(f.path)
+        return pathlist
+
+    def __str__(self) -> str:
+        pathlist: list[RPath] = self._to_dir_list()
+        return str(DirListing(pathlist))
+
+    def __repr__(self) -> str:
+        pathlist: list[RPath] = self._to_dir_list()
+        return repr(DirListing(pathlist))

rclone_api/process.py

@@ -0,0 +1,124 @@
+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
+        else:
+            rclone_conf = args.rclone_conf
+
+        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:
+            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/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
@@ -14,6 +15,8 @@ from rclone_api.convert import convert_to_filestr_list, convert_to_str
 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
@@ -29,8 +32,11 @@ 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]) -> subprocess.CompletedProcess:
-        return self._exec.execute(cmd)
+    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,
@@ -63,7 +69,7 @@ class Rclone:
         remote = path.remote if isinstance(path, Dir) else path
         assert isinstance(remote, Remote)
 
-        cp = self._run(cmd)
+        cp = self._run(cmd, check=True)
         text = cp.stdout
         parent_path: str | None = None
         if isinstance(path, Dir):
@@ -159,30 +165,36 @@ class Rclone:
                 # self._run(cmd_list)
                 executor.submit(self._run, cmd_list)
 
-    def copy(self, src: Dir, dst: Dir) -> None:
+    def copy(
+        self, src: Dir | str, dst: Dir | str, filelist: FileList | None = None
+    ) -> subprocess.CompletedProcess:
         """Copy files from source to destination.
 
         Args:
             src: Source directory
             dst: Destination directory
         """
-        src_dir = src.path.path
-        dst_dir = dst.path.path
+        # src_dir = src.path.path
+        # dst_dir = dst.path.path
+        src_dir = convert_to_str(src)
+        dst_dir = convert_to_str(dst)
         cmd_list: list[str] = ["copy", src_dir, dst_dir]
-        self._run(cmd_list)
+        return self._run(cmd_list)
 
-    def purge(self, path: Dir | str) -> None:
+    def purge(self, path: Dir | str) -> subprocess.CompletedProcess:
         """Purge a directory"""
         # path should always be a string
         path = path if isinstance(path, str) else str(path.path)
         cmd_list: list[str] = ["purge", str(path)]
-        self._run(cmd_list)
+        return self._run(cmd_list)
 
-    def deletefiles(self, files: str | File | list[str] | list[File]) -> None:
+    def deletefiles(
+        self, files: str | File | list[str] | list[File]
+    ) -> subprocess.CompletedProcess:
         """Delete a directory"""
         payload: list[str] = convert_to_filestr_list(files)
         cmd_list: list[str] = ["delete"] + payload
-        self._run(cmd_list)
+        return self._run(cmd_list)
 
     def exists(self, path: Dir | Remote | str | File) -> bool:
         """Check if a file or directory exists."""
@@ -205,10 +217,57 @@ class Rclone:
         except subprocess.CalledProcessError:
             return False
 
-    def copy_dir(self, src: str | Dir, dst: str | Dir) -> None:
+    def copy_dir(
+        self, src: str | Dir, dst: str | Dir, args: list[str] | None = None
+    ) -> subprocess.CompletedProcess:
         """Copy a directory from source to destination."""
         # convert src to str, also dst
         src = convert_to_str(src)
         dst = convert_to_str(dst)
         cmd_list: list[str] = ["copy", src, dst]
-        self._run(cmd_list)
+        if args is not None:
+            cmd_list += args
+        return self._run(cmd_list)
+
+    def copy_remote(
+        self, src: Remote, dst: Remote, args: list[str] | None = None
+    ) -> subprocess.CompletedProcess:
+        """Copy a remote to another remote."""
+        cmd_list: list[str] = ["copy", str(src), str(dst)]
+        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
+    ) -> 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")
+        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

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
@@ -75,10 +75,11 @@ def rclone_execute(
     cmd: list[str],
     rclone_conf: Path | Config,
     rclone_exe: Path,
+    check: bool,
     verbose: bool | None = None,
 ) -> subprocess.CompletedProcess:
     tempdir: TemporaryDirectory | None = None
-    verbose = _get_verbose(verbose)
+    verbose = get_verbose(verbose)
     assert verbose is not None
 
     try:
@@ -94,7 +95,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=True, encoding="utf-8", check=check, shell=False
         )
         if cp.returncode != 0:
             cmd_str = subprocess.list2cmdline(cmd)

rclone_api-1.0.17.dist-info/METADATA

@@ -0,0 +1,149 @@
+Metadata-Version: 2.2
+Name: rclone_api
+Version: 1.0.17
+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.17.dist-info/RECORD

@@ -0,0 +1,21 @@
+rclone_api/__init__.py,sha256=UWQMbhE4WOQ3Skfb0LagFKW8PUKUGOm9_T3z--5FHiY,388
+rclone_api/cli.py,sha256=dibfAZIh0kXWsBbfp3onKLjyZXo54mTzDjUdzJlDlWo,231
+rclone_api/config.py,sha256=tP6cU9DnCCEIRc_KP9HPur1jFLLg2QGFSxNwFm6_MVw,118
+rclone_api/convert.py,sha256=Mx9Qo7zhkOedJd8LdhPvNGHp8znJzOk4f_2KWnoGc78,1012
+rclone_api/dir.py,sha256=xUV4i9_E7QHrqHld2IPBlon1CGaAp8qQYMKfJTyVvoQ,2088
+rclone_api/dir_listing.py,sha256=8t5Jx9ZVOJPqGKTJbWaES6bjgogUT2bnpbPVWwK1Fcs,1124
+rclone_api/exec.py,sha256=9qSOpZo8YRYxv3hOvNr57ApnY2KbjxwT1QNr8OgcLM4,883
+rclone_api/file.py,sha256=D02iHJW1LhfOiM_R_yPHP8_ApnDiYrkuraVcrV8-qkw,1246
+rclone_api/filelist.py,sha256=xbiusvNgaB_b_kQOZoHMJJxn6TWGtPrWd2J042BI28o,767
+rclone_api/process.py,sha256=QLI-65R4Jvov9oOJSVY5UpDOS2xj6m-9YCg8upR4-0M,3560
+rclone_api/rclone.py,sha256=hvzo5zZmP5IQAtuwLcsTeeazDY0slqz76DdulV2mn3s,9640
+rclone_api/remote.py,sha256=c9hlRKBCg1BFB9MCINaQIoCg10qyAkeqiS4brl8ce-8,343
+rclone_api/rpath.py,sha256=8ZA_1wxWtskwcy0I8V2VbjKDmzPkiWd8Q2JQSvh-sYE,2586
+rclone_api/util.py,sha256=BDRJ2MIceDoKVTjUQBwyhjbA8UwPrZ-0ZSa9xyMJd0E,3343
+rclone_api/walk.py,sha256=J78-bY2AhNpt2ICsI5LqmXRE7oC6wVDoKoicIoU6XMg,1953
+rclone_api/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
+rclone_api-1.0.17.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+rclone_api-1.0.17.dist-info/METADATA,sha256=9_ahew4G4YXDjXQljGkoA8s1KZa76mPrv3TZ99c2Xo4,4421
+rclone_api-1.0.17.dist-info/WHEEL,sha256=9Hm2OB-j1QcCUq9Jguht7ayGIIZBRTdOXD1qg9cCgPM,109
+rclone_api-1.0.17.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
+rclone_api-1.0.17.dist-info/RECORD,,

rclone_api-1.0.14.dist-info/METADATA

@@ -1,34 +0,0 @@
-Metadata-Version: 2.2
-Name: rclone_api
-Version: 1.0.14
-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.14.dist-info/RECORD

@@ -1,19 +0,0 @@
-rclone_api/__init__.py,sha256=gca3IDhDdKBtyoS1ekGQ-xTa6zrShZ6Gb4XS8ChdlYo,266
-rclone_api/cli.py,sha256=dibfAZIh0kXWsBbfp3onKLjyZXo54mTzDjUdzJlDlWo,231
-rclone_api/config.py,sha256=tP6cU9DnCCEIRc_KP9HPur1jFLLg2QGFSxNwFm6_MVw,118
-rclone_api/convert.py,sha256=Mx9Qo7zhkOedJd8LdhPvNGHp8znJzOk4f_2KWnoGc78,1012
-rclone_api/dir.py,sha256=xUV4i9_E7QHrqHld2IPBlon1CGaAp8qQYMKfJTyVvoQ,2088
-rclone_api/dir_listing.py,sha256=8t5Jx9ZVOJPqGKTJbWaES6bjgogUT2bnpbPVWwK1Fcs,1124
-rclone_api/exec.py,sha256=PgiNF5eQpsY8Pb62ZPwLli1WA9iMEJeMZwX43VEYKII,472
-rclone_api/file.py,sha256=bb9FWQy54wKRydy0M12MQwNxycBwRSn_10ubYGAw0ag,1234
-rclone_api/rclone.py,sha256=m2V3BQX0buK3mwImBiTSNTUh_JcdQJ27OeJWxqvgRZs,7455
-rclone_api/remote.py,sha256=c9hlRKBCg1BFB9MCINaQIoCg10qyAkeqiS4brl8ce-8,343
-rclone_api/rpath.py,sha256=8ZA_1wxWtskwcy0I8V2VbjKDmzPkiWd8Q2JQSvh-sYE,2586
-rclone_api/util.py,sha256=uiTfOlKCFB5FdUkYR2-Hriz0fVyrWeuZtSgHgc9RrpA,3328
-rclone_api/walk.py,sha256=J78-bY2AhNpt2ICsI5LqmXRE7oC6wVDoKoicIoU6XMg,1953
-rclone_api/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
-rclone_api-1.0.14.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-rclone_api-1.0.14.dist-info/METADATA,sha256=pATg2JeY8MQ2I7kywlJj6x4KPdL0QKKcbxjxbvq1OCs,1375
-rclone_api-1.0.14.dist-info/WHEEL,sha256=9Hm2OB-j1QcCUq9Jguht7ayGIIZBRTdOXD1qg9cCgPM,109
-rclone_api-1.0.14.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
-rclone_api-1.0.14.dist-info/RECORD,,