rclone-api 1.4.32__py2.py3-none-any.whl → 1.5.0__py2.py3-none-any.whl

rclone_api/db/__init__.py

@@ -1,3 +1,3 @@
-from .db import DB
-
-__all__ = ["DB"]
+from .db import DB
+
+__all__ = ["DB"]

rclone_api/detail/walk.py

@@ -1,116 +1,116 @@
-import random
-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
-from rclone_api.types import Order
-
-_MAX_OUT_QUEUE_SIZE = 50
-
-
-def walk_runner_breadth_first(
-    dir: Dir,
-    max_depth: int,
-    out_queue: Queue[DirListing | None],
-    order: Order = Order.NORMAL,
-) -> None:
-    queue: Queue[Dir] = Queue()
-    queue.put(dir)
-    try:
-        while not queue.empty():
-            current_dir = queue.get()
-            dirlisting = current_dir.ls(max_depth=0, order=order)
-            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_runner_depth_first(
-    dir: Dir,
-    max_depth: int,
-    out_queue: Queue[DirListing | None],
-    order: Order = Order.NORMAL,
-) -> None:
-    try:
-        stack = [(dir, max_depth)]
-        while stack:
-            current_dir, depth = stack.pop()
-            dirlisting = current_dir.ls()
-            if order == Order.REVERSE:
-                dirlisting.dirs.reverse()
-            if order == Order.RANDOM:
-
-                random.shuffle(dirlisting.dirs)
-            if depth != 0:
-                for subdir in dirlisting.dirs:  # Process deeper directories first
-                    # stack.append((child, depth - 1 if depth > 0 else depth))
-                    next_depth = depth - 1 if depth > 0 else depth
-                    walk_runner_depth_first(subdir, next_depth, out_queue, order=order)
-            out_queue.put(dirlisting)
-        out_queue.put(None)
-    except KeyboardInterrupt:
-        import _thread
-
-        out_queue.put(None)
-        _thread.interrupt_main()
-
-
-def walk(
-    dir: Dir | Remote,
-    breadth_first: bool,
-    max_depth: int = -1,
-    order: Order = Order.NORMAL,
-) -> 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)
-
-    Yields:
-        DirListing: Directory listing for each directory encountered
-    """
-    try:
-        # Convert Remote to Dir if needed
-        if isinstance(dir, Remote):
-            dir = Dir(dir)
-        out_queue: Queue[DirListing | None] = Queue(maxsize=_MAX_OUT_QUEUE_SIZE)
-
-        def _task() -> None:
-            if breadth_first:
-                walk_runner_breadth_first(dir, max_depth, out_queue, order)
-            else:
-                walk_runner_depth_first(dir, max_depth, out_queue, order)
-
-        # Start worker thread
-        worker = Thread(
-            target=_task,
-            daemon=True,
-        )
-        worker.start()
-
-        while dirlisting := out_queue.get():
-            if dirlisting is None:
-                break
-            yield dirlisting
-
-        worker.join()
-    except KeyboardInterrupt:
-        pass
+import random
+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
+from rclone_api.types import Order
+
+_MAX_OUT_QUEUE_SIZE = 50
+
+
+def walk_runner_breadth_first(
+    dir: Dir,
+    max_depth: int,
+    out_queue: Queue[DirListing | None],
+    order: Order = Order.NORMAL,
+) -> None:
+    queue: Queue[Dir] = Queue()
+    queue.put(dir)
+    try:
+        while not queue.empty():
+            current_dir = queue.get()
+            dirlisting = current_dir.ls(max_depth=0, order=order)
+            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_runner_depth_first(
+    dir: Dir,
+    max_depth: int,
+    out_queue: Queue[DirListing | None],
+    order: Order = Order.NORMAL,
+) -> None:
+    try:
+        stack = [(dir, max_depth)]
+        while stack:
+            current_dir, depth = stack.pop()
+            dirlisting = current_dir.ls()
+            if order == Order.REVERSE:
+                dirlisting.dirs.reverse()
+            if order == Order.RANDOM:
+
+                random.shuffle(dirlisting.dirs)
+            if depth != 0:
+                for subdir in dirlisting.dirs:  # Process deeper directories first
+                    # stack.append((child, depth - 1 if depth > 0 else depth))
+                    next_depth = depth - 1 if depth > 0 else depth
+                    walk_runner_depth_first(subdir, next_depth, out_queue, order=order)
+            out_queue.put(dirlisting)
+        out_queue.put(None)
+    except KeyboardInterrupt:
+        import _thread
+
+        out_queue.put(None)
+        _thread.interrupt_main()
+
+
+def walk(
+    dir: Dir | Remote,
+    breadth_first: bool,
+    max_depth: int = -1,
+    order: Order = Order.NORMAL,
+) -> 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)
+
+    Yields:
+        DirListing: Directory listing for each directory encountered
+    """
+    try:
+        # Convert Remote to Dir if needed
+        if isinstance(dir, Remote):
+            dir = Dir(dir)
+        out_queue: Queue[DirListing | None] = Queue(maxsize=_MAX_OUT_QUEUE_SIZE)
+
+        def _task() -> None:
+            if breadth_first:
+                walk_runner_breadth_first(dir, max_depth, out_queue, order)
+            else:
+                walk_runner_depth_first(dir, max_depth, out_queue, order)
+
+        # Start worker thread
+        worker = Thread(
+            target=_task,
+            daemon=True,
+        )
+        worker.start()
+
+        while dirlisting := out_queue.get():
+            if dirlisting is None:
+                break
+            yield dirlisting
+
+        worker.join()
+    except KeyboardInterrupt:
+        pass

rclone_api/dir.py

@@ -1,113 +1,113 @@
-import json
-from pathlib import Path
-from typing import Generator
-
-from rclone_api.dir_listing import DirListing
-from rclone_api.remote import Remote
-from rclone_api.rpath import RPath
-from rclone_api.types import ListingOption, Order
-
-
-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.
-
-        Args:
-            path: Either an RPath object or a Remote object
-        """
-        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,
-                mime_type="inode/directory",
-                mod_time="",
-                is_dir=True,
-            )
-            # Ensure the RPath has the same rclone instance as the Remote
-            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 | None = None,
-        glob: str | None = None,
-        order: Order = Order.NORMAL,
-        listing_option: ListingOption = ListingOption.ALL,
-    ) -> DirListing:
-        """List files and directories in the given path."""
-        assert self.path.rclone is not None
-        dir = Dir(self.path)
-        return self.path.rclone.ls(
-            dir,
-            max_depth=max_depth,
-            glob=glob,
-            order=order,
-            listing_option=listing_option,
-        )
-
-    def relative_to(self, other: "Dir") -> str:
-        """Return the relative path to the other directory."""
-        self_path = Path(self.path.path)
-        other_path = Path(other.path.path)
-        rel_path = self_path.relative_to(other_path)
-        return str(rel_path.as_posix())
-
-    def walk(
-        self, breadth_first: bool, max_depth: int = -1
-    ) -> Generator[DirListing, None, None]:
-        """List files and directories in the given path."""
-        from rclone_api.detail.walk import walk
-
-        assert self.path.rclone is not None
-        return walk(self, breadth_first=breadth_first, 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
-
-    def to_string(self, include_remote: bool = True) -> str:
-        """Convert the File to a string."""
-        out = str(self.path)
-        if not include_remote:
-            _, out = out.split(":", 1)
-        return out
-
-    # / operator
-    def __truediv__(self, other: str) -> "Dir":
-        """Join the current path with another path."""
-        path = Path(self.path.path) / other
-        rpath = RPath(
-            self.path.remote,
-            str(path.as_posix()),
-            name=other,
-            size=0,
-            mime_type="inode/directory",
-            mod_time="",
-            is_dir=True,
-        )
-        rpath.set_rclone(self.path.rclone)
-        return Dir(rpath)
+import json
+from pathlib import Path
+from typing import Generator
+
+from rclone_api.dir_listing import DirListing
+from rclone_api.remote import Remote
+from rclone_api.rpath import RPath
+from rclone_api.types import ListingOption, Order
+
+
+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.
+
+        Args:
+            path: Either an RPath object or a Remote object
+        """
+        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,
+                mime_type="inode/directory",
+                mod_time="",
+                is_dir=True,
+            )
+            # Ensure the RPath has the same rclone instance as the Remote
+            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 | None = None,
+        glob: str | None = None,
+        order: Order = Order.NORMAL,
+        listing_option: ListingOption = ListingOption.ALL,
+    ) -> DirListing:
+        """List files and directories in the given path."""
+        assert self.path.rclone is not None
+        dir = Dir(self.path)
+        return self.path.rclone.ls(
+            dir,
+            max_depth=max_depth,
+            glob=glob,
+            order=order,
+            listing_option=listing_option,
+        )
+
+    def relative_to(self, other: "Dir") -> str:
+        """Return the relative path to the other directory."""
+        self_path = Path(self.path.path)
+        other_path = Path(other.path.path)
+        rel_path = self_path.relative_to(other_path)
+        return str(rel_path.as_posix())
+
+    def walk(
+        self, breadth_first: bool, max_depth: int = -1
+    ) -> Generator[DirListing, None, None]:
+        """List files and directories in the given path."""
+        from rclone_api.detail.walk import walk
+
+        assert self.path.rclone is not None
+        return walk(self, breadth_first=breadth_first, 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
+
+    def to_string(self, include_remote: bool = True) -> str:
+        """Convert the File to a string."""
+        out = str(self.path)
+        if not include_remote:
+            _, out = out.split(":", 1)
+        return out
+
+    # / operator
+    def __truediv__(self, other: str) -> "Dir":
+        """Join the current path with another path."""
+        path = Path(self.path.path) / other
+        rpath = RPath(
+            self.path.remote,
+            str(path.as_posix()),
+            name=other,
+            size=0,
+            mime_type="inode/directory",
+            mod_time="",
+            is_dir=True,
+        )
+        rpath.set_rclone(self.path.rclone)
+        return Dir(rpath)

rclone_api/install.py

@@ -0,0 +1,90 @@
+import os
+import platform
+import shutil
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from warnings import warn
+
+from download import download
+
+URL_WINDOWS = "https://downloads.rclone.org/rclone-current-windows-amd64.zip"
+URL_LINUX = "https://downloads.rclone.org/rclone-current-linux-amd64.zip"
+URL_MACOS_ARM = "https://downloads.rclone.org/rclone-current-osx-arm64.zip"
+URL_MACOS_X86 = "https://downloads.rclone.org/rclone-current-osx-amd64.zip"
+
+
+def rclone_download_url() -> str:
+    system = platform.system()
+    if system == "Windows":
+        return URL_WINDOWS
+    elif system == "Linux":
+        return URL_LINUX
+    elif system == "Darwin":
+        arch = platform.machine()
+        if "x86" in arch:
+            return URL_MACOS_X86
+        elif "arm" in arch:
+            return URL_MACOS_ARM
+        else:
+            raise Exception(f"Unsupported arch: {arch}")
+    else:
+        raise Exception("Unsupported system")
+
+
+def _remove_signed_binary_requirements(out: Path) -> None:
+    if platform.system() == "Windows":
+        return
+    # mac os
+    if platform.system() == "Darwin":
+        # remove signed binary requirements
+        #
+        # xattr -d com.apple.quarantine rclone
+        import subprocess
+
+        subprocess.run(
+            ["xattr", "-d", "com.apple.quarantine", str(out)],
+            capture_output=True,
+            check=False,
+        )
+        return
+
+
+def _make_executable(out: Path) -> None:
+    if platform.system() == "Windows":
+        return
+    # linux and mac os
+    os.chmod(out, 0o755)
+
+
+def _find_rclone_exe(start: Path) -> Path | None:
+    for root, dirs, files in os.walk(start):
+        if platform.system() == "Windows":
+            if "rclone.exe" in files:
+                return Path(root) / "rclone.exe"
+        else:
+            if "rclone" in files:
+                return Path(root) / "rclone"
+    return None
+
+
+def rclone_download(out: Path, replace=False) -> Exception | None:
+    try:
+        url = rclone_download_url()
+        with TemporaryDirectory() as tmpdir:
+            tmp = Path(tmpdir)
+            download(url, tmp, kind="zip", replace=replace)
+            exe = _find_rclone_exe(tmp)
+            if exe is None:
+                raise FileNotFoundError("rclone executable not found")
+            if os.path.exists(out):
+                os.remove(out)
+            shutil.move(exe, out)
+        _remove_signed_binary_requirements(out)
+        _make_executable(out)
+        return None
+    except Exception as e:
+        import traceback
+
+        stacktrace = traceback.format_exc()
+        warn(f"Failed to download rclone: {e}\n{stacktrace}")
+        return e

rclone_api/log.py

@@ -1,44 +1,44 @@
-import logging
-import sys
-
-_INITIALISED = False
-
-
-def setup_default_logging():
-    """Set up default logging configuration if none exists."""
-    global _INITIALISED
-    if _INITIALISED:
-        return
-    if not logging.root.handlers:
-        logging.basicConfig(
-            level=logging.INFO,
-            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-            handlers=[
-                logging.StreamHandler(sys.stdout),
-                # Uncomment to add file logging
-                # logging.FileHandler('rclone_api.log')
-            ],
-        )
-
-
-def configure_logging(level=logging.INFO, log_file=None):
-    """Configure logging for the rclone_api package.
-
-    Args:
-        level: The logging level (default: logging.INFO)
-        log_file: Optional path to a log file
-    """
-    handlers = [logging.StreamHandler(sys.stdout)]
-    if log_file:
-        handlers.append(logging.FileHandler(log_file))
-
-    logging.basicConfig(
-        level=level,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-        handlers=handlers,
-        force=True,  # Override any existing configuration
-    )
-
-
-# Call setup_default_logging when this module is imported
-setup_default_logging()
+import logging
+import sys
+
+_INITIALISED = False
+
+
+def setup_default_logging():
+    """Set up default logging configuration if none exists."""
+    global _INITIALISED
+    if _INITIALISED:
+        return
+    if not logging.root.handlers:
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            handlers=[
+                logging.StreamHandler(sys.stdout),
+                # Uncomment to add file logging
+                # logging.FileHandler('rclone_api.log')
+            ],
+        )
+
+
+def configure_logging(level=logging.INFO, log_file=None):
+    """Configure logging for the rclone_api package.
+
+    Args:
+        level: The logging level (default: logging.INFO)
+        log_file: Optional path to a log file
+    """
+    handlers = [logging.StreamHandler(sys.stdout)]
+    if log_file:
+        handlers.append(logging.FileHandler(log_file))
+
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=handlers,
+        force=True,  # Override any existing configuration
+    )
+
+
+# Call setup_default_logging when this module is imported
+setup_default_logging()