rclone-api 1.1.26__tar.gz → 1.1.29__tar.gz

{rclone_api-1.1.26 → rclone_api-1.1.29}/PKG-INFO

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

{rclone_api-1.1.26 → rclone_api-1.1.29}/pyproject.toml

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

{rclone_api-1.1.26 → rclone_api-1.1.29}/src/rclone_api/rclone.py

@@ -691,7 +691,7 @@ class Rclone:
         from rclone_api.util import S3PathInfo, random_str, split_s3_path
 
         other_args: list[str] = ["--no-modtime", "--vfs-read-wait", "1s"]
-        chunk_size = chunk_size or SizeSuffix("128M")
+        chunk_size = chunk_size or SizeSuffix("64M")
         unit_chunk_size = chunk_size / read_threads
         vfs_read_chunk_size = unit_chunk_size
         vfs_read_chunk_size_limit = chunk_size
@@ -726,8 +726,6 @@ class Rclone:
             verbose=False,
             other_args=other_args,
         ):
-            # raise NotImplementedError("Not implemented yet")
-
             path_info: S3PathInfo = split_s3_path(dst)
             remote = path_info.remote
             bucket_name = path_info.bucket
@@ -813,6 +811,50 @@ class Rclone:
             )
             return out
 
+    def copy_bytes(
+        self,
+        src: str,
+        offset: int,
+        length: int,
+        transfers: int = 16,
+    ) -> bytes | Exception:
+        """Copy bytes from a file to another file."""
+        from rclone_api.util import random_str
+
+        tmp_mnt = Path("tmp_mnt") / random_str(12)
+        src_parent_path = Path(src).parent.as_posix()
+        src_file = Path(src).name
+        other_args: list[str] = ["--no-modtime", "--vfs-read-wait", "1s"]
+        unit_chunk_size = length
+        vfs_read_chunk_size = unit_chunk_size
+        vfs_read_chunk_size_limit = length
+        vfs_read_chunk_streams = transfers
+        vfs_disk_space_total_size = length
+        other_args += ["--vfs-read-chunk-size", str(vfs_read_chunk_size)]
+        other_args += ["--vfs-read-chunk-size-limit", str(vfs_read_chunk_size_limit)]
+        other_args += ["--vfs-read-chunk-streams", str(vfs_read_chunk_streams)]
+        other_args += ["--vfs-disk-space-total-size", str(vfs_disk_space_total_size)]
+        other_args += ["--read-only"]
+        other_args += ["--direct-io"]
+
+        try:
+            # use scoped mount to do the read, then write the bytes to the destination
+            with self.scoped_mount(
+                src_parent_path,
+                tmp_mnt,
+                use_links=True,
+                verbose=False,
+                vfs_cache_mode="minimal",
+                other_args=other_args,
+            ):
+                src_file_mnt = tmp_mnt / src_file
+                with open(src_file_mnt, "rb") as f:
+                    f.seek(offset)
+                    data = f.read(length)
+                    return data
+        except Exception as e:
+            return e
+
     def copy_dir(
         self, src: str | Dir, dst: str | Dir, args: list[str] | None = None
     ) -> CompletedProcess:

{rclone_api-1.1.26 → rclone_api-1.1.29}/src/rclone_api/s3/api.py

@@ -9,9 +9,9 @@ from rclone_api.s3.basic_ops import (
     list_bucket_contents,
     upload_file,
 )
-from rclone_api.s3.chunk_uploader import MultiUploadResult, upload_file_multipart
 from rclone_api.s3.create import create_s3_client
 from rclone_api.s3.types import S3Credentials, S3MutliPartUploadConfig, S3UploadTarget
+from rclone_api.s3.upload_file_multipart import MultiUploadResult, upload_file_multipart
 
 _MIN_THRESHOLD_FOR_CHUNKING = 5 * 1024 * 1024
 

{rclone_api-1.1.26 → rclone_api-1.1.29}/src/rclone_api/types.py

@@ -37,41 +37,68 @@ class SizeResult:
 
 
 def _to_size_suffix(size: int) -> str:
-    if size < 1024:
-        return f"{size}B"
-    elif size < 1024**2:
-        val = size / 1024
-        unit = "K"
-    elif size < 1024**3:
-        val = size / (1024**2)
-        unit = "M"
-    elif size < 1024**4:
-        val = size / (1024**3)
-        unit = "G"
-    elif size < 1024**5:
-        val = size / (1024**4)
-        unit = "T"
-    elif size < 1024**6:
-        val = size / (1024**5)
-        unit = "P"
-    else:
-        raise ValueError(f"Invalid size: {size}")
-
-    # If the float is an integer, drop the decimal, otherwise format with one decimal.
-    return f"{int(val) if val.is_integer() else f'{val:.1f}'}{unit}"
+    def _convert(size: int) -> tuple[float, str]:
+        val: float
+        unit: str
+        if size < 1024:
+            val = size
+            unit = "B"
+        elif size < 1024**2:
+            val = size / 1024
+            unit = "K"
+        elif size < 1024**3:
+            val = size / (1024**2)
+            unit = "M"
+        elif size < 1024**4:
+            val = size / (1024**3)
+            unit = "G"
+        elif size < 1024**5:
+            val = size / (1024**4)
+            unit = "T"
+        elif size < 1024**6:
+            val = size / (1024**5)
+            unit = "P"
+        else:
+            raise ValueError(f"Invalid size: {size}")
+
+        return val, unit
+
+    def _fmt(_val: float | int, _unit: str) -> str:
+        # If the float is an integer, drop the decimal, otherwise format with one decimal.
+        val_str: str = str(_val)
+        if not val_str.endswith(".0"):
+            first_str: str = f"{_val:.1f}"
+        else:
+            first_str = str(int(_val))
+        return first_str + _unit
+
+    val, unit = _convert(size)
+    out = _fmt(val, unit)
+    # Now round trip the value to fix floating point issues via rounding.
+    int_val = _from_size_suffix(out)
+    val, unit = _convert(int_val)
+    out = _fmt(val, unit)
+    return out
 
 
 # Update regex to allow decimals (e.g., 16.5MB)
 _PATTERN_SIZE_SUFFIX = re.compile(r"^(\d+(?:\.\d+)?)([A-Za-z]+)$")
 
 
+def _parse_elements(value: str) -> tuple[str, str] | None:
+    match = _PATTERN_SIZE_SUFFIX.match(value)
+    if match is None:
+        return None
+    return match.group(1), match.group(2)
+
+
 def _from_size_suffix(size: str) -> int:
     if size == "0":
         return 0
-    match = _PATTERN_SIZE_SUFFIX.match(size)
-    if match is None:
+    pair = _parse_elements(size)
+    if pair is None:
         raise ValueError(f"Invalid size suffix: {size}")
-    num_str, suffix = match.group(1), match.group(2)
+    num_str, suffix = pair
     n = float(num_str)
     # Determine the unit from the first letter (e.g., "M" from "MB")
     unit = suffix[0].upper()

{rclone_api-1.1.26 → rclone_api-1.1.29}/src/rclone_api.egg-info/PKG-INFO

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

{rclone_api-1.1.26 → rclone_api-1.1.29}/src/rclone_api.egg-info/SOURCES.txt

@@ -57,13 +57,14 @@ src/rclone_api/s3/api.py
 src/rclone_api/s3/basic_ops.py
 src/rclone_api/s3/chunk_file.py
 src/rclone_api/s3/chunk_types.py
-src/rclone_api/s3/chunk_uploader.py
 src/rclone_api/s3/create.py
 src/rclone_api/s3/types.py
+src/rclone_api/s3/upload_file_multipart.py
 tests/test_cmd_list_files.py
 tests/test_copy.py
 tests/test_copy_file_resumable_s3.py
 tests/test_copy_files.py
+tests/test_copy_range.py
 tests/test_diff.py
 tests/test_group_files.py
 tests/test_is_synced.py

rclone_api-1.1.29/tests/test_copy_range.py

@@ -0,0 +1,75 @@
+"""
+Unit test file.
+"""
+
+import os
+import unittest
+
+from dotenv import load_dotenv
+
+from rclone_api import Config, Rclone
+
+load_dotenv()
+
+BUCKET_NAME = os.getenv("BUCKET_NAME")  # Default if not in .env
+
+
+def _generate_rclone_config() -> 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}
+"""
+
+    out = Config(config_text)
+    return out
+
+
+class RcloneCopyBytesTester(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"
+
+    def test_copy_bytes(self) -> None:
+        rclone = Rclone(_generate_rclone_config())
+        bytes_or_err: bytes | Exception = rclone.copy_bytes(
+            src="dst:rclone-api-unit-test/zachs_video/breaking_ai_mind.mp4",
+            offset=0,
+            length=1024 * 1024,
+        )
+        if isinstance(bytes_or_err, Exception):
+            print(bytes_or_err)
+            self.fail(f"Error: {bytes_or_err}")
+        assert isinstance(bytes_or_err, bytes)
+        self.assertEqual(
+            len(bytes_or_err), 1024 * 1024
+        )  # , f"Length: {len(bytes_or_err)}"
+
+
+if __name__ == "__main__":
+    unittest.main()

{rclone_api-1.1.26 → rclone_api-1.1.29}/tests/test_s3.py

@@ -6,9 +6,9 @@ from pathlib import Path
 from dotenv import load_dotenv
 
 from rclone_api.s3.api import S3Client
-from rclone_api.s3.chunk_uploader import MultiUploadResult
 from rclone_api.s3.create import S3Provider
 from rclone_api.s3.types import S3Credentials, S3MutliPartUploadConfig, S3UploadTarget
+from rclone_api.s3.upload_file_multipart import MultiUploadResult
 
 load_dotenv()
 

{rclone_api-1.1.26 → rclone_api-1.1.29}/tests/test_size_suffix.py

@@ -24,6 +24,15 @@ class RcloneSuffixSize(unittest.TestCase):
         out_str = str(size_suffix)
         self.assertEqual(out_str, "16.5M")
 
+    def test_float_suffix_border(self) -> None:
+        size_suffix = SizeSuffix("1M")
+        size_int = size_suffix.as_int()
+        size_int -= 1
+        # now assert that the string value is the same as the input
+        tmp = SizeSuffix(size_int)
+        out_str = tmp.as_str()
+        self.assertEqual(out_str, "1M")
+
 
 if __name__ == "__main__":
     unittest.main()