rclone-api 1.5.52__py3-none-any.whl → 1.5.54__py3-none-any.whl

rclone_api/fs/filesystem.py

@@ -1,318 +1,330 @@
-import abc
-import logging
-import shutil
-import warnings
-from pathlib import Path
-
-from rclone_api.config import Config
-
-logger = logging.getLogger(__name__)
-
-
-class FS(abc.ABC):
-    def __init__(self) -> None:
-        pass
-
-    @abc.abstractmethod
-    def copy(self, src: Path | str, dst: Path | str) -> None:
-        pass
-
-    @abc.abstractmethod
-    def read_bytes(self, path: Path | str) -> bytes:
-        pass
-
-    @abc.abstractmethod
-    def exists(self, path: Path | str) -> bool:
-        pass
-
-    @abc.abstractmethod
-    def write_binary(self, path: Path | str, data: bytes) -> None:
-        pass
-
-    @abc.abstractmethod
-    def mkdir(self, path: str, parents=True, exist_ok=True) -> None:
-        pass
-
-    @abc.abstractmethod
-    def ls(self, path: Path | str) -> tuple[list[str], list[str]]:
-        """First is files and second is directories."""
-        pass
-
-    @abc.abstractmethod
-    def cwd(self) -> "FSPath":
-        pass
-
-    @abc.abstractmethod
-    def get_path(self, path: str) -> "FSPath":
-        pass
-
-    @abc.abstractmethod
-    def dispose(self) -> None:
-        pass
-
-
-class RealFS(FS):
-
-    @staticmethod
-    def from_path(path: Path | str) -> "FSPath":
-        path_str = Path(path).as_posix()
-        return FSPath(RealFS(), path_str)
-
-    def __init__(self) -> None:
-        super().__init__()
-
-    def ls(self, path: Path | str) -> tuple[list[str], list[str]]:
-        files_and_dirs = [str(p) for p in Path(path).iterdir()]
-        files = [f for f in files_and_dirs if Path(f).is_file()]
-        dirs = [d for d in files_and_dirs if Path(d).is_dir()]
-        return files, dirs
-
-    def cwd(self) -> "FSPath":
-        return RealFS.from_path(Path.cwd())
-
-    def copy(self, src: Path | str, dst: Path | str) -> None:
-        shutil.copy(str(src), str(dst))
-
-    def read_bytes(self, path: Path | str) -> bytes:
-        with open(path, "rb") as f:
-            return f.read()
-
-    def write_binary(self, path: Path | str, data: bytes) -> None:
-        with open(path, "wb") as f:
-            f.write(data)
-
-    def exists(self, path: Path | str) -> bool:
-        return Path(path).exists()
-
-    def mkdir(self, path: str, parents=True, exist_ok=True) -> None:
-        Path(path).mkdir(parents=parents, exist_ok=exist_ok)
-
-    def get_path(self, path: str) -> "FSPath":
-        return FSPath(self, path)
-
-    def dispose(self) -> None:
-        pass
-
-
-class RemoteFS(FS):
-
-    @staticmethod
-    def from_rclone_config(
-        src: str, rclone_conf: Path | Config | str | dict | None
-    ) -> "RemoteFS":
-        if isinstance(rclone_conf, str) or isinstance(rclone_conf, dict):
-            rclone_conf = Config(text=rclone_conf)
-        return RemoteFS(rclone_conf, src)
-
-    def __init__(self, rclone_conf: Path | Config | None, src: str) -> None:
-        from rclone_api import HttpServer, Rclone
-
-        super().__init__()
-        self.src = src
-        self.shutdown = False
-        self.server: HttpServer | None = None
-        if rclone_conf is None:
-            from rclone_api.config import find_conf_file
-
-            rclone_conf = find_conf_file()
-            if rclone_conf is None:
-                raise FileNotFoundError("rclone.conf not found")
-        self.rclone_conf = rclone_conf
-        self.rclone: Rclone = Rclone(rclone_conf)
-        self.server = self.rclone.serve_http(src=src)
-
-    def root(self) -> "FSPath":
-        return FSPath(self, self.src)
-
-    def cwd(self) -> "FSPath":
-        return self.root()
-
-    def _to_str(self, path: Path | str) -> str:
-        if isinstance(path, Path):
-            return path.as_posix()
-        return path
-
-    def _to_remote_path(self, path: str | Path) -> str:
-        return Path(path).relative_to(self.src).as_posix()
-
-    def copy(self, src: Path | str, dst: Path | str) -> None:
-        from rclone_api.completed_process import CompletedProcess
-
-        src = src if isinstance(src, Path) else Path(src)
-        if not src.is_file():
-            raise FileNotFoundError(f"File not found: {src}")
-        dst = self._to_remote_path(dst)
-
-        is_s3 = self.rclone.is_s3(dst)
-        if is_s3:
-            filesize = src.stat().st_size
-            if filesize < 512 * 1024 * 1024:
-                logger.info(f"S3 OPTIMIZED: Copying {src} -> {dst}")
-                err = self.rclone.copy_file_s3(src, dst)
-                if isinstance(err, Exception):
-                    raise FileNotFoundError(
-                        f"File not found: {src}, specified by {err}"
-                    )
-                return
-        # Fallback.
-        logging.info(f"Copying {src} -> {dst}")
-        src_path = src.as_posix()
-        cp: CompletedProcess = self.rclone.copy(src_path, dst)
-        if cp.returncode != 0:
-            raise FileNotFoundError(f"File not found: {src}, specified by {cp.stderr}")
-
-    def read_bytes(self, path: Path | str) -> bytes:
-        path = self._to_str(path)
-        err = self.rclone.read_bytes(path)
-        if isinstance(err, Exception):
-            raise FileNotFoundError(f"File not found: {path}")
-        return err
-
-    def write_binary(self, path: Path | str, data: bytes) -> None:
-        path = self._to_str(path)
-        self.rclone.write_bytes(data, path)  # Already optimized for s3.
-
-    def exists(self, path: Path | str) -> bool:
-        from rclone_api.http_server import HttpServer
-
-        assert isinstance(self.server, HttpServer)
-        path = self._to_str(path)
-        dst_rel = self._to_remote_path(path)
-        return self.server.exists(dst_rel)
-
-    def mkdir(self, path: str, parents=True, exist_ok=True) -> None:
-        # Ignore mkdir for remote backend, it will be made when file is written.
-        import warnings
-
-        warnings.warn("mkdir is not supported for remote backend", stacklevel=2)
-        return None
-
-    def is_dir(self, path: Path | str) -> bool:
-        from rclone_api.http_server import HttpServer
-
-        assert isinstance(self.server, HttpServer)
-        path = self._to_remote_path(path)
-        err = self.server.list(path)
-        return isinstance(err, list)
-
-    def is_file(self, path: Path | str) -> bool:
-        from rclone_api.http_server import HttpServer
-
-        assert isinstance(self.server, HttpServer)
-        path = self._to_remote_path(path)
-        err = self.server.list(path)
-        # Make faster.
-        return isinstance(err, Exception) and self.exists(path)
-
-    def ls(self, path: Path | str) -> tuple[list[str], list[str]]:
-        from rclone_api.http_server import HttpServer
-
-        assert isinstance(self.server, HttpServer)
-        path = self._to_remote_path(path)
-        err = self.server.list(path)
-        if isinstance(err, Exception):
-            raise FileNotFoundError(f"File not found: {path}, because of {err}")
-        return err
-
-    def get_path(self, path: str) -> "FSPath":
-        return FSPath(self, path)
-
-    def dispose(self) -> None:
-        if self.shutdown or not self.server:
-            return
-        self.shutdown = True
-        self.server.shutdown()
-
-    def __del__(self) -> None:
-        self.dispose()
-
-
-class FSPath:
-    def __init__(self, fs: FS, path: str) -> None:
-        self.fs: FS = fs
-        self.path: str = path
-        self.fs_holder: FS | None = None
-
-    def set_owner(self) -> None:
-        self.fs_holder = self.fs
-
-    def is_real_fs(self) -> bool:
-        return isinstance(self.fs, RealFS)
-
-    def read_text(self) -> str:
-        data = self.read_bytes()
-        return data.decode("utf-8")
-
-    def read_bytes(self) -> bytes:
-        data: bytes | None = None
-        try:
-            data = self.fs.read_bytes(self.path)
-            return data
-        except Exception as e:
-            raise FileNotFoundError(f"File not found: {self.path}, because of {e}")
-
-    def exists(self) -> bool:
-        return self.fs.exists(self.path)
-
-    def __str__(self) -> str:
-        return self.path
-
-    def __repr__(self) -> str:
-        return f"FSPath({self.path})"
-
-    def __enter__(self) -> "FSPath":
-        if self.fs_holder is not None:
-            warnings.warn("This operation is reserved for the cwd returned by FS")
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        if self.fs_holder is not None:
-            self.fs_holder.dispose()
-            self.fs_holder = None
-
-    def mkdir(self, parents=True, exist_ok=True) -> None:
-        self.fs.mkdir(self.path, parents=parents, exist_ok=exist_ok)
-
-    def write_text(self, data: str, encoding: str | None = None) -> None:
-        if encoding is None:
-            encoding = "utf-8"
-        self.write_bytes(data.encode(encoding))
-
-    def write_bytes(self, data: bytes) -> None:
-        self.fs.write_binary(self.path, data)
-
-    def rmtree(self, ignore_errors=False) -> None:
-        assert self.exists(), f"Path does not exist: {self.path}"
-        # check fs is RealFS
-        assert isinstance(self.fs, RealFS)
-        shutil.rmtree(self.path, ignore_errors=ignore_errors)
-
-    def lspaths(self) -> "tuple[list[FSPath], list[FSPath]]":
-        filenames, dirnames = self.ls()
-        fpaths: list[FSPath] = [self / name for name in filenames]
-        dpaths: list[FSPath] = [self / name for name in dirnames]
-        return fpaths, dpaths
-
-    def ls(self) -> tuple[list[str], list[str]]:
-        filenames: list[str]
-        dirnames: list[str]
-        filenames, dirnames = self.fs.ls(self.path)
-        return filenames, dirnames
-
-    @property
-    def name(self) -> str:
-        return Path(self.path).name
-
-    @property
-    def parent(self) -> "FSPath":
-        parent_path = Path(self.path).parent
-        parent_str = parent_path.as_posix()
-        return FSPath(self.fs, parent_str)
-
-    def __truediv__(self, other: str) -> "FSPath":
-        new_path = Path(self.path) / other
-        return FSPath(self.fs, new_path.as_posix())
-
-    # hashable
-    def __hash__(self) -> int:
-        return hash(f"{repr(self.fs)}:{self.path}")
+import abc
+import logging
+import shutil
+import warnings
+from pathlib import Path
+from typing import Generator
+
+from rclone_api.config import Config
+
+logger = logging.getLogger(__name__)
+
+
+class FS(abc.ABC):
+    def __init__(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def copy(self, src: Path | str, dst: Path | str) -> None:
+        pass
+
+    @abc.abstractmethod
+    def read_bytes(self, path: Path | str) -> bytes:
+        pass
+
+    @abc.abstractmethod
+    def exists(self, path: Path | str) -> bool:
+        pass
+
+    @abc.abstractmethod
+    def write_binary(self, path: Path | str, data: bytes) -> None:
+        pass
+
+    @abc.abstractmethod
+    def mkdir(self, path: str, parents=True, exist_ok=True) -> None:
+        pass
+
+    @abc.abstractmethod
+    def ls(self, path: Path | str) -> tuple[list[str], list[str]]:
+        """First is files and second is directories."""
+        pass
+
+    @abc.abstractmethod
+    def cwd(self) -> "FSPath":
+        pass
+
+    @abc.abstractmethod
+    def get_path(self, path: str) -> "FSPath":
+        pass
+
+    @abc.abstractmethod
+    def dispose(self) -> None:
+        pass
+
+
+class RealFS(FS):
+
+    @staticmethod
+    def from_path(path: Path | str) -> "FSPath":
+        path_str = Path(path).as_posix()
+        return FSPath(RealFS(), path_str)
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def ls(self, path: Path | str) -> tuple[list[str], list[str]]:
+        files_and_dirs = [str(p) for p in Path(path).iterdir()]
+        files = [f for f in files_and_dirs if Path(f).is_file()]
+        dirs = [d for d in files_and_dirs if Path(d).is_dir()]
+        return files, dirs
+
+    def cwd(self) -> "FSPath":
+        return RealFS.from_path(Path.cwd())
+
+    def copy(self, src: Path | str, dst: Path | str) -> None:
+        shutil.copy(str(src), str(dst))
+
+    def read_bytes(self, path: Path | str) -> bytes:
+        with open(path, "rb") as f:
+            return f.read()
+
+    def write_binary(self, path: Path | str, data: bytes) -> None:
+        with open(path, "wb") as f:
+            f.write(data)
+
+    def exists(self, path: Path | str) -> bool:
+        return Path(path).exists()
+
+    def mkdir(self, path: str, parents=True, exist_ok=True) -> None:
+        Path(path).mkdir(parents=parents, exist_ok=exist_ok)
+
+    def get_path(self, path: str) -> "FSPath":
+        return FSPath(self, path)
+
+    def dispose(self) -> None:
+        pass
+
+
+class RemoteFS(FS):
+
+    @staticmethod
+    def from_rclone_config(
+        src: str, rclone_conf: Path | Config | str | dict | None
+    ) -> "RemoteFS":
+        if isinstance(rclone_conf, str) or isinstance(rclone_conf, dict):
+            rclone_conf = Config(text=rclone_conf)
+        return RemoteFS(rclone_conf, src)
+
+    def __init__(self, rclone_conf: Path | Config | None, src: str) -> None:
+        from rclone_api import HttpServer, Rclone
+
+        super().__init__()
+        self.src = src
+        self.shutdown = False
+        self.server: HttpServer | None = None
+        if rclone_conf is None:
+            from rclone_api.config import find_conf_file
+
+            rclone_conf = find_conf_file()
+            if rclone_conf is None:
+                raise FileNotFoundError("rclone.conf not found")
+        self.rclone_conf = rclone_conf
+        self.rclone: Rclone = Rclone(rclone_conf)
+        self.server = self.rclone.serve_http(src=src)
+
+    def root(self) -> "FSPath":
+        return FSPath(self, self.src)
+
+    def cwd(self) -> "FSPath":
+        return self.root()
+
+    def _to_str(self, path: Path | str) -> str:
+        if isinstance(path, Path):
+            return path.as_posix()
+        return path
+
+    def _to_remote_path(self, path: str | Path) -> str:
+        return Path(path).relative_to(self.src).as_posix()
+
+    def copy(self, src: Path | str, dst: Path | str) -> None:
+        from rclone_api.completed_process import CompletedProcess
+
+        src = src if isinstance(src, Path) else Path(src)
+        if not src.is_file():
+            raise FileNotFoundError(f"File not found: {src}")
+        dst = self._to_remote_path(dst)
+
+        is_s3 = self.rclone.is_s3(dst)
+        if is_s3:
+            filesize = src.stat().st_size
+            if filesize < 1024 * 1024 * 1024:  # 1GB
+                logger.info(f"S3 OPTIMIZED: Copying {src} -> {dst}")
+                err = self.rclone.copy_file_s3(src, dst)
+                if isinstance(err, Exception):
+                    raise FileNotFoundError(
+                        f"File not found: {src}, specified by {err}"
+                    )
+                return
+        # Fallback.
+        logging.info(f"Copying {src} -> {dst}")
+        src_path = src.as_posix()
+        cp: CompletedProcess = self.rclone.copy(src_path, dst)
+        if cp.returncode != 0:
+            raise FileNotFoundError(f"File not found: {src}, specified by {cp.stderr}")
+
+    def read_bytes(self, path: Path | str) -> bytes:
+        path = self._to_str(path)
+        err = self.rclone.read_bytes(path)
+        if isinstance(err, Exception):
+            raise FileNotFoundError(f"File not found: {path}")
+        return err
+
+    def write_binary(self, path: Path | str, data: bytes) -> None:
+        path = self._to_str(path)
+        self.rclone.write_bytes(data, path)  # Already optimized for s3.
+
+    def exists(self, path: Path | str) -> bool:
+        from rclone_api.http_server import HttpServer
+
+        assert isinstance(self.server, HttpServer)
+        path = self._to_str(path)
+        dst_rel = self._to_remote_path(path)
+        return self.server.exists(dst_rel)
+
+    def mkdir(self, path: str, parents=True, exist_ok=True) -> None:
+        # Ignore mkdir for remote backend, it will be made when file is written.
+        import warnings
+
+        warnings.warn("mkdir is not supported for remote backend", stacklevel=2)
+        return None
+
+    def is_dir(self, path: Path | str) -> bool:
+        from rclone_api.http_server import HttpServer
+
+        assert isinstance(self.server, HttpServer)
+        path = self._to_remote_path(path)
+        err = self.server.list(path)
+        return isinstance(err, list)
+
+    def is_file(self, path: Path | str) -> bool:
+        from rclone_api.http_server import HttpServer
+
+        assert isinstance(self.server, HttpServer)
+        path = self._to_remote_path(path)
+        err = self.server.list(path)
+        # Make faster.
+        return isinstance(err, Exception) and self.exists(path)
+
+    def ls(self, path: Path | str) -> tuple[list[str], list[str]]:
+        from rclone_api.http_server import HttpServer
+
+        assert isinstance(self.server, HttpServer)
+        path = self._to_remote_path(path)
+        err = self.server.list(path)
+        if isinstance(err, Exception):
+            raise FileNotFoundError(f"File not found: {path}, because of {err}")
+        return err
+
+    def get_path(self, path: str) -> "FSPath":
+        return FSPath(self, path)
+
+    def dispose(self) -> None:
+        if self.shutdown or not self.server:
+            return
+        self.shutdown = True
+        self.server.shutdown()
+
+    def __del__(self) -> None:
+        self.dispose()
+
+
+class FSPath:
+    def __init__(self, fs: FS, path: str) -> None:
+        self.fs: FS = fs
+        self.path: str = path
+        self.fs_holder: FS | None = None
+
+    def set_owner(self) -> None:
+        self.fs_holder = self.fs
+
+    def is_real_fs(self) -> bool:
+        return isinstance(self.fs, RealFS)
+
+    def read_text(self) -> str:
+        data = self.read_bytes()
+        return data.decode("utf-8")
+
+    def read_bytes(self) -> bytes:
+        data: bytes | None = None
+        try:
+            data = self.fs.read_bytes(self.path)
+            return data
+        except Exception as e:
+            raise FileNotFoundError(f"File not found: {self.path}, because of {e}")
+
+    def exists(self) -> bool:
+        return self.fs.exists(self.path)
+
+    def __str__(self) -> str:
+        return self.path
+
+    def __repr__(self) -> str:
+        return f"FSPath({self.path})"
+
+    def __enter__(self) -> "FSPath":
+        if self.fs_holder is not None:
+            warnings.warn("This operation is reserved for the cwd returned by FS")
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        if self.fs_holder is not None:
+            self.fs_holder.dispose()
+            self.fs_holder = None
+
+    def mkdir(self, parents=True, exist_ok=True) -> None:
+        self.fs.mkdir(self.path, parents=parents, exist_ok=exist_ok)
+
+    def walk(
+        self,
+    ) -> "Generator[tuple[FSPath, list[str], list[str]], None, None]":
+        from rclone_api.fs.walk import os_walk
+
+        return os_walk(self)
+
+    def relative_to(self, other: "FSPath") -> "FSPath":
+        p = Path(self.path).relative_to(other.path)
+        return FSPath(self.fs, p.as_posix())
+
+    def write_text(self, data: str, encoding: str | None = None) -> None:
+        if encoding is None:
+            encoding = "utf-8"
+        self.write_bytes(data.encode(encoding))
+
+    def write_bytes(self, data: bytes) -> None:
+        self.fs.write_binary(self.path, data)
+
+    def rmtree(self, ignore_errors=False) -> None:
+        assert self.exists(), f"Path does not exist: {self.path}"
+        # check fs is RealFS
+        assert isinstance(self.fs, RealFS)
+        shutil.rmtree(self.path, ignore_errors=ignore_errors)
+
+    def lspaths(self) -> "tuple[list[FSPath], list[FSPath]]":
+        filenames, dirnames = self.ls()
+        fpaths: list[FSPath] = [self / name for name in filenames]
+        dpaths: list[FSPath] = [self / name for name in dirnames]
+        return fpaths, dpaths
+
+    def ls(self) -> tuple[list[str], list[str]]:
+        filenames: list[str]
+        dirnames: list[str]
+        filenames, dirnames = self.fs.ls(self.path)
+        return filenames, dirnames
+
+    @property
+    def name(self) -> str:
+        return Path(self.path).name
+
+    @property
+    def parent(self) -> "FSPath":
+        parent_path = Path(self.path).parent
+        parent_str = parent_path.as_posix()
+        return FSPath(self.fs, parent_str)
+
+    def __truediv__(self, other: str) -> "FSPath":
+        new_path = Path(self.path) / other
+        return FSPath(self.fs, new_path.as_posix())
+
+    # hashable
+    def __hash__(self) -> int:
+        return hash(f"{repr(self.fs)}:{self.path}")

rclone_api/fs/walk.py

@@ -0,0 +1,24 @@
+from typing import Generator
+
+from rclone_api.fs.filesystem import FSPath, logger
+
+
+def os_walk(
+    self: FSPath,
+) -> Generator[tuple[FSPath, list[str], list[str]], None, None]:
+    root_path = self
+    stack: list[str] = [self.path]
+
+    while stack:
+        current_dir = root_path / stack.pop()
+        try:
+            filenames, dirnames = current_dir.ls()
+        except Exception as e:
+            logger.warning(f"Unable to list directory {current_dir}: {e}")
+            continue
+
+        yield current_dir, dirnames, filenames
+
+        # Add subdirectories to stack for further traversal
+        for dirname in reversed(dirnames):
+            stack.append((current_dir / dirname).path)

{rclone_api-1.5.52.dist-info → rclone_api-1.5.54.dist-info}/METADATA

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

{rclone_api-1.5.52.dist-info → rclone_api-1.5.54.dist-info}/RECORD

@@ -40,7 +40,8 @@ rclone_api/detail/copy_file_parts_resumable.py,sha256=RoUWV2eBWEvuuTfsvrz5BhtvX3
 rclone_api/detail/walk.py,sha256=-54NVE8EJcCstwDoaC_UtHm73R2HrZwVwQmsnv55xNU,3369
 rclone_api/experimental/flags.py,sha256=qCVD--fSTmzlk9hloRLr0q9elzAOFzPsvVpKM3aB1Mk,2739
 rclone_api/experimental/flags_base.py,sha256=ajU_czkTcAxXYU-SlmiCfHY7aCQGHvpCLqJ-Z8uZLk0,2102
-rclone_api/fs/filesystem.py,sha256=KgaLqk6OCePcWWtPgh9NDf3dMJzYpHdhQspvzgQ0r1s,9919
+rclone_api/fs/filesystem.py,sha256=NjAe5T79YOUpE8cwKmFVQTjwdu-2iIJTXotV4iEwjlo,10617
+rclone_api/fs/walk.py,sha256=usNCSGCXiP50Ijx9uTxGb8MuZPqFazzQ-746R7KsbP4,722
 rclone_api/s3/api.py,sha256=HpheMOGHcCc0CyNdv0zvB0S92g312urjRdssRrkdpb8,4162
 rclone_api/s3/basic_ops.py,sha256=hK3366xhVEzEcjz9Gk_8lFx6MRceAk72cax6mUrr6ko,2104
 rclone_api/s3/chunk_task.py,sha256=waEYe-iYQ1_BR3NCS4BrzVrK9UANvH1EcbXx2I6Z_NM,6839
@@ -55,9 +56,9 @@ rclone_api/s3/multipart/upload_parts_inline.py,sha256=V7syKjFyVIe4U9Ahl5XgqVTzt9
 rclone_api/s3/multipart/upload_parts_resumable.py,sha256=6-nlMclS8jyVvMvFbQDcZOX9MY1WbCcKA_s9bwuYxnk,9793
 rclone_api/s3/multipart/upload_parts_server_side_merge.py,sha256=Fp2pdrs5dONQI9LkfNolgAGj1-Z2V1SsRd0r0sreuXI,18040
 rclone_api/s3/multipart/upload_state.py,sha256=f-Aq2NqtAaMUMhYitlICSNIxCKurWAl2gDEUVizLIqw,6019
-rclone_api-1.5.52.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-rclone_api-1.5.52.dist-info/METADATA,sha256=pzUkl7zLuD22M8z-gOpbEkACDpT0tZ6r62N3hJ-LwMc,37305
-rclone_api-1.5.52.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-rclone_api-1.5.52.dist-info/entry_points.txt,sha256=ognh2e11HTjn73_KL5MWI67pBKS2jekBi-QTiRXySXA,316
-rclone_api-1.5.52.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
-rclone_api-1.5.52.dist-info/RECORD,,
+rclone_api-1.5.54.dist-info/licenses/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+rclone_api-1.5.54.dist-info/METADATA,sha256=FTf3dzDB3CbF3TsUKdqg-q7M5SVxQX7fExEcXmwb2go,37305
+rclone_api-1.5.54.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+rclone_api-1.5.54.dist-info/entry_points.txt,sha256=ognh2e11HTjn73_KL5MWI67pBKS2jekBi-QTiRXySXA,316
+rclone_api-1.5.54.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
+rclone_api-1.5.54.dist-info/RECORD,,