rclone-api 1.3.28__py2.py3-none-any.whl → 1.4.2__py2.py3-none-any.whl

rclone_api/types.py

@@ -1,14 +1,11 @@
-import atexit
 import os
 import re
-import threading
 import time
 import warnings
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
 from threading import Lock
-from typing import Any
 
 
 class ModTimeStrategy(Enum):
@@ -164,14 +161,25 @@ class SizeSuffix:
         other_int = SizeSuffix(other)
         return SizeSuffix(self._size * other_int._size)
 
+    # multiply when int is on the left
+    def __rmul__(self, other: "int | SizeSuffix") -> "SizeSuffix":
+        return self.__mul__(other)
+
     def __add__(self, other: "int | SizeSuffix") -> "SizeSuffix":
         other_int = SizeSuffix(other)
         return SizeSuffix(self._size + other_int._size)
 
+    def __radd__(self, other: "int | SizeSuffix") -> "SizeSuffix":
+        return self.__add__(other)
+
     def __sub__(self, other: "int | SizeSuffix") -> "SizeSuffix":
         other_int = SizeSuffix(other)
         return SizeSuffix(self._size - other_int._size)
 
+    def __rsub__(self, other: "int | SizeSuffix") -> "SizeSuffix":
+        other_int = SizeSuffix(other)
+        return SizeSuffix(other_int._size - self._size)
+
     def __truediv__(self, other: "int | SizeSuffix") -> "SizeSuffix":
         other_int = SizeSuffix(other)
         if other_int._size == 0:
@@ -179,6 +187,13 @@ class SizeSuffix:
         # Use floor division to maintain integer arithmetic.
         return SizeSuffix(self._size // other_int._size)
 
+    def __rtruediv__(self, other: "int | SizeSuffix") -> "SizeSuffix":
+        other_int = SizeSuffix(other)
+        if self._size == 0:
+            raise ZeroDivisionError("Division by zero is undefined")
+        # Use floor division to maintain integer arithmetic.
+        return SizeSuffix(other_int._size // self._size)
+
     # support / division
     def __floordiv__(self, other: "int | SizeSuffix") -> "SizeSuffix":
         other_int = SizeSuffix(other)
@@ -187,35 +202,38 @@ class SizeSuffix:
         # Use floor division to maintain integer arithmetic.
         return SizeSuffix(self._size // other_int._size)
 
+    def __rfloordiv__(self, other: "int | SizeSuffix") -> "SizeSuffix":
+        other_int = SizeSuffix(other)
+        if self._size == 0:
+            raise ZeroDivisionError("Division by zero is undefined")
+        # Use floor division to maintain integer arithmetic.
+        return SizeSuffix(other_int._size // self._size)
+
     def __eq__(self, other: object) -> bool:
-        if not isinstance(other, SizeSuffix):
+        if not isinstance(other, SizeSuffix) and not isinstance(other, int):
             return False
-        return self._size == other._size
+        return self._size == SizeSuffix(other)._size
 
     def __ne__(self, other: object) -> bool:
-        if not isinstance(other, SizeSuffix):
-            return True
-        return self._size != other._size
+        return not self.__ne__(other)
 
-    def __lt__(self, other: object) -> bool:
-        if not isinstance(other, SizeSuffix):
-            return False
-        return self._size < other._size
+    def __lt__(self, other: "int | SizeSuffix") -> bool:
+        # if not isinstance(other, SizeSuffix):
+        #     return False
+        # return self._size < other._size
+        return self._size < SizeSuffix(other)._size
 
-    def __le__(self, other: object) -> bool:
-        if not isinstance(other, SizeSuffix):
-            return False
-        return self._size <= other._size
+    def __le__(self, other: "int | SizeSuffix") -> bool:
+        # if not isinstance(other, SizeSuffix):
+        #     return False
+        # return self._size <= other._size
+        return self._size < SizeSuffix(other)._size
 
-    def __gt__(self, other: object) -> bool:
-        if not isinstance(other, SizeSuffix):
-            return False
-        return self._size > other._size
+    def __gt__(self, other: "int | SizeSuffix") -> bool:
+        return self._size > SizeSuffix(other)._size
 
-    def __ge__(self, other: object) -> bool:
-        if not isinstance(other, SizeSuffix):
-            return False
-        return self._size >= other._size
+    def __ge__(self, other: "int | SizeSuffix") -> bool:
+        return self._size >= SizeSuffix(other)._size
 
     def __hash__(self) -> int:
         return hash(self._size)
@@ -223,6 +241,16 @@ class SizeSuffix:
     def __int__(self) -> int:
         return self._size
 
+    def __iadd__(self, other: "int | SizeSuffix") -> "SizeSuffix":
+        other_int = SizeSuffix(other)
+        self._size += other_int._size
+        return self
+
+    def __isub__(self, other: "int | SizeSuffix") -> "SizeSuffix":
+        other_int = SizeSuffix(other)
+        self._size -= other_int._size
+        return self
+
 
 _TMP_DIR_ACCESS_LOCK = Lock()
 
@@ -269,150 +297,93 @@ class EndOfStream:
     pass
 
 
-_CLEANUP_LIST: list[Path] = []
-
-
-def _add_for_cleanup(path: Path) -> None:
-    _CLEANUP_LIST.append(path)
-
-
-def _on_exit_cleanup() -> None:
-    paths = list(_CLEANUP_LIST)
-    for path in paths:
-        try:
-            if path.exists():
-                path.unlink()
-        except Exception as e:
-            warnings.warn(f"Cannot cleanup {path}: {e}")
-
-
-atexit.register(_on_exit_cleanup)
-
-
-_FILEPARTS: list["FilePart"] = []
-
-_FILEPARTS_LOCK = Lock()
-
-
-def _add_filepart(part: "FilePart") -> None:
-    with _FILEPARTS_LOCK:
-        if part not in _FILEPARTS:
-            _FILEPARTS.append(part)
+class Range:
+    def __init__(self, start: int | SizeSuffix, end: int | SizeSuffix):
+        self.start: SizeSuffix = SizeSuffix(start)  # inclusive
+        self.end: SizeSuffix = SizeSuffix(
+            end
+        )  # exclusive (not like http byte range which is inclusive)
+
+    def to_header(self) -> dict[str, str]:
+        last = self.end - 1
+        val = f"bytes={self.start.as_int()}-{last.as_int()}"
+        return {"Range": val}
+
+
+_MAX_PART_NUMBER = 10000
+
+
+def _get_chunk_size(
+    src_size: int | SizeSuffix, target_chunk_size: int | SizeSuffix
+) -> SizeSuffix:
+    src_size = SizeSuffix(src_size)
+    target_chunk_size = SizeSuffix(target_chunk_size)
+    min_chunk_size = src_size // (_MAX_PART_NUMBER - 1)  # overriden
+    # chunk_size = max(min_chunk_size, target_chunk_size)
+    if min_chunk_size > target_chunk_size:
+        warnings.warn(
+            f"min_chunk_size: {min_chunk_size} is greater than target_chunk_size: {target_chunk_size}, adjusting target_chunk_size to min_chunk_size"
+        )
+        chunk_size = SizeSuffix(min_chunk_size)
+    else:
+        chunk_size = SizeSuffix(target_chunk_size)
+    return chunk_size
+
+
+def _create_part_infos(
+    src_size: int | SizeSuffix, target_chunk_size: int | SizeSuffix
+) -> list["PartInfo"]:
+    # now break it up into 10 parts
+    target_chunk_size = SizeSuffix(target_chunk_size)
+    src_size = SizeSuffix(src_size)
+    chunk_size = _get_chunk_size(src_size=src_size, target_chunk_size=target_chunk_size)
+
+    part_infos: list[PartInfo] = []
+    curr_offset: int = 0
+    part_number: int = 0
+    while True:
+        part_number += 1
+        done = False
+        end = curr_offset + chunk_size
+        if end > src_size:
+            done = True
+            chunk_size = src_size - curr_offset
+        range: Range = Range(start=curr_offset, end=curr_offset + chunk_size)
+        part_info = PartInfo(
+            part_number=part_number,
+            range=range,
+        )
+        part_infos.append(part_info)
+        curr_offset += chunk_size.as_int()
+        if curr_offset >= src_size:
+            break
+        if done:
+            break
+    return part_infos
 
 
-def _remove_filepart(part: "FilePart") -> None:
-    with _FILEPARTS_LOCK:
-        if part in _FILEPARTS:
-            _FILEPARTS.remove(part)
+@dataclass
+class PartInfo:
+    part_number: int
+    range: Range
 
+    @staticmethod
+    def split_parts(
+        size: int | SizeSuffix, target_chunk_size: int | SizeSuffix
+    ) -> list["PartInfo"]:
+        out = _create_part_infos(size, target_chunk_size)
+        return out
 
-def run_debug_parts():
-    while True:
-        print("\nAlive file parts:")
-        for part in list(_FILEPARTS):
-            print(part)
-            # print(part.stacktrace)
-        print("\n\n")
-        time.sleep(60)
-
-
-dbg_thread = threading.Thread(target=run_debug_parts)
-dbg_thread.start()
-
-
-class FilePart:
-    def __init__(self, payload: Path | bytes | Exception, extra: Any) -> None:
-        import traceback
-
-        from rclone_api.util import random_str
-
-        stacktrace = traceback.format_stack()
-        stacktrace_str = "".join(stacktrace)
-        self.stacktrace = stacktrace_str
-        # _FILEPARTS.append(self)
-        _add_filepart(self)
-
-        self.extra = extra
-        self._lock = Lock()
-        self.payload: Path | Exception
-        if isinstance(payload, Exception):
-            self.payload = payload
-            return
-        if isinstance(payload, bytes):
-            print(f"Creating file part with payload: {len(payload)}")
-            self.payload = get_chunk_tmpdir() / f"{random_str(12)}.chunk"
-            with _TMP_DIR_ACCESS_LOCK:
-                if not self.payload.parent.exists():
-                    self.payload.parent.mkdir(parents=True, exist_ok=True)
-                self.payload.write_bytes(payload)
-            _add_for_cleanup(self.payload)
-        if isinstance(payload, Path):
-            print("Adopting payload: ", payload)
-            self.payload = payload
-            _add_for_cleanup(self.payload)
-
-    def get_file(self) -> Path | Exception:
-        return self.payload
+    def __post_init__(self):
+        assert self.part_number >= 0
+        assert self.part_number <= 10000
+        assert self.range.start >= 0
+        assert self.range.end > self.range.start
 
     @property
-    def size(self) -> int:
-        with self._lock:
-            if isinstance(self.payload, Path):
-                return self.payload.stat().st_size
-            return -1
-
-    def n_bytes(self) -> int:
-        with self._lock:
-            if isinstance(self.payload, Path):
-                return self.payload.stat().st_size
-            return -1
-
-    def load(self) -> bytes:
-        with self._lock:
-            if isinstance(self.payload, Path):
-                with open(self.payload, "rb") as f:
-                    return f.read()
-            raise ValueError("Cannot load from error")
-
-    def __post_init__(self):
-        if isinstance(self.payload, Path):
-            assert self.payload.exists(), f"File part {self.payload} does not exist"
-            assert self.payload.is_file(), f"File part {self.payload} is not a file"
-            assert self.payload.stat().st_size > 0, f"File part {self.payload} is empty"
-        elif isinstance(self.payload, Exception):
-            warnings.warn(f"File part error: {self.payload}")
-        print(f"File part created with payload: {self.payload}")
-
-    def is_error(self) -> bool:
-        return isinstance(self.payload, Exception)
-
-    def dispose(self) -> None:
-        # _FILEPARTS.remove(self)
-        _remove_filepart(self)
-        print("Disposing file part")
-        with self._lock:
-            if isinstance(self.payload, Exception):
-                warnings.warn(
-                    f"Cannot close file part because the payload represents an error: {self.payload}"
-                )
-                print("Cannot close file part because the payload represents an error")
-                return
-            if self.payload.exists():
-                print(f"File part {self.payload} exists")
-                try:
-                    print(f"Unlinking file part {self.payload}")
-                    self.payload.unlink()
-                    print(f"File part {self.payload} deleted")
-                except Exception as e:
-                    warnings.warn(f"Cannot close file part because of error: {e}")
-            else:
-                warnings.warn(
-                    f"Cannot close file part because it does not exist: {self.payload}"
-                )
-
-    def __del__(self):
-        self.dispose()
-
-    def __repr__(self):
-        payload_str = "err" if self.is_error() else f"{SizeSuffix(self.n_bytes())}"
-        return f"FilePart(payload={payload_str}, extra={self.extra})"
+    def name(self) -> str:
+        partnumber = f"{self.part_number:05d}"
+        offset = self.range.start.as_int()
+        end = SizeSuffix(self.range.end._size).as_int()
+        dst_name = f"part.{partnumber}_{offset}-{end}"
+        return dst_name

rclone_api/util.py

@@ -1,4 +1,5 @@
 import os
+import random
 import shutil
 import subprocess
 import warnings
@@ -23,10 +24,29 @@ def locked_print(*args, **kwargs):
         print(*args, **kwargs)
 
 
+def port_is_free(port: int) -> bool:
+    import socket
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(("localhost", port)) != 0
+
+
+def find_free_port() -> int:
+    tries = 20
+    port = random.randint(10000, 20000)
+    while tries > 0:
+        if port_is_free(port):
+            return port
+        tries -= 1
+        port = random.randint(10000, 20000)
+    warnings.warn(f"Failed to find a free port, so using {port}")
+    return port
+
+
 def to_path(item: Dir | Remote | str, rclone: Any) -> RPath:
-    from rclone_api.rclone import Rclone
+    from rclone_api.rclone_impl import RcloneImpl
 
-    assert isinstance(rclone, Rclone)
+    assert isinstance(rclone, RcloneImpl)
     # if str then it will be remote:path
     if isinstance(item, str):
         # return RPath(item)

{rclone_api-1.3.28.dist-info → rclone_api-1.4.2.dist-info}/METADATA

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

rclone_api-1.4.2.dist-info/RECORD

@@ -0,0 +1,55 @@
+rclone_api/__init__.py,sha256=cJpn62AmlcCXdbRIMIls4yEek6SLWJ-ONlr2mDnkIFk,17530
+rclone_api/cli.py,sha256=dibfAZIh0kXWsBbfp3onKLjyZXo54mTzDjUdzJlDlWo,231
+rclone_api/completed_process.py,sha256=_IZ8IWK7DM1_tsbDEkH6wPZ-bbcrgf7A7smls854pmg,1775
+rclone_api/config.py,sha256=f6jEAxVorGFr31oHfcsu5AJTtOJj2wR5tTSsbGGZuIw,2558
+rclone_api/convert.py,sha256=Mx9Qo7zhkOedJd8LdhPvNGHp8znJzOk4f_2KWnoGc78,1012
+rclone_api/deprecated.py,sha256=qWKpnZdYcBK7YQZKuVoWWXDwi-uqiAtbjgPcci_efow,590
+rclone_api/diff.py,sha256=tMoJMAGmLSE6Q_7QhPf6PnCzb840djxMZtDmhc2GlGQ,5227
+rclone_api/dir.py,sha256=_9o-_5tbWVJkL1Vf_Yb8aiQV3xAqvUq5bk3zoJblvEg,3547
+rclone_api/dir_listing.py,sha256=bSmd8yZtSeyVaDRw2JPB4bCpbCeDzhoa_pomgdJp44c,1884
+rclone_api/exec.py,sha256=Bq0gkyZ10mEY0FRyzNZgdN4FaWP9vpeCk1kjpg-gN_8,1083
+rclone_api/file.py,sha256=JLPqjUcW_YVb4UQjX6FQ7PABJqhchFUXVy1W-X9rJLk,5659
+rclone_api/file_item.py,sha256=cH-AQYsxedhNPp4c8NHY1ad4Z7St4yf_VGbmiGD59no,1770
+rclone_api/file_part.py,sha256=i6ByS5_sae8Eba-4imBVTxd-xKC8ExWy7NR8QGr0ors,6155
+rclone_api/file_stream.py,sha256=_W3qnwCuigqA0hzXl2q5pAxSZDRaUSwet4BkT0lpnzs,1431
+rclone_api/filelist.py,sha256=xbiusvNgaB_b_kQOZoHMJJxn6TWGtPrWd2J042BI28o,767
+rclone_api/group_files.py,sha256=H92xPW9lQnbNw5KbtZCl00bD6iRh9yRbCuxku4j_3dg,8036
+rclone_api/http_server.py,sha256=YrILbxK0Xpnpkm8l9uGEXH_AOCGPUX8Cx33jKVtu7ZM,8207
+rclone_api/log.py,sha256=VZHM7pNSXip2ZLBKMP7M1u-rp_F7zoafFDuR8CPUoKI,1271
+rclone_api/mount.py,sha256=TE_VIBMW7J1UkF_6HRCt8oi_jGdMov4S51bm2OgxFAM,10045
+rclone_api/process.py,sha256=BGXJTZVT__jeaDyjN8_kRycliOhkBErMPdHO1hKRvJE,5271
+rclone_api/rclone_impl.py,sha256=BAnRi4jB_TLRHwZE_mQfX7b1L1SODn3XhdHL7hozTAs,47960
+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
+rclone_api/types.py,sha256=gpEYVHNkxB7X3p_B4nEc1ls1kF_ykjNuUyZXCsvU-Cs,11788
+rclone_api/util.py,sha256=j252WPB-UMiz6zQcLvsZe9XvMq-Z2FIeZrjb-y01eL4,5947
+rclone_api/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
+rclone_api/cmd/analyze.py,sha256=RHbvk1G5ZUc3qLqlm1AZEyQzd_W_ZjcbCNDvW4YpTKQ,1252
+rclone_api/cmd/copy_large_s3.py,sha256=w1aCaq9EQ84aRoMj9mHtdr0Svjflkx6KTKcoldzRSo8,3788
+rclone_api/cmd/list_files.py,sha256=x8FHODEilwKqwdiU1jdkeJbLwOqUkUQuDWPo2u_zpf0,741
+rclone_api/cmd/save_to_db.py,sha256=ylvnhg_yzexM-m6Zr7XDiswvoDVSl56ELuFAdb9gqBY,1957
+rclone_api/db/__init__.py,sha256=OSRUdnSWUlDTOHmjdjVmxYTUNpTbtaJ5Ll9sl-PfZg0,40
+rclone_api/db/db.py,sha256=YRnYrCaXHwytQt07uEZ_mMpvPHo9-0IWcOb95fVOOfs,10086
+rclone_api/db/models.py,sha256=v7qaXUehvsDvU51uk69JI23fSIs9JFGcOa-Tv1c_wVs,1600
+rclone_api/detail/copy_file_parts.py,sha256=KgLl5vVF67RLqZ1aUmRR98BvoqTrbcFzPY9oZd0yyI0,12316
+rclone_api/detail/walk.py,sha256=-54NVE8EJcCstwDoaC_UtHm73R2HrZwVwQmsnv55xNU,3369
+rclone_api/experimental/flags.py,sha256=qCVD--fSTmzlk9hloRLr0q9elzAOFzPsvVpKM3aB1Mk,2739
+rclone_api/experimental/flags_base.py,sha256=ajU_czkTcAxXYU-SlmiCfHY7aCQGHvpCLqJ-Z8uZLk0,2102
+rclone_api/s3/api.py,sha256=PafsIEyWDpLWAXsZAjFm9CY14vJpsDr9lOsn0kGRLZ0,4009
+rclone_api/s3/basic_ops.py,sha256=hK3366xhVEzEcjz9Gk_8lFx6MRceAk72cax6mUrr6ko,2104
+rclone_api/s3/chunk_task.py,sha256=waEYe-iYQ1_BR3NCS4BrzVrK9UANvH1EcbXx2I6Z_NM,6839
+rclone_api/s3/create.py,sha256=wgfkapv_j904CfKuWyiBIWJVxfAx_ftemFSUV14aT68,3149
+rclone_api/s3/s3_multipart_uploader.py,sha256=KY9k585Us0VW8uqgS5jdSVrYynxlnO8Wzb52pcvR06M,4570
+rclone_api/s3/types.py,sha256=VqnvH0qhvb3_4wngqk0vSSStH-TgVQxNNxo9slz9-p8,1595
+rclone_api/s3/upload_file_multipart.py,sha256=V7syKjFyVIe4U9Ahl5XgqVTzt9akiew3MFjGmufLo2w,12503
+rclone_api/s3/multipart/file_info.py,sha256=8v_07_eADo0K-Nsv7F0Ac1wcv3lkIsrR3MaRCmkYLTQ,105
+rclone_api/s3/multipart/finished_piece.py,sha256=TcwA58-qgKBiskfHrePoCWaSSep6Za9psZEpzrLUUhE,1199
+rclone_api/s3/multipart/upload_info.py,sha256=d6_OfzFR_vtDzCEegFfzCfWi2kUBUV4aXZzqAEVp1c4,1874
+rclone_api/s3/multipart/upload_state.py,sha256=f-Aq2NqtAaMUMhYitlICSNIxCKurWAl2gDEUVizLIqw,6019
+rclone_api-1.4.2.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+rclone_api-1.4.2.dist-info/METADATA,sha256=oRC3WBMs6KdWFK8NOJOaa2LjKC4ze4tKy7fQlU63uIA,4627
+rclone_api-1.4.2.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+rclone_api-1.4.2.dist-info/entry_points.txt,sha256=fJteOlYVwgX3UbNuL9jJ0zUTuX2O79JFAeNgK7Sw7EQ,255
+rclone_api-1.4.2.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
+rclone_api-1.4.2.dist-info/RECORD,,

rclone_api/mount_read_chunker.py

@@ -1,130 +0,0 @@
-import logging
-import traceback
-from concurrent.futures import Future, ThreadPoolExecutor
-from pathlib import Path
-from threading import Lock, Semaphore
-from typing import Any
-
-from rclone_api.mount import Mount
-from rclone_api.types import FilePart, SizeSuffix
-
-# Create a logger for this module
-logger = logging.getLogger(__name__)
-
-
-def _read_from_mount_task(
-    offset: int, size: int, path: Path, verbose: bool
-) -> bytes | Exception:
-    if verbose:
-        logger.debug(f"Fetching chunk: offset={offset}, size={size}, path={path}")
-    try:
-        with path.open("rb") as f:
-            f.seek(offset)
-            payload = f.read(size)
-            assert len(payload) == size, f"Invalid read size: {len(payload)}"
-            return payload
-
-    except KeyboardInterrupt as e:
-        import _thread
-
-        logger.error("KeyboardInterrupt received during chunk read")
-        _thread.interrupt_main()
-        return Exception(e)
-    except Exception as e:
-        stack_trace = traceback.format_exc()
-        logger.error(
-            f"Error fetching file chunk at offset {offset} + {size}: {e}\n{stack_trace}"
-        )
-        return e
-
-
-class MultiMountFileChunker:
-    def __init__(
-        self,
-        filename: str,
-        filesize: int,
-        mounts: list[Mount],
-        executor: ThreadPoolExecutor,
-        verbose: bool | None,
-    ) -> None:
-        from rclone_api.util import get_verbose
-
-        self.filename = filename
-        self.filesize = filesize
-        self.executor = executor
-        self.mounts_processing: list[Mount] = []
-        self.mounts_availabe: list[Mount] = mounts
-        self.semaphore = Semaphore(len(mounts))
-        self.lock = Lock()
-        self.verbose = get_verbose(verbose)
-        logger.info(
-            f"Initialized MultiMountFileChunker for {filename} ({filesize} bytes)"
-        )
-
-    def shutdown(self) -> None:
-        logger.info("Shutting down MultiMountFileChunker")
-        self.executor.shutdown(wait=True, cancel_futures=True)
-        with ThreadPoolExecutor() as executor:
-            for mount in self.mounts_processing:
-                executor.submit(lambda: mount.close())
-        logger.debug("MultiMountFileChunker shutdown complete")
-
-    def _acquire_mount(self) -> Mount:
-        logger.debug("Acquiring mount")
-        self.semaphore.acquire()
-        with self.lock:
-            mount = self.mounts_availabe.pop()
-            self.mounts_processing.append(mount)
-        logger.debug(f"Mount acquired: {mount}")
-        return mount
-
-    def _release_mount(self, mount: Mount) -> None:
-        logger.debug(f"Releasing mount: {mount}")
-        with self.lock:
-            self.mounts_processing.remove(mount)
-            self.mounts_availabe.append(mount)
-            self.semaphore.release()
-        logger.debug("Mount released")
-
-    def fetch(
-        self, offset: int | SizeSuffix, size: int | SizeSuffix, extra: Any
-    ) -> Future[FilePart]:
-        offset = SizeSuffix(offset).as_int()
-        size = SizeSuffix(size).as_int()
-        if isinstance(size, SizeSuffix):
-            size = size.as_int()
-        if self.verbose:
-            logger.debug(f"Fetching data range: offset={offset}, size={size}")
-
-        assert size > 0, f"Invalid size: {size}"
-        assert offset >= 0, f"Invalid offset: {offset}"
-        assert (
-            offset + size <= self.filesize
-        ), f"Invalid offset + size: {offset} + {size} ({offset+size}) > {self.filesize}"
-
-        try:
-            mount = self._acquire_mount()
-            path = mount.mount_path / self.filename
-
-            def task_fetch_file_range(
-                size=size, path=path, mount=mount, verbose=self.verbose
-            ) -> FilePart:
-                bytes_or_err = _read_from_mount_task(
-                    offset=offset, size=size, path=path, verbose=verbose
-                )
-                self._release_mount(mount)
-
-                if isinstance(bytes_or_err, Exception):
-                    err: Exception = bytes_or_err
-                    logger.warning(f"Fetch task returned exception: {bytes_or_err}")
-                    return FilePart(payload=err, extra=extra)
-                logger.debug(f"Successfully fetched {size} bytes from offset {offset}")
-                out = FilePart(payload=bytes_or_err, extra=extra)
-                return out
-
-            fut = self.executor.submit(task_fetch_file_range)
-            return fut
-        except Exception as e:
-            logger.error(f"Error setting up file chunk fetch: {e}", exc_info=True)
-            fp = FilePart(payload=e, extra=extra)
-            return self.executor.submit(lambda: fp)