rclone-api 1.1.26__py2.py3-none-any.whl → 1.1.38__py2.py3-none-any.whl

rclone_api/exec.py

@@ -23,7 +23,9 @@ class RcloneExec:
             cmd, self.rclone_config, self.rclone_exe, check=check, capture=capture
         )
 
-    def launch_process(self, cmd: list[str], capture: bool | None) -> Process:
+    def launch_process(
+        self, cmd: list[str], capture: bool | None, log: Path | None
+    ) -> Process:
         """Launch rclone process."""
 
         args: ProcessArgs = ProcessArgs(
@@ -32,6 +34,7 @@ class RcloneExec:
             rclone_exe=self.rclone_exe,
             cmd_list=cmd,
             capture_stdout=capture,
+            log=log,
         )
         process = Process(args)
         return process

rclone_api/mount.py

@@ -105,8 +105,8 @@ def clean_mount(mount: Mount | Path, verbose: bool = False, wait=True) -> None:
     mount_path = mount.mount_path if isinstance(mount, Mount) else mount
     try:
         mount_exists = mount_path.exists()
-    except OSError as e:
-        warnings.warn(f"Error checking {mount_path}: {e}")
+    except OSError:
+        # warnings.warn(f"Error checking {mount_path}: {e}")
         mount_exists = True
 
     # Give the system a moment (if unmount is in progress, etc.)
@@ -139,8 +139,9 @@ def clean_mount(mount: Mount | Path, verbose: bool = False, wait=True) -> None:
             mount_path.rmdir()
             if verbose:
                 print(f"Successfully removed mount directory {mount_path}")
-        except Exception as e:
-            warnings.warn(f"Failed to remove mount {mount_path}: {e}")
+        except Exception:
+            # warnings.warn(f"Failed to remove mount {mount_path}: {e}")
+            pass
     else:
         warnings.warn(f"Unsupported platform: {_SYSTEM}")
 

rclone_api/process.py

@@ -1,5 +1,4 @@
 import atexit
-import os
 import subprocess
 import threading
 import time
@@ -13,12 +12,6 @@ from rclone_api.config import Config
 from rclone_api.util import get_verbose
 
 
-def _get_verbose(verbose: bool | None) -> bool:
-    if verbose is not None:
-        return verbose
-    return bool(int(os.getenv("RCLONE_API_VERBOSE", "0")))
-
-
 @dataclass
 class ProcessArgs:
     cmd: list[str]
@@ -27,12 +20,14 @@ class ProcessArgs:
     cmd_list: list[str]
     verbose: bool | None = None
     capture_stdout: bool | None = None
+    log: Path | None = None
 
 
 class Process:
     def __init__(self, args: ProcessArgs) -> None:
         assert args.rclone_exe.exists()
         self.args = args
+        self.log = args.log
         self.tempdir: TemporaryDirectory | None = None
         verbose = get_verbose(args.verbose)
         if isinstance(args.rclone_conf, Config):
@@ -52,6 +47,9 @@ class Process:
             + ["--config", str(rclone_conf.resolve())]
             + args.cmd
         )
+        if self.args.log:
+            self.args.log.parent.mkdir(parents=True, exist_ok=True)
+            self.cmd += ["--log-file", str(self.args.log)]
         if verbose:
             cmd_str = subprocess.list2cmdline(self.cmd)
             print(f"Running: {cmd_str}")

rclone_api/profile/mount_copy_bytes.py

@@ -0,0 +1,187 @@
+"""
+Unit test file.
+"""
+
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import psutil
+from dotenv import load_dotenv
+
+from rclone_api import Config, Rclone, SizeSuffix
+
+load_dotenv()
+
+
+@dataclass
+class Credentials:
+    BUCKET_KEY_SECRET: str
+    BUCKET_KEY_PUBLIC: str
+    BUCKET_NAME: str
+    SRC_SFTP_HOST: str
+    SRC_SFTP_USER: str
+    SRC_SFTP_PORT: str
+    SRC_SFTP_PASS: str
+    BUCKET_URL: str
+
+
+def _generate_rclone_config() -> tuple[Config, Credentials]:
+
+    cwd = Path.cwd()
+    print(f"Current working directory: {cwd}")
+
+    # assert that .env exists for this test
+    assert os.path.exists(
+        ".env"
+    ), "this test requires that the secret .env file exists with the credentials"
+
+    # 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_NAME = os.getenv("BUCKET_NAME")
+    SRC_SFTP_HOST = os.getenv("SRC_SFTP_HOST")
+    SRC_SFTP_USER = os.getenv("SRC_SFTP_USER")
+    SRC_SFTP_PORT = os.getenv("SRC_SFTP_PORT")
+    SRC_SFTP_PASS = os.getenv("SRC_SFTP_PASS")
+    # 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}
+
+[src]
+type = sftp
+host = {SRC_SFTP_HOST}
+user = {SRC_SFTP_USER}
+port = {SRC_SFTP_PORT}
+pass = {SRC_SFTP_PASS}
+
+"""
+    print("Config text:")
+    print(config_text)
+    # _CONFIG_PATH.write_text(config_text, encoding="utf-8")
+    # print(f"Config file written to: {_CONFIG_PATH}")
+
+    creds = Credentials(
+        BUCKET_KEY_SECRET=str(BUCKET_KEY_SECRET),
+        BUCKET_KEY_PUBLIC=str(BUCKET_KEY_PUBLIC),
+        BUCKET_NAME=str(BUCKET_NAME),
+        SRC_SFTP_HOST=str(SRC_SFTP_HOST),
+        SRC_SFTP_USER=str(SRC_SFTP_USER),
+        SRC_SFTP_PORT=str(SRC_SFTP_PORT),
+        SRC_SFTP_PASS=str(SRC_SFTP_PASS),
+        BUCKET_URL=str(BUCKET_URL),
+    )
+
+    return Config(config_text), creds
+
+
+def _init() -> 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:
+        print(f"Missing required environment variables: {', '.join(missing)}")
+    os.environ["RCLONE_API_VERBOSE"] = "1"
+
+
+def test_profile_copy_bytes() -> None:
+    print("Running test_profile_copy_bytes")
+    config, creds = _generate_rclone_config()
+    print("Config:")
+    print(config)
+    print("Credentials:")
+    print(creds)
+    rclone = Rclone(config)
+
+    sizes = [
+        1024 * 1024 * 1,
+        1024 * 1024 * 2,
+        1024 * 1024 * 4,
+        1024 * 1024 * 8,
+        1024 * 1024 * 16,
+        1024 * 1024 * 32,
+        1024 * 1024 * 64,
+    ]
+    # transfer_list = [1, 2, 4, 8, 16]
+    transfer_list = [1, 2, 4]
+
+    # src_file = "dst:rclone-api-unit-test/zachs_video/internaly_ai_alignment.mp4"
+    # sftp mount
+    src_file = "src:aa_misc_data/aa_misc_data/world_lending_library_2024_11.tar.zst"
+
+    for size in sizes:
+        for transfers in transfer_list:
+            mount_log = Path("logs") / "mount" / f"mount_{size}_{transfers}.log"
+            print("\n\n")
+            print("#" * 80)
+            print(
+                f"# Started test download of {SizeSuffix(size)} with {transfers} transfers"
+            )
+            print("#" * 80)
+            net_io_start = psutil.net_io_counters()
+            start = time.time()
+            bytes_or_err: bytes | Exception = rclone.copy_bytes(
+                src=src_file,
+                offset=0,
+                length=size,
+                direct_io=True,
+                transfers=transfers,
+                mount_log=mount_log,
+            )
+            diff = time.time() - start
+            net_io_end = psutil.net_io_counters()
+            if isinstance(bytes_or_err, Exception):
+                print(bytes_or_err)
+                stack_trace = bytes_or_err.__traceback__
+                assert False, f"Error: {bytes_or_err}\nStack trace:\n{stack_trace}"
+            assert isinstance(bytes_or_err, bytes)
+            # self.assertEqual(len(bytes_or_err), size)
+            assert len(bytes_or_err) == size, f"Length: {len(bytes_or_err)} != {size}"
+
+            # print io stats
+            bytes_sent = net_io_end.bytes_sent - net_io_start.bytes_sent
+            bytes_recv = net_io_end.bytes_recv - net_io_start.bytes_recv
+            packets_sent = net_io_end.packets_sent - net_io_start.packets_sent
+            efficiency = size / (bytes_recv)
+            efficiency_100 = efficiency * 100
+            efficiency_str = f"{efficiency_100:.2f}"
+
+            bytes_send_suffix = SizeSuffix(bytes_sent)
+            bytes_recv_suffix = SizeSuffix(bytes_recv)
+            range_size = SizeSuffix(size)
+
+            print(f"\nFinished downloading {range_size} with {transfers} transfers")
+            print("Net IO stats:")
+            print(f"Bytes sent: {bytes_send_suffix}")
+            print(f"Bytes received: {bytes_recv_suffix}")
+            print(f"Packets sent: {packets_sent}")
+            print(f"Efficiency: {efficiency_str}%")
+            print(f"Time: {diff:.1f} seconds")
+
+    print("done")
+
+
+def main() -> None:
+    """Main entry point."""
+    _init()
+    test_profile_copy_bytes()
+
+
+if __name__ == "__main__":
+    main()

rclone_api/rclone.py

@@ -80,8 +80,10 @@ class Rclone:
     ) -> subprocess.CompletedProcess:
         return self._exec.execute(cmd, check=check, capture=capture)
 
-    def _launch_process(self, cmd: list[str], capture: bool | None = None) -> Process:
-        return self._exec.launch_process(cmd, capture=capture)
+    def _launch_process(
+        self, cmd: list[str], capture: bool | None = None, log: Path | None = None
+    ) -> Process:
+        return self._exec.launch_process(cmd, capture=capture, log=log)
 
     def webgui(self, other_args: list[str] | None = None) -> Process:
         """Launch the Rclone web GUI."""
@@ -684,6 +686,7 @@ class Rclone:
         verbose: bool | None = None,
         max_chunks_before_suspension: int | None = None,
         mount_path: Path | None = None,
+        mount_log: Path | None = None,
     ) -> MultiUploadResult:
         """For massive files that rclone can't handle in one go, this function will copy the file in chunks to an S3 store"""
         from rclone_api.s3.api import S3Client
@@ -691,7 +694,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
@@ -724,10 +727,9 @@ class Rclone:
             use_links=True,
             vfs_cache_mode="minimal",
             verbose=False,
+            log=mount_log,
             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 +815,61 @@ class Rclone:
             )
             return out
 
+    def copy_bytes(
+        self,
+        src: str,
+        offset: int,
+        length: int,
+        transfers: int = 1,  # Note, increasing transfers can result in devestating drop in performance.
+        # If outfile is supplied then bytes are written to this file and success returns bytes(0)
+        outfile: Path | None = None,
+        mount_log: Path | None = None,
+        direct_io: bool = True,
+    ) -> 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"]
+        vfs_read_chunk_size = length // transfers
+        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"]
+        if direct_io:
+            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=mount_log is not None,
+                vfs_cache_mode="minimal",
+                other_args=other_args,
+                log=mount_log,
+            ):
+                src_file_mnt = tmp_mnt / src_file
+                with open(src_file_mnt, "rb") as f:
+                    f.seek(offset)
+                    data = f.read(length)
+                    if outfile is None:
+                        return data
+                    with open(outfile, "wb") as out:
+                        out.write(data)
+                        del data
+                    return bytes(0)
+
+        except Exception as e:
+            return e
+
     def copy_dir(
         self, src: str | Dir, dst: str | Dir, args: list[str] | None = None
     ) -> CompletedProcess:
@@ -845,6 +902,7 @@ class Rclone:
         use_links: bool | None = None,
         vfs_cache_mode: str | None = None,
         verbose: bool | None = None,
+        log: Path | None = None,
         other_args: list[str] | None = None,
     ) -> Mount:
         """Mount a remote or directory to a local path.
@@ -879,7 +937,7 @@ class Rclone:
             cmd_list.append("-vvvv")
         if other_args:
             cmd_list += other_args
-        proc = self._launch_process(cmd_list)
+        proc = self._launch_process(cmd_list, log=log)
         mount_read_only = "--read-only" in cmd_list  # hint to allow fast teardown
         mount: Mount = Mount(mount_path=outdir, process=proc, read_only=mount_read_only)
         return mount
@@ -893,6 +951,7 @@ class Rclone:
         use_links: bool | None = None,
         vfs_cache_mode: str | None = None,
         verbose: bool | None = None,
+        log: Path | None = None,
         other_args: list[str] | None = None,
     ) -> Generator[Mount, None, None]:
         """Like mount, but can be used in a context manager."""
@@ -905,6 +964,7 @@ class Rclone:
             use_links=use_links,
             vfs_cache_mode=vfs_cache_mode,
             verbose=verbose,
+            log=log,
             other_args=other_args,
         )
         try:

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/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.dist-info → rclone_api-1.1.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: rclone_api
-Version: 1.1.26
+Version: 1.1.38
 Summary: rclone api in python
 Home-page: https://github.com/zackees/rclone-api
 License: BSD 3-Clause License
@@ -12,6 +12,7 @@ License-File: LICENSE
 Requires-Dist: pyright>=1.1.393
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: certifi>=2025.1.31
+Requires-Dist: psutil
 Requires-Dist: boto3<=1.35.99,>=1.20.1
 Dynamic: home-page
 

{rclone_api-1.1.26.dist-info → rclone_api-1.1.38.dist-info}/RECORD

@@ -7,17 +7,17 @@ rclone_api/deprecated.py,sha256=qWKpnZdYcBK7YQZKuVoWWXDwi-uqiAtbjgPcci_efow,590
 rclone_api/diff.py,sha256=tMoJMAGmLSE6Q_7QhPf6PnCzb840djxMZtDmhc2GlGQ,5227
 rclone_api/dir.py,sha256=i4h7LX5hB_WmVixxDRWL_l1nifvscrdWct_8Wx7wHZc,3540
 rclone_api/dir_listing.py,sha256=GoziW8Sne6FY90MLNcb2aO3aaa3jphB6H8ExYrV0Ryo,1882
-rclone_api/exec.py,sha256=1ovvaMXDEfLiT7BrYZyE85u_yFhEUwUNW3jPOzqknR8,1023
+rclone_api/exec.py,sha256=Pd7pUBd8ib5MzqvMybG2DQISPRbDRu20VjVRL2mLAVY,1076
 rclone_api/file.py,sha256=EP5yT2dZ0H2p7CY5n0y5k5pHhIliV25pm8KOwBklUTk,1863
 rclone_api/filelist.py,sha256=xbiusvNgaB_b_kQOZoHMJJxn6TWGtPrWd2J042BI28o,767
 rclone_api/group_files.py,sha256=H92xPW9lQnbNw5KbtZCl00bD6iRh9yRbCuxku4j_3dg,8036
-rclone_api/mount.py,sha256=g9YkKCGJbWvGF7gzSKtWa8pEgphuW0-e0SySxtOirH4,6093
-rclone_api/process.py,sha256=Hgn8MGEPkBt8C6C4oIuh-n1t1GkFF2miPlIE1lh_Zbc,5045
-rclone_api/rclone.py,sha256=gszjs6MJFoT5tKmBB06sd0OjbtZZAtRdjvha4RrE-lI,40252
+rclone_api/mount.py,sha256=ryAjkX4_kFeFZWLiBVpcGy2VilpvVhFbWeWfEX4jMKs,6104
+rclone_api/process.py,sha256=rBj_S86jC6nqCYop-jq8r9eMSteKeObxUrJMgH8LZvI,5084
+rclone_api/rclone.py,sha256=meZkXmIM1M_L0Xu2hf0fcm-tG1cF5t6AHSIM6TOXUQM,42624
 rclone_api/remote.py,sha256=O9WDUFQy9f6oT1HdUbTixK2eg0xtBBm8k4Xl6aa6K00,431
 rclone_api/rpath.py,sha256=8ZA_1wxWtskwcy0I8V2VbjKDmzPkiWd8Q2JQSvh-sYE,2586
 rclone_api/scan_missing_folders.py,sha256=Kulca2Q6WZodt00ATFHkmqqInuoPvBkhTcS9703y6po,4740
-rclone_api/types.py,sha256=-jb8_cU-vTw7oFRcjUiMhXlskavp26Q67EBmENxjsPU,3941
+rclone_api/types.py,sha256=AWVIoCaRkUBCXOQffxdkFCOeUhPwolQh9d2albyAGHc,4730
 rclone_api/util.py,sha256=_Z-GUMVXnHYOGdo2dy2ie2P5fGgyg8KdGjHKicx68Ko,4573
 rclone_api/walk.py,sha256=-54NVE8EJcCstwDoaC_UtHm73R2HrZwVwQmsnv55xNU,3369
 rclone_api/assets/example.txt,sha256=lTBovRjiz0_TgtAtbA1C5hNi2ffbqnNPqkKg6UiKCT8,54
@@ -25,16 +25,17 @@ rclone_api/cmd/copy_large_s3.py,sha256=-rfedi-ZzPUdCSP8ai9LRL0y1xVkvN-viQQlk8HVU
 rclone_api/cmd/list_files.py,sha256=x8FHODEilwKqwdiU1jdkeJbLwOqUkUQuDWPo2u_zpf0,741
 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=VstlaEnBjO2JDQuCRLdTfUGvQLbfshlXXhAzimFv4Vc,3763
+rclone_api/profile/mount_copy_bytes.py,sha256=eVxF830AcsUTrDh5CwyyBLtgxh9AZa5ae51tk0yn9Xo,5626
+rclone_api/s3/api.py,sha256=qxtRDUpHYqJ7StJRtP8U_PbF_BvYRg705568SyvF-R0,3770
 rclone_api/s3/basic_ops.py,sha256=hK3366xhVEzEcjz9Gk_8lFx6MRceAk72cax6mUrr6ko,2104
 rclone_api/s3/chunk_file.py,sha256=YELR-EzR7RHpzCDGpYdzlwu21NZW5wttIDvLoONI4aU,3477
 rclone_api/s3/chunk_types.py,sha256=LbXayXY1KgVU1LkdbASD_BQ7TpVpwVnzMjtz--8LBaE,10316
-rclone_api/s3/chunk_uploader.py,sha256=1jQAdk35Fa9Tcq36bS65262cs7AcNG2DAFQ-NdYlWSw,9961
 rclone_api/s3/create.py,sha256=wgfkapv_j904CfKuWyiBIWJVxfAx_ftemFSUV14aT68,3149
 rclone_api/s3/types.py,sha256=yBnJ38Tjk6RlydJ-sqZ7DSfyFloy8KDYJ0mv3vlOzLE,1388
-rclone_api-1.1.26.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
-rclone_api-1.1.26.dist-info/METADATA,sha256=XP4PVPRFpIgNBCDE-dj1s2Ah4Hw5zBAo-AjAQKwu-f4,4514
-rclone_api-1.1.26.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
-rclone_api-1.1.26.dist-info/entry_points.txt,sha256=6eNqTRXKhVf8CpWNjXiOa_0Du9tHiW_HD2iQSXRsUg8,132
-rclone_api-1.1.26.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
-rclone_api-1.1.26.dist-info/RECORD,,
+rclone_api/s3/upload_file_multipart.py,sha256=1jQAdk35Fa9Tcq36bS65262cs7AcNG2DAFQ-NdYlWSw,9961
+rclone_api-1.1.38.dist-info/LICENSE,sha256=b6pOoifSXiUaz_lDS84vWlG3fr4yUKwB8fzkrH9R8bQ,1064
+rclone_api-1.1.38.dist-info/METADATA,sha256=xjIzdVaEv0B_zQJLXJCkONJBns3rvpc91QC3-BWAAvM,4537
+rclone_api-1.1.38.dist-info/WHEEL,sha256=rF4EZyR2XVS6irmOHQIJx2SUqXLZKRMUrjsg8UwN-XQ,109
+rclone_api-1.1.38.dist-info/entry_points.txt,sha256=TV8kwP3FRzYwUEr0RLC7aJh0W03SAefIJNXTJ-FdMIQ,200
+rclone_api-1.1.38.dist-info/top_level.txt,sha256=EvZ7uuruUpe9RiUyEp25d1Keq7PWYNT0O_-mr8FCG5g,11
+rclone_api-1.1.38.dist-info/RECORD,,

{rclone_api-1.1.26.dist-info → rclone_api-1.1.38.dist-info}/entry_points.txt

@@ -1,3 +1,4 @@
 [console_scripts]
 rclone-api-copylarge-s3 = rclone_api.cmd.copy_large_s3:main
 rclone-api-listfiles = rclone_api.cmd.list_files:main
+rclone-api-profile-mount = rclone_api.profile.mount_copy_bytes:main