rclone-bin-api 1.0.4__tar.gz → 1.0.6__tar.gz

{rclone_bin_api-1.0.4 → rclone_bin_api-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rclone-bin-api
-Version: 1.0.4
+Version: 1.0.6
 Summary: Rclone API for Python including the Rclone binaries.
 Author-email: Michael G <me@mgineer85.de>
 Maintainer-email: Michael G <me@mgineer85.de>
@@ -41,7 +41,7 @@ from rclone_api.api import RcloneApi
 api = RcloneApi()
 api.start()
 
-print(api.version()) # CoreVersion(version='v1.72.1')
+print(api.version())  # CoreVersion(version='v1.72.1')
 
 api.stop()
 ```

{rclone_bin_api-1.0.4 → rclone_bin_api-1.0.6}/README.md

@@ -24,7 +24,7 @@ from rclone_api.api import RcloneApi
 api = RcloneApi()
 api.start()
 
-print(api.version()) # CoreVersion(version='v1.72.1')
+print(api.version())  # CoreVersion(version='v1.72.1')
 
 api.stop()
 ```

{rclone_bin_api-1.0.4 → rclone_bin_api-1.0.6}/pyproject.toml

@@ -2,7 +2,7 @@
 [project]
 name = "rclone-bin-api"
 description = "Rclone API for Python including the Rclone binaries."
-version = "1.0.4"
+version = "1.0.6"
 authors = [{ name = "Michael G", email = "me@mgineer85.de" }]
 maintainers = [{ name = "Michael G", email = "me@mgineer85.de" }]
 requires-python = ">=3.11"
@@ -30,17 +30,19 @@ dev = [
   "pytest",
   "pytest-cov",
   "coverage[toml]",
-  "pyright",
+  "basedpyright",
   "poethepoet",
   "setuptools",
   "wheel",
+  "requests",
+  "psutil",
 ]
 
 
 # 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 basedpyright" },
   { cmd = "uv run ruff check" },
   { cmd = "uv run ruff format --check" },
 ]
@@ -59,7 +61,7 @@ build = [
 ]
 
 
-[tool.pyright]
+[tool.basedpyright]
 venvPath = "."
 venv = ".venv"
 ignore = ["./experimental/", "./vendor/"]

{rclone_bin_api-1.0.4 → rclone_bin_api-1.0.6}/setup.py

@@ -11,7 +11,7 @@ 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.73.0")
+rclone_version = os.environ.get("RCLONE_VERSION", "1.75.0")
 rclone_build_platform = os.environ.get("RCLONE_BUILD_PLATFORM", None)
 
 PLATFORMS = {

rclone_bin_api-1.0.6/src/examples/about.py

@@ -0,0 +1,18 @@
+import logging
+import sys
+
+from rclone_api.api import RcloneApi
+
+if __name__ == "__main__":
+    logging.basicConfig(
+        stream=sys.stdout,
+        level=logging.DEBUG,
+        format="[%(asctime)s] {%(filename)s:%(lineno)d} %(levelname)s - %(message)s",
+    )
+
+    rc = RcloneApi()
+    rc.start()
+
+    print(rc.version())
+
+    rc.stop()

{rclone_bin_api-1.0.4 → rclone_bin_api-1.0.6}/src/rclone_api/api.py

@@ -1,8 +1,8 @@
 import atexit
 import json
-import os
-import signal
+import logging
 import subprocess
+import threading
 import time
 import urllib.error
 import urllib.request
@@ -13,11 +13,14 @@ from . import BINARY_PATH
 from .dto import AsyncJobResponse, ConfigListremotes, CoreStats, CoreVersion, JobList, JobStatus, LsJsonEntry, PubliclinkResponse
 from .exceptions import RcloneConnectionException, RcloneProcessException, RclonePublicLinkNotSupportedException
 
+logger = logging.getLogger(name="rclone_api")
+
 
 class RcloneApi:
     def __init__(
         self,
-        bind="localhost:5572",
+        bind="127.0.0.1:5572",  # bind to IPv4 127.0.0.1 until https://github.com/rclone/rclone-web/issues/71 is resolved
+        bind_gui="127.0.0.1:5573",  # bind to IPv4 127.0.0.1 until https://github.com/rclone/rclone-web/issues/71 is resolved
         log_file: Path | None = None,
         log_level: Literal["DEBUG", "INFO", "NOTICE", "ERROR"] = "NOTICE",
         transfers: int = 4,
@@ -27,6 +30,7 @@ class RcloneApi:
         config_file: Path | None = None,
     ):
         self.__bind_addr = bind
+        self.__bind_addr_gui = bind_gui
         self.__log_file = log_file
         self.__log_level = log_level
         self.__transfers = transfers
@@ -38,78 +42,99 @@ class RcloneApi:
         self.__connect_addr = f"http://{bind}"
         self.__process = None
         self.__rclone_bin = BINARY_PATH
+        self.__startstop_lock = threading.Lock()
 
-        atexit.register(self._cleanup)
+        atexit.register(self.stop)
 
     # -------------------------
     # 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"--config={self.__config_file}"] if self.__config_file else []),
-                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
+        with self.__startstop_lock:
+            if self.__process:
+                logger.info("RcloneApi already started a rclone instance - skipping.")
+                return
+
+            if self.__log_file:
+                logger.debug(f"rclone logging to file {self.__log_file}, setting log level {self.__log_level}")
+                self.__log_file.parent.mkdir(parents=True, exist_ok=True)
+
+            # since rclone 1.74.0 a new built-in webgui is avail.
+            # start using gui to enable the gui, otherwise only rcd which just exposes the api
+            if self.__enable_webui:
+                logger.info("starting rclone with gui enabled")
+                rc_cmd = "gui"
+                rc_cmd_args = [
+                    "--rc-no-auth",
+                    "--no-open-browser",
+                    f"--api-addr={self.__bind_addr}",
+                    f"--addr={self.__bind_addr_gui}",
+                ]
+            else:
+                logger.info("starting rclone with remote command daemon (api only, no gui)")
+                rc_cmd = "rcd"
+                rc_cmd_args = [
+                    "--rc-no-auth",
+                    f"--rc-addr={self.__bind_addr}",
+                ]
+
+            self.__process = subprocess.Popen(
+                [
+                    str(self.__rclone_bin),
+                    rc_cmd,
+                    *rc_cmd_args,
+                    *([f"--config={self.__config_file}"] if self.__config_file else []),
+                    *([f"--log-file={self.__log_file}"] if self.__log_file else []),
+                    f"--log-level={self.__log_level}",
+                    # 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"--bwlimit={self.__bwlimit}"] if self.__bwlimit else []),
+                ],
+                stderr=subprocess.PIPE,
+                text=True,
+                start_new_session=True,  # for _cleanup
+            )
+
+            logger.info(f"rclone started, cmd={' '.join(self.__process.args)}")  # type: ignore
+
+            # 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)
+            logger.info("rclone is operational now")
 
     def wait_until_operational(self, timeout: float = 5) -> None:
-        deadline = time.time() + timeout
-
-        while time.time() < deadline:
+        with self.__startstop_lock:
             if not self.__process:
-                # maybe instance created already but code using the api did not start yet.
-                continue
+                logger.error("cannot wait for rclone being operational while not started before")
+                return
 
-            # If rclone died immediately, capture stderr and raise
-            ret = self.__process.poll()
-            if ret is not None:
-                stderr = self.__process.stderr.read()  # type: ignore
-                raise RuntimeError(f"rclone failed to start (exit={ret}): {stderr.strip()}")
+            deadline = time.time() + timeout
 
-            if ret is None and self.operational():
-                return
+            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()  # type: ignore
+                    raise RuntimeError(f"rclone failed to start (exit={ret}): {stderr.strip()}")
 
-            time.sleep(0.1)
+                if ret is None and self.operational():
+                    return
 
-        raise RuntimeError(f"rclone did not become operational after {timeout}s")
+                time.sleep(0.1)
 
-    def stop(self):
-        if self.__process:
-            self.__process.terminate()
-            self.__process.wait(timeout=5)
+            raise RuntimeError(f"rclone did not become operational after {timeout}s")
 
-            self.__process = None
+    def stop(self):
+        with self.__startstop_lock:
+            if self.__process:
+                self.__process.terminate()
+                self.__process.wait(timeout=5)
 
-    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)
+                self.__process = None
 
     # -------------------------
     # Internal helper
@@ -136,12 +161,12 @@ class RcloneApi:
 
         try:
             with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
-                raw: bytes = resp.read()
-                response_json = json.loads(raw.decode("utf-8"))
+                raw_resp: bytes = resp.read()
+                response_json = json.loads(raw_resp.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"))
+            raw_exc: bytes = exc.read()
+            response_json = json.loads(raw_exc.decode("utf-8"))
             raise RcloneProcessException.from_dict(response_json) from exc
         except TimeoutError as exc:
             raise RcloneConnectionException(f"Operation timed out after {TIMEOUT}s. To copy large files consider using _async methods.") from exc

{rclone_bin_api-1.0.4 → rclone_bin_api-1.0.6}/src/rclone_bin_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rclone-bin-api
-Version: 1.0.4
+Version: 1.0.6
 Summary: Rclone API for Python including the Rclone binaries.
 Author-email: Michael G <me@mgineer85.de>
 Maintainer-email: Michael G <me@mgineer85.de>
@@ -41,7 +41,7 @@ from rclone_api.api import RcloneApi
 api = RcloneApi()
 api.start()
 
-print(api.version()) # CoreVersion(version='v1.72.1')
+print(api.version())  # CoreVersion(version='v1.72.1')
 
 api.stop()
 ```

{rclone_bin_api-1.0.4 → rclone_bin_api-1.0.6}/src/tests/test_rclone.py

@@ -5,8 +5,11 @@ from dataclasses import dataclass
 from pathlib import Path
 from uuid import uuid4
 
+import psutil
 import pytest
+import requests
 
+from rclone_api import BINARY_PATH
 from rclone_api.api import RcloneApi
 from rclone_api.exceptions import RcloneProcessException
 
@@ -21,7 +24,10 @@ class RcloneFixture:
 
 @pytest.fixture()
 def _rclone_fixture() -> Generator[RcloneFixture, None, None]:
-    client = RcloneApi("localhost:5573", log_file=Path("./log/rclone.log"))
+    # ensure no instance running prior testrun (also no other instances in separate terminals)
+    assert BINARY_PATH.name not in (p.name() for p in psutil.process_iter())
+
+    client = RcloneApi("127.0.0.1:5582", log_file=Path("./log/rclone.log"))
 
     client.start()
 
@@ -37,22 +43,39 @@ def _rclone_fixture() -> Generator[RcloneFixture, None, None]:
 
 
 def test_operational():
-    ins = RcloneApi("localhost:5573")
+    ins = RcloneApi("127.0.0.1:5582", log_file=Path("./log/rclone.log"))
     assert ins.operational() is False
 
     ins.start()
-
+    assert BINARY_PATH.name in (p.name() for p in psutil.process_iter())
     assert ins.operational() is True
 
     ins.start()  # ensure second start doesn't break everything...
+    assert BINARY_PATH.name in (p.name() for p in psutil.process_iter())
 
     ins.stop()
+    assert BINARY_PATH.name not in (p.name() for p in psutil.process_iter())
+    assert ins.operational() is False
+
+
+def test_operational_gui():
+    ins = RcloneApi("127.0.0.1:5582", "127.0.0.1:5583", enable_webui=True, log_file=Path("./log/rclone.log"))
+    assert ins.operational() is False
 
+    ins.start()
+    assert BINARY_PATH.name in (p.name() for p in psutil.process_iter())
+    assert ins.operational() is True
+
+    res = requests.get(url="http://localhost:5583")
+    assert res.ok
+
+    ins.stop()
+    assert BINARY_PATH.name not in (p.name() for p in psutil.process_iter())
     assert ins.operational() is False
 
 
 def test_transfers_status_request(tmp_path: Path):
-    ins = RcloneApi("localhost:5573", bwlimit="5M")
+    ins = RcloneApi("127.0.0.1:5582", bwlimit="0.5M", log_file=Path("./log/rclone.log"))
     ins.start()
 
     dummy_local = tmp_path / "in" / "file1.txt"
@@ -66,8 +89,11 @@ def test_transfers_status_request(tmp_path: Path):
     # queue the copy
     job = ins.copyfile_async(str(dummy_local.parent), dummy_local.name, str(dummy_local_remote.parent), dummy_local_remote.name)
 
+    abort_counter = 100
     while len(ins.core_stats().transferring) == 0:
         # wait until actually transferring
+        abort_counter -= 1
+        assert abort_counter > 0, "abort because test got stuck! this could happen if another rclone instance was started on the test port"
         time.sleep(0.1)
 
     # ensure the filename is part of the transfer queue

rclone_bin_api-1.0.4/src/examples/about.py

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