rclone-api 1.1.48__tar.gz → 1.1.50__tar.gz

{rclone_api-1.1.48 → rclone_api-1.1.50}/PKG-INFO

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

{rclone_api-1.1.48 → rclone_api-1.1.50}/pyproject.toml

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

{rclone_api-1.1.48 → rclone_api-1.1.50}/src/rclone_api/mount.py

@@ -1,8 +1,12 @@
+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
@@ -11,6 +15,27 @@ 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, wait=False)
+
+
+atexit.register(_cleanup_mounts)
+
 
 @dataclass
 class Mount:
@@ -27,15 +52,18 @@ class 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)
 
     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
@@ -46,6 +74,10 @@ class Mount:
     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:
     """Run a shell command and print its output if verbose is True."""
@@ -76,25 +108,83 @@ def prepare_mount(outdir: Path, verbose: bool) -> None:
         outdir.mkdir(parents=True, exist_ok=True)
 
 
-def wait_for_mount(path: Path, mount_process: Any, timeout: int = 10) -> None:
-    from rclone_api.process import Process
+def wait_for_mount(
+    path: Path,
+    mount_process: Any,
+    timeout: int = 10,
+    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")
 
-    assert isinstance(mount_process, 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():
-            return
-            # how many files?
-            # dircontents = os.listdir(str(path))
-            # if len(dircontents) > 0:
-            #     print(f"Mount point {path}, waiting 5 seconds for files to appear.")
-            #     time.sleep(5)
-            #     return
-        time.sleep(1)
+            # 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:

{rclone_api-1.1.48 → rclone_api-1.1.50}/src/rclone_api.egg-info/PKG-INFO

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