asanypath 2.3.0__tar.gz → 2.3.1__tar.gz

{asanypath-2.3.0 → asanypath-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: asanypath
-Version: 2.3.0
+Version: 2.3.1
 Summary: Async pathlib for local and cloud storage
 License-Expression: MIT
 License-File: LICENSE
@@ -31,6 +31,7 @@ Requires-Dist: aiobotocore; extra == 'bench'
 Requires-Dist: aiofiles; extra == 'bench'
 Requires-Dist: asyncssh>=2.14; extra == 'bench'
 Requires-Dist: azure-storage-blob; extra == 'bench'
+Requires-Dist: boto3; extra == 'bench'
 Requires-Dist: cloudpathlib[all]; extra == 'bench'
 Requires-Dist: fsspec; extra == 'bench'
 Requires-Dist: gcloud-aio-storage; extra == 'bench'
@@ -157,7 +158,9 @@ shared reader for local downloads and source reads in cross-backend copies.
 FTP/FTPS, sources without size metadata, and HTTP servers without advertised
 range support retain single-stream downloads. Local-only copies and native
 server-side copy/rename operations retain their existing implementations.
-Uploads remain single writes; this does not introduce multipart uploads.
+Large S3/Azure uploads also use concurrent parts within this shared budget.
+GCS resumable sessions remain sequential because the protocol requires ordered
+offsets.
 
 Concurrent library copies share a default budget within the event loop. To
 configure a batch explicitly:
@@ -170,10 +173,14 @@ with TransferBudget(floor=8, ceiling=32, min_range_size=8 * 1024 * 1024, per_fil
     await asyncio.gather(*(src.copy(dst) for src, dst in pairs))
 ```
 
-The ceiling bounds concurrent reads in this budget, not metadata requests or
-other processes. Parallel range buffers are bounded by the active streams
-times the range size; cross-backend destinations still buffer the complete
-object for their existing write API. `floor=1` disables automatic splitting.
+The ceiling bounds concurrent range reads and upload parts in this budget,
+not metadata requests, single-request writes, or other processes. Parallel
+buffers are bounded by active streams times their chunk sizes. Cross-backend
+copies spool the downloaded source to a temporary file before using the
+destination's upload API. S3/Azure then upload concurrent parts; destinations
+without a streaming upload implementation can still buffer the complete write.
+Same-backend server-side copies are unchanged.
+`floor=1` disables automatic range splitting and makes upload parts sequential.
 Explicit `chunk_size` requests retain sequential streaming when splitting
 would be inappropriate, and `chunk_size=0` disables streaming to local paths.
 
@@ -218,14 +225,24 @@ async with AsAnyPath("s3://bucket/huge.bin").open("wb") as f:
 await AsAnyPath("/data/movie.mp4").copy("s3://bucket/movie.mp4")
 ```
 
-Peak memory per upload is one part — **8 MiB by default**. Objects smaller than
-one part upload in a single request. (`write_bytes(data)` / `write_text(...)`
+S3 multipart and Azure block uploads send **up to 8 parts concurrently by
+default**, filling freed slots without waiting for a whole batch. Concurrent
+files share the budget rather than each multiplying the target concurrency.
+At the default 8 MiB part size, a single large upload buffers up to **64 MiB of
+part payload**, plus file spooling, transport and runtime overhead. Native part
+requests borrow immutable Python bytes instead of copying each buffer again.
+Objects smaller than one part upload in a single request.
+(`write_bytes(data)` / `write_text(...)`
 take the whole payload in memory by definition — use `open("wb")` or `copy()`
-for large data.)
+for large data; direct `write_bytes()` remains a single write.)
 
-**Tuning the memory footprint.** The part size *is* the max RAM held per
-in-flight chunk (parts upload sequentially, so there is no concurrency
-multiplier). Set it globally via env, or per call:
+**Tuning throughput and memory.** Buffered part payload scales with part size
+times concurrent upload slots. A slot is reserved before reading its part,
+so queued uploads do not allocate unbounded buffers. Tune concurrency with
+`TransferBudget(floor=..., ceiling=..., per_file_cap=...)`, or CLI
+`--concurrency-floor` (also used by `cp`, `mv`, and `sync`). To limit a batch
+to one in-flight part/range, use `TransferBudget(floor=1, ceiling=1)`.
+Set part size globally via env, or per call:
 
 ```bash
 export ASANYPATH_UPLOAD_CHUNK_SIZE=33554432   # 32 MiB parts (bytes)
@@ -244,6 +261,11 @@ Bigger parts mean fewer requests and a larger single-object ceiling (S3 allows
 applied automatically: **S3** clamps to ≥ 5 MiB parts, **GCS** rounds down to a
 256 KiB multiple.
 
+On S3 failure or cancellation, in-flight workers are cancelled and joined
+before aborting the multipart upload; completion lists remain in source order.
+Azure only commits the ordered block list after all stages succeed; abandoned
+uncommitted blocks are left for Azure's automatic expiry.
+
 Unknown URI schemes now construct as `UnsupportedProtocolPath` placeholders.
 Pure path operations (e.g. `.name`, `.parent`, joins) still work, while backend
 operations (e.g. `.exists()`, `.read_bytes()`, `.open()`) raise
@@ -510,6 +532,22 @@ uv run --extra bench python scripts/bench.py --backend all --rounds 3 --objects
 uv run --extra bench python scripts/bench.py --backend art --rounds 3 --concurrency-levels 1,10,50
 ```
 
+For multipart upload throughput, use `scripts/bench_upload.py` with real shard
+files and an explicitly selected S3-compatible endpoint:
+
+```bash
+uv run --extra bench python scripts/bench_upload.py \
+  --destination s3://my-bucket/bench --endpoint-url https://my-storage-endpoint \
+  --part-mib 8 --streams 1 8 --rounds 3 /data/shard-001 /data/shard-002
+```
+
+This compares asanypath and boto3 using one shared request budget per client.
+It warms up each case, reports JSON timings and MiB/s, verifies uploaded contents
+outside the timed interval, and deletes only the uniquely named benchmark
+objects it created. Both clients use normal AWS credentials (or `--profile`).
+Run with one large shard and again with several representative shards; results
+from a local test server are not evidence of production endpoint throughput.
+
 ### S3 — live S3-compatible service (median of 20 rounds, 10 objects, c=1)
 
 | Operation | asanypath | s3fs | aiobotocore | cloudpathlib |

{asanypath-2.3.0 → asanypath-2.3.1}/README.md

@@ -102,7 +102,9 @@ shared reader for local downloads and source reads in cross-backend copies.
 FTP/FTPS, sources without size metadata, and HTTP servers without advertised
 range support retain single-stream downloads. Local-only copies and native
 server-side copy/rename operations retain their existing implementations.
-Uploads remain single writes; this does not introduce multipart uploads.
+Large S3/Azure uploads also use concurrent parts within this shared budget.
+GCS resumable sessions remain sequential because the protocol requires ordered
+offsets.
 
 Concurrent library copies share a default budget within the event loop. To
 configure a batch explicitly:
@@ -115,10 +117,14 @@ with TransferBudget(floor=8, ceiling=32, min_range_size=8 * 1024 * 1024, per_fil
     await asyncio.gather(*(src.copy(dst) for src, dst in pairs))
 ```
 
-The ceiling bounds concurrent reads in this budget, not metadata requests or
-other processes. Parallel range buffers are bounded by the active streams
-times the range size; cross-backend destinations still buffer the complete
-object for their existing write API. `floor=1` disables automatic splitting.
+The ceiling bounds concurrent range reads and upload parts in this budget,
+not metadata requests, single-request writes, or other processes. Parallel
+buffers are bounded by active streams times their chunk sizes. Cross-backend
+copies spool the downloaded source to a temporary file before using the
+destination's upload API. S3/Azure then upload concurrent parts; destinations
+without a streaming upload implementation can still buffer the complete write.
+Same-backend server-side copies are unchanged.
+`floor=1` disables automatic range splitting and makes upload parts sequential.
 Explicit `chunk_size` requests retain sequential streaming when splitting
 would be inappropriate, and `chunk_size=0` disables streaming to local paths.
 
@@ -163,14 +169,24 @@ async with AsAnyPath("s3://bucket/huge.bin").open("wb") as f:
 await AsAnyPath("/data/movie.mp4").copy("s3://bucket/movie.mp4")
 ```
 
-Peak memory per upload is one part — **8 MiB by default**. Objects smaller than
-one part upload in a single request. (`write_bytes(data)` / `write_text(...)`
+S3 multipart and Azure block uploads send **up to 8 parts concurrently by
+default**, filling freed slots without waiting for a whole batch. Concurrent
+files share the budget rather than each multiplying the target concurrency.
+At the default 8 MiB part size, a single large upload buffers up to **64 MiB of
+part payload**, plus file spooling, transport and runtime overhead. Native part
+requests borrow immutable Python bytes instead of copying each buffer again.
+Objects smaller than one part upload in a single request.
+(`write_bytes(data)` / `write_text(...)`
 take the whole payload in memory by definition — use `open("wb")` or `copy()`
-for large data.)
+for large data; direct `write_bytes()` remains a single write.)
 
-**Tuning the memory footprint.** The part size *is* the max RAM held per
-in-flight chunk (parts upload sequentially, so there is no concurrency
-multiplier). Set it globally via env, or per call:
+**Tuning throughput and memory.** Buffered part payload scales with part size
+times concurrent upload slots. A slot is reserved before reading its part,
+so queued uploads do not allocate unbounded buffers. Tune concurrency with
+`TransferBudget(floor=..., ceiling=..., per_file_cap=...)`, or CLI
+`--concurrency-floor` (also used by `cp`, `mv`, and `sync`). To limit a batch
+to one in-flight part/range, use `TransferBudget(floor=1, ceiling=1)`.
+Set part size globally via env, or per call:
 
 ```bash
 export ASANYPATH_UPLOAD_CHUNK_SIZE=33554432   # 32 MiB parts (bytes)
@@ -189,6 +205,11 @@ Bigger parts mean fewer requests and a larger single-object ceiling (S3 allows
 applied automatically: **S3** clamps to ≥ 5 MiB parts, **GCS** rounds down to a
 256 KiB multiple.
 
+On S3 failure or cancellation, in-flight workers are cancelled and joined
+before aborting the multipart upload; completion lists remain in source order.
+Azure only commits the ordered block list after all stages succeed; abandoned
+uncommitted blocks are left for Azure's automatic expiry.
+
 Unknown URI schemes now construct as `UnsupportedProtocolPath` placeholders.
 Pure path operations (e.g. `.name`, `.parent`, joins) still work, while backend
 operations (e.g. `.exists()`, `.read_bytes()`, `.open()`) raise
@@ -455,6 +476,22 @@ uv run --extra bench python scripts/bench.py --backend all --rounds 3 --objects
 uv run --extra bench python scripts/bench.py --backend art --rounds 3 --concurrency-levels 1,10,50
 ```
 
+For multipart upload throughput, use `scripts/bench_upload.py` with real shard
+files and an explicitly selected S3-compatible endpoint:
+
+```bash
+uv run --extra bench python scripts/bench_upload.py \
+  --destination s3://my-bucket/bench --endpoint-url https://my-storage-endpoint \
+  --part-mib 8 --streams 1 8 --rounds 3 /data/shard-001 /data/shard-002
+```
+
+This compares asanypath and boto3 using one shared request budget per client.
+It warms up each case, reports JSON timings and MiB/s, verifies uploaded contents
+outside the timed interval, and deletes only the uniquely named benchmark
+objects it created. Both clients use normal AWS credentials (or `--profile`).
+Run with one large shard and again with several representative shards; results
+from a local test server are not evidence of production endpoint throughput.
+
 ### S3 — live S3-compatible service (median of 20 rounds, 10 objects, c=1)
 
 | Operation | asanypath | s3fs | aiobotocore | cloudpathlib |

{asanypath-2.3.0 → asanypath-2.3.1}/pyproject.toml

@@ -59,6 +59,7 @@ cli = ["rich-click>=1.9.7"]
 ftp = ["aioftp>=0.21"]
 credstore = ["keyring>=24"]
 bench = [
+    "boto3",
     "asyncssh>=2.14",
     "fsspec",
     "s3fs",

asanypath-2.3.1/scripts/bench_upload.py

@@ -0,0 +1,181 @@
+# Copyright (C) 2026 Axis Communications AB, Lund, Sweden
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+"""Compare bounded multipart uploads of real files to an explicitly chosen S3 prefix.
+
+Uses normal AWS credential resolution; never reads repository credential files.
+Each case warms up once, uploads to unique keys, verifies contents outside the
+timed interval, and deletes only its own objects. Timings include public copy API
+overhead for asanypath and upload_file API overhead for boto3.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import hashlib
+import json
+import statistics
+import time
+from collections.abc import Awaitable, Iterable
+from pathlib import Path
+from uuid import uuid4
+
+from asanypath import AsAnyPath, TransferBudget
+
+
+async def finish_uploads(uploads: Iterable[Awaitable[object]]) -> None:
+    pending = asyncio.gather(*uploads, return_exceptions=True)
+    try:
+        results = await asyncio.shield(pending)
+    except asyncio.CancelledError:
+        await pending
+        raise
+    for result in results:
+        if isinstance(result, BaseException):
+            raise result
+
+
+def positive(value: str) -> int:
+    result = int(value)
+    if result < 1:
+        raise argparse.ArgumentTypeError("must be positive")
+    return result
+
+
+def digest(path: Path) -> bytes:
+    checksum = hashlib.sha256()
+    with path.open("rb") as file:
+        while chunk := file.read(8 * 1024 * 1024):
+            checksum.update(chunk)
+    return checksum.digest()
+
+
+async def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("files", nargs="+", type=Path, help="Representative local shard files")
+    parser.add_argument("--destination", required=True, help="s3://bucket/benchmark-prefix")
+    parser.add_argument("--endpoint-url", help="The storage endpoint used by both clients")
+    parser.add_argument("--profile", help="AWS profile used by both clients")
+    parser.add_argument("--streams", nargs="+", type=positive, default=[1, 8])
+    parser.add_argument("--part-mib", type=positive, default=8)
+    parser.add_argument("--rounds", type=positive, default=3)
+    parser.add_argument(
+        "--implementations",
+        nargs="+",
+        choices=["asanypath", "boto3"],
+        default=["asanypath", "boto3"],
+    )
+    args = parser.parse_args()
+    if not args.destination.startswith("s3://") or not args.destination[5:].split("/")[0]:
+        parser.error("--destination must be an s3://bucket/prefix URI")
+    if args.part_mib < 5:
+        parser.error("--part-mib must be at least 5 for S3")
+    for file in args.files:
+        if not file.is_file():
+            parser.error(f"Not a file: {file}")
+    kwargs = {}
+    if args.endpoint_url:
+        kwargs["endpoint_url"] = args.endpoint_url
+    if args.profile:
+        kwargs["profile"] = args.profile
+    part_size = args.part_mib * 1024 * 1024
+    total = sum(file.stat().st_size for file in args.files)
+    expected = [digest(file) for file in args.files]
+    base = args.destination.rstrip("/") + "/asanypath-upload-bench-" + uuid4().hex
+    bucket = base[5:].split("/", 1)[0]
+
+    for streams in args.streams:
+        for implementation in args.implementations:
+            client = transfer = None
+            if implementation == "boto3":
+                import boto3
+                from boto3.s3.transfer import S3Transfer, TransferConfig
+                from botocore.config import Config
+
+                client = boto3.Session(profile_name=args.profile).client(
+                    "s3",
+                    endpoint_url=args.endpoint_url,
+                    config=Config(max_pool_connections=max(10, streams)),
+                )
+                # One manager shares its request budget across all files.
+                transfer = S3Transfer(
+                    client,
+                    TransferConfig(
+                        multipart_threshold=part_size,
+                        multipart_chunksize=part_size,
+                        max_concurrency=streams,
+                        preferred_transfer_client="classic",
+                    ),
+                )
+            samples = []
+            try:
+                for round_number in range(args.rounds + 1):
+                    uris = [
+                        f"{base}/{implementation}/{streams}/{round_number}/{index}"
+                        for index in range(len(args.files))
+                    ]
+                    destinations = [AsAnyPath(uri, **kwargs) for uri in uris]
+                    try:
+                        start = time.perf_counter()
+                        if implementation == "asanypath":
+                            with TransferBudget(
+                                floor=streams, ceiling=streams, per_file_cap=streams
+                            ):
+                                await finish_uploads(
+                                    (
+                                        AsAnyPath(file).copy(dst, chunk_size=part_size)
+                                        for file, dst in zip(args.files, destinations, strict=True)
+                                    )
+                                )
+                        else:
+                            await finish_uploads(
+                                (
+                                    asyncio.to_thread(
+                                        transfer.upload_file,
+                                        str(file),
+                                        bucket,
+                                        uri[5:].split("/", 1)[1],
+                                    )
+                                    for file, uri in zip(args.files, uris, strict=True)
+                                )
+                            )
+                        elapsed = time.perf_counter() - start
+                        for dst, checksum in zip(destinations, expected, strict=True):
+                            actual = hashlib.sha256()
+                            async for chunk in dst.iter_bytes(part_size):
+                                actual.update(chunk)
+                            if actual.digest() != checksum:
+                                raise OSError(f"Uploaded content verification failed: {dst}")
+                        if round_number:
+                            samples.append(elapsed)
+                    finally:
+                        await asyncio.gather(*(dst.unlink(missing_ok=True) for dst in destinations))
+                median = statistics.median(samples)
+                print(
+                    json.dumps(
+                        {
+                            "implementation": implementation,
+                            "streams": streams,
+                            "files": len(args.files),
+                            "bytes": total,
+                            "part_bytes": part_size,
+                            "seconds": samples,
+                            "median_seconds": median,
+                            "median_mib_per_second": total / (1024 * 1024) / median,
+                        }
+                    ),
+                    flush=True,
+                )
+            finally:
+                if transfer is not None:
+                    await asyncio.to_thread(transfer.__exit__, None, None, None)
+                if client is not None:
+                    client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{asanypath-2.3.0 → asanypath-2.3.1}/src/asanypath/_transfer.py

@@ -11,13 +11,13 @@ import inspect
 import os
 import shutil
 import uuid
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
 from contextlib import aclosing, asynccontextmanager
 from contextvars import ContextVar, Token
 from functools import wraps
 from hashlib import sha256
 from pathlib import Path
-from typing import Any, ParamSpec, TypeVar
+from typing import IO, Any, ParamSpec, TypeVar
 
 from asanypath.exceptions import UnsupportedProtocolError
 
@@ -34,7 +34,12 @@ class RangeNotSupportedError(OSError):
 
 
 class TransferBudget:
-    """Share size-aware range concurrency within one transfer operation."""
+    """Share range-read and multipart-upload concurrency across transfers.
+
+    ``floor`` is a best-effort stream target divided among active files;
+    ``ceiling`` bounds requests across this budget, and ``per_file_cap`` bounds
+    each file's fan-out. Upload workers reserve capacity before buffering.
+    """
 
     def __init__(
         self,
@@ -80,7 +85,7 @@ async def transfer_scope() -> AsyncIterator[TransferBudget]:
     if budget is None:
         loop = asyncio.get_running_loop()
         budget = getattr(loop, "_asanypath_transfer_budget", None)
-        if budget is None:
+        if not isinstance(budget, TransferBudget):
             budget = TransferBudget()
             setattr(loop, "_asanypath_transfer_budget", budget)
     if _registered_transfer.get() is budget:
@@ -98,7 +103,74 @@ async def transfer_scope() -> AsyncIterator[TransferBudget]:
         _transfer_budget.reset(budget_token)
 
 
-async def iter_transfer_chunks(src: Any, chunk_size: int | None = None) -> AsyncIterator[bytes]:
+UploadResult = TypeVar("UploadResult")
+
+
+async def _file_io(operation: Callable[[], UploadResult]) -> UploadResult:
+    task = asyncio.create_task(asyncio.to_thread(operation))
+    try:
+        return await asyncio.shield(task)
+    except asyncio.CancelledError:
+        # Join non-cancellable disk I/O before the caller can close its file.
+        await task
+        raise
+
+
+async def upload_parts(
+    fileobj: IO[bytes],
+    size: int,
+    part_size: int,
+    upload: Callable[[int, bytes], Awaitable[UploadResult]],
+    *,
+    parallel: bool = True,
+) -> list[UploadResult]:
+    """Upload bounded parts with backpressure, returning results in source order."""
+    if part_size < 1:
+        raise ValueError("upload part size must be positive")
+    async with transfer_scope() as budget:
+        workers = (
+            min(
+                budget.per_file_cap,
+                max(1, budget.floor // budget.active_files),
+                max(1, (size + part_size - 1) // part_size),
+            )
+            if parallel
+            else 1
+        )
+        read_lock = asyncio.Lock()
+        results: dict[int, UploadResult] = {}
+        part_number = 0
+
+        async def worker() -> None:
+            nonlocal part_number
+            while True:
+                # Reserve capacity before allocating a buffer, not just before I/O.
+                async with budget._slots:
+                    async with read_lock:
+                        chunk = await _file_io(lambda: fileobj.read(part_size))
+                        if not chunk:
+                            return
+                        part_number += 1
+                        number = part_number
+                    try:
+                        results[number] = await upload(number, chunk)
+                    finally:
+                        del chunk
+
+        tasks = [asyncio.create_task(worker()) for _ in range(workers)]
+        try:
+            await asyncio.gather(*tasks)
+        finally:
+            for task in tasks:
+                if not task.done():
+                    task.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
+        return [results[number] for number in sorted(results)]
+
+
+async def iter_transfer_chunks(
+    src: Any, chunk_size: int | None = None
+) -> AsyncGenerator[bytes, None]:
     """Read supported sources in bounded, ordered, size-aware parallel ranges."""
     async with transfer_scope() as budget:
         if (
@@ -143,6 +215,7 @@ async def iter_transfer_chunks(src: Any, chunk_size: int | None = None) -> Async
 
         async def read_range(start: int, end: int) -> bytes:
             async with budget._slots:
+                data: bytes
                 if getattr(src, "_conditional_range_read", False) and any(
                     getattr(metadata, field, None)
                     for field in ("etag", "last_modified", "version_id")

{asanypath-2.3.0 → asanypath-2.3.1}/src/asanypath/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.3.0'
-__version_tuple__ = version_tuple = (2, 3, 0)
+__version__ = version = '2.3.1'
+__version_tuple__ = version_tuple = (2, 3, 1)
 
 __commit_id__ = commit_id = None

{asanypath-2.3.0 → asanypath-2.3.1}/src/asanypath/azure.py

@@ -17,6 +17,7 @@ from collections.abc import Mapping
 from datetime import datetime, timezone
 from os import getenv
 from types import SimpleNamespace
+from uuid import uuid4
 
 import msgspec
 from asanypath_native import (
@@ -37,6 +38,7 @@ from asanypath_native import (
     az_put_container_acl,
 )
 
+from asanypath._transfer import upload_parts
 from asanypath.cloud import CloudPathMixin
 from asanypath.options import (
     UPLOAD_CHUNK_SIZE,
@@ -203,26 +205,26 @@ class AzurePath(CloudPathMixin):
             else:
                 await self.write_bytes(data, backend_options=backend_options)
             return
-        await self._block_upload(fileobj, part, backend_options=backend_options)
+        await self._block_upload(fileobj, part, size=size, backend_options=backend_options)
 
-    async def _block_upload(self, fileobj, part_size: int, *, backend_options=None) -> None:
-        """Stage fixed-size blocks then commit the list (memory bounded to one block)."""
+    async def _block_upload(
+        self, fileobj, part_size: int, *, size: int, backend_options=None
+    ) -> None:
+        """Stage bounded concurrent blocks, then commit them in source order."""
         options_json = (
             msgspec.json.encode(backend_options).decode() if backend_options is not None else "{}"
         )
-        block_ids: list[str] = []
-        index = 0
-        while True:
-            chunk = fileobj.read(part_size)
-            if not chunk:
-                break
-            # Block ids must be equal-length base64 strings.
-            block_id = base64.b64encode(f"{index:048d}".encode()).decode()
+        upload_id = uuid4().hex
+
+        async def upload(index: int, chunk: bytes) -> str:
+            # Equal-length, upload-specific ids avoid mixing concurrent writers.
+            block_id = base64.b64encode(f"{upload_id}{index:016d}".encode()).decode()
             await az_put_block(
                 blob=self._item_path, block_id=block_id, data=chunk, **self._native_kwargs
             )
-            block_ids.append(block_id)
-            index += 1
+            return block_id
+
+        block_ids = await upload_parts(fileobj, size, part_size, upload)
         await az_put_block_list(
             blob=self._item_path,
             block_ids=block_ids,

{asanypath-2.3.0 → asanypath-2.3.1}/src/asanypath/cli.py

@@ -1726,7 +1726,7 @@ def rm(paths: tuple[str, ...], token: str | None, force: bool, recursive: bool,
     "--chunk-size",
     default=None,
     type=click.IntRange(min=0),
-    help="Streaming chunk size for local-destination transfers (default: auto; 0 disables)",
+    help="Range/upload part size in bytes (default: auto; 0 disables local streaming)",
 )
 @click.option(
     "--verbose",
@@ -1746,7 +1746,7 @@ def rm(paths: tuple[str, ...], token: str | None, force: bool, recursive: bool,
     "--concurrency-floor",
     default=DEFAULT_CONCURRENCY,
     type=click.IntRange(min=1),
-    help="Target transfer streams when few large files are active (default: 8; 1 disables ranges)",
+    help="Target range/upload streams (default: 8; 1 makes each file sequential)",
 )
 def mv(
     paths: tuple[str, ...],
@@ -1878,7 +1878,7 @@ def mv(
     "--chunk-size",
     default=None,
     type=click.IntRange(min=0),
-    help="Streaming chunk size for local-destination transfers (default: auto; 0 disables)",
+    help="Range/upload part size in bytes (default: auto; 0 disables local streaming)",
 )
 @click.option("--recursive", "recursive", "-r", is_flag=True, help="Copy directories recursively")
 @click.option(
@@ -1899,7 +1899,7 @@ def mv(
     "--concurrency-floor",
     default=DEFAULT_CONCURRENCY,
     type=click.IntRange(min=1),
-    help="Target transfer streams when few large files are active (default: 8; 1 disables ranges)",
+    help="Target range/upload streams (default: 8; 1 makes each file sequential)",
 )
 @click.option(
     "--listing",
@@ -2335,7 +2335,7 @@ def presign(path: str, expires: int, method: str, token: str | None) -> None:
     "--concurrency-floor",
     default=DEFAULT_CONCURRENCY,
     type=click.IntRange(min=1),
-    help="Target transfer streams when few large files are active (default: 8; 1 disables ranges)",
+    help="Target range/upload streams (default: 8; 1 makes each file sequential)",
 )
 @click.option("--exclude", multiple=True, help="Exclude files matching glob pattern (repeatable)")
 @click.option(