rclone-api 1.5.6__tar.gz → 1.5.7__tar.gz

{rclone_api-1.5.6 → rclone_api-1.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.5.6
+Version: 1.5.7
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 License: BSD 3-Clause License

{rclone_api-1.5.6 → rclone_api-1.5.7}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 
 # Change this with the version number bump.
-version = "1.5.6"
+version = "1.5.7"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

rclone_api-1.5.7/src/rclone_api/mount.py

@@ -0,0 +1,55 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from rclone_api.process import Process
+
+
+@dataclass
+class Mount:
+    """Mount information."""
+
+    src: str
+    mount_path: Path
+    process: Process
+    read_only: bool
+    cache_dir: Path | None = None
+    cache_dir_delete_on_exit: bool | None = None
+    _closed: bool = False
+
+    def __post_init__(self):
+        from rclone_api.mount_util import add_mount_for_gc, wait_for_mount
+
+        assert isinstance(self.mount_path, Path)
+        assert self.process is not None
+        wait_for_mount(self)
+        add_mount_for_gc(self)
+
+    def close(self, wait=True) -> None:
+        """Clean up the mount."""
+        from rclone_api.mount_util import (
+            cache_dir_delete_on_exit,
+            clean_mount,
+            remove_mount_for_gc,
+        )
+
+        if self._closed:
+            return
+        self._closed = True
+        self.process.terminate()
+        clean_mount(self, verbose=False, wait=wait)
+        if self.cache_dir and self.cache_dir_delete_on_exit:
+            cache_dir_delete_on_exit(self.cache_dir)
+        remove_mount_for_gc(self)
+
+    def __enter__(self) -> "Mount":
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        self.close(wait=True)
+
+    def __del__(self):
+        self.close(wait=False)
+
+    # make this a hashable object
+    def __hash__(self):
+        return hash(self.mount_path)

rclone_api-1.5.6/src/rclone_api/mount.py → rclone_api-1.5.7/src/rclone_api/mount_util.py

@@ -7,10 +7,9 @@ import time
 import warnings
 import weakref
 from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
 
+from rclone_api.mount import Mount
 from rclone_api.process import Process
 
 _SYSTEM = platform.system()  # "Linux", "Darwin", "Windows", etc.
@@ -18,15 +17,6 @@ _SYSTEM = platform.system()  # "Linux", "Darwin", "Windows", etc.
 _MOUNTS_FOR_GC: weakref.WeakSet = weakref.WeakSet()
 
 
-def _add_mount_for_gc(mount: "Mount") -> None:
-    # weak reference to avoid circular references
-    _MOUNTS_FOR_GC.add(mount)
-
-
-def _remove_mount_for_gc(mount: "Mount") -> None:
-    _MOUNTS_FOR_GC.discard(mount)
-
-
 def _cleanup_mounts() -> None:
     with ThreadPoolExecutor() as executor:
         mount: Mount
@@ -34,61 +24,7 @@ def _cleanup_mounts() -> None:
             executor.submit(mount.close)
 
 
-def _cache_dir_delete_on_exit(cache_dir: Path) -> None:
-    if cache_dir.exists():
-        try:
-            shutil.rmtree(cache_dir)
-        except Exception as e:
-            warnings.warn(f"Error removing cache directory {cache_dir}: {e}")
-
-
-atexit.register(_cleanup_mounts)
-
-
-@dataclass
-class Mount:
-    """Mount information."""
-
-    src: str
-    mount_path: Path
-    process: Process
-    read_only: bool
-    cache_dir: Path | None = None
-    cache_dir_delete_on_exit: bool | None = None
-    _closed: bool = False
-
-    def __post_init__(self):
-        assert isinstance(self.mount_path, Path)
-        assert self.process is not None
-        wait_for_mount(self.mount_path, self.process)
-        _add_mount_for_gc(self)
-
-    def close(self, wait=True) -> None:
-        """Clean up the mount."""
-        if self._closed:
-            return
-        self._closed = True
-        self.process.terminate()
-        clean_mount(self, verbose=False, wait=wait)
-        if self.cache_dir and self.cache_dir_delete_on_exit:
-            _cache_dir_delete_on_exit(self.cache_dir)
-        _remove_mount_for_gc(self)
-
-    def __enter__(self) -> "Mount":
-        return self
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        self.close(wait=True)
-
-    def __del__(self):
-        self.close(wait=False)
-
-    # make this a hashable object
-    def __hash__(self):
-        return hash(self.mount_path)
-
-
-def run_command(cmd: str, verbose: bool) -> int:
+def _run_command(cmd: str, verbose: bool) -> int:
     """Run a shell command and print its output if verbose is True."""
     if verbose:
         print(f"Executing: {cmd}")
@@ -104,6 +40,26 @@ def run_command(cmd: str, verbose: bool) -> int:
         return -1
 
 
+atexit.register(_cleanup_mounts)
+
+
+def cache_dir_delete_on_exit(cache_dir: Path) -> None:
+    if cache_dir.exists():
+        try:
+            shutil.rmtree(cache_dir)
+        except Exception as e:
+            warnings.warn(f"Error removing cache directory {cache_dir}: {e}")
+
+
+def add_mount_for_gc(mount: Mount) -> None:
+    # weak reference to avoid circular references
+    _MOUNTS_FOR_GC.add(mount)
+
+
+def remove_mount_for_gc(mount: Mount) -> None:
+    _MOUNTS_FOR_GC.discard(mount)
+
+
 def prepare_mount(outdir: Path, verbose: bool) -> None:
     if _SYSTEM == "Windows":
         # Windows -> Must create parent directories only if they don't exist
@@ -118,8 +74,7 @@ def prepare_mount(outdir: Path, verbose: bool) -> None:
 
 
 def wait_for_mount(
-    path: Path,
-    mount_process: Any,
+    mount: Mount,
     timeout: int = 20,
     post_mount_delay: int = 5,
     poll_interval: float = 1.0,
@@ -132,7 +87,7 @@ def wait_for_mount(
     is still running, and applies an extra delay after detecting content for stabilization.
 
     Args:
-        path (Path): The mount point directory to check.
+        src (Path): The mount point directory to check.
         mount_process (Any): A Process instance handling the mount (must be an instance of Process).
         timeout (int): Maximum time in seconds to wait for the mount to become available.
         post_mount_delay (int): Additional seconds to wait after detecting files.
@@ -145,6 +100,9 @@ def wait_for_mount(
         TypeError: If mount_process is not an instance of Process.
     """
 
+    mount_process = mount.process
+    src = mount.mount_path
+
     if not isinstance(mount_process, Process):
         raise TypeError("mount_process must be an instance of Process")
 
@@ -160,40 +118,42 @@ def wait_for_mount(
             raise subprocess.CalledProcessError(rtn, cmd_str)
 
         # Check if the mount path exists.
-        if path.exists():
+        if src.exists():
             # Optionally check if path is a mount point.
             if check_mount_flag:
                 try:
-                    if not os.path.ismount(str(path)):
+                    if not os.path.ismount(str(src)):
                         print(
-                            f"{path} exists but is not recognized as a mount point yet."
+                            f"{src} exists but is not recognized as a mount point yet."
                         )
                         time.sleep(poll_interval)
                         continue
                 except Exception as e:
-                    print(f"Could not verify mount point status for {path}: {e}")
+                    print(f"Could not verify mount point status for {src}: {e}")
 
             try:
                 # Check for at least one entry in the directory.
-                if any(path.iterdir()):
+                if any(src.iterdir()):
                     print(
-                        f"Mount point {path} appears available with files. Waiting {post_mount_delay} seconds for stabilization."
+                        f"Mount point {src} appears available with files. Waiting {post_mount_delay} seconds for stabilization."
                     )
                     time.sleep(post_mount_delay)
                     return
                 else:
-                    print(f"Mount point {path} is empty. Waiting for files to appear.")
+                    print(f"Mount point {src} is empty. Waiting for files to appear.")
             except Exception as e:
                 last_error = e
-                print(f"Error accessing {path}: {e}")
+                print(f"Error accessing {src}: {e}")
         else:
-            print(f"Mount point {path} does not exist yet.")
+            print(f"Mount point {src} does not exist yet.")
 
         time.sleep(poll_interval)
 
-    raise TimeoutError(
-        f"Mount point {path} did not become available within {timeout} seconds. Last error: {last_error}"
-    )
+    # raise TimeoutError(
+    #     f"Mount point {src} did not become available within {timeout} seconds. Last error: {last_error}"
+    # )
+    if last_error is not None:
+        raise last_error
 
 
 def clean_mount(mount: Mount | Path, verbose: bool = False, wait=True) -> None:
@@ -205,10 +165,14 @@ def clean_mount(mount: Mount | Path, verbose: bool = False, wait=True) -> None:
     and 'umount'. On macOS it uses 'umount' (and optionally 'diskutil unmount'),
     while on Windows it attempts to remove the mount point via 'mountvol /D'.
     """
+
+    def verbose_print(msg: str):
+        if verbose:
+            print(msg)
+
     proc = mount.process if isinstance(mount, Mount) else None
     if proc is not None and proc.poll() is None:
-        if verbose:
-            print(f"Terminating mount process {proc.pid}")
+        verbose_print(f"Terminating mount process {proc.pid}")
         proc.kill()
 
     # Check if the mount path exists; if an OSError occurs, assume it exists.
@@ -224,26 +188,24 @@ def clean_mount(mount: Mount | Path, verbose: bool = False, wait=True) -> None:
         time.sleep(2)
 
     if not mount_exists:
-        if verbose:
-            print(f"{mount_path} does not exist; nothing to clean up.")
+        verbose_print(f"{mount_path} does not exist; nothing to clean up.")
         return
 
-    if verbose:
-        print(f"{mount_path} still exists, attempting to unmount and remove.")
+    verbose_print(f"{mount_path} still exists, attempting to unmount and remove.")
 
     # Platform-specific unmount procedures
     if _SYSTEM == "Linux":
         # Try FUSE unmount first (if applicable), then the regular umount.
-        run_command(f"fusermount -u {mount_path}", verbose)
-        run_command(f"umount {mount_path}", verbose)
+        _run_command(f"fusermount -u {mount_path}", verbose)
+        _run_command(f"umount {mount_path}", verbose)
     elif _SYSTEM == "Darwin":
         # On macOS, use umount; optionally try diskutil for stubborn mounts.
-        run_command(f"umount {mount_path}", verbose)
+        _run_command(f"umount {mount_path}", verbose)
         # Optionally: uncomment the next line if diskutil unmount is preferred.
-        # run_command(f"diskutil unmount {mount_path}", verbose)
+        # _run_command(f"diskutil unmount {mount_path}", verbose)
     elif _SYSTEM == "Windows":
         # On Windows, remove the mount point using mountvol.
-        run_command(f"mountvol {mount_path} /D", verbose)
+        _run_command(f"mountvol {mount_path} /D", verbose)
         # If that does not work, try to remove the directory directly.
         try:
             mount_path.rmdir()
@@ -267,19 +229,17 @@ def clean_mount(mount: Mount | Path, verbose: bool = False, wait=True) -> None:
         still_exists = True
 
     if still_exists:
-        if verbose:
-            print(f"{mount_path} still exists after unmount attempt.")
+        verbose_print(f"{mount_path} still exists after unmount attempt.")
         # Attempt to remove the directory if it is empty.
         try:
             # Only remove if the directory is empty.
             if not any(mount_path.iterdir()):
                 mount_path.rmdir()
                 if verbose:
-                    print(f"Removed empty mount directory {mount_path}")
+                    verbose_print(f"Removed empty mount directory {mount_path}")
             else:
                 warnings.warn(f"{mount_path} is not empty; cannot remove.")
         except Exception as e:
             warnings.warn(f"Failed during cleanup of {mount_path}: {e}")
     else:
-        if verbose:
-            print(f"{mount_path} successfully cleaned up.")
+        verbose_print(f"{mount_path} successfully cleaned up.")

{rclone_api-1.5.6 → rclone_api-1.5.7}/src/rclone_api/rclone_impl.py

@@ -27,7 +27,7 @@ from rclone_api.file import File
 from rclone_api.file_stream import FilesStream
 from rclone_api.group_files import group_files
 from rclone_api.http_server import HttpServer
-from rclone_api.mount import Mount, clean_mount, prepare_mount
+from rclone_api.mount import Mount
 from rclone_api.process import Process
 from rclone_api.remote import Remote
 from rclone_api.rpath import RPath
@@ -1017,6 +1017,7 @@ class RcloneImpl:
         Raises:
             subprocess.CalledProcessError: If the mount operation fails
         """
+        from rclone_api.mount_util import clean_mount, prepare_mount
 
         allow_writes = allow_writes or False
         use_links = use_links or True

{rclone_api-1.5.6 → rclone_api-1.5.7}/src/rclone_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.5.6
+Version: 1.5.7
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 License: BSD 3-Clause License

{rclone_api-1.5.6 → rclone_api-1.5.7}/src/rclone_api.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ src/rclone_api/http_server.py
 src/rclone_api/install.py
 src/rclone_api/log.py
 src/rclone_api/mount.py
+src/rclone_api/mount_util.py
 src/rclone_api/process.py
 src/rclone_api/rclone_impl.py
 src/rclone_api/remote.py