rclone-api 1.2.5__tar.gz → 1.2.7__tar.gz

{rclone_api-1.2.5 → rclone_api-1.2.7}/PKG-INFO

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

{rclone_api-1.2.5 → rclone_api-1.2.7}/pyproject.toml

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

{rclone_api-1.2.5 → rclone_api-1.2.7}/src/rclone_api/mount.py

@@ -319,89 +319,54 @@ class MultiMountFileChunker:
     def fetch(self, offset: int, size: int) -> Future[bytes | Exception]:
         if self.verbose:
             print(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:
-            try:
-                if offset + size > self.filesize:
-                    size = self.filesize - offset
-                assert (
-                    offset + size <= self.filesize
-                ), f"Invalid offset + size: {offset + size}, it is beyond the end of the file."
-                assert size > 0, f"Invalid size: {size}"
-                assert offset >= 0, f"Invalid offset: {offset}"
-            except AssertionError as e:
-                warnings.warn(f"Invalid chunk request: {e}")
-                # return ValueError(e)
-                # return self.executor.submit(lambda: Exception(e))
-                err = Exception(e)
-                return self.executor.submit(lambda: err)
-
-            chunks: list[tuple[int, int]] = []
-            start = offset
-            end = offset + size
-            while start < end:
-                chunk_size = min(self.chunk_size.as_int(), end - start)
-                chunks.append((start, chunk_size))
-                start += chunk_size
-
-            futures: list[Future[bytes | Exception]] = []
-            for start, chunk_size in chunks:
-                self.semaphore.acquire()
-                with self.lock:
-                    mount = self.mounts_availabe.pop()
-                    self.mounts_processing.append(mount)
-
-                path = mount.mount_path / self.filename
-
-                def task(
-                    offset=start, size=chunk_size, path=path, mount=mount
-                ) -> bytes | Exception:
-                    if self.verbose:
-                        print(
-                            f"Fetching chunk: offset={offset}, size={size}, path={path}"
-                        )
-                    try:
-                        # make sure we don't overflow the file size
-                        # assert (
-                        #     offset + size <= self.chunk_size.as_int()
-                        # ), f"Invalid offset + size: {offset + size}, it is beyond the end of the file."
-                        if offset + size > self.filesize:
-                            size = self.filesize - offset
-                        with path.open("rb") as f:
-                            f.seek(offset)
-                            return f.read(size)
-                    except KeyboardInterrupt as e:
-                        import _thread
-
-                        warnings.warn(f"Error fetching file chunk: {e}")
-
-                        _thread.interrupt_main()
-                        return Exception(e)
-                    except Exception as e:
-                        stack_trace = traceback.format_exc()
-                        warnings.warn(
-                            f"Error fetching file chunk at offset {offset} + {size}: {e}\n{stack_trace}"
-                        )
-                        return e
-                    finally:
-                        with self.lock:
-                            self.mounts_processing.remove(mount)
-                            self.mounts_availabe.append(mount)
-                            self.semaphore.release()
-
-                fut = self.executor.submit(task)
-                futures.append(fut)
-
-            def combine(futs: list[Future[bytes | Exception]]) -> bytes | Exception:
-                finished_list: list[bytes | Exception] = [f.result() for f in futs]
-                bytes_list = [f for f in finished_list if isinstance(f, bytes)]
-                if len(bytes_list) != len(finished_list):
-                    exceptions = [f for f in finished_list if isinstance(f, Exception)]
-                    return Exception(f"Error fetching file chunk: {exceptions}")
-                return b"".join(bytes_list)
-
-            if len(futures) == 1:
-                return futures[0]
-            fut = self.executor.submit(combine, futures)
+            self.semaphore.acquire()
+            with self.lock:
+                mount = self.mounts_availabe.pop()
+                self.mounts_processing.append(mount)
+
+            path = mount.mount_path / self.filename
+
+            def task(
+                offset=offset, size=size, path=path, mount=mount
+            ) -> bytes | Exception:
+                if self.verbose or True:
+                    print(f"Fetching chunk: offset={offset}, size={size}, path={path}")
+                try:
+                    if offset + size > self.filesize:
+                        raise ValueError(f"Invalid offset + size: {offset + size}")
+                    with path.open("rb") as f:
+                        f.seek(offset)
+                        sz = f.read(size)
+                        assert len(sz) == size, f"Invalid read size: {len(sz)}"
+                        return sz
+                except KeyboardInterrupt as e:
+                    import _thread
+
+                    warnings.warn(f"Error fetching file chunk: {e}")
+
+                    _thread.interrupt_main()
+                    return Exception(e)
+                except Exception as e:
+                    stack_trace = traceback.format_exc()
+                    warnings.warn(
+                        f"Error fetching file chunk at offset {offset} + {size}: {e}\n{stack_trace}"
+                    )
+                    return e
+                finally:
+                    with self.lock:
+                        self.mounts_processing.remove(mount)
+                        self.mounts_availabe.append(mount)
+                        self.semaphore.release()
+
+            fut = self.executor.submit(task)
             return fut
         except Exception as e:
             warnings.warn(f"Error fetching file chunk: {e}")

{rclone_api-1.2.5 → rclone_api-1.2.7}/src/rclone_api/s3/chunk_file.py

@@ -105,15 +105,11 @@ def file_chunker(
                     )
                     return
 
-                if isinstance(data, Exception):
-                    err: Exception = data
-                    warnings.warn(
-                        f"Error reading file: {err}, skipping part {part_number}"
-                    )
-                    return
-
-                if not data:
+                if not data or len(data) == 0:
                     warnings.warn(f"Empty data for part {part_number} of {file_path}")
+                    raise ValueError(
+                        f"Empty data for part {part_number} of {file_path}"
+                    )
 
                 file_chunk = FileChunk(
                     src,

{rclone_api-1.2.5 → rclone_api-1.2.7}/src/rclone_api.egg-info/PKG-INFO

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