rclone-api 1.5.6__py2.py3-none-any.whl → 1.5.7__py2.py3-none-any.whl

rclone_api/mount.py

@@ -1,49 +1,8 @@
-import atexit
-import os
-import platform
-import shutil
-import subprocess
-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.process import Process
 
-_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
-        for mount in _MOUNTS_FOR_GC:
-            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:
@@ -58,21 +17,29 @@ class Mount:
     _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.mount_path, self.process)
-        _add_mount_for_gc(self)
+        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)
+            cache_dir_delete_on_exit(self.cache_dir)
+        remove_mount_for_gc(self)
 
     def __enter__(self) -> "Mount":
         return self
@@ -86,200 +53,3 @@ class Mount:
     # make this a hashable object
     def __hash__(self):
         return hash(self.mount_path)
-
-
-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}")
-    try:
-        result = subprocess.run(
-            cmd, shell=True, capture_output=True, text=True, check=False
-        )
-        if result.returncode != 0 and verbose:
-            print(f"Command failed: {cmd}\nStdErr: {result.stderr.strip()}")
-        return result.returncode
-    except Exception as e:
-        warnings.warn(f"Error running command '{cmd}': {e}")
-        return -1
-
-
-def prepare_mount(outdir: Path, verbose: bool) -> None:
-    if _SYSTEM == "Windows":
-        # Windows -> Must create parent directories only if they don't exist
-        if verbose:
-            print(f"Creating parent directories for {outdir}")
-        outdir.parent.mkdir(parents=True, exist_ok=True)
-    else:
-        # Linux -> Must create parent directories and the directory itself
-        if verbose:
-            print(f"Creating directories for {outdir}")
-        outdir.mkdir(parents=True, exist_ok=True)
-
-
-def wait_for_mount(
-    path: Path,
-    mount_process: Any,
-    timeout: int = 20,
-    post_mount_delay: int = 5,
-    poll_interval: float = 1.0,
-    check_mount_flag: bool = False,
-) -> None:
-    """
-    Wait for a mount point to become available by checking if the directory exists,
-    optionally verifying that it is a mount point, and confirming that it contains files.
-    This function periodically polls for the mount status, ensures the mount process
-    is still running, and applies an extra delay after detecting content for stabilization.
-
-    Args:
-        path (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.
-        poll_interval (float): Seconds between each poll iteration.
-        check_mount_flag (bool): If True, verifies that the path is recognized as a mount point.
-
-    Raises:
-        subprocess.CalledProcessError: If the mount_process exits unexpectedly.
-        TimeoutError: If the mount is not available within the timeout period.
-        TypeError: If mount_process is not an instance of Process.
-    """
-
-    if not isinstance(mount_process, Process):
-        raise TypeError("mount_process must be an instance of Process")
-
-    expire_time = time.time() + timeout
-    last_error = None
-
-    while time.time() < expire_time:
-        # Check if the mount process has terminated unexpectedly.
-        rtn = mount_process.poll()
-        if rtn is not None:
-            cmd_str = subprocess.list2cmdline(mount_process.cmd)
-            print(f"Mount process terminated unexpectedly: {cmd_str}")
-            raise subprocess.CalledProcessError(rtn, cmd_str)
-
-        # Check if the mount path exists.
-        if path.exists():
-            # Optionally check if path is a mount point.
-            if check_mount_flag:
-                try:
-                    if not os.path.ismount(str(path)):
-                        print(
-                            f"{path} 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}")
-
-            try:
-                # Check for at least one entry in the directory.
-                if any(path.iterdir()):
-                    print(
-                        f"Mount point {path} 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.")
-            except Exception as e:
-                last_error = e
-                print(f"Error accessing {path}: {e}")
-        else:
-            print(f"Mount point {path} 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}"
-    )
-
-
-def clean_mount(mount: Mount | Path, verbose: bool = False, wait=True) -> None:
-    """
-    Clean up a mount path across Linux, macOS, and Windows.
-
-    The function attempts to unmount the mount at mount_path, then, if the
-    directory is empty, removes it. On Linux it uses 'fusermount -u' (for FUSE mounts)
-    and 'umount'. On macOS it uses 'umount' (and optionally 'diskutil unmount'),
-    while on Windows it attempts to remove the mount point via 'mountvol /D'.
-    """
-    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}")
-        proc.kill()
-
-    # Check if the mount path exists; if an OSError occurs, assume it exists.
-    mount_path = mount.mount_path if isinstance(mount, Mount) else mount
-    try:
-        mount_exists = mount_path.exists()
-    except OSError:
-        # warnings.warn(f"Error checking {mount_path}: {e}")
-        mount_exists = True
-
-    # Give the system a moment (if unmount is in progress, etc.)
-    if wait:
-        time.sleep(2)
-
-    if not mount_exists:
-        if 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.")
-
-    # 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)
-    elif _SYSTEM == "Darwin":
-        # On macOS, use umount; optionally try diskutil for stubborn mounts.
-        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)
-    elif _SYSTEM == "Windows":
-        # On Windows, remove the mount point using mountvol.
-        run_command(f"mountvol {mount_path} /D", verbose)
-        # If that does not work, try to remove the directory directly.
-        try:
-            mount_path.rmdir()
-            if verbose:
-                print(f"Successfully removed mount directory {mount_path}")
-        except Exception:
-            # warnings.warn(f"Failed to remove mount {mount_path}: {e}")
-            pass
-    else:
-        warnings.warn(f"Unsupported platform: {_SYSTEM}")
-
-    # Allow some time for the unmount commands to take effect.
-    if wait:
-        time.sleep(2)
-
-    # Re-check if the mount path still exists.
-    try:
-        still_exists = mount_path.exists()
-    except OSError as e:
-        warnings.warn(f"Error re-checking {mount_path}: {e}")
-        still_exists = True
-
-    if still_exists:
-        if 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}")
-            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.")

rclone_api/mount_util.py

@@ -0,0 +1,245 @@
+import atexit
+import os
+import platform
+import shutil
+import subprocess
+import time
+import warnings
+import weakref
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+from rclone_api.mount import Mount
+from rclone_api.process import Process
+
+_SYSTEM = platform.system()  # "Linux", "Darwin", "Windows", etc.
+
+_MOUNTS_FOR_GC: weakref.WeakSet = weakref.WeakSet()
+
+
+def _cleanup_mounts() -> None:
+    with ThreadPoolExecutor() as executor:
+        mount: Mount
+        for mount in _MOUNTS_FOR_GC:
+            executor.submit(mount.close)
+
+
+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}")
+    try:
+        result = subprocess.run(
+            cmd, shell=True, capture_output=True, text=True, check=False
+        )
+        if result.returncode != 0 and verbose:
+            print(f"Command failed: {cmd}\nStdErr: {result.stderr.strip()}")
+        return result.returncode
+    except Exception as e:
+        warnings.warn(f"Error running command '{cmd}': {e}")
+        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
+        if verbose:
+            print(f"Creating parent directories for {outdir}")
+        outdir.parent.mkdir(parents=True, exist_ok=True)
+    else:
+        # Linux -> Must create parent directories and the directory itself
+        if verbose:
+            print(f"Creating directories for {outdir}")
+        outdir.mkdir(parents=True, exist_ok=True)
+
+
+def wait_for_mount(
+    mount: Mount,
+    timeout: int = 20,
+    post_mount_delay: int = 5,
+    poll_interval: float = 1.0,
+    check_mount_flag: bool = False,
+) -> None:
+    """
+    Wait for a mount point to become available by checking if the directory exists,
+    optionally verifying that it is a mount point, and confirming that it contains files.
+    This function periodically polls for the mount status, ensures the mount process
+    is still running, and applies an extra delay after detecting content for stabilization.
+
+    Args:
+        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.
+        poll_interval (float): Seconds between each poll iteration.
+        check_mount_flag (bool): If True, verifies that the path is recognized as a mount point.
+
+    Raises:
+        subprocess.CalledProcessError: If the mount_process exits unexpectedly.
+        TimeoutError: If the mount is not available within the timeout period.
+        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")
+
+    expire_time = time.time() + timeout
+    last_error = None
+
+    while time.time() < expire_time:
+        # Check if the mount process has terminated unexpectedly.
+        rtn = mount_process.poll()
+        if rtn is not None:
+            cmd_str = subprocess.list2cmdline(mount_process.cmd)
+            print(f"Mount process terminated unexpectedly: {cmd_str}")
+            raise subprocess.CalledProcessError(rtn, cmd_str)
+
+        # Check if the mount path exists.
+        if src.exists():
+            # Optionally check if path is a mount point.
+            if check_mount_flag:
+                try:
+                    if not os.path.ismount(str(src)):
+                        print(
+                            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 {src}: {e}")
+
+            try:
+                # Check for at least one entry in the directory.
+                if any(src.iterdir()):
+                    print(
+                        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 {src} is empty. Waiting for files to appear.")
+            except Exception as e:
+                last_error = e
+                print(f"Error accessing {src}: {e}")
+        else:
+            print(f"Mount point {src} does not exist yet.")
+
+        time.sleep(poll_interval)
+
+    # 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:
+    """
+    Clean up a mount path across Linux, macOS, and Windows.
+
+    The function attempts to unmount the mount at mount_path, then, if the
+    directory is empty, removes it. On Linux it uses 'fusermount -u' (for FUSE mounts)
+    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:
+        verbose_print(f"Terminating mount process {proc.pid}")
+        proc.kill()
+
+    # Check if the mount path exists; if an OSError occurs, assume it exists.
+    mount_path = mount.mount_path if isinstance(mount, Mount) else mount
+    try:
+        mount_exists = mount_path.exists()
+    except OSError:
+        # warnings.warn(f"Error checking {mount_path}: {e}")
+        mount_exists = True
+
+    # Give the system a moment (if unmount is in progress, etc.)
+    if wait:
+        time.sleep(2)
+
+    if not mount_exists:
+        verbose_print(f"{mount_path} does not exist; nothing to clean up.")
+        return
+
+    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)
+    elif _SYSTEM == "Darwin":
+        # On macOS, use umount; optionally try diskutil for stubborn mounts.
+        _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)
+    elif _SYSTEM == "Windows":
+        # On Windows, remove the mount point using mountvol.
+        _run_command(f"mountvol {mount_path} /D", verbose)
+        # If that does not work, try to remove the directory directly.
+        try:
+            mount_path.rmdir()
+            if verbose:
+                print(f"Successfully removed mount directory {mount_path}")
+        except Exception:
+            # warnings.warn(f"Failed to remove mount {mount_path}: {e}")
+            pass
+    else:
+        warnings.warn(f"Unsupported platform: {_SYSTEM}")
+
+    # Allow some time for the unmount commands to take effect.
+    if wait:
+        time.sleep(2)
+
+    # Re-check if the mount path still exists.
+    try:
+        still_exists = mount_path.exists()
+    except OSError as e:
+        warnings.warn(f"Error re-checking {mount_path}: {e}")
+        still_exists = True
+
+    if still_exists:
+        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:
+                    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:
+        verbose_print(f"{mount_path} successfully cleaned up.")

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.dist-info → rclone_api-1.5.7.dist-info}/METADATA

@@ -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.dist-info → rclone_api-1.5.7.dist-info}/RECORD

@@ -17,9 +17,10 @@ rclone_api/group_files.py,sha256=H92xPW9lQnbNw5KbtZCl00bD6iRh9yRbCuxku4j_3dg,803
 rclone_api/http_server.py,sha256=LhovQu2AI-Z7zQIWflWelCiCDLnWzisL32Rs5350kxE,8850
 rclone_api/install.py,sha256=Xb1BRn8rQcSpSd4dzmvIOELP2zM2DytUeIZ6jzv738A,2893
 rclone_api/log.py,sha256=VZHM7pNSXip2ZLBKMP7M1u-rp_F7zoafFDuR8CPUoKI,1271
-rclone_api/mount.py,sha256=TE_VIBMW7J1UkF_6HRCt8oi_jGdMov4S51bm2OgxFAM,10045
+rclone_api/mount.py,sha256=LZqEhuKZunbWVqmsOIqkkCotaxWJpdFRS1InXveoU5E,1428
+rclone_api/mount_util.py,sha256=jCoObKMNTKO7xG2udAmEXtXdF182rCS5tn56Oc2CEUk,8993
 rclone_api/process.py,sha256=tGooS5NLdPuqHh7hCH8SfK44A6LGftPQCPQUNgSo0a0,5714
-rclone_api/rclone_impl.py,sha256=fhpl149P_dtfxTfwT0hHBaCIe4AJ3BHLXLVsC-QzmPo,46304
+rclone_api/rclone_impl.py,sha256=kr0gvOSuiwxU15rvATYZmSzpWYDiAzjZ2WNe1wqI6NM,46345
 rclone_api/remote.py,sha256=mTgMTQTwxUmbLjTpr-AGTId2ycXKI9mLX5L7PPpDIoc,520
 rclone_api/rpath.py,sha256=Y1JjQWcie39EgQrq-UtbfDz5yDLCwwfu27W7AQXllSE,2860
 rclone_api/scan_missing_folders.py,sha256=-8NCwpCaHeHrX-IepCoAEsX1rl8S-GOCxcIhTr_w3gA,4747
@@ -52,9 +53,9 @@ rclone_api/s3/multipart/upload_parts_inline.py,sha256=V7syKjFyVIe4U9Ahl5XgqVTzt9
 rclone_api/s3/multipart/upload_parts_resumable.py,sha256=diJoUpVYow6No_dNgOZIYVsv43k4evb6zixqpzWJaUk,9771
 rclone_api/s3/multipart/upload_parts_server_side_merge.py,sha256=Fp2pdrs5dONQI9LkfNolgAGj1-Z2V1SsRd0r0sreuXI,18040
 rclone_api/s3/multipart/upload_state.py,sha256=f-Aq2NqtAaMUMhYitlICSNIxCKurWAl2gDEUVizLIqw,6019
-rclone_api-1.5.6.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-rclone_api-1.5.6.dist-info/METADATA,sha256=WQndsxBcQyikEIYTaIJ3IH8tzC00wUeW9BTFC3s-vkM,32633
-rclone_api-1.5.6.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
-rclone_api-1.5.6.dist-info/entry_points.txt,sha256=fJteOlYVwgX3UbNuL9jJ0zUTuX2O79JFAeNgK7Sw7EQ,255
-rclone_api-1.5.6.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
-rclone_api-1.5.6.dist-info/RECORD,,
+rclone_api-1.5.7.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+rclone_api-1.5.7.dist-info/METADATA,sha256=f2c9hq_CZYIpVr-U9jV44E9FwPg1Tn59XTJf_zhme14,32633
+rclone_api-1.5.7.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+rclone_api-1.5.7.dist-info/entry_points.txt,sha256=fJteOlYVwgX3UbNuL9jJ0zUTuX2O79JFAeNgK7Sw7EQ,255
+rclone_api-1.5.7.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
+rclone_api-1.5.7.dist-info/RECORD,,