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

rclone_api/__init__.py

@@ -1,9 +1,9 @@
+from .config import Config
 from .dir import Dir
 from .dir_listing import DirListing
 from .file import File
 from .rclone import Rclone
 from .remote import Remote
 from .rpath import RPath
-from .types import Config
 
 __all__ = ["Rclone", "File", "Config", "Remote", "Dir", "RPath", "DirListing"]

rclone_api/config.py

@@ -1,19 +1,8 @@
-import subprocess
 from dataclasses import dataclass
-from pathlib import Path
-
-from rclone_api.types import Config
 
 
 @dataclass
-class RcloneExec:
-    """Rclone execution dataclass."""
-
-    rclone_config: Path | Config
-    rclone_exe: Path
-
-    def execute(self, cmd: list[str]) -> subprocess.CompletedProcess:
-        """Execute rclone command."""
-        from rclone_api.util import rclone_execute
+class Config:
+    """Rclone configuration dataclass."""
 
-        return rclone_execute(cmd, self.rclone_config, self.rclone_exe)
+    text: str

rclone_api/convert.py

@@ -0,0 +1,31 @@
+from rclone_api.dir import Dir
+from rclone_api.file import File
+from rclone_api.remote import Remote
+
+
+def convert_to_filestr_list(files: str | File | list[str] | list[File]) -> list[str]:
+    out: list[str] = []
+    if isinstance(files, str):
+        out.append(files)
+    elif isinstance(files, File):
+        out.append(str(files.path))
+    elif isinstance(files, list):
+        for f in files:
+            if isinstance(f, File):
+                f = str(f.path)
+            out.append(f)
+    else:
+        raise ValueError(f"Invalid type for file: {type(files)}")
+    return out
+
+
+def convert_to_str(file_or_dir: str | File | Dir | Remote) -> str:
+    if isinstance(file_or_dir, str):
+        return file_or_dir
+    if isinstance(file_or_dir, File):
+        return str(file_or_dir.path)
+    if isinstance(file_or_dir, Dir):
+        return str(file_or_dir.path)
+    if isinstance(file_or_dir, Remote):
+        return str(file_or_dir)
+    raise ValueError(f"Invalid type for file_or_dir: {type(file_or_dir)}")

rclone_api/dir.py

@@ -1,3 +1,4 @@
+import json
 from typing import Generator
 
 from rclone_api.dir_listing import DirListing
@@ -8,6 +9,14 @@ from rclone_api.rpath import RPath
 class Dir:
     """Remote file dataclass."""
 
+    @property
+    def remote(self) -> Remote:
+        return self.path.remote
+
+    @property
+    def name(self) -> str:
+        return self.path.name
+
     def __init__(self, path: RPath | Remote) -> None:
         """Initialize Dir with either an RPath or Remote.
 
@@ -17,6 +26,7 @@ class Dir:
         if isinstance(path, Remote):
             # Need to create an RPath for the Remote's root
             self.path = RPath(
+                remote=path,
                 path=str(path),
                 name=str(path),
                 size=0,
@@ -28,11 +38,14 @@ class Dir:
             self.path.set_rclone(path.rclone)
         else:
             self.path = path
+        # self.path.set_rclone(self.path.remote.rclone)
+        assert self.path.rclone is not None
 
     def ls(self, max_depth: int = 0) -> DirListing:
         """List files and directories in the given path."""
         assert self.path.rclone is not None
-        return self.path.rclone.ls(self.path.path, max_depth=max_depth)
+        dir = Dir(self.path)
+        return self.path.rclone.ls(dir, max_depth=max_depth)
 
     def walk(self, max_depth: int = -1) -> Generator[DirListing, None, None]:
         """List files and directories in the given path."""
@@ -41,5 +54,14 @@ class Dir:
         assert self.path.rclone is not None
         return walk(self, max_depth=max_depth)
 
+    def to_json(self) -> dict:
+        """Convert the Dir to a JSON serializable dictionary."""
+        return self.path.to_json()
+
     def __str__(self) -> str:
         return str(self.path)
+
+    def __repr__(self) -> str:
+        data = self.path.to_json()
+        data_str = json.dumps(data)
+        return data_str

rclone_api/dir_listing.py

@@ -1,5 +1,5 @@
-# from rclone_api.dir import Dir
-# from rclone_api.file import File
+import json
+
 from rclone_api.rpath import RPath
 
 
@@ -12,3 +12,29 @@ class DirListing:
 
         self.dirs: list[Dir] = [Dir(d) for d in dirs_and_files if d.is_dir]
         self.files: list[File] = [File(f) for f in dirs_and_files if not f.is_dir]
+
+    def __str__(self) -> str:
+        n_files = len(self.files)
+        n_dirs = len(self.dirs)
+        msg = f"Files: {n_files}\n"
+        if n_files > 0:
+            for f in self.files:
+                msg += f"  {f}\n"
+        msg += f"Dirs: {n_dirs}\n"
+        if n_dirs > 0:
+            for d in self.dirs:
+                msg += f"  {d}\n"
+        return msg
+
+    def __repr__(self) -> str:
+        dirs: list = []
+        files: list = []
+        for d in self.dirs:
+            dirs.append(d.path.to_json())
+        for f in self.files:
+            files.append(f.path.to_json())
+        json_obj = {
+            "dirs": dirs,
+            "files": files,
+        }
+        return json.dumps(json_obj, indent=2)

rclone_api/{types.py → exec.py}

@@ -2,12 +2,7 @@ import subprocess
 from dataclasses import dataclass
 from pathlib import Path
 
-
-@dataclass
-class Config:
-    """Rclone configuration dataclass."""
-
-    text: str
+from rclone_api.config import Config
 
 
 @dataclass

rclone_api/file.py

@@ -12,6 +12,10 @@ class File:
     ) -> None:
         self.path = path
 
+    @property
+    def name(self) -> str:
+        return self.path.name
+
     def read_text(self) -> str:
         """Read the file contents as bytes.
 
@@ -30,6 +34,14 @@ class File:
         result = self.path.rclone._run(["cat", self.path.path])
         return result.stdout
 
+    def to_json(self) -> dict:
+        """Convert the File to a JSON serializable dictionary."""
+        return self.path.to_json()
+
     def __str__(self) -> str:
-        out = self.path.to_json()
-        return json.dumps(out)
+        return str(self.path)
+
+    def __repr__(self) -> str:
+        data = self.path.to_json()
+        data_str = json.dumps(data)
+        return data_str

rclone_api/rclone.py

@@ -3,15 +3,20 @@ Unit test file.
 """
 
 import subprocess
+from concurrent.futures import ThreadPoolExecutor
+from fnmatch import fnmatch
 from pathlib import Path
 from typing import Generator
 
 from rclone_api import Dir
+from rclone_api.config import Config
+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.remote import Remote
 from rclone_api.rpath import RPath
-from rclone_api.types import Config, RcloneExec
-from rclone_api.util import get_rclone_exe
+from rclone_api.util import get_rclone_exe, to_path
 from rclone_api.walk import walk
 
 
@@ -27,7 +32,12 @@ class Rclone:
     def _run(self, cmd: list[str]) -> subprocess.CompletedProcess:
         return self._exec.execute(cmd)
 
-    def ls(self, path: str | Remote, max_depth: int = 0) -> DirListing:
+    def ls(
+        self,
+        path: Dir | Remote | str,
+        max_depth: int | None = None,
+        glob: str | None = None,
+    ) -> DirListing:
         """List files in the given path.
 
         Args:
@@ -37,16 +47,35 @@ class Rclone:
         Returns:
             List of File objects found at the path
         """
+
+        if isinstance(path, str):
+            path = Dir(
+                to_path(path, self)
+            )  # assume it's a directory if ls is being called.
+
         cmd = ["lsjson"]
-        if max_depth > 0:
-            cmd.extend(["--recursive", "--max-depth", str(max_depth)])
+        if max_depth is not None:
+            cmd.append("--recursive")
+            if max_depth > -1:
+                cmd.append("--max-depth")
+                cmd.append(str(max_depth))
         cmd.append(str(path))
+        remote = path.remote if isinstance(path, Dir) else path
+        assert isinstance(remote, Remote)
 
         cp = self._run(cmd)
         text = cp.stdout
-        paths: list[RPath] = RPath.from_json_str(text)
+        parent_path: str | None = None
+        if isinstance(path, Dir):
+            parent_path = path.path.path
+        paths: list[RPath] = RPath.from_json_str(text, remote, parent_path=parent_path)
+        # print(parent_path)
         for o in paths:
             o.set_rclone(self)
+
+        # do we have a glob pattern?
+        if glob is not None:
+            paths = [p for p in paths if fnmatch(p.path, glob)]
         return DirListing(paths)
 
     def listremotes(self) -> list[Remote]:
@@ -61,7 +90,7 @@ class Rclone:
         return out
 
     def walk(
-        self, path: str | Remote, max_depth: int = -1
+        self, path: Dir | Remote | str, max_depth: int = -1
     ) -> Generator[DirListing, None, None]:
         """Walk through the given path recursively.
 
@@ -72,11 +101,13 @@ class Rclone:
         Yields:
             DirListing: Directory listing for each directory encountered
         """
-        if isinstance(path, str):
+        if isinstance(path, Dir):
             # Create a Remote object for the path
+            remote = path.remote
             rpath = RPath(
-                path=path,
-                name=path,
+                remote=remote,
+                path=path.path.path,
+                name=path.path.name,
                 size=0,
                 mime_type="inode/directory",
                 mod_time="",
@@ -84,7 +115,100 @@ class Rclone:
             )
             rpath.set_rclone(self)
             dir_obj = Dir(rpath)
-        else:
+        elif isinstance(path, str):
+            dir_obj = Dir(to_path(path, self))
+        elif isinstance(path, Remote):
             dir_obj = Dir(path)
+        else:
+            assert f"Invalid type for path: {type(path)}"
 
         yield from walk(dir_obj, max_depth=max_depth)
+
+    def copyfile(self, src: File | str, dst: File | str) -> None:
+        """Copy a single file from source to destination.
+
+        Args:
+            src: Source file path (including remote if applicable)
+            dst: Destination file path (including remote if applicable)
+
+        Raises:
+            subprocess.CalledProcessError: If the copy operation fails
+        """
+        src = src if isinstance(src, str) else str(src.path)
+        dst = dst if isinstance(dst, str) else str(dst.path)
+        cmd_list: list[str] = ["copyto", src, dst]
+        self._run(cmd_list)
+
+    def copyfiles(self, filelist: dict[File, File] | dict[str, str]) -> None:
+        """Copy multiple files from source to destination.
+
+        Warning - slow.
+
+        Args:
+            payload: Dictionary of source and destination file paths
+        """
+        str_dict: dict[str, str] = {}
+        for src, dst in filelist.items():
+            src = src if isinstance(src, str) else str(src.path)
+            dst = dst if isinstance(dst, str) else str(dst.path)
+            str_dict[src] = dst
+
+        with ThreadPoolExecutor(max_workers=64) as executor:
+            for src, dst in str_dict.items():  # warning - slow
+                cmd_list: list[str] = ["copyto", src, dst]
+                # self._run(cmd_list)
+                executor.submit(self._run, cmd_list)
+
+    def copy(self, src: Dir, dst: Dir) -> None:
+        """Copy files from source to destination.
+
+        Args:
+            src: Source directory
+            dst: Destination directory
+        """
+        src_dir = src.path.path
+        dst_dir = dst.path.path
+        cmd_list: list[str] = ["copy", src_dir, dst_dir]
+        self._run(cmd_list)
+
+    def purge(self, path: Dir | str) -> None:
+        """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)
+
+    def deletefiles(self, files: str | File | list[str] | list[File]) -> None:
+        """Delete a directory"""
+        payload: list[str] = convert_to_filestr_list(files)
+        cmd_list: list[str] = ["delete"] + payload
+        self._run(cmd_list)
+
+    def exists(self, path: Dir | Remote | str | File) -> bool:
+        """Check if a file or directory exists."""
+        arg: str = convert_to_str(path)
+        assert isinstance(arg, str)
+        try:
+            self.ls(arg)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def is_synced(self, src: str | Dir, dst: str | Dir) -> bool:
+        """Check if two directories are in sync."""
+        src = convert_to_str(src)
+        dst = convert_to_str(dst)
+        cmd_list: list[str] = ["check", str(src), str(dst)]
+        try:
+            self._run(cmd_list)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def copy_dir(self, src: str | Dir, dst: str | Dir) -> None:
+        """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)

rclone_api/rpath.py

@@ -1,12 +1,15 @@
 import json
 from typing import Any
 
+from rclone_api.remote import Remote
+
 
 class RPath:
     """Remote file dataclass."""
 
     def __init__(
         self,
+        remote: Remote,
         path: str,
         name: str,
         size: int,
@@ -16,6 +19,7 @@ class RPath:
     ) -> None:
         from rclone_api.rclone import Rclone
 
+        self.remote = remote
         self.path = path
         self.name = name
         self.size = size
@@ -32,10 +36,16 @@ class RPath:
         self.rclone = rclone
 
     @staticmethod
-    def from_dict(data: dict) -> "RPath":
+    def from_dict(
+        data: dict, remote: Remote, parent_path: str | None = None
+    ) -> "RPath":
         """Create a File from a dictionary."""
+        path = data["Path"]
+        if parent_path is not None:
+            path = f"{parent_path}/{path}"
         return RPath(
-            data["Path"],
+            remote,
+            path,
             data["Name"],
             data["Size"],
             data["MimeType"],
@@ -45,21 +55,25 @@ class RPath:
         )
 
     @staticmethod
-    def from_array(data: list[dict]) -> list["RPath"]:
+    def from_array(
+        data: list[dict], remote: Remote, parent_path: str | None = None
+    ) -> list["RPath"]:
         """Create a File from a dictionary."""
         out: list[RPath] = []
         for d in data:
-            file: RPath = RPath.from_dict(d)
+            file: RPath = RPath.from_dict(d, remote, parent_path)
             out.append(file)
         return out
 
     @staticmethod
-    def from_json_str(json_str: str) -> list["RPath"]:
+    def from_json_str(
+        json_str: str, remote: Remote, parent_path: str | None = None
+    ) -> list["RPath"]:
         """Create a File from a JSON string."""
         json_obj = json.loads(json_str)
         if isinstance(json_obj, dict):
-            return [RPath.from_dict(json_obj)]
-        return RPath.from_array(json_obj)
+            return [RPath.from_dict(json_obj, remote, parent_path)]
+        return RPath.from_array(json_obj, remote, parent_path)
 
     def to_json(self) -> dict:
         return {
@@ -73,5 +87,9 @@ class RPath:
         }
 
     def __str__(self) -> str:
-        out = self.to_json()
-        return json.dumps(out)
+        return f"{self.remote.name}:{self.path}"
+
+    def __repr__(self):
+        data = self.to_json()
+        data["Remote"] = self.remote.name
+        return json.dumps(data)

rclone_api/util.py

@@ -1,9 +1,64 @@
+import os
 import shutil
 import subprocess
 from pathlib import Path
 from tempfile import TemporaryDirectory
+from typing import Any
 
-from rclone_api.types import Config
+from rclone_api.config import Config
+from rclone_api.dir import Dir
+from rclone_api.remote import Remote
+from rclone_api.rpath import RPath
+
+# from .rclone import Rclone
+
+
+def to_path(item: Dir | Remote | str, rclone: Any) -> RPath:
+    from rclone_api.rclone import Rclone
+
+    assert isinstance(rclone, Rclone)
+    # if str then it will be remote:path
+    if isinstance(item, str):
+        # return RPath(item)
+        # remote_name: str = item.split(":")[0]
+        parts = item.split(":")
+        remote_name = parts[0]
+        path = ":".join(parts[1:])
+        remote = Remote(name=remote_name, rclone=rclone)
+        out = RPath(
+            remote=remote,
+            path=path,
+            name="",
+            size=0,
+            mime_type="",
+            mod_time="",
+            is_dir=True,
+        )
+        out.set_rclone(rclone)
+        return out
+    elif isinstance(item, Dir):
+        return item.path
+    elif isinstance(item, Remote):
+        out = RPath(
+            remote=item,
+            path=str(item),
+            name=str(item),
+            size=0,
+            mime_type="inode/directory",
+            mod_time="",
+            is_dir=True,
+        )
+        out.set_rclone(rclone)
+        return out
+    else:
+        raise ValueError(f"Invalid type for item: {type(item)}")
+
+
+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")))
 
 
 def get_rclone_exe(rclone_exe: Path | None) -> Path:
@@ -20,10 +75,11 @@ def rclone_execute(
     cmd: list[str],
     rclone_conf: Path | Config,
     rclone_exe: Path,
-    verbose: bool = False,
+    verbose: bool | None = None,
 ) -> subprocess.CompletedProcess:
-    print(subprocess.list2cmdline(cmd))
     tempdir: TemporaryDirectory | None = None
+    verbose = _get_verbose(verbose)
+    assert verbose is not None
 
     try:
         if isinstance(rclone_conf, Config):
@@ -38,8 +94,16 @@ def rclone_execute(
             cmd_str = subprocess.list2cmdline(cmd)
             print(f"Running: {cmd_str}")
         cp = subprocess.run(
-            cmd, capture_output=True, encoding="utf-8", check=True, shell=False
+            cmd, capture_output=True, encoding="utf-8", check=False, shell=False
         )
+        if cp.returncode != 0:
+            cmd_str = subprocess.list2cmdline(cmd)
+            print(
+                f"Error running: {cmd_str}, returncode: {cp.returncode}\n{cp.stdout}\n{cp.stderr}"
+            )
+            raise subprocess.CalledProcessError(
+                cp.returncode, cmd, cp.stdout, cp.stderr
+            )
         return cp
     finally:
         if tempdir:

rclone_api/walk.py

@@ -1,87 +1,70 @@
-from concurrent.futures import ThreadPoolExecutor
-from queue import Empty, Queue
+from queue import Queue
+from threading import Thread
 from typing import Generator
 
 from rclone_api import Dir
 from rclone_api.dir_listing import DirListing
 from rclone_api.remote import Remote
 
+_MAX_OUT_QUEUE_SIZE = 50
 
-def walk(
-    dir: Dir | Remote, max_depth: int = -1, max_workers: int = 4
-) -> Generator[DirListing, None, None]:
+
+def _walk_runner(
+    queue: Queue[Dir], max_depth: int, out_queue: Queue[DirListing | None]
+) -> None:
+    try:
+        while not queue.empty():
+            current_dir = queue.get()
+            dirlisting = current_dir.ls()
+            out_queue.put(dirlisting)
+            dirs = dirlisting.dirs
+
+            if max_depth != 0 and len(dirs) > 0:
+                for child in dirs:
+                    queue.put(child)
+            if max_depth < 0:
+                continue
+            if max_depth > 0:
+                max_depth -= 1
+        out_queue.put(None)
+    except KeyboardInterrupt:
+        import _thread
+
+        out_queue.put(None)
+
+        _thread.interrupt_main()
+
+
+def walk(dir: Dir | Remote, max_depth: int = -1) -> Generator[DirListing, None, None]:
     """Walk through the given directory recursively.
 
     Args:
         dir: Directory or Remote to walk through
         max_depth: Maximum depth to traverse (-1 for unlimited)
-        max_workers: Maximum number of concurrent workers
 
     Yields:
         DirListing: Directory listing for each directory encountered
     """
-    # Convert Remote to Dir if needed
-    if isinstance(dir, Remote):
-        dir = Dir(dir)
-    pending: Queue[tuple[Dir | None, int]] = Queue()
-    results: Queue[DirListing | Exception] = Queue()
+    try:
+        # Convert Remote to Dir if needed
+        if isinstance(dir, Remote):
+            dir = Dir(dir)
 
-    def worker():
-        while True:
-            try:
-                # Add timeout to allow checking for sentinel value
-                try:
-                    current_dir, depth = pending.get(timeout=0.1)
-                except Empty:
-                    continue
+        in_queue: Queue[Dir] = Queue()
+        out_queue: Queue[DirListing] = Queue(maxsize=_MAX_OUT_QUEUE_SIZE)
+        in_queue.put(dir)
 
-                # Check for sentinel value
-                if current_dir is None:
-                    pending.task_done()
-                    break
+        # Start worker thread
+        worker = Thread(
+            target=_walk_runner, args=(in_queue, max_depth, out_queue), daemon=True
+        )
+        worker.start()
 
-                listing = current_dir.ls()
-                results.put(listing)
-
-                if max_depth == -1 or depth < max_depth:
-                    for d in listing.dirs:
-                        pending.put((d, depth + 1))
-
-                pending.task_done()
-            except Exception as e:
-                results.put(e)
-                pending.task_done()
+        while dirlisting := out_queue.get():
+            if dirlisting is None:
                 break
-        return None
-
-    # Start workers
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        workers = [executor.submit(worker) for _ in range(max_workers)]
-
-        # Start walking
-        pending.put((dir, 0))
-
-        # Process results while workers are running
-        completed = 0
-        while completed < max_workers:
-            try:
-                result = results.get(timeout=0.1)
-                if isinstance(result, Exception):
-                    # Propagate exception
-                    raise result
-                yield result
-            except Empty:
-                # Check if any workers have completed
-                completed = sum(1 for w in workers if w.done())
-                continue
-
-        # Signal workers to stop
-        for _ in range(max_workers):
-            pending.put((None, 0))
+            yield dirlisting
 
-        # Drain any remaining results
-        while not results.empty():
-            result = results.get()
-            if isinstance(result, Exception):
-                raise result
-            yield result
+        worker.join()
+    except KeyboardInterrupt:
+        pass

rclone_api-1.0.14.dist-info/METADATA

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,19 @@
+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,,

rclone_api-1.0.12.dist-info/METADATA

@@ -1,36 +0,0 @@
-Metadata-Version: 2.2
-Name: rclone_api
-Version: 1.0.12
-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.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: home-page
-Dynamic: maintainer
-
-# template-python-cmd
-A template for quickly making a python lib that has a command line program attached
-
-[![Linting](../../actions/workflows/lint.yml/badge.svg)](../../actions/workflows/lint.yml)
-
-[![MacOS_Tests](../../actions/workflows/push_macos.yml/badge.svg)](../../actions/workflows/push_macos.yml)
-[![Ubuntu_Tests](../../actions/workflows/push_ubuntu.yml/badge.svg)](../../actions/workflows/push_ubuntu.yml)
-[![Win_Tests](../../actions/workflows/push_win.yml/badge.svg)](../../actions/workflows/push_win.yml)
-
-Replace `template-python-cmd` and `template_python_cmd` with your command. Run tox until it's
-correct.
-
-To develop software, run `. ./activate.sh`
-
-# Windows
-
-This environment requires you to use `git-bash`.
-
-# Linting
-
-Run `./lint.sh` to find linting errors using `pylint`, `flake8` and `mypy`.

rclone_api-1.0.12.dist-info/RECORD

@@ -1,18 +0,0 @@
-rclone_api/__init__.py,sha256=YH7KQaPwUiJWJiRf0NRKD7XHhMXsxWdXDjt9WLSwdjA,265
-rclone_api/cli.py,sha256=dibfAZIh0kXWsBbfp3onKLjyZXo54mTzDjUdzJlDlWo,231
-rclone_api/config.py,sha256=UujjDNcpwgipgdyFPMhC3zikvlsrurUvvZiwXm5NlPg,471
-rclone_api/dir.py,sha256=rd40egerhoKGAdIKfeGh_P70fSDzMo-EiTl0euABGOU,1497
-rclone_api/dir_listing.py,sha256=NWleKHCCRW7_eh9JfRwE6r3QbjmiHD5ZEGQcd2vm4uY,458
-rclone_api/file.py,sha256=409neYPfCUKQX2w7Uw7_D0wR2PtH42srNe9u_nnOLxM,925
-rclone_api/rclone.py,sha256=EUsLW5qcipI5RzhpHUd0PQqQow43m2uKJmNgVR8ZBuU,2859
-rclone_api/remote.py,sha256=c9hlRKBCg1BFB9MCINaQIoCg10qyAkeqiS4brl8ce-8,343
-rclone_api/rpath.py,sha256=_k59z-O75hAhpPyUSH4glPEoiYtIS3RUQb7ltU9Ianw,2009
-rclone_api/types.py,sha256=Yp15HrjwZonSQhE323R0WP7fA4NWqKjAfM7z3OwHpWI,518
-rclone_api/util.py,sha256=EXnijLLdFHqwoZvHrZdqeM8r6T7ad9-pN7qBN1b0I_g,1465
-rclone_api/walk.py,sha256=3GKnu9P5aPNiftfoi52U7wo1wixZxwxdqqS0_IlMGCE,2816
-rclone_api/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
-rclone_api-1.0.12.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-rclone_api-1.0.12.dist-info/METADATA,sha256=fkbaFAbZssh_WIKBJs-M1VNNUf3o3YKcEo3wIYDGO8o,1245
-rclone_api-1.0.12.dist-info/WHEEL,sha256=9Hm2OB-j1QcCUq9Jguht7ayGIIZBRTdOXD1qg9cCgPM,109
-rclone_api-1.0.12.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
-rclone_api-1.0.12.dist-info/RECORD,,