rclone-api 1.1.6__tar.gz → 1.1.8__tar.gz

{rclone_api-1.1.6 → rclone_api-1.1.8}/PKG-INFO

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

{rclone_api-1.1.6 → rclone_api-1.1.8}/pyproject.toml

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

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api/cmd/copy_large_s3.py

@@ -12,8 +12,8 @@ class Args:
     config_path: Path
     src: str
     dst: str
-    chunk_size_mb: SizeSuffix
-    read_concurrent_chunks: int
+    chunk_size: SizeSuffix
+    threads: int
     retries: int
     save_state_json: Path
     verbose: bool
@@ -38,13 +38,13 @@ def _parse_args() -> Args:
         "--chunk-size",
         help="Chunk size that will be read and uploaded in in SizeSuffix (i.e. 128M = 128 megabytes) form",
         type=str,
-        default="128M",
+        default="512M",
     )
     parser.add_argument(
-        "--read-concurrent-chunks",
-        help="Maximum number of chunks to read in a look ahead cache",
+        "--threads",
+        help="Number of threads to use per chunk",
         type=int,
-        default=1,
+        default=16,
     )
     parser.add_argument("--retries", help="Number of retries", type=int, default=3)
     parser.add_argument(
@@ -59,10 +59,10 @@ def _parse_args() -> Args:
         config_path=Path(args.config),
         src=args.src,
         dst=args.dst,
-        chunk_size_mb=SizeSuffix(args.chunk_size),
-        read_concurrent_chunks=args.read_concurrent_chunks,
+        chunk_size=SizeSuffix(args.chunk_size),
+        threads=args.threads,
         retries=args.retries,
-        save_state_json=args.resumable_json,
+        save_state_json=args.resume_json,
         verbose=args.verbose,
     )
     return out
@@ -72,11 +72,15 @@ def main() -> int:
     """Main entry point."""
     args = _parse_args()
     rclone = Rclone(rclone_conf=args.config_path)
+    # unit_chunk = args.chunk_size / args.threads
     rslt: MultiUploadResult = rclone.copy_file_resumable_s3(
         src=args.src,
         dst=args.dst,
-        chunk_size=args.chunk_size_mb * _1MB,
-        concurrent_chunks=args.read_concurrent_chunks,
+        chunk_size=args.chunk_size,
+        threads=args.threads,
+        # vfs_read_chunk_size=unit_chunk,
+        # vfs_read_chunk_size_limit=args.chunk_size,
+        # vfs_read_chunk_streams=args.threads,
         retries=args.retries,
         save_state_json=args.save_state_json,
         verbose=args.verbose,

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api/experimental/flags.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 
 from rclone_api.experimental.flags_base import BaseFlags, merge_flags
+from rclone_api.types import SizeSuffix
 
 
 @dataclass
@@ -20,7 +21,7 @@ class CopyFlags(BaseFlags):
     links: bool | None = None
     max_backlog: int | None = None
     max_duration: str | None = None
-    max_transfer: str | None = None
+    max_transfer: SizeSuffix | None = None
     metadata: bool | None = None
     modify_window: str | None = None
     multi_thread_chunk_size: str | None = None
@@ -77,6 +78,12 @@ def unit_test() -> None:
     merged_d_c = copy_flags_d.merge(copy_flags_c)
     print("C:", merged_d_c)
 
+    # now do the one with the SizeSuffix type
+    copy_flags_e = CopyFlags(max_transfer=SizeSuffix("128M"))
+    copy_flags_f = CopyFlags(max_transfer=SizeSuffix("256M"))
+    merged_e_f = copy_flags_e.merge(copy_flags_f)
+    print("D:", merged_e_f)
+
 
 if __name__ == "__main__":
     unit_test()

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api/mount.py

@@ -1,12 +1,30 @@
+import os
 import platform
 import subprocess
 import time
 import warnings
+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.
 
 
+@dataclass
+class Mount:
+    """Mount information."""
+
+    mount_path: Path
+    process: Process
+
+    def __post_init__(self):
+        assert isinstance(self.mount_path, Path)
+        assert self.process is not None
+        wait_for_mount(self.mount_path, self.process)
+
+
 def run_command(cmd: str, verbose: bool) -> int:
     """Run a shell command and print its output if verbose is True."""
     if verbose:
@@ -36,7 +54,27 @@ def prepare_mount(outdir: Path, verbose: bool) -> None:
         outdir.mkdir(parents=True, exist_ok=True)
 
 
-def clean_mount(mount_path: Path, verbose: bool = False) -> None:
+def wait_for_mount(path: Path, mount_process: Any, timeout: int = 10) -> None:
+    from rclone_api.process import Process
+
+    assert isinstance(mount_process, Process)
+    expire_time = time.time() + timeout
+    while time.time() < expire_time:
+        rtn = mount_process.poll()
+        if rtn is not None:
+            cmd_str = subprocess.list2cmdline(mount_process.cmd)
+            raise subprocess.CalledProcessError(rtn, cmd_str)
+        if path.exists():
+            # 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)
+
+
+def clean_mount(mount: Mount | Path, verbose: bool = False) -> None:
     """
     Clean up a mount path across Linux, macOS, and Windows.
 
@@ -45,7 +83,14 @@ def clean_mount(mount_path: Path, verbose: bool = False) -> 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'.
     """
+    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 as e:

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api/process.py

@@ -100,6 +100,10 @@ class Process:
             except Exception as e:
                 print(f"Error cleaning up tempdir: {e}")
 
+    @property
+    def pid(self) -> int:
+        return self.process.pid
+
     def __del__(self) -> None:
         self.cleanup()
 

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api/rclone.py

@@ -25,6 +25,7 @@ from rclone_api.dir_listing import DirListing
 from rclone_api.exec import RcloneExec
 from rclone_api.file import File
 from rclone_api.group_files import group_files
+from rclone_api.mount import Mount, clean_mount, prepare_mount
 from rclone_api.process import Process
 from rclone_api.remote import Remote
 from rclone_api.rpath import RPath
@@ -46,12 +47,9 @@ from rclone_api.util import (
     get_rclone_exe,
     get_verbose,
     to_path,
-    wait_for_mount,
 )
 from rclone_api.walk import walk
 
-_IS_WINDOWS = os.name == "nt"
-
 
 def rclone_verbose(verbose: bool | None) -> bool:
     if verbose is not None:
@@ -680,12 +678,7 @@ class Rclone:
         dst: str,
         save_state_json: Path,
         chunk_size: SizeSuffix | None = None,
-        # 16
-        # * 1024
-        # * 1024,  # This setting will scale the performance of the upload
-        concurrent_chunks: (
-            int | None
-        ) = None,  # This setting will scale the performance of the upload
+        threads: int = 16,
         retries: int = 3,
         verbose: bool | None = None,
         max_chunks_before_suspension: int | None = None,
@@ -696,30 +689,24 @@ class Rclone:
         from rclone_api.s3.create import S3Credentials
         from rclone_api.util import S3PathInfo, random_str, split_s3_path
 
-        _tmp: SizeSuffix | str = chunk_size or "16MiB"
-        chunk_size = SizeSuffix(_tmp)
-        assert chunk_size is not None
-        concurrent_chunks = concurrent_chunks or 4
-        size_limit = SizeSuffix(chunk_size * concurrent_chunks)
-
-        other_args: list[str] = [
-            "--no-modtime",
-            "--vfs-read-wait",
-            "1s",
-            "--vfs-disk-space-total-size",
-            size_limit.as_str(),  # purge quickly.
-            "--vfs-read-chunk-size",
-            chunk_size.as_str(),
+        other_args: list[str] = ["--no-modtime", "--vfs-read-wait", "1s"]
+        chunk_size = chunk_size or SizeSuffix("128M")
+        unit_chunk_size = chunk_size / threads
+        vfs_read_chunk_size = unit_chunk_size
+        vfs_read_chunk_size_limit = chunk_size
+        vfs_read_chunk_streams = threads
+        assert (
+            chunk_size.as_int() % vfs_read_chunk_size.as_int() == 0
+        ), f"chunk_size {chunk_size} must be a multiple of vfs_read_chunk_size {vfs_read_chunk_size}"
+        other_args += ["--vfs-read-chunk-size", vfs_read_chunk_size.as_str()]
+        other_args += [
             "--vfs-read-chunk-size-limit",
-            size_limit.as_str(),
-            "--vfs-read-chunk-streams",
-            str(concurrent_chunks),
-            "--vfs-fast-fingerprint",
+            vfs_read_chunk_size_limit.as_str(),
         ]
+        other_args += ["--vfs-read-chunk-streams", str(vfs_read_chunk_streams)]
         mount_path = mount_path or Path("tmp_mnts") / random_str(12)
         src_path = Path(src)
         name = src_path.name
-
         parent_path = str(src_path.parent.as_posix())
         with self.scoped_mount(
             parent_path,
@@ -847,7 +834,7 @@ class Rclone:
         vfs_cache_mode: str | None = None,
         verbose: bool | None = None,
         other_args: list[str] | None = None,
-    ) -> Process:
+    ) -> Mount:
         """Mount a remote or directory to a local path.
 
         Args:
@@ -860,7 +847,6 @@ class Rclone:
         Raises:
             subprocess.CalledProcessError: If the mount operation fails
         """
-        from rclone_api.mount import clean_mount, prepare_mount
 
         allow_writes = allow_writes or False
         use_links = use_links or True
@@ -882,8 +868,9 @@ class Rclone:
         if other_args:
             cmd_list += other_args
         proc = self._launch_process(cmd_list)
-        wait_for_mount(outdir, proc)
-        return proc
+
+        mount: Mount = Mount(mount_path=outdir, process=proc)
+        return mount
 
     @contextmanager
     def scoped_mount(
@@ -895,11 +882,11 @@ class Rclone:
         vfs_cache_mode: str | None = None,
         verbose: bool | None = None,
         other_args: list[str] | None = None,
-    ) -> Generator[Process, None, None]:
+    ) -> Generator[Mount, None, None]:
         """Like mount, but can be used in a context manager."""
         error_happened = False
         verbose = get_verbose(verbose)
-        proc = self.mount(
+        mount: Mount = self.mount(
             src,
             outdir,
             allow_writes=allow_writes,
@@ -909,77 +896,18 @@ class Rclone:
             other_args=other_args,
         )
         try:
-            yield proc
+            yield mount
         except Exception as e:
             error_happened = True
             stack_trace = traceback.format_exc()
             warnings.warn(f"Error in scoped_mount: {e}\n\nStack Trace:\n{stack_trace}")
             raise
         finally:
-            if proc.poll() is None:
-                proc.terminate()
-            proc.wait()
+
             if not error_happened:
                 from rclone_api.mount import clean_mount
 
-                clean_mount(outdir, verbose=verbose)
-
-    @deprecated("mount")
-    def mount_webdav(
-        self,
-        url: str,
-        outdir: Path,
-        vfs_cache_mode: str | None = None,
-        vfs_disk_space_total_size: str | None = "10G",
-        other_args: list[str] | None = None,
-    ) -> Process:
-        """Mount a remote or directory to a local path.
-
-        Args:
-            src: Remote or directory to mount
-            outdir: Local path to mount to
-
-        Returns:
-            CompletedProcess from the mount command execution
-
-        Raises:
-            subprocess.CalledProcessError: If the mount operation fails
-        """
-        other_args = other_args or []
-        if vfs_cache_mode is None:
-            if "--vfs-cache-mode" in other_args:
-                pass
-            else:
-                vfs_cache_mode = "full"
-        elif "--vfs-cache-mode" in other_args:
-            warnings.warn(
-                f"vfs_cache_mode is set to {vfs_cache_mode} but --vfs-cache-mode is already in other_args"
-            )
-            idx = other_args.index("--vfs-cache-mode")
-            other_args.pop(idx)
-            other_args.pop(idx)  # also the next value which will be the cache mode.
-
-        if outdir.exists():
-            is_empty = not list(outdir.iterdir())
-            if not is_empty:
-                raise ValueError(
-                    f"Mount directory already exists and is not empty: {outdir}"
-                )
-            outdir.rmdir()
-
-        src_str = url
-        cmd_list: list[str] = ["mount", src_str, str(outdir)]
-        if vfs_cache_mode:
-            cmd_list.append("--vfs-cache-mode")
-            cmd_list.append(vfs_cache_mode)
-        if other_args:
-            cmd_list += other_args
-        if vfs_disk_space_total_size is not None:
-            cmd_list.append("--vfs-cache-max-size")
-            cmd_list.append(vfs_disk_space_total_size)
-        proc = self._launch_process(cmd_list)
-        wait_for_mount(outdir, proc)
-        return proc
+                clean_mount(mount, verbose=verbose)
 
     # Settings optimized for s3.
     def mount_s3(
@@ -988,11 +916,8 @@ class Rclone:
         outdir: Path,
         allow_writes=False,
         vfs_cache_mode="full",
-        # dir-cache-time
         dir_cache_time: str | None = "1h",
         attribute_timeout: str | None = "1h",
-        # --vfs-cache-max-size
-        # vfs-cache-max-size
         vfs_disk_space_total_size: str | None = "100M",
         transfers: int | None = 128,
         modtime_strategy: (
@@ -1004,7 +929,7 @@ class Rclone:
         # vfs-refresh
         vfs_refresh: bool = True,
         other_args: list[str] | None = None,
-    ) -> Process:
+    ) -> Mount:
         """Mount a remote or directory to a local path.
 
         Args:

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api/s3/chunk_types.py

@@ -7,6 +7,7 @@ from threading import Lock
 
 from botocore.client import BaseClient
 
+from rclone_api.types import SizeSuffix
 from rclone_api.util import locked_print
 
 _MIN_UPLOAD_CHUNK_SIZE = 5 * 1024 * 1024  # 5MB
@@ -108,16 +109,20 @@ class UploadInfo:
             value = getattr(self, f.name)
             # Convert non-serializable objects (like s3_client) to a string representation.
             if f.name == "s3_client":
-                json_dict[f.name] = "RUNTIME OBJECT"
+                continue
             else:
                 if isinstance(value, Path):
                     value = str(value)
                 json_dict[f.name] = value
+
         return json_dict
 
     @staticmethod
     def from_json(s3_client: BaseClient, json_dict: dict) -> "UploadInfo":
-        json_dict.pop("s3_client")  # Remove the placeholder string
+        # json_dict.pop("s3_client")  # Remove the placeholder string
+        if "s3_client" in json_dict:
+            json_dict.pop("s3_client")
+
         return UploadInfo(s3_client=s3_client, **json_dict)
 
 
@@ -224,6 +229,12 @@ class UploadState:
 
         # self.count()
         finished_count, total = self.count()
+        total_finished: SizeSuffix = SizeSuffix(
+            finished_count * self.upload_info.chunk_size
+        )
+        total_remaining: SizeSuffix = SizeSuffix(
+            self.remaining() * self.upload_info.chunk_size
+        )
 
         # parts.sort(key=lambda x: x.part_number)  # Some backends need this.
         out_json = {
@@ -232,6 +243,10 @@ class UploadState:
             "is_done": is_done,
             "finished_count": finished_count,
             "total_parts": total,
+            "total_size": SizeSuffix(self.upload_info.file_size).as_str(),
+            "total_finished": total_finished.as_str(),
+            "total_remaining": total_remaining.as_str(),
+            "completed": f"{(finished_count / total) * 100:.2f}%",
         }
 
         # check that we can sererialize

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api/types.py

@@ -58,6 +58,8 @@ _PATTERN_SIZE_SUFFIX = re.compile(r"^(\d+)([A-Za-z]+)$")
 def _from_size_suffix(size: str) -> int:
     # 16MiB
     # parse out number and suffix
+    if size == "0":
+        return 0
     match = _PATTERN_SIZE_SUFFIX.match(size)
     if match is None:
         raise ValueError(f"Invalid size suffix: {size}")
@@ -88,6 +90,8 @@ class SizeSuffix:
             self._size = size
         elif isinstance(size, str):
             self._size = _from_size_suffix(size)
+        elif isinstance(size, float):
+            self._size = int(size)
         else:
             raise ValueError(f"Invalid type for size: {type(size)}")
 
@@ -123,3 +127,10 @@ class SizeSuffix:
     def __sub__(self, other: "int | SizeSuffix") -> "SizeSuffix":
         other_int = SizeSuffix(other)
         return SizeSuffix(self._size - other_int._size)
+
+    def __truediv__(self, other: "int | SizeSuffix") -> "SizeSuffix":
+        other_int = SizeSuffix(other)
+        if other_int._size == 0:
+            raise ZeroDivisionError("Division by zero is undefined")
+        # Use floor division to maintain integer arithmetic.
+        return SizeSuffix(self._size // other_int._size)

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api/util.py

@@ -1,7 +1,6 @@
 import os
 import shutil
 import subprocess
-import time
 import warnings
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -135,26 +134,6 @@ def rclone_execute(
                 print(f"Error cleaning up tempdir: {e}")
 
 
-def wait_for_mount(path: Path, mount_process: Any, timeout: int = 10) -> None:
-    from rclone_api.process import Process
-
-    assert isinstance(mount_process, Process)
-    expire_time = time.time() + timeout
-    while time.time() < expire_time:
-        rtn = mount_process.poll()
-        if rtn is not None:
-            cmd_str = subprocess.list2cmdline(mount_process.cmd)
-            raise subprocess.CalledProcessError(rtn, cmd_str)
-        if path.exists():
-            # 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)
-
-
 def split_s3_path(path: str) -> S3PathInfo:
     if ":" not in path:
         raise ValueError(f"Invalid S3 path: {path}")

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api.egg-info/PKG-INFO

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

{rclone_api-1.1.6 → rclone_api-1.1.8}/src/rclone_api.egg-info/SOURCES.txt

@@ -69,7 +69,6 @@ tests/test_is_synced.py
 tests/test_ls.py
 tests/test_mount.py
 tests/test_mount_s3.py
-tests/test_mount_webdav.py
 tests/test_mounted_ranged_download.py
 tests/test_obscure.py
 tests/test_rclone_config.py

{rclone_api-1.1.6 → rclone_api-1.1.8}/tests/test_mount.py

@@ -68,7 +68,9 @@ class RcloneMountTests(unittest.TestCase):
 
         try:
             # Start the mount process
-            process = self.rclone.mount(remote_path, self.mount_point)
+            mount = self.rclone.mount(remote_path, self.mount_point)
+            process = mount.process
+            assert process is not None
             self.assertIsNone(
                 process.poll(), "Mount process should still be running after 2 seconds"
             )

{rclone_api-1.1.6 → rclone_api-1.1.8}/tests/test_mount_s3.py

@@ -70,7 +70,9 @@ class RcloneMountS3Tests(unittest.TestCase):
 
         try:
             # Start the mount process
-            process = self.rclone.mount_s3(remote_path, self.mount_point)
+            mount = self.rclone.mount_s3(remote_path, self.mount_point)
+            process = mount.process
+            assert process
             self.assertIsNone(
                 process.poll(), "Mount process should still be running after 2 seconds"
             )

rclone_api-1.1.6/tests/test_mount_webdav.py

@@ -1,117 +0,0 @@
-"""
-Unit test file.
-"""
-
-import os
-import unittest
-from pathlib import Path
-
-from dotenv import load_dotenv
-
-from rclone_api import Config, Process, Rclone, Remote
-
-_ENABLED = False
-
-load_dotenv()
-
-BUCKET_NAME = os.getenv("BUCKET_NAME")  # Default if not in .env
-
-
-def _generate_rclone_config(port: int) -> Config:
-
-    # BUCKET_NAME = os.getenv("BUCKET_NAME", "TorrentBooks")  # Default if not in .env
-
-    # Load additional environment variables
-    BUCKET_KEY_SECRET = os.getenv("BUCKET_KEY_SECRET")
-    BUCKET_KEY_PUBLIC = os.getenv("BUCKET_KEY_PUBLIC")
-    # BUCKET_URL = os.getenv("BUCKET_URL")
-    BUCKET_URL = "sfo3.digitaloceanspaces.com"
-
-    config_text = f"""
-[dst]
-type = s3
-provider = DigitalOcean
-access_key_id = {BUCKET_KEY_PUBLIC}
-secret_access_key = {BUCKET_KEY_SECRET}
-endpoint = {BUCKET_URL}
-bucket = {BUCKET_NAME}
-
-
-[webdav]
-type = webdav
-user = guest
-# obscured password for "1234", use Rclone.obscure("1234") to generate
-pass = d4IbQLV9W0JhI2tm5Zp88hpMtEg
-url = http://localhost:{port}
-vendor = rclone
-"""
-
-    out = Config(config_text)
-    return out
-
-
-class RcloneMountWebdavTester(unittest.TestCase):
-    """Test rclone functionality."""
-
-    def setUp(self) -> None:
-        """Check if all required environment variables are set before running tests."""
-        required_vars = [
-            "BUCKET_NAME",
-            "BUCKET_KEY_SECRET",
-            "BUCKET_KEY_PUBLIC",
-            "BUCKET_URL",
-        ]
-        missing = [var for var in required_vars if not os.getenv(var)]
-        if missing:
-            self.skipTest(
-                f"Missing required environment variables: {', '.join(missing)}"
-            )
-        os.environ["RCLONE_API_VERBOSE"] = "1"
-
-    @unittest.skipIf(not _ENABLED, "Test not enabled")
-    def test_serve_webdav_and_mount(self) -> None:
-        """Test basic NFS serve functionality."""
-        port = 8090
-        config = _generate_rclone_config(port)
-        rclone = Rclone(config)
-
-        # Start NFS server for the remote
-        remote = Remote("dst", rclone=rclone)
-        # serve = Remote("webdav", rclone=rclone)
-        test_addr = f"localhost:{port}"
-        user = "guest"
-        password = "1234"
-
-        process = rclone.serve_webdav(
-            f"{remote.name}:{BUCKET_NAME}", addr=test_addr, user=user, password=password
-        )
-        mount_proc: Process | None = None
-
-        try:
-            # Verify process is running
-            self.assertIsNone(process.poll())
-            mount_point = Path("test_mount2")
-            mount_proc = rclone.mount_webdav("webdav:", mount_point)
-            # test that the mount point exists
-            self.assertTrue(mount_point.exists())
-            # test the folder is not empty
-            next_path = next(mount_point.iterdir())
-            self.assertIsNotNone(next_path)
-
-        finally:
-            # Clean up
-            if mount_proc:
-                mount_proc.terminate()
-                mount_proc.wait()
-            process.terminate()
-            process.wait()
-            if mount_proc:
-                mount_proc.terminate()
-                mount_proc.wait()
-
-        # Verify process terminated
-        self.assertIsNotNone(process.poll())
-
-
-if __name__ == "__main__":
-    unittest.main()