rclone-bin-api 1.0.0__py3-none-win_amd64.whl

examples/about.py

@@ -0,0 +1,9 @@
+from rclone_api.api import RcloneApi
+
+if __name__ == "__main__":
+    rc = RcloneApi()
+    rc.start()
+
+    print(rc.version())
+
+    rc.stop()

rclone_api/__init__.py

@@ -0,0 +1,11 @@
+import sys
+from pathlib import Path
+
+bin_dir = Path(__file__).parent / "bin"
+bin_name = "rclone.exe" if sys.platform == "win32" else "rclone"
+rclone = bin_dir / bin_name
+
+assert rclone.is_file(), "rclone binary missing!"
+
+
+BINARY_PATH = rclone.absolute()

rclone_api/api.py

@@ -0,0 +1,238 @@
+import atexit
+import json
+import os
+import signal
+import subprocess
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any, Literal
+
+from . import BINARY_PATH
+from .dto import AsyncJobResponse, ConfigListremotes, CoreStats, CoreVersion, JobList, JobStatus, LsJsonEntry, PubliclinkResponse
+from .exceptions import RcloneConnectionException, RcloneProcessException
+
+
+class RcloneApi:
+    def __init__(
+        self,
+        bind="localhost:5572",
+        log_file: Path | None = None,
+        log_level: Literal["DEBUG", "INFO", "NOTICE", "ERROR"] = "NOTICE",
+        transfers: int = 4,
+        checkers: int = 4,
+        enable_webui: bool = False,
+        bwlimit: str | None = None,
+    ):
+        self.__bind_addr = bind
+        self.__log_file = log_file
+        self.__log_level = log_level
+        self.__transfers = transfers
+        self.__checkers = checkers
+        self.__enable_webui = enable_webui
+        self.__bwlimit = bwlimit
+        self.__connect_addr = f"http://{bind}"
+        self.__process = None
+        self.__rclone_bin = BINARY_PATH
+
+        atexit.register(self._cleanup)
+
+    # -------------------------
+    # Lifecycle
+    # -------------------------
+    def start(self, startup_timeout: float | None = 5):
+        if self.__process:
+            return
+
+        if self.__log_file:
+            self.__log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        self.__process = subprocess.Popen(
+            [
+                str(self.__rclone_bin),
+                "rcd",
+                f"--rc-addr={self.__bind_addr}",
+                "--rc-no-auth",  # TODO: add auth.
+                *(["--rc-web-gui"] if self.__enable_webui else []),
+                "--rc-web-gui-no-open-browser",
+                # The server needs to accept at least transfers+checkers connections, otherwise sync might fail!
+                # The connections could be limited, but it could cause deadlocks, so it's preferred to change transfers/checkers only
+                f"--transfers={self.__transfers}",
+                f"--checkers={self.__checkers}",
+                *([f"--log-file={self.__log_file}"] if self.__log_file else []),
+                f"--log-level={self.__log_level}",
+                *([f"--bwlimit={self.__bwlimit}"] if self.__bwlimit else []),
+            ],
+            stderr=subprocess.PIPE,
+            text=True,
+            start_new_session=True,  # for _cleanup
+        )
+        # during dev you might want to start on cli separately:
+        # rclone rcd --rc-no-auth --rc-addr=localhost:5572 --rc-web-gui --transfers=4 --checkers=4 --bwlimit=5K
+
+        if startup_timeout:
+            self.wait_until_operational(startup_timeout)
+
+    def wait_until_operational(self, timeout: float = 5) -> None:
+        assert self.__process
+        assert self.__process.stderr  # enable PIPE in subprocess
+
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            # If rclone died immediately, capture stderr and raise
+            ret = self.__process.poll()
+            if ret is not None:
+                stderr = self.__process.stderr.read()
+                raise RuntimeError(f"rclone failed to start (exit={ret}): {stderr.strip()}")
+
+            if ret is None and self.operational():
+                return
+
+            time.sleep(0.1)
+
+        raise RuntimeError(f"rclone did not become operational after {timeout}s")
+
+    def stop(self):
+        if self.__process:
+            self.__process.terminate()
+            self.__process.wait(timeout=5)
+
+            self.__process = None
+
+    def _cleanup(self):
+        # if forgot to call stop, we still kill a possible rclone instance at py program exit.
+        if self.__process and self.__process.poll() is None:
+            os.killpg(self.__process.pid, signal.SIGTERM)
+
+    # -------------------------
+    # Internal helper
+    # -------------------------
+
+    @staticmethod
+    def _valid_fs_remote(fs: str, remote: str):
+        # Remote backend: fs ends with ":" → remote must NOT be absolute
+
+        assert not (fs.endswith(":") and Path(remote).is_absolute()), f"remote must be relative when fs is a remote: {fs=} {remote=}"
+
+        # Local backend: fs does NOT end with ":" → remote must be absolute
+        assert not (not fs.endswith(":") and not Path(fs).is_absolute()), f"fs must be absolute when remote is a local path: {fs=} {remote=}"
+
+    def _post(self, endpoint: str, data: dict[str, Any] | None = None):
+        req = urllib.request.Request(
+            url=f"{self.__connect_addr}/{endpoint}",
+            data=json.dumps(data or {}).encode("utf-8"),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=20) as resp:
+                raw: bytes = resp.read()
+                response_json = json.loads(raw.decode("utf-8"))
+
+        except urllib.error.HTTPError as exc:  # non 200 HTTP codes
+            raw: bytes = exc.read()
+            response_json = json.loads(raw.decode("utf-8"))
+            raise RcloneProcessException.from_dict(response_json) from exc
+        except Exception as exc:  # all other errors
+            raise RcloneConnectionException(f"Issue connecting to rclone RC server, error: {exc}") from exc
+        else:
+            return response_json
+
+    def _noopauth(self, input: dict):
+        return self._post("rc/noopauth", input)
+
+    def wait_for_jobs(self, job_ids: list[int]):
+        _job_ids = set(job_ids)
+
+        while self.__process:  # only wait if there is a process running
+            running = set(self.job_list().runningIds)
+            if _job_ids.isdisjoint(running):
+                return
+
+            time.sleep(0.05)
+
+    # -------------------------
+    # Operations
+    # -------------------------
+
+    def deletefile(self, fs: str, remote: str) -> None:
+        self._valid_fs_remote(fs, remote)
+        self._post("operations/deletefile", {"fs": fs, "remote": remote})
+
+    def copyfile(self, src_fs: str, src_remote: str, dst_fs: str, dst_remote: str) -> None:
+        self._valid_fs_remote(src_fs, src_remote)
+        self._valid_fs_remote(dst_fs, dst_remote)
+        self._post("operations/copyfile", {"srcFs": src_fs, "srcRemote": src_remote, "dstFs": dst_fs, "dstRemote": dst_remote})
+
+    def copyfile_async(self, src_fs: str, src_remote: str, dst_fs: str, dst_remote: str) -> AsyncJobResponse:
+        self._valid_fs_remote(src_fs, src_remote)
+        self._valid_fs_remote(dst_fs, dst_remote)
+        result = self._post(
+            "operations/copyfile", {"_async": True, "srcFs": src_fs, "srcRemote": src_remote, "dstFs": dst_fs, "dstRemote": dst_remote}
+        )
+        return AsyncJobResponse.from_dict(result)
+
+    def copy(self, src_fs: str, dst_fs: str, create_empty_src_dirs: bool = False) -> None:
+        self._post("sync/copy", {"srcFs": src_fs, "dstFs": dst_fs, "createEmptySrcDirs": create_empty_src_dirs})
+
+    def copy_async(self, src_fs: str, dst_fs: str, create_empty_src_dirs: bool = False) -> AsyncJobResponse:
+        result = self._post("sync/copy", {"_async": True, "srcFs": src_fs, "dstFs": dst_fs, "createEmptySrcDirs": create_empty_src_dirs})
+        return AsyncJobResponse.from_dict(result)
+
+    def sync(self, src_fs: str, dst_fs: str, create_empty_src_dirs: bool = False) -> None:
+        self._post("sync/sync", {"srcFs": src_fs, "dstFs": dst_fs, "createEmptySrcDirs": create_empty_src_dirs})
+
+    def sync_async(self, src_fs: str, dst_fs: str, create_empty_src_dirs: bool = False) -> AsyncJobResponse:
+        result = self._post("sync/sync", {"_async": True, "srcFs": src_fs, "dstFs": dst_fs, "createEmptySrcDirs": create_empty_src_dirs})
+        return AsyncJobResponse.from_dict(result)
+
+    def publiclink(self, fs: str, remote: str, unlink: bool = False, expire: str | None = None) -> PubliclinkResponse:
+        self._valid_fs_remote(fs, remote)
+        result = self._post("operations/publiclink", {"fs": fs, "remote": remote, "unlink": unlink, **({"expire": expire} if expire else {})})
+        return PubliclinkResponse.from_dict(result)
+
+    def ls(self, fs: str, remote: str) -> list[LsJsonEntry]:
+        self._valid_fs_remote(fs, remote)
+        response: dict = self._post("operations/list", {"fs": fs, "remote": remote})
+        ls: list[dict] = response["list"]
+        return [LsJsonEntry.from_dict(x) for x in ls]
+
+    # -------------------------
+    # Utilities
+    # -------------------------
+    def job_status(self, jobid: int) -> JobStatus:
+        return JobStatus.from_dict(self._post("job/status", {"jobid": jobid}))
+
+    def job_list(self) -> JobList:
+        return JobList.from_dict(self._post("job/list"))
+
+    # def abort_job(self, jobid: int) -> None:
+    #     self._post("job/stop", {"jobid": jobid})
+
+    # def abort_jobgroup(self, group: str) -> None:
+    #     self._post("job/stopgroup", {"group": group})
+
+    def core_stats(self) -> CoreStats:
+        return CoreStats.from_dict(self._post("core/stats"))
+
+    def version(self) -> CoreVersion:
+        return CoreVersion.from_dict(self._post("core/version"))
+
+    def config_create(self, name: str, type: str, parameters: dict[str, Any]) -> None:
+        return self._post("config/create", {"name": name, "type": type, "parameters": parameters})
+
+    def config_delete(self, name: str) -> None:
+        return self._post("config/delete", {"name": name})
+
+    def config_listremotes(self) -> ConfigListremotes:
+        return ConfigListremotes.from_dict(self._post("config/listremotes"))
+
+    def operational(self) -> bool:
+        chk_input = {"op": True}
+        try:
+            return self._noopauth(chk_input) == chk_input
+        except Exception:
+            return False

rclone_api/dto.py

@@ -0,0 +1,210 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(slots=True)
+class CoreVersion:
+    version: str
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]):
+        return CoreVersion(version=d.get("version", "unknown"))
+
+
+@dataclass(slots=True)
+class JobList:
+    executeId: str | None
+    jobids: list[int]
+    runningIds: list[int]
+    finishedIds: list[int]
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]):
+        return JobList(
+            executeId=str(d.get("executeId")),
+            jobids=d.get("jobids", []),
+            runningIds=d.get("runningIds", []),
+            finishedIds=d.get("finishedIds", []),
+        )
+
+
+@dataclass(slots=True)
+class ConfigListremotes:
+    remotes: list[str]
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]):
+        return ConfigListremotes(remotes=d.get("remotes", []))
+
+
+@dataclass(slots=True)
+class AsyncJobResponse:
+    jobid: int
+    executeId: str | None
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]):
+        return AsyncJobResponse(
+            jobid=d["jobid"],
+            executeId=d.get("executeId"),
+        )
+
+
+@dataclass(slots=True)
+class JobStatus:
+    finished: bool
+    duration: float
+    endTime: str | None
+    error: str | None
+    id: int
+    executeId: int | None
+    startTime: str | None
+    success: bool
+    output: Any
+    progress: Any
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]):
+        return JobStatus(
+            finished=d.get("finished", False),
+            duration=d.get("duration", 0.0),
+            endTime=d.get("endTime"),
+            error=d.get("error"),
+            id=d.get("id", 0),
+            executeId=d.get("executeId"),
+            startTime=d.get("startTime"),
+            success=d.get("success", False),
+            output=d.get("output"),
+            progress=d.get("progress"),
+        )
+
+
+@dataclass(slots=True)
+class TransferEntry:
+    bytes: int
+    eta: float | None
+    name: str
+    percentage: float
+    speed: float
+    speedAvg: float
+    size: int
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]):
+        return TransferEntry(
+            bytes=d.get("bytes", 0),
+            eta=d.get("eta"),  # may be None
+            name=d.get("name", ""),
+            percentage=d.get("percentage", 0.0),
+            speed=d.get("speed", 0.0),
+            speedAvg=d.get("speedAvg", 0.0),
+            size=d.get("size", 0),
+        )
+
+
+@dataclass(slots=True)
+class CoreStats:
+    bytes: int
+    checks: int
+    deletes: int
+    elapsedTime: float
+    errors: int
+    eta: float | None
+    fatalError: bool
+    lastError: str | None
+    renames: int
+    listed: int
+    retryError: bool
+
+    serverSideCopies: int
+    serverSideCopyBytes: int
+    serverSideMoves: int
+    serverSideMoveBytes: int
+
+    speed: float
+
+    totalBytes: int
+    totalChecks: int
+    totalTransfers: int
+    transferTime: float
+    transfers: int
+
+    transferring: list[TransferEntry]
+    checking: list[str]
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]):
+        return CoreStats(
+            bytes=d.get("bytes", 0),
+            checks=d.get("checks", 0),
+            deletes=d.get("deletes", 0),
+            elapsedTime=d.get("elapsedTime", 0.0),
+            errors=d.get("errors", 0),
+            eta=d.get("eta"),
+            fatalError=d.get("fatalError", False),
+            lastError=d.get("lastError"),
+            renames=d.get("renames", 0),
+            listed=d.get("listed", 0),
+            retryError=d.get("retryError", False),
+            serverSideCopies=d.get("serverSideCopies", 0),
+            serverSideCopyBytes=d.get("serverSideCopyBytes", 0),
+            serverSideMoves=d.get("serverSideMoves", 0),
+            serverSideMoveBytes=d.get("serverSideMoveBytes", 0),
+            speed=d.get("speed", 0.0),
+            totalBytes=d.get("totalBytes", 0),
+            totalChecks=d.get("totalChecks", 0),
+            totalTransfers=d.get("totalTransfers", 0),
+            transferTime=d.get("transferTime", 0.0),
+            transfers=d.get("transfers", 0),
+            transferring=[TransferEntry.from_dict(x) for x in d.get("transferring", [])],
+            checking=d.get("checking", []),
+        )
+
+
+@dataclass(slots=True)
+class LsJsonEntry:
+    Name: str
+    Size: int
+    Path: str
+    IsDir: bool
+
+    ModTime: str | None
+    MimeType: str | None
+    Hashes: dict[str, str] | None = None
+    ID: str | None = None
+    OrigID: str | None = None
+    IsBucket: bool | None = None
+    Encrypted: str | None = None
+    EncryptedPath: str | None = None
+    Tier: str | None = None
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]):
+        return LsJsonEntry(
+            # mandatory
+            Name=str(d["Name"]),
+            Size=int(d["Size"]),
+            Path=str(d["Path"]),
+            IsDir=bool(d["IsDir"]),
+            # optional and/or backend dependent
+            ModTime=d.get("ModTime"),
+            MimeType=d.get("MimeType"),
+            Hashes=d.get("Hashes"),
+            ID=d.get("ID"),
+            OrigID=d.get("OrigID"),
+            IsBucket=d.get("IsBucket"),
+            Encrypted=d.get("Encrypted"),
+            EncryptedPath=d.get("EncryptedPath"),
+            Tier=d.get("Tier"),
+        )
+
+
+@dataclass(slots=True)
+class PubliclinkResponse:
+    link: str
+
+    @staticmethod
+    def from_dict(d: dict[str, Any]):
+        return PubliclinkResponse(
+            link=str(d["link"]),
+        )

rclone_api/exceptions.py

@@ -0,0 +1,22 @@
+class RcloneConnectionException(Exception): ...
+
+
+class RcloneProcessException(Exception):
+    def __init__(self, error: str, input: dict | None, status: int | None, path: str | None):
+        super().__init__(error)
+        self.error = error
+        self.input = input
+        self.status = status
+        self.path = path
+
+    @staticmethod
+    def from_dict(d: dict):
+        return RcloneProcessException(
+            error=d.get("error", "Unknown error"),
+            input=d.get("input", None),
+            status=d.get("status", None),
+            path=d.get("path", None),
+        )
+
+    def __str__(self):
+        return f"RcloneProcessException(status={self.status}, path='{self.path}', error='{self.error}', input={self.input})"

rclone_bin_api-1.0.0.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: rclone-bin-api
+Version: 1.0.0
+Summary: Rclone API for Python including the Rclone binaries.
+Author-email: Michael G <me@mgineer85.de>
+Maintainer-email: Michael G <me@mgineer85.de>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/mgineer85/rclone-bin-api
+Keywords: rclone
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Rclone Api for Python including Rclone binaries
+
+This package is developed for use in the photobooth-app.
+It serves to distribute the rclone binary via wheels so a recent version is available
+on all platforms that are supported by the photobooth-app.
+
+[![PyPI](https://img.shields.io/pypi/v/rclone-bin-api)](https://pypi.org/project/rclone-bin-api/)
+[![ruff](https://github.com/mgineer85/rclone-bin-api/actions/workflows/ruff.yml/badge.svg)](https://github.com/mgineer85/rclone-bin-api/workflows/ruff.yml)
+[![pytest](https://github.com/mgineer85/rclone-bin-api/actions/workflows/pytests.yml/badge.svg)](https://github.com/mgineer85/rclone-bin-api/actions/workflows/pytests.yml)
+[![codecov](https://codecov.io/gh/mgineer85/rclone-bin-api/graph/badge.svg?token=87aLWw2gIT)](https://codecov.io/gh/mgineer85/rclone-bin-api)
+
+## How it works
+
+The PyPi packages include the Rclone binaries for Linux/Windows/Mac (64bit/ARM64). To use the API, create an instance of the `api=RcloneApi()`.
+The provided binding methods make use of [Rclones remote control capabilites](https://rclone.org/rc/), the service needs to be started prior starting file operations `api.start()`.
+
+## Usage
+
+Get the version of the Rclone included in the distribution:
+
+```python
+from rclone_api.api import RcloneApi
+
+api = RcloneApi()
+api.start()
+
+print(api.version()) # CoreVersion(version='v1.72.1')
+
+api.stop()
+```
+
+Synchonize a folder to a remote
+
+```python
+from rclone_api.api import RcloneApi
+
+api = RcloneApi()
+api.start()
+
+api.sync("localdir/", "cloudremote:remotedir/")
+
+api.stop()
+```

rclone_bin_api-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+examples/about.py,sha256=8HE9-k-MMsn7B5T6r3QYDD-ksCSaJHT9JyF81XfdtQw,141
+rclone_api/__init__.py,sha256=9y4k5CZDsaHL1Wx1oIiHPSWwN-f39NjSRBpDVYvgV1A,255
+rclone_api/api.py,sha256=Xx4sOPjlEuG8yY2oTqfumQ0tPs-UbWCYeB_4Ob-BNSw,9768
+rclone_api/dto.py,sha256=auAaG-oPL4U3rqq-gInraAj_H96NVIYkxkkEYSHEPK8,5398
+rclone_api/exceptions.py,sha256=iM8HJqsA0DCbHX-E2VM1M8dMSmSNmjIk7bT9wv6XsqM,741
+rclone_api/bin/rclone.exe,sha256=RJWROLLJspXX1VjiKfC3SVpa9EarD-RyuNyYKwcOWns,73190912
+tests/test_exceptions.py,sha256=SFD5JbL9Uf6fvjWg1DfmurJGt33Mn_mI38Ym5XSdkqo,312
+tests/test_rclone.py,sha256=I-MfsOEqyXL9FJoIFjM3c6hYE7j2BSqo8uYdLmxqJ9s,8961
+rclone_bin_api-1.0.0.dist-info/METADATA,sha256=VWIBDCwjoPxcmxYyf8RfNmiIDgl64m8hIJzfK5F11MQ,2198
+rclone_bin_api-1.0.0.dist-info/WHEEL,sha256=ZjXRCNaQ9YSypEK2TE0LRB0sy2OVXSszb4Sx1XjM99k,97
+rclone_bin_api-1.0.0.dist-info/top_level.txt,sha256=2Mx55HkFxfNF4Bg_IvGfrl4dxgmeZlfEMkmU4fTmnU8,26
+rclone_bin_api-1.0.0.dist-info/RECORD,,

rclone_bin_api-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-win_amd64
+

rclone_bin_api-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+examples
+rclone_api
+tests

tests/test_exceptions.py

@@ -0,0 +1,7 @@
+from rclone_api.exceptions import RcloneProcessException
+
+
+def test_rclone_process_exception_str():
+    exc = RcloneProcessException(error="boom", input={"op": True}, status=5, path="/tmp/rclone")
+
+    assert str(exc) == ("RcloneProcessException(status=5, path='/tmp/rclone', error='boom', input={'op': True})")

tests/test_rclone.py

@@ -0,0 +1,311 @@
+import logging
+import time
+from collections.abc import Generator
+from dataclasses import dataclass
+from pathlib import Path
+from uuid import uuid4
+
+import pytest
+
+from rclone_api.api import RcloneApi
+from rclone_api.exceptions import RcloneProcessException
+
+logger = logging.getLogger(name=None)
+
+
+@dataclass
+class RcloneFixture:
+    client: RcloneApi
+    remote_name: str
+
+
+@pytest.fixture()
+def _rclone_fixture() -> Generator[RcloneFixture, None, None]:
+    client = RcloneApi("localhost:5573", log_file=Path("./log/rclone.log"))
+
+    client.start()
+
+    # create local remote for testing
+    remote_name = uuid4().hex
+    client.config_create(remote_name, "local", {})
+
+    try:
+        yield RcloneFixture(client, remote_name)
+    finally:
+        client.config_delete(remote_name)
+        client.stop()
+
+
+def test_operational():
+    ins = RcloneApi("localhost:5573")
+    assert ins.operational() is False
+
+    ins.start()
+
+    assert ins.operational() is True
+
+    ins.start()  # ensure second start doesn't break everything...
+
+    ins.stop()
+
+    assert ins.operational() is False
+
+
+def test_transfers_status_request(tmp_path: Path):
+    ins = RcloneApi("localhost:5573", bwlimit="5M")
+    ins.start()
+
+    dummy_local = tmp_path / "in" / "file1.txt"
+    dummy_local.parent.mkdir(parents=True)
+    dummy_local.write_bytes(b"0" * 1024 * 1024)
+
+    dummy_local_remote = Path(tmp_path / "out" / "file1.txt").absolute()
+
+    assert len(ins.core_stats().transferring) == 0
+
+    # queue the copy
+    job = ins.copyfile_async(str(dummy_local.parent), dummy_local.name, str(dummy_local_remote.parent), dummy_local_remote.name)
+
+    while len(ins.core_stats().transferring) == 0:
+        # wait until actually transferring
+        time.sleep(0.1)
+
+    # ensure the filename is part of the transfer queue
+    assert dummy_local.name in ins.core_stats().transferring[0].name
+
+    ins.wait_for_jobs([job.jobid])
+
+    final_status = ins.job_status(jobid=job.jobid)
+
+    assert final_status.success
+
+    ins.stop()
+
+
+def test_version(_rclone_fixture: RcloneFixture):
+    version = _rclone_fixture.client.version()
+
+    assert _rclone_fixture.client.version()
+
+    logger.info(version)
+
+
+def test_core_stats(_rclone_fixture: RcloneFixture):
+    assert _rclone_fixture.client.core_stats()
+
+
+def test_create_list_delete_remotes(_rclone_fixture: RcloneFixture):
+    name = uuid4().hex
+
+    _rclone_fixture.client.config_create(name, "local", {})
+    assert name in _rclone_fixture.client.config_listremotes().remotes
+
+    _rclone_fixture.client.config_delete(name)
+    assert name not in _rclone_fixture.client.config_listremotes().remotes
+
+
+def test_deletefile(_rclone_fixture: RcloneFixture, tmp_path: Path):
+    client = _rclone_fixture.client
+    remote = _rclone_fixture.remote_name
+
+    dummy_local = tmp_path / "file1.txt"
+    dummy_local.touch()
+
+    dummy_remote = Path(tmp_path / "file1.txt").relative_to(Path.cwd())
+
+    # Perform
+    client.deletefile(f"{remote}:", dummy_remote.as_posix())
+
+    # Assertions
+    listing = client.ls(f"{remote}:", dummy_remote.parent.as_posix())
+
+    assert not any(entry.Name == "file1.txt" for entry in listing)
+
+    assert not dummy_local.exists()
+
+
+def test_copyfile(_rclone_fixture: RcloneFixture, tmp_path: Path):
+    client = _rclone_fixture.client
+    remote = _rclone_fixture.remote_name
+
+    dummy_local = tmp_path / "in" / "file1.txt"
+    dummy_local.parent.mkdir(parents=True)
+    dummy_local.touch()
+
+    dummy_remote = Path(tmp_path / "out" / "file1.txt").relative_to(Path.cwd())
+
+    # Perform
+    client.copyfile(str(dummy_local.parent), dummy_local.name, f"{remote}:", dummy_remote.as_posix())
+
+    # Assertions
+    listing = client.ls(f"{remote}:", dummy_remote.parent.as_posix())
+
+    assert any(entry.Name == "file1.txt" for entry in listing)
+
+    assert dummy_remote.is_file()
+
+
+def test_copyfile_async(_rclone_fixture: RcloneFixture, tmp_path: Path):
+    client = _rclone_fixture.client
+    remote = _rclone_fixture.remote_name
+
+    dummy_local = tmp_path / "in" / "file1.txt"
+    dummy_local.parent.mkdir(parents=True)
+    dummy_local.touch()
+
+    dummy_remote = Path(tmp_path / "out" / "file1.txt").relative_to(Path.cwd())
+
+    # Perform the copy
+    job = client.copyfile_async(str(dummy_local.parent), dummy_local.name, f"{remote}:", dummy_remote.as_posix())
+    client.wait_for_jobs([job.jobid])
+
+    final_status = client.job_status(jobid=job.jobid)
+    final_joblist = client.job_list()
+
+    # --- Assertions ---
+    assert final_status.success
+
+    assert job.jobid in final_joblist.jobids
+    assert job.jobid in final_joblist.finishedIds
+
+    listing = client.ls(f"{remote}:", dummy_remote.parent.as_posix())
+    assert any(entry.Name == "file1.txt" for entry in listing)
+
+    assert dummy_remote.is_file()
+
+
+def test_copy(_rclone_fixture: RcloneFixture, tmp_path: Path):
+    client = _rclone_fixture.client
+    remote = _rclone_fixture.remote_name
+
+    dummy_local = tmp_path / "in" / "file1.txt"
+    dummy_local.parent.mkdir(parents=True)
+    dummy_local.touch()
+
+    dummy_remote = Path(tmp_path / "out").relative_to(Path.cwd())
+
+    # Perform
+    client.copy(str(dummy_local.parent), f"{remote}:{dummy_remote.as_posix()}")
+
+    # Assertions
+    listing = client.ls(f"{remote}:", dummy_remote.as_posix())
+
+    assert any(entry.Name == "file1.txt" for entry in listing)
+
+    assert Path(dummy_remote, "file1.txt").is_file()
+
+
+def test_copy_async(_rclone_fixture: RcloneFixture, tmp_path: Path):
+    client = _rclone_fixture.client
+    remote = _rclone_fixture.remote_name
+
+    dummy_local = tmp_path / "in" / "file1.txt"
+    dummy_local.parent.mkdir(parents=True)
+    dummy_local.touch()
+
+    dummy_remote = Path(tmp_path / "out").relative_to(Path.cwd())
+
+    # Perform
+    job = client.copy_async(str(dummy_local.parent), f"{remote}:{dummy_remote.as_posix()}")
+    client.wait_for_jobs([job.jobid])
+
+    final_status = client.job_status(jobid=job.jobid)
+    final_joblist = client.job_list()
+
+    # --- Assertions ---
+    assert final_status.success
+
+    assert job.jobid in final_joblist.jobids
+    assert job.jobid in final_joblist.finishedIds
+
+    listing = client.ls(f"{remote}:", dummy_remote.as_posix())
+    assert any(entry.Name == "file1.txt" for entry in listing)
+
+    assert Path(dummy_remote, "file1.txt").is_file()
+
+
+def test_copy_localonly(_rclone_fixture: RcloneFixture, tmp_path: Path):
+    client = _rclone_fixture.client
+    # remote = _rclone_fixture.remote_name
+
+    dummy_local = tmp_path / "in" / "file1.txt"
+    dummy_local.parent.mkdir(parents=True)
+    dummy_local.touch()
+
+    dummy_local_remote = Path(tmp_path / "out").absolute()
+
+    # Perform
+    client.copy(str(dummy_local.parent), str(dummy_local_remote))
+
+    # Assertions
+    listing1 = client.ls(str(dummy_local_remote), "/")
+    listing2 = client.ls(str(dummy_local_remote), "")
+
+    assert any(entry.Name == "file1.txt" for entry in listing1)
+    assert any(entry.Name == "file1.txt" for entry in listing2)
+
+    assert Path(dummy_local_remote, "file1.txt").is_file()
+
+
+def test_sync(_rclone_fixture: RcloneFixture, tmp_path: Path):
+    client = _rclone_fixture.client
+    remote = _rclone_fixture.remote_name
+
+    dummy_local = tmp_path / "in" / "file1.txt"
+    dummy_local.parent.mkdir(parents=True)
+    dummy_local.touch()
+
+    dummy_remote = Path(tmp_path / "out").relative_to(Path.cwd())
+
+    # Perform
+    client.sync(str(dummy_local.parent), f"{remote}:{dummy_remote.as_posix()}")
+
+    # Assertions
+    listing = client.ls(f"{remote}:", dummy_remote.as_posix())
+
+    assert any(entry.Name == "file1.txt" for entry in listing)
+
+    assert Path(dummy_remote, "file1.txt").is_file()
+
+
+def test_sync_async(_rclone_fixture: RcloneFixture, tmp_path: Path):
+    client = _rclone_fixture.client
+    remote = _rclone_fixture.remote_name
+
+    dummy_local = tmp_path / "in" / "file1.txt"
+    dummy_local.parent.mkdir(parents=True)
+    dummy_local.touch()
+
+    dummy_remote = Path(tmp_path / "out").relative_to(Path.cwd())
+
+    # Perform
+    job = client.sync_async(str(dummy_local.parent), f"{remote}:{dummy_remote.as_posix()}")
+    client.wait_for_jobs([job.jobid])
+
+    final_status = client.job_status(jobid=job.jobid)
+    final_joblist = client.job_list()
+
+    # --- Assertions ---
+    assert final_status.success
+
+    assert job.jobid in final_joblist.jobids
+    assert job.jobid in final_joblist.finishedIds
+
+    listing = client.ls(f"{remote}:", dummy_remote.as_posix())
+    assert any(entry.Name == "file1.txt" for entry in listing)
+
+    assert Path(dummy_remote, "file1.txt").is_file()
+
+
+def test_publiclink(_rclone_fixture: RcloneFixture, tmp_path: Path):
+    client = _rclone_fixture.client
+    remote = _rclone_fixture.remote_name
+
+    dummy_local = tmp_path / "file1.txt"
+    dummy_local.touch()
+
+    dummy_remote = Path(tmp_path / "file1.txt").relative_to(Path.cwd())
+
+    # Perform
+    with pytest.raises(RcloneProcessException):
+        client.publiclink(f"{remote}:", dummy_remote.as_posix())