rclone-api 1.1.7__py2.py3-none-any.whl → 1.1.8__py2.py3-none-any.whl

rclone_api/cmd/copy_large_s3.py

@@ -12,8 +12,8 @@ class Args:
     config_path: Path
     src: str
     dst: str
-    chunk_size_mb: SizeSuffix
-    read_concurrent_chunks: int
+    chunk_size: SizeSuffix
+    threads: int
     retries: int
     save_state_json: Path
     verbose: bool
@@ -38,13 +38,13 @@ def _parse_args() -> Args:
         "--chunk-size",
         help="Chunk size that will be read and uploaded in in SizeSuffix (i.e. 128M = 128 megabytes) form",
         type=str,
-        default="128M",
+        default="512M",
     )
     parser.add_argument(
-        "--read-concurrent-chunks",
-        help="Maximum number of chunks to read in a look ahead cache",
+        "--threads",
+        help="Number of threads to use per chunk",
         type=int,
-        default=1,
+        default=16,
     )
     parser.add_argument("--retries", help="Number of retries", type=int, default=3)
     parser.add_argument(
@@ -59,8 +59,8 @@ def _parse_args() -> Args:
         config_path=Path(args.config),
         src=args.src,
         dst=args.dst,
-        chunk_size_mb=SizeSuffix(args.chunk_size),
-        read_concurrent_chunks=args.read_concurrent_chunks,
+        chunk_size=SizeSuffix(args.chunk_size),
+        threads=args.threads,
         retries=args.retries,
         save_state_json=args.resume_json,
         verbose=args.verbose,
@@ -72,11 +72,15 @@ def main() -> int:
     """Main entry point."""
     args = _parse_args()
     rclone = Rclone(rclone_conf=args.config_path)
+    # unit_chunk = args.chunk_size / args.threads
     rslt: MultiUploadResult = rclone.copy_file_resumable_s3(
         src=args.src,
         dst=args.dst,
-        chunk_size=args.chunk_size_mb * _1MB,
-        concurrent_chunks=args.read_concurrent_chunks,
+        chunk_size=args.chunk_size,
+        threads=args.threads,
+        # vfs_read_chunk_size=unit_chunk,
+        # vfs_read_chunk_size_limit=args.chunk_size,
+        # vfs_read_chunk_streams=args.threads,
         retries=args.retries,
         save_state_json=args.save_state_json,
         verbose=args.verbose,

rclone_api/experimental/flags.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 
 from rclone_api.experimental.flags_base import BaseFlags, merge_flags
+from rclone_api.types import SizeSuffix
 
 
 @dataclass
@@ -20,7 +21,7 @@ class CopyFlags(BaseFlags):
     links: bool | None = None
     max_backlog: int | None = None
     max_duration: str | None = None
-    max_transfer: str | None = None
+    max_transfer: SizeSuffix | None = None
     metadata: bool | None = None
     modify_window: str | None = None
     multi_thread_chunk_size: str | None = None
@@ -77,6 +78,12 @@ def unit_test() -> None:
     merged_d_c = copy_flags_d.merge(copy_flags_c)
     print("C:", merged_d_c)
 
+    # now do the one with the SizeSuffix type
+    copy_flags_e = CopyFlags(max_transfer=SizeSuffix("128M"))
+    copy_flags_f = CopyFlags(max_transfer=SizeSuffix("256M"))
+    merged_e_f = copy_flags_e.merge(copy_flags_f)
+    print("D:", merged_e_f)
+
 
 if __name__ == "__main__":
     unit_test()

rclone_api/mount.py

@@ -1,12 +1,30 @@
+import os
 import platform
 import subprocess
 import time
 import warnings
+from dataclasses import dataclass
 from pathlib import Path
+from typing import Any
+
+from rclone_api.process import Process
 
 _SYSTEM = platform.system()  # "Linux", "Darwin", "Windows", etc.
 
 
+@dataclass
+class Mount:
+    """Mount information."""
+
+    mount_path: Path
+    process: Process
+
+    def __post_init__(self):
+        assert isinstance(self.mount_path, Path)
+        assert self.process is not None
+        wait_for_mount(self.mount_path, self.process)
+
+
 def run_command(cmd: str, verbose: bool) -> int:
     """Run a shell command and print its output if verbose is True."""
     if verbose:
@@ -36,7 +54,27 @@ def prepare_mount(outdir: Path, verbose: bool) -> None:
         outdir.mkdir(parents=True, exist_ok=True)
 
 
-def clean_mount(mount_path: Path, verbose: bool = False) -> None:
+def wait_for_mount(path: Path, mount_process: Any, timeout: int = 10) -> None:
+    from rclone_api.process import Process
+
+    assert isinstance(mount_process, Process)
+    expire_time = time.time() + timeout
+    while time.time() < expire_time:
+        rtn = mount_process.poll()
+        if rtn is not None:
+            cmd_str = subprocess.list2cmdline(mount_process.cmd)
+            raise subprocess.CalledProcessError(rtn, cmd_str)
+        if path.exists():
+            # how many files?
+            dircontents = os.listdir(str(path))
+            if len(dircontents) > 0:
+                print(f"Mount point {path}, waiting 5 seconds for files to appear.")
+                time.sleep(5)
+                return
+        time.sleep(1)
+
+
+def clean_mount(mount: Mount | Path, verbose: bool = False) -> None:
     """
     Clean up a mount path across Linux, macOS, and Windows.
 
@@ -45,7 +83,14 @@ def clean_mount(mount_path: Path, verbose: bool = False) -> None:
     and 'umount'. On macOS it uses 'umount' (and optionally 'diskutil unmount'),
     while on Windows it attempts to remove the mount point via 'mountvol /D'.
     """
+    proc = mount.process if isinstance(mount, Mount) else None
+    if proc is not None and proc.poll() is None:
+        if verbose:
+            print(f"Terminating mount process {proc.pid}")
+        proc.kill()
+
     # Check if the mount path exists; if an OSError occurs, assume it exists.
+    mount_path = mount.mount_path if isinstance(mount, Mount) else mount
     try:
         mount_exists = mount_path.exists()
     except OSError as e:

rclone_api/process.py

@@ -100,6 +100,10 @@ class Process:
             except Exception as e:
                 print(f"Error cleaning up tempdir: {e}")
 
+    @property
+    def pid(self) -> int:
+        return self.process.pid
+
     def __del__(self) -> None:
         self.cleanup()
 

rclone_api/rclone.py

@@ -25,6 +25,7 @@ from rclone_api.dir_listing import DirListing
 from rclone_api.exec import RcloneExec
 from rclone_api.file import File
 from rclone_api.group_files import group_files
+from rclone_api.mount import Mount, clean_mount, prepare_mount
 from rclone_api.process import Process
 from rclone_api.remote import Remote
 from rclone_api.rpath import RPath
@@ -46,12 +47,9 @@ from rclone_api.util import (
     get_rclone_exe,
     get_verbose,
     to_path,
-    wait_for_mount,
 )
 from rclone_api.walk import walk
 
-_IS_WINDOWS = os.name == "nt"
-
 
 def rclone_verbose(verbose: bool | None) -> bool:
     if verbose is not None:
@@ -680,12 +678,7 @@ class Rclone:
         dst: str,
         save_state_json: Path,
         chunk_size: SizeSuffix | None = None,
-        # 16
-        # * 1024
-        # * 1024,  # This setting will scale the performance of the upload
-        concurrent_chunks: (
-            int | None
-        ) = None,  # This setting will scale the performance of the upload
+        threads: int = 16,
         retries: int = 3,
         verbose: bool | None = None,
         max_chunks_before_suspension: int | None = None,
@@ -696,30 +689,24 @@ class Rclone:
         from rclone_api.s3.create import S3Credentials
         from rclone_api.util import S3PathInfo, random_str, split_s3_path
 
-        _tmp: SizeSuffix | str = chunk_size or "16MiB"
-        chunk_size = SizeSuffix(_tmp)
-        assert chunk_size is not None
-        concurrent_chunks = concurrent_chunks or 4
-        size_limit = SizeSuffix(chunk_size * concurrent_chunks)
-
-        other_args: list[str] = [
-            "--no-modtime",
-            "--vfs-read-wait",
-            "1s",
-            "--vfs-disk-space-total-size",
-            size_limit.as_str(),  # purge quickly.
-            "--vfs-read-chunk-size",
-            chunk_size.as_str(),
+        other_args: list[str] = ["--no-modtime", "--vfs-read-wait", "1s"]
+        chunk_size = chunk_size or SizeSuffix("128M")
+        unit_chunk_size = chunk_size / threads
+        vfs_read_chunk_size = unit_chunk_size
+        vfs_read_chunk_size_limit = chunk_size
+        vfs_read_chunk_streams = threads
+        assert (
+            chunk_size.as_int() % vfs_read_chunk_size.as_int() == 0
+        ), f"chunk_size {chunk_size} must be a multiple of vfs_read_chunk_size {vfs_read_chunk_size}"
+        other_args += ["--vfs-read-chunk-size", vfs_read_chunk_size.as_str()]
+        other_args += [
             "--vfs-read-chunk-size-limit",
-            size_limit.as_str(),
-            "--vfs-read-chunk-streams",
-            str(concurrent_chunks),
-            "--vfs-fast-fingerprint",
+            vfs_read_chunk_size_limit.as_str(),
         ]
+        other_args += ["--vfs-read-chunk-streams", str(vfs_read_chunk_streams)]
         mount_path = mount_path or Path("tmp_mnts") / random_str(12)
         src_path = Path(src)
         name = src_path.name
-
         parent_path = str(src_path.parent.as_posix())
         with self.scoped_mount(
             parent_path,
@@ -847,7 +834,7 @@ class Rclone:
         vfs_cache_mode: str | None = None,
         verbose: bool | None = None,
         other_args: list[str] | None = None,
-    ) -> Process:
+    ) -> Mount:
         """Mount a remote or directory to a local path.
 
         Args:
@@ -860,7 +847,6 @@ class Rclone:
         Raises:
             subprocess.CalledProcessError: If the mount operation fails
         """
-        from rclone_api.mount import clean_mount, prepare_mount
 
         allow_writes = allow_writes or False
         use_links = use_links or True
@@ -882,8 +868,9 @@ class Rclone:
         if other_args:
             cmd_list += other_args
         proc = self._launch_process(cmd_list)
-        wait_for_mount(outdir, proc)
-        return proc
+
+        mount: Mount = Mount(mount_path=outdir, process=proc)
+        return mount
 
     @contextmanager
     def scoped_mount(
@@ -895,11 +882,11 @@ class Rclone:
         vfs_cache_mode: str | None = None,
         verbose: bool | None = None,
         other_args: list[str] | None = None,
-    ) -> Generator[Process, None, None]:
+    ) -> Generator[Mount, None, None]:
         """Like mount, but can be used in a context manager."""
         error_happened = False
         verbose = get_verbose(verbose)
-        proc = self.mount(
+        mount: Mount = self.mount(
             src,
             outdir,
             allow_writes=allow_writes,
@@ -909,77 +896,18 @@ class Rclone:
             other_args=other_args,
         )
         try:
-            yield proc
+            yield mount
         except Exception as e:
             error_happened = True
             stack_trace = traceback.format_exc()
             warnings.warn(f"Error in scoped_mount: {e}\n\nStack Trace:\n{stack_trace}")
             raise
         finally:
-            if proc.poll() is None:
-                proc.terminate()
-            proc.wait()
+
             if not error_happened:
                 from rclone_api.mount import clean_mount
 
-                clean_mount(outdir, verbose=verbose)
-
-    @deprecated("mount")
-    def mount_webdav(
-        self,
-        url: str,
-        outdir: Path,
-        vfs_cache_mode: str | None = None,
-        vfs_disk_space_total_size: str | None = "10G",
-        other_args: 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
-        """
-        other_args = other_args or []
-        if vfs_cache_mode is None:
-            if "--vfs-cache-mode" in other_args:
-                pass
-            else:
-                vfs_cache_mode = "full"
-        elif "--vfs-cache-mode" in other_args:
-            warnings.warn(
-                f"vfs_cache_mode is set to {vfs_cache_mode} but --vfs-cache-mode is already in other_args"
-            )
-            idx = other_args.index("--vfs-cache-mode")
-            other_args.pop(idx)
-            other_args.pop(idx)  # also the next value which will be the cache mode.
-
-        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)]
-        if vfs_cache_mode:
-            cmd_list.append("--vfs-cache-mode")
-            cmd_list.append(vfs_cache_mode)
-        if other_args:
-            cmd_list += other_args
-        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
+                clean_mount(mount, verbose=verbose)
 
     # Settings optimized for s3.
     def mount_s3(
@@ -988,11 +916,8 @@ class Rclone:
         outdir: Path,
         allow_writes=False,
         vfs_cache_mode="full",
-        # dir-cache-time
         dir_cache_time: str | None = "1h",
         attribute_timeout: str | None = "1h",
-        # --vfs-cache-max-size
-        # vfs-cache-max-size
         vfs_disk_space_total_size: str | None = "100M",
         transfers: int | None = 128,
         modtime_strategy: (
@@ -1004,7 +929,7 @@ class Rclone:
         # vfs-refresh
         vfs_refresh: bool = True,
         other_args: list[str] | None = None,
-    ) -> Process:
+    ) -> Mount:
         """Mount a remote or directory to a local path.
 
         Args:

rclone_api/s3/chunk_types.py

@@ -7,6 +7,7 @@ from threading import Lock
 
 from botocore.client import BaseClient
 
+from rclone_api.types import SizeSuffix
 from rclone_api.util import locked_print
 
 _MIN_UPLOAD_CHUNK_SIZE = 5 * 1024 * 1024  # 5MB
@@ -108,16 +109,20 @@ class UploadInfo:
             value = getattr(self, f.name)
             # Convert non-serializable objects (like s3_client) to a string representation.
             if f.name == "s3_client":
-                json_dict[f.name] = "RUNTIME OBJECT"
+                continue
             else:
                 if isinstance(value, Path):
                     value = str(value)
                 json_dict[f.name] = value
+
         return json_dict
 
     @staticmethod
     def from_json(s3_client: BaseClient, json_dict: dict) -> "UploadInfo":
-        json_dict.pop("s3_client")  # Remove the placeholder string
+        # json_dict.pop("s3_client")  # Remove the placeholder string
+        if "s3_client" in json_dict:
+            json_dict.pop("s3_client")
+
         return UploadInfo(s3_client=s3_client, **json_dict)
 
 
@@ -224,6 +229,12 @@ class UploadState:
 
         # self.count()
         finished_count, total = self.count()
+        total_finished: SizeSuffix = SizeSuffix(
+            finished_count * self.upload_info.chunk_size
+        )
+        total_remaining: SizeSuffix = SizeSuffix(
+            self.remaining() * self.upload_info.chunk_size
+        )
 
         # parts.sort(key=lambda x: x.part_number)  # Some backends need this.
         out_json = {
@@ -232,6 +243,10 @@ class UploadState:
             "is_done": is_done,
             "finished_count": finished_count,
             "total_parts": total,
+            "total_size": SizeSuffix(self.upload_info.file_size).as_str(),
+            "total_finished": total_finished.as_str(),
+            "total_remaining": total_remaining.as_str(),
+            "completed": f"{(finished_count / total) * 100:.2f}%",
         }
 
         # check that we can sererialize

rclone_api/types.py

@@ -58,6 +58,8 @@ _PATTERN_SIZE_SUFFIX = re.compile(r"^(\d+)([A-Za-z]+)$")
 def _from_size_suffix(size: str) -> int:
     # 16MiB
     # parse out number and suffix
+    if size == "0":
+        return 0
     match = _PATTERN_SIZE_SUFFIX.match(size)
     if match is None:
         raise ValueError(f"Invalid size suffix: {size}")
@@ -88,6 +90,8 @@ class SizeSuffix:
             self._size = size
         elif isinstance(size, str):
             self._size = _from_size_suffix(size)
+        elif isinstance(size, float):
+            self._size = int(size)
         else:
             raise ValueError(f"Invalid type for size: {type(size)}")
 
@@ -123,3 +127,10 @@ class SizeSuffix:
     def __sub__(self, other: "int | SizeSuffix") -> "SizeSuffix":
         other_int = SizeSuffix(other)
         return SizeSuffix(self._size - other_int._size)
+
+    def __truediv__(self, other: "int | SizeSuffix") -> "SizeSuffix":
+        other_int = SizeSuffix(other)
+        if other_int._size == 0:
+            raise ZeroDivisionError("Division by zero is undefined")
+        # Use floor division to maintain integer arithmetic.
+        return SizeSuffix(self._size // other_int._size)

rclone_api/util.py

@@ -1,7 +1,6 @@
 import os
 import shutil
 import subprocess
-import time
 import warnings
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -135,26 +134,6 @@ def rclone_execute(
                 print(f"Error cleaning up tempdir: {e}")
 
 
-def wait_for_mount(path: Path, mount_process: Any, timeout: int = 10) -> None:
-    from rclone_api.process import Process
-
-    assert isinstance(mount_process, Process)
-    expire_time = time.time() + timeout
-    while time.time() < expire_time:
-        rtn = mount_process.poll()
-        if rtn is not None:
-            cmd_str = subprocess.list2cmdline(mount_process.cmd)
-            raise subprocess.CalledProcessError(rtn, cmd_str)
-        if path.exists():
-            # how many files?
-            dircontents = os.listdir(str(path))
-            if len(dircontents) > 0:
-                print(f"Mount point {path}, waiting 5 seconds for files to appear.")
-                time.sleep(5)
-                return
-        time.sleep(1)
-
-
 def split_s3_path(path: str) -> S3PathInfo:
     if ":" not in path:
         raise ValueError(f"Invalid S3 path: {path}")

{rclone_api-1.1.7.dist-info → rclone_api-1.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.1.7
+Version: 1.1.8
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 License: BSD 3-Clause License

{rclone_api-1.1.7.dist-info → rclone_api-1.1.8.dist-info}/RECORD

@@ -11,30 +11,30 @@ rclone_api/exec.py,sha256=1ovvaMXDEfLiT7BrYZyE85u_yFhEUwUNW3jPOzqknR8,1023
 rclone_api/file.py,sha256=EP5yT2dZ0H2p7CY5n0y5k5pHhIliV25pm8KOwBklUTk,1863
 rclone_api/filelist.py,sha256=xbiusvNgaB_b_kQOZoHMJJxn6TWGtPrWd2J042BI28o,767
 rclone_api/group_files.py,sha256=H92xPW9lQnbNw5KbtZCl00bD6iRh9yRbCuxku4j_3dg,8036
-rclone_api/mount.py,sha256=Zf41gGfTXtSB-KkQoXCq_dpqBvezgz_dPBzk_aDk5Dc,4354
-rclone_api/process.py,sha256=RrMfTe0bndmJ6gBK67ioqNvCstJ8aTC8RlGX1XBLlcw,4191
-rclone_api/rclone.py,sha256=yI_8QdDXppcLO-KbRVGteu-onTa4fTd4ojy_N1HYxx4,42029
+rclone_api/mount.py,sha256=8vSXIaVwj6RNwPvk0N4IA6pPBXkI3XRnO4W0JcrAbDc,5759
+rclone_api/process.py,sha256=xYUgU17txkZfZdr4vtRfvD8YjvSfdrbjM7PYW1npAMI,4264
+rclone_api/rclone.py,sha256=-WJseVj--ko_D4dLcEqtfG6i7G_U3fu4YL95XCWH1wE,39718
 rclone_api/remote.py,sha256=O9WDUFQy9f6oT1HdUbTixK2eg0xtBBm8k4Xl6aa6K00,431
 rclone_api/rpath.py,sha256=8ZA_1wxWtskwcy0I8V2VbjKDmzPkiWd8Q2JQSvh-sYE,2586
 rclone_api/scan_missing_folders.py,sha256=Kulca2Q6WZodt00ATFHkmqqInuoPvBkhTcS9703y6po,4740
-rclone_api/types.py,sha256=e7VmqA2U6MkTT9VDHeP2qwRw_lUUFbaiN6RO-R8B1oo,3336
-rclone_api/util.py,sha256=ujinqW4xUkZAHBCL1VMhGu88LMdUFIu1ApF8rZEH8rQ,5324
+rclone_api/types.py,sha256=OWj9mUFaehC3PMAyt-uBYB1V2MfQ-ugJfUlIVjZ09cw,3775
+rclone_api/util.py,sha256=_Z-GUMVXnHYOGdo2dy2ie2P5fGgyg8KdGjHKicx68Ko,4573
 rclone_api/walk.py,sha256=-54NVE8EJcCstwDoaC_UtHm73R2HrZwVwQmsnv55xNU,3369
 rclone_api/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
-rclone_api/cmd/copy_large_s3.py,sha256=kF0wRVRGjIB2CxuwN4z1WnfYjiux7fHkY9FLCw3EJsI,2999
+rclone_api/cmd/copy_large_s3.py,sha256=DNALWMwinu7I03nBhao-7Huo7OoS5k1HcqiaHTM0QZU,3071
 rclone_api/cmd/list_files.py,sha256=x8FHODEilwKqwdiU1jdkeJbLwOqUkUQuDWPo2u_zpf0,741
-rclone_api/experimental/flags.py,sha256=0-mtXg9J4MoMm2uBKbsMLj4pSGRLQUAqNRDJWGttnAQ,2443
+rclone_api/experimental/flags.py,sha256=qCVD--fSTmzlk9hloRLr0q9elzAOFzPsvVpKM3aB1Mk,2739
 rclone_api/experimental/flags_base.py,sha256=ajU_czkTcAxXYU-SlmiCfHY7aCQGHvpCLqJ-Z8uZLk0,2102
 rclone_api/s3/api.py,sha256=VstlaEnBjO2JDQuCRLdTfUGvQLbfshlXXhAzimFv4Vc,3763
 rclone_api/s3/basic_ops.py,sha256=hK3366xhVEzEcjz9Gk_8lFx6MRceAk72cax6mUrr6ko,2104
 rclone_api/s3/chunk_file.py,sha256=XPoDl7DJMJIGBMRoPO2wqwqCMT7ZrIsEkDqlbMH8jzs,3506
-rclone_api/s3/chunk_types.py,sha256=Fq0IlhZ0IftuFQFkbICmmrOonII0BNzuY4CIKNC4wB0,8006
+rclone_api/s3/chunk_types.py,sha256=6_ythhT7EcchJ9MI8qBKVKh-SVOe1Rf15t_JepHPilA,8587
 rclone_api/s3/chunk_uploader.py,sha256=KO8834Gery9HKWSqjQTNW0pbBbVoGrza9gj-1OaNLQQ,9130
 rclone_api/s3/create.py,sha256=SK3IGHZwsSkoG4Zb4NCphcVg9_f7VifDKng-tExMS2s,3088
 rclone_api/s3/types.py,sha256=81_3jwg6MGIxC-GxL-6zANzKO6au9C0BWvAqRyODxOM,1361
-rclone_api-1.1.7.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-rclone_api-1.1.7.dist-info/METADATA,sha256=HujPmSO7dGtf6yoYvjQ3ZkVHfezRF9sTXx1ZXLcaCO8,4478
-rclone_api-1.1.7.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
-rclone_api-1.1.7.dist-info/entry_points.txt,sha256=6eNqTRXKhVf8CpWNjXiOa_0Du9tHiW_HD2iQSXRsUg8,132
-rclone_api-1.1.7.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
-rclone_api-1.1.7.dist-info/RECORD,,
+rclone_api-1.1.8.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+rclone_api-1.1.8.dist-info/METADATA,sha256=o2HlbSg87QWtMTq0983EdoivnDCTUsPI4tN5Cowi5Tc,4478
+rclone_api-1.1.8.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+rclone_api-1.1.8.dist-info/entry_points.txt,sha256=6eNqTRXKhVf8CpWNjXiOa_0Du9tHiW_HD2iQSXRsUg8,132
+rclone_api-1.1.8.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
+rclone_api-1.1.8.dist-info/RECORD,,