rclone-bin-api 1.0.0__tar.gz

rclone_bin_api-1.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,43 @@
+# 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/pyproject.toml

@@ -0,0 +1,111 @@
+
+[project]
+name = "rclone-bin-api"
+description = "Rclone API for Python including the Rclone binaries."
+version = "1.0.0"
+authors = [{ name = "Michael G", email = "me@mgineer85.de" }]
+maintainers = [{ name = "Michael G", email = "me@mgineer85.de" }]
+requires-python = ">=3.11"
+readme = "README.md"
+license = "MIT"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+]
+keywords = ["rclone"]
+
+
+dependencies = []
+
+
+[project.urls]
+Repository = "https://github.com/mgineer85/rclone-bin-api"
+
+[dependency-groups]
+dev = [
+  "ruff",
+  "pytest",
+  "pytest-cov",
+  "coverage[toml]",
+  "pyright",
+  "poethepoet",
+  "setuptools",
+  "wheel",
+]
+
+
+# uv does not yet support [tool.pdm.scripts], so we skip this for now... https://github.com/astral-sh/uv/issues/5903
+[tool.poe.tasks]
+lint = [
+  { cmd = "uv run pyright" },
+  { cmd = "uv run ruff check" },
+  { cmd = "uv run ruff format --check" },
+]
+format = [{ cmd = "uv run ruff check --fix" }, { cmd = "uv run ruff format" }]
+test = [
+  { cmd = "pytest --basetemp=./tests_tmp/ -v ./src/tests --cov-report=term --cov-report=xml:coverage.xml --cov --durations=10" },
+]
+build = [
+  { cmd = "uv build --wheel", env = { "RCLONE_BUILD_PLATFORM" = "win_amd64" } },
+  { cmd = "uv build --wheel", env = { "RCLONE_BUILD_PLATFORM" = "win_arm64" } },
+  { cmd = "uv build --wheel", env = { "RCLONE_BUILD_PLATFORM" = "manylinux_2_28_x86_64" } },
+  { cmd = "uv build --wheel", env = { "RCLONE_BUILD_PLATFORM" = "manylinux_2_28_aarch64" } },
+  { cmd = "uv build --wheel", env = { "RCLONE_BUILD_PLATFORM" = "macosx_10_9_x86_64" } },
+  { cmd = "uv build --wheel", env = { "RCLONE_BUILD_PLATFORM" = "macosx_11_0_arm64" } },
+  { cmd = "uv build --sdist" },
+]
+
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"
+ignore = ["./experimental/", "./vendor/"]
+typeCheckingMode = "standard"
+
+
+[tool.ruff]
+line-length = 150
+
+[tool.ruff.lint]
+select = [
+  "E",  # pycodestyle
+  "W",  # pycodestyle
+  "F",  # pyflakes
+  "B",  # bugbear
+  "UP", # pyupgrade
+  "I",  # isort
+  #"D",   # pydocstyle   # add later
+]
+ignore = [
+  "B008", #used for DI injection
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+log_cli = true
+log_cli_level = "DEBUG"
+log_cli_format = "%(asctime)s [%(levelname)8s] %(message)s (%(filename)s:%(lineno)s)"
+log_cli_date_format = "%Y-%m-%d %H:%M:%S"
+
+[tool.coverage.run]
+# disable couldnt-parse: https://github.com/nedbat/coveragepy/issues/1392
+disable_warnings = ["couldnt-parse"]
+omit = ["test_*.py", "./tests/*"]
+parallel = true
+concurrency = ["thread", "multiprocessing"]
+
+
+[build-system]
+requires = ["setuptools", "wheel", "requests"]
+build-backend = "setuptools.build_meta"
+
+
+[tool.setuptools]
+package-dir = { "" = "src/" }

rclone_bin_api-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rclone_bin_api-1.0.0/setup.py

@@ -0,0 +1,155 @@
+import hashlib
+import io
+import os
+import pathlib
+import shutil
+import zipfile
+
+import requests
+from packaging.tags import sys_tags
+from setuptools import setup
+from setuptools.command.build_py import build_py
+from wheel.bdist_wheel import bdist_wheel
+
+rclone_version = os.environ.get("RCLONE_VERSION", "1.72.1")
+rclone_build_platform = os.environ.get("RCLONE_BUILD_PLATFORM", None)
+
+PLATFORMS = {
+    # (pypa platform tag) -> (rclone variant)
+    "win_amd64": ("windows", "amd64"),
+    "win_arm64": ("windows", "arm64"),
+    "manylinux_2_28_x86_64": ("linux", "amd64"),
+    "manylinux_2_28_aarch64": ("linux", "arm64"),
+    "macosx_10_9_x86_64": ("osx", "amd64"),
+    "macosx_11_0_arm64": ("osx", "arm64"),
+}
+
+
+def get_rclone_variant(platform_tag: str):
+    try:
+        return PLATFORMS[platform_tag]
+    except KeyError:
+        raise RuntimeError(f"Unsupported platform tag '{platform_tag}'. Supported: {sorted(PLATFORMS)}") from None
+
+
+def detect_supported_platform_tag():
+    """Return the first sys_tags() platform that we explicitly support."""
+    for tag in sys_tags():
+        if tag.platform in PLATFORMS:
+            return tag.platform
+
+    raise RuntimeError(f"No supported platform tag found for this interpreter. Supported: {sorted(PLATFORMS)}")
+
+
+def rclone_download(system: str, arch: str, rclone_version: str, dest: pathlib.Path) -> pathlib.Path:
+    shutil.rmtree(dest, ignore_errors=True)  # ensure clean bin dir, because build dir might be reused.
+    dest.mkdir(parents=True, exist_ok=True)
+
+    base_url = f"https://downloads.rclone.org/v{rclone_version}"
+    filename = f"rclone-v{rclone_version}-{system}-{arch}.zip"
+    url = f"{base_url}/{filename}"
+    sums_url = f"{base_url}/SHA256SUMS"
+
+    print(f"Downloading rclone from {url}")
+
+    req_session = requests.Session()
+    resp = req_session.get(url)
+    resp.raise_for_status()
+    assert resp.content
+    zip_bytes = resp.content
+
+    try:
+        hash_valid = None
+        resp = req_session.get(sums_url)
+        resp.raise_for_status()
+        assert resp.text
+        sums_text = resp.text
+
+        for line in sums_text.splitlines():
+            parts = line.strip().split()
+            if len(parts) == 2 and parts[1] == filename:
+                hash_valid = parts[0]
+                break
+
+        if not hash_valid:
+            raise RuntimeError(f"{filename} not found in SHA256SUMS")
+
+        hash = hashlib.sha256(zip_bytes).hexdigest()
+        if hash != hash_valid.lower():
+            raise RuntimeError(f"rclone checksum mismatch: expected {hash_valid}, got {hash}")
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to verify rclone checksum: {e}") from e
+    else:
+        print("download verified successfully")
+
+    bin_name = "rclone.exe" if system == "windows" else "rclone"
+    bin_path = dest / bin_name
+
+    bin_path.unlink(missing_ok=True)
+
+    with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
+        for member in zf.filelist:
+            if pathlib.Path(member.filename).name == bin_name:
+                data = zf.read(member)
+                bin_path.write_bytes(data)
+                break
+
+    assert bin_path.is_file(), f"Binary '{bin_name}' not found inside rclone archive {filename}"
+
+    print(f"unpacked rclone to {bin_path}")
+
+    if system != "windows":
+        bin_path.chmod(0o755)
+
+    print("unpacking done")
+
+    return bin_path
+
+
+class BuildWithRclone(build_py):
+    def initialize_options(self):
+        super().initialize_options()
+        self.platform_tag = rclone_build_platform or detect_supported_platform_tag()
+
+    def run(self):
+        # 1. Run normal build first (creates build_lib)
+        super().run()
+
+        rclone_sys, rclone_arch = get_rclone_variant(self.platform_tag)
+
+        # 2. Determine where to place the binary inside the wheel
+        if self.editable_mode:
+            print("editable installation!")
+            pkg_dir = pathlib.Path(self.get_package_dir("rclone_api")) / "bin"
+
+            bin_name = "rclone.exe" if rclone_sys == "windows" else "rclone"
+            if pkg_dir.joinpath(bin_name).exists():
+                print("not downloading rclone as it already exists.")
+                return
+        else:
+            pkg_dir = pathlib.Path(self.build_lib) / "rclone_api/bin"
+
+        print(pkg_dir)
+
+        # 3. Download rclone
+
+        print(f"Downloading binary for {rclone_sys}_{rclone_arch}")
+        rclone_download(rclone_sys, rclone_arch, rclone_version, pkg_dir)
+
+
+class PlatformWheel(bdist_wheel):
+    def initialize_options(self):
+        super().initialize_options()
+        self.platform_tag = rclone_build_platform or detect_supported_platform_tag()
+
+    def get_tag(self):
+        return ("py3", "none", self.platform_tag)
+
+
+setup(
+    cmdclass={
+        "build_py": BuildWithRclone,
+        "bdist_wheel": PlatformWheel,
+    },
+)

rclone_bin_api-1.0.0/src/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_bin_api-1.0.0/src/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_bin_api-1.0.0/src/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_bin_api-1.0.0/src/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_bin_api-1.0.0/src/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/src/rclone_bin_api.egg-info/PKG-INFO

@@ -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/src/rclone_bin_api.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+setup.py
+src/examples/__init__.py
+src/examples/about.py
+src/rclone_api/__init__.py
+src/rclone_api/api.py
+src/rclone_api/dto.py
+src/rclone_api/exceptions.py
+src/rclone_bin_api.egg-info/PKG-INFO
+src/rclone_bin_api.egg-info/SOURCES.txt
+src/rclone_bin_api.egg-info/dependency_links.txt
+src/rclone_bin_api.egg-info/top_level.txt
+src/tests/test_exceptions.py
+src/tests/test_rclone.py

rclone_bin_api-1.0.0/src/rclone_bin_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rclone_bin_api-1.0.0/src/rclone_bin_api.egg-info/top_level.txt

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

rclone_bin_api-1.0.0/src/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})")

rclone_bin_api-1.0.0/src/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())