asanypath 2.1.0__tar.gz → 2.2.0__tar.gz

{asanypath-2.1.0 → asanypath-2.2.0}/.github/workflows/publish.yml

@@ -102,7 +102,7 @@ jobs:
           rm rust/Cargo.toml.bak
 
       - name: Set up uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
         with:
           enable-cache: false
 
@@ -128,7 +128,7 @@ jobs:
           persist-credentials: false
 
       - name: Set up uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
         with:
           enable-cache: false
 

{asanypath-2.1.0 → asanypath-2.2.0}/.github/workflows/unittests.yml

@@ -44,16 +44,13 @@ jobs:
           python-version: ${{ matrix.python-version }}
 
       - name: Set up uv
-        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
 
       - name: Ruff checks
         run: uvx ruff check src tests && uvx ruff format --check src tests
 
-      - name: Create virtual environment
-        run: uv venv --python "${{ matrix.python-version }}"
-
-      - name: Install project and native extension
-        run: uv pip install -e ".[dev]"
+      - name: Install project and native extension from uv.lock
+        run: uv sync --locked --extra dev --python "${{ matrix.python-version }}"
 
       - name: Test with pytest and coverage
         env:

{asanypath-2.1.0 → asanypath-2.2.0}/.gitignore

@@ -15,6 +15,7 @@ __pycache__
 !.github/**
 !*.py
 !*.pyi
+!py.typed
 !asanypath.png
 # auto-generated by hatch-vcs
 _version.py

{asanypath-2.1.0 → asanypath-2.2.0}/.pre-commit-config.yaml

@@ -22,4 +22,10 @@ repos:
       entry: cargo check --manifest-path rust/Cargo.toml --locked
       language: system
       files: ^rust/.*\.(rs|toml|lock)$
-      pass_filenames: false
+      pass_filenames: false
+    # uv.lock must only reference the public index (a mirror URL leaks internal hosts).
+    - id: uv-lock-public-index
+      name: uv.lock uses only public index URLs
+      language: pygrep
+      entry: '(registry|url) = "https?://(?!pypi\.org/|files\.pythonhosted\.org/)'
+      files: ^uv\.lock$

{asanypath-2.1.0 → asanypath-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: asanypath
-Version: 2.1.0
+Version: 2.2.0
 Summary: Async pathlib for local and cloud storage
 License-Expression: MIT
 License-File: LICENSE
@@ -19,11 +19,12 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: anyio>=4
-Requires-Dist: asanypath-native~=2.1.0
-Requires-Dist: msgspec>=0.21.1
+Requires-Dist: asanypath-native~=2.2.0
+Requires-Dist: msgspec>=0.22.0
 Requires-Dist: yarl>=1.2
 Provides-Extra: all
 Requires-Dist: aioftp>=0.21; extra == 'all'
+Requires-Dist: diskcache>=5.6; extra == 'all'
 Requires-Dist: keyring>=24; extra == 'all'
 Provides-Extra: bench
 Requires-Dist: adlfs; extra == 'bench'
@@ -37,12 +38,15 @@ Requires-Dist: gcloud-aio-storage; extra == 'bench'
 Requires-Dist: gcsfs; extra == 'bench'
 Requires-Dist: requests; extra == 'bench'
 Requires-Dist: s3fs; extra == 'bench'
+Provides-Extra: cache
+Requires-Dist: diskcache>=5.6; extra == 'cache'
 Provides-Extra: cli
 Requires-Dist: rich-click>=1.9.7; extra == 'cli'
 Provides-Extra: credstore
 Requires-Dist: keyring>=24; extra == 'credstore'
 Provides-Extra: dev
 Requires-Dist: aioftp>=0.21; extra == 'dev'
+Requires-Dist: diskcache>=5.6; extra == 'dev'
 Requires-Dist: keyring>=24; extra == 'dev'
 Requires-Dist: pre-commit>=4; extra == 'dev'
 Requires-Dist: pytest-asyncio>=1.3; extra == 'dev'
@@ -161,11 +165,131 @@ for child in p.parent.iterdir():  # yields synchronously
 Local paths (`file://` or bare `/path`) bypass the proxy entirely and use
 `pathlib.Path` directly — zero threading overhead.
 
+### Large uploads stream automatically
+
+Writing or copying a large object never buffers the whole thing in memory — it
+streams in bounded-size parts using each backend's native mechanism (S3
+multipart, Azure block blobs, GCS resumable, SSH chunked writes, FTP data
+connection, Artifactory streamed `PUT`). This is the **default** behaviour — no
+flag, no API change:
+
+```python
+# open("wb") spills to disk past 16 MiB and uploads in parts on close
+async with AsAnyPath("s3://bucket/huge.bin").open("wb") as f:
+    f.write(data)
+
+# local -> cloud copy streams straight from the source file (async and sync)
+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(...)`
+take the whole payload in memory by definition — use `open("wb")` or `copy()`
+for large data.)
+
+**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:
+
+```bash
+export ASANYPATH_UPLOAD_CHUNK_SIZE=33554432   # 32 MiB parts (bytes)
+export ASANYPATH_SPOOL_MAX_SIZE=67108864      # 64 MiB before open("wb") spills to disk
+```
+
+```python
+# per call: copy(chunk_size=...) or, for writes, open(..., buffering=...)
+await src.copy("s3://bucket/huge.bin", chunk_size=32 * 1024 * 1024)
+async with dst.open("wb", buffering=32 * 1024 * 1024) as f:
+    f.write(data)
+```
+
+Bigger parts mean fewer requests and a larger single-object ceiling (S3 allows
+10,000 parts, so 8 MiB parts cap an object at ~80 GB). Backend minimums are
+applied automatically: **S3** clamps to ≥ 5 MiB parts, **GCS** rounds down to a
+256 KiB multiple.
+
 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
 `UnsupportedProtocolError` on use.
 
+### Download caching (opt-in)
+
+Reading the same object or URL twice always re-downloads it — there is **no
+cache by default**, and the read path is unchanged unless you opt in, so
+non-caching callers pay zero overhead.
+
+Enable it with the optional `cache` extra (`pip install asanypath[cache]`,
+backed by [`diskcache`](https://pypi.org/project/diskcache/) — a pure-Python,
+zero-dependency store). Opt in per read with `use_cache=True`:
+
+```python
+from asanypath import AsAnyPath
+
+p = AsAnyPath("s3://bucket/model.bin")
+data = await p.read_bytes(use_cache=True)   # first call fetches + stores
+data = await p.read_bytes(use_cache=True)   # subsequent calls served from disk
+text = await p.read_text(use_cache=True)
+```
+
+Configure the location and limits once (location defaults to
+`~/.cache/asanypath`, honoring `$XDG_CACHE_HOME` and `$ASANYPATH_CACHE_DIR`):
+
+```python
+from asanypath import configure_cache
+
+configure_cache(
+    directory="/var/cache/asanypath",  # default: ~/.cache/asanypath
+    size_limit=2 * 1024**3,            # total on-disk cap in bytes (default 1 GiB, LRU)
+    ttl=3600,                          # per-entry expiry in seconds (default: none)
+    enabled=True,                      # make use_cache default to True process-wide
+)
+```
+
+Or via environment: `ASANYPATH_CACHE_DIR`, `ASANYPATH_CACHE_SIZE_LIMIT` (bytes),
+`ASANYPATH_CACHE_TTL` (seconds).
+
+Behaviour and trade-offs:
+
+- **Off by default, opt-in per call.** With `configure_cache(enabled=True)` the
+  default flips process-wide; an explicit `use_cache=False` always bypasses.
+- **Works for every remote backend** (S3, GCS, Azure, Artifactory, HTTP, SSH,
+  FTP). Local paths are never cached.
+- **Total-size bounded, LRU-evicted;** disk I/O runs in a worker thread so the
+  event loop stays responsive. Concurrent reads of the same key collapse to a
+  single fetch.
+- **Staleness is on you.** Entries are keyed by URL with no revalidation — a
+  cached object that changes upstream is served stale until it expires (`ttl`)
+  or is evicted. Prefer caching immutable/versioned objects, or set a `ttl`.
+
+### Resumable downloads
+
+`download(dst)` streams an object to a local file and **resumes an interrupted
+transfer** instead of starting over:
+
+```python
+await AsAnyPath("s3://bucket/huge.bin").download("/data/huge.bin")
+# process killed mid-download... run the same call again — it continues
+await AsAnyPath("s3://bucket/huge.bin").download("/data/huge.bin")
+```
+
+Bytes stream into `<dst>.part` with a `<dst>.part.meta` sidecar recording the
+object's ETag (or `Last-Modified`) and total size. On resume the identity is
+re-checked: if the upstream object is unchanged the download continues from the
+saved offset; if it changed, the partial is discarded and it restarts cleanly.
+On completion `<dst>.part` is atomically renamed to `dst`.
+
+```python
+# tune the range-request size; disable resume to always start fresh
+await path.download("/data/huge.bin", chunk_size=32 * 1024 * 1024, resume=False)
+```
+
+Resume needs range reads **and** a HEAD probe, so it's available on the object
+stores (S3/GCS/Azure) and Artifactory/HTTP where the server supports it.
+Backends without those (e.g. FTP) download in a single pass automatically. This
+needs no extra dependency — resume state is plain sidecar files, independent of
+the optional download cache.
+
 ## Installation
 
 Most cloud backends (S3, GCS, Azure, Artifactory, HTTP) are included in the base
@@ -438,10 +562,11 @@ Factory that returns the appropriate path instance based on the URI scheme.
 
 All path implementations support:
 
-- `open(mode, buffering)` — file-like streaming with lazy range reads
-- `copy(dst, recursive)` — copy file or tree (cross-backend)
-- `read_bytes()` / `write_bytes(data)`
-- `read_text(encoding)` / `write_text(data, encoding)`
+- `open(mode, buffering)` — file-like streaming with lazy range reads; for writes, `buffering` sets the upload part size
+- `copy(dst, recursive, chunk_size)` — copy file or tree (cross-backend); `chunk_size` tunes the upload part size
+- `download(dst, resume, chunk_size)` — stream an object to a local file, resuming an interrupted transfer
+- `read_bytes()` / `write_bytes(data)` — `read_bytes(use_cache=True)` serves from / stores in the opt-in [download cache](#download-caching-opt-in)
+- `read_text(encoding)` / `write_text(data, encoding)` — `read_text` also accepts `use_cache`
 - `exists()` / `is_file()` / `is_dir()`
 - `stat()` / `checksums()` (cloud backends)
 - `mkdir(parents, exist_ok)` / `touch(exist_ok)`

{asanypath-2.1.0 → asanypath-2.2.0}/README.md

@@ -106,11 +106,131 @@ for child in p.parent.iterdir():  # yields synchronously
 Local paths (`file://` or bare `/path`) bypass the proxy entirely and use
 `pathlib.Path` directly — zero threading overhead.
 
+### Large uploads stream automatically
+
+Writing or copying a large object never buffers the whole thing in memory — it
+streams in bounded-size parts using each backend's native mechanism (S3
+multipart, Azure block blobs, GCS resumable, SSH chunked writes, FTP data
+connection, Artifactory streamed `PUT`). This is the **default** behaviour — no
+flag, no API change:
+
+```python
+# open("wb") spills to disk past 16 MiB and uploads in parts on close
+async with AsAnyPath("s3://bucket/huge.bin").open("wb") as f:
+    f.write(data)
+
+# local -> cloud copy streams straight from the source file (async and sync)
+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(...)`
+take the whole payload in memory by definition — use `open("wb")` or `copy()`
+for large data.)
+
+**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:
+
+```bash
+export ASANYPATH_UPLOAD_CHUNK_SIZE=33554432   # 32 MiB parts (bytes)
+export ASANYPATH_SPOOL_MAX_SIZE=67108864      # 64 MiB before open("wb") spills to disk
+```
+
+```python
+# per call: copy(chunk_size=...) or, for writes, open(..., buffering=...)
+await src.copy("s3://bucket/huge.bin", chunk_size=32 * 1024 * 1024)
+async with dst.open("wb", buffering=32 * 1024 * 1024) as f:
+    f.write(data)
+```
+
+Bigger parts mean fewer requests and a larger single-object ceiling (S3 allows
+10,000 parts, so 8 MiB parts cap an object at ~80 GB). Backend minimums are
+applied automatically: **S3** clamps to ≥ 5 MiB parts, **GCS** rounds down to a
+256 KiB multiple.
+
 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
 `UnsupportedProtocolError` on use.
 
+### Download caching (opt-in)
+
+Reading the same object or URL twice always re-downloads it — there is **no
+cache by default**, and the read path is unchanged unless you opt in, so
+non-caching callers pay zero overhead.
+
+Enable it with the optional `cache` extra (`pip install asanypath[cache]`,
+backed by [`diskcache`](https://pypi.org/project/diskcache/) — a pure-Python,
+zero-dependency store). Opt in per read with `use_cache=True`:
+
+```python
+from asanypath import AsAnyPath
+
+p = AsAnyPath("s3://bucket/model.bin")
+data = await p.read_bytes(use_cache=True)   # first call fetches + stores
+data = await p.read_bytes(use_cache=True)   # subsequent calls served from disk
+text = await p.read_text(use_cache=True)
+```
+
+Configure the location and limits once (location defaults to
+`~/.cache/asanypath`, honoring `$XDG_CACHE_HOME` and `$ASANYPATH_CACHE_DIR`):
+
+```python
+from asanypath import configure_cache
+
+configure_cache(
+    directory="/var/cache/asanypath",  # default: ~/.cache/asanypath
+    size_limit=2 * 1024**3,            # total on-disk cap in bytes (default 1 GiB, LRU)
+    ttl=3600,                          # per-entry expiry in seconds (default: none)
+    enabled=True,                      # make use_cache default to True process-wide
+)
+```
+
+Or via environment: `ASANYPATH_CACHE_DIR`, `ASANYPATH_CACHE_SIZE_LIMIT` (bytes),
+`ASANYPATH_CACHE_TTL` (seconds).
+
+Behaviour and trade-offs:
+
+- **Off by default, opt-in per call.** With `configure_cache(enabled=True)` the
+  default flips process-wide; an explicit `use_cache=False` always bypasses.
+- **Works for every remote backend** (S3, GCS, Azure, Artifactory, HTTP, SSH,
+  FTP). Local paths are never cached.
+- **Total-size bounded, LRU-evicted;** disk I/O runs in a worker thread so the
+  event loop stays responsive. Concurrent reads of the same key collapse to a
+  single fetch.
+- **Staleness is on you.** Entries are keyed by URL with no revalidation — a
+  cached object that changes upstream is served stale until it expires (`ttl`)
+  or is evicted. Prefer caching immutable/versioned objects, or set a `ttl`.
+
+### Resumable downloads
+
+`download(dst)` streams an object to a local file and **resumes an interrupted
+transfer** instead of starting over:
+
+```python
+await AsAnyPath("s3://bucket/huge.bin").download("/data/huge.bin")
+# process killed mid-download... run the same call again — it continues
+await AsAnyPath("s3://bucket/huge.bin").download("/data/huge.bin")
+```
+
+Bytes stream into `<dst>.part` with a `<dst>.part.meta` sidecar recording the
+object's ETag (or `Last-Modified`) and total size. On resume the identity is
+re-checked: if the upstream object is unchanged the download continues from the
+saved offset; if it changed, the partial is discarded and it restarts cleanly.
+On completion `<dst>.part` is atomically renamed to `dst`.
+
+```python
+# tune the range-request size; disable resume to always start fresh
+await path.download("/data/huge.bin", chunk_size=32 * 1024 * 1024, resume=False)
+```
+
+Resume needs range reads **and** a HEAD probe, so it's available on the object
+stores (S3/GCS/Azure) and Artifactory/HTTP where the server supports it.
+Backends without those (e.g. FTP) download in a single pass automatically. This
+needs no extra dependency — resume state is plain sidecar files, independent of
+the optional download cache.
+
 ## Installation
 
 Most cloud backends (S3, GCS, Azure, Artifactory, HTTP) are included in the base
@@ -383,10 +503,11 @@ Factory that returns the appropriate path instance based on the URI scheme.
 
 All path implementations support:
 
-- `open(mode, buffering)` — file-like streaming with lazy range reads
-- `copy(dst, recursive)` — copy file or tree (cross-backend)
-- `read_bytes()` / `write_bytes(data)`
-- `read_text(encoding)` / `write_text(data, encoding)`
+- `open(mode, buffering)` — file-like streaming with lazy range reads; for writes, `buffering` sets the upload part size
+- `copy(dst, recursive, chunk_size)` — copy file or tree (cross-backend); `chunk_size` tunes the upload part size
+- `download(dst, resume, chunk_size)` — stream an object to a local file, resuming an interrupted transfer
+- `read_bytes()` / `write_bytes(data)` — `read_bytes(use_cache=True)` serves from / stores in the opt-in [download cache](#download-caching-opt-in)
+- `read_text(encoding)` / `write_text(data, encoding)` — `read_text` also accepts `use_cache`
 - `exists()` / `is_file()` / `is_dir()`
 - `stat()` / `checksums()` (cloud backends)
 - `mkdir(parents, exist_ok)` / `touch(exist_ok)`

{asanypath-2.1.0 → asanypath-2.2.0}/hatch_build.py

@@ -15,6 +15,6 @@ class PinNativeHook(MetadataHookInterface):
         metadata["dependencies"] = [
             "anyio>=4",
             f"asanypath-native~={major}.{minor}.0",
-            "msgspec>=0.21.1",
+            "msgspec>=0.22.0",
             "yarl>=1.2",
         ]

{asanypath-2.1.0 → asanypath-2.2.0}/pyproject.toml

@@ -20,7 +20,7 @@ asanypath-native = { path = "rust" }
 root = "src"
 
 [tool.hatch.build.targets.sdist]
-exclude = ["rust"]
+exclude = ["rust", "uv.lock"]
 
 [tool.hatch.metadata.hooks.custom]
 
@@ -58,6 +58,7 @@ dev = [
 cli = ["rich-click>=1.9.7"]
 ftp = ["aioftp>=0.21"]
 credstore = ["keyring>=24"]
+cache = ["diskcache>=5.6"]
 bench = [
     "asyncssh>=2.14",
     "fsspec",
@@ -71,7 +72,7 @@ bench = [
     "aiofiles",
     "requests",
 ]
-all = ["asanypath[credstore,ftp]"]
+all = ["asanypath[credstore,ftp,cache]"]
 [project.scripts]
 asanypath = "asanypath.cli:main"
 
@@ -88,6 +89,9 @@ python_version = "3.10"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true
+# asanypath_native.pyi lives in rust/ (its canonical home, shipped in the native
+# wheel by maturin); keep it resolvable for dev type-checking.
+mypy_path = ["src", "rust"]
 
 [[tool.mypy.overrides]]
 module = "asanypath.cli"
@@ -99,7 +103,7 @@ disable_error_code = ["attr-defined", "arg-type", "assignment"]
 module = "asanypath.local"
 disallow_untyped_defs = false
 warn_return_any = false
-disable_error_code = ["type-var", "misc", "override", "return-value"]
+disable_error_code = ["type-var", "misc", "override", "return-value", "assignment", "no-redef"]
 
 [[tool.mypy.overrides]]
 module = "asanypath.common"
@@ -111,30 +115,46 @@ disable_error_code = ["arg-type", "assignment", "misc", "attr-defined"]
 module = "asanypath.http"
 disallow_untyped_defs = false
 warn_return_any = false
-disable_error_code = ["override", "type-arg", "return-value", "assignment"]
+disable_error_code = ["override", "type-arg", "return-value", "assignment", "attr-defined"]
 
 [[tool.mypy.overrides]]
 module = ["asanypath.s3", "asanypath.gcs", "asanypath.azure", "asanypath.artifactory"]
 disallow_untyped_defs = false
 warn_return_any = false
-disable_error_code = ["no-any-return", "attr-defined", "assignment", "override"]
+disable_error_code = ["no-any-return", "attr-defined", "assignment", "override", "arg-type", "misc"]
+
+[[tool.mypy.overrides]]
+module = ["asanypath.ssh", "asanypath.ftp"]
+disallow_untyped_defs = false
+warn_return_any = false
+disable_error_code = ["attr-defined", "override", "arg-type", "misc", "no-any-return", "assignment"]
+
+[[tool.mypy.overrides]]
+module = "asanypath.sync"
+disallow_untyped_defs = false
+warn_return_any = false
+disable_error_code = ["no-any-return", "misc", "attr-defined", "arg-type"]
 
 [[tool.mypy.overrides]]
 module = "asanypath.cloud"
 disallow_untyped_defs = false
 warn_return_any = false
-disable_error_code = ["no-any-return", "arg-type"]
+disable_error_code = ["no-any-return", "arg-type", "attr-defined", "misc", "assignment"]
 
 [[tool.mypy.overrides]]
 module = "asanypath.asanypath"
 disallow_untyped_defs = false
 warn_return_any = false
-disable_error_code = ["no-any-return", "misc", "union-attr", "type-var"]
+disable_error_code = ["no-any-return", "misc", "union-attr", "type-var", "attr-defined"]
 
 [[tool.mypy.overrides]]
 module = "asanypath.batcher"
 disallow_untyped_defs = false
 
+[[tool.mypy.overrides]]
+module = "diskcache.*"
+ignore_missing_imports = true
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]

{asanypath-2.1.0 → asanypath-2.2.0}/src/asanypath/__init__.py

@@ -13,6 +13,7 @@ from asanypath.asanypath import (
     register_protocol,
 )
 from asanypath.azure import AzurePath
+from asanypath.cache import configure_cache
 from asanypath.cloud import CloudPathMixin
 from asanypath.common import CommonPurePathMixin
 from asanypath.exceptions import (
@@ -62,6 +63,7 @@ __all__ = [
     "GCSPath",
     "AzurePath",
     "ArtifactoryPath",
+    "configure_cache",
     "register_protocol",
     "list_protocols",
     "AsAnyPathError",

asanypath-2.2.0/src/asanypath/_resume.py

@@ -0,0 +1,43 @@
+# 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.
+
+"""Sidecar state for resumable downloads.
+
+A partial download lives in ``<dst>.part`` with a ``<dst>.part.meta`` sidecar
+recording the remote object's identity (ETag/Last-Modified) and total size. On
+resume the identity is re-checked so a changed upstream object restarts cleanly
+rather than stitching mismatched bytes. State is plain files — no dependency on
+the optional download cache.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import msgspec
+
+
+class ResumeMeta(msgspec.Struct, frozen=True):
+    """Identity and size of the object a ``.part`` file is downloading."""
+
+    identity: str | None
+    size: int
+
+
+_encoder = msgspec.json.Encoder()
+_decoder = msgspec.json.Decoder(ResumeMeta)
+
+
+def read_meta(path: Path) -> ResumeMeta | None:
+    """Return the sidecar meta at *path*, or ``None`` if missing/corrupt."""
+    try:
+        return _decoder.decode(path.read_bytes())
+    except (OSError, msgspec.DecodeError):
+        return None
+
+
+def write_meta(path: Path, meta: ResumeMeta) -> None:
+    path.write_bytes(_encoder.encode(meta))

{asanypath-2.1.0 → asanypath-2.2.0}/src/asanypath/_transfer.py

@@ -15,6 +15,8 @@ from hashlib import sha256
 from pathlib import Path
 from typing import Any
 
+from asanypath.exceptions import UnsupportedProtocolError
+
 _CHECKSUM_PREFERENCE = ("sha256", "sha1", "md5")
 
 # Default streaming chunk size for chunk_size=None ("auto").
@@ -79,19 +81,25 @@ def _normalized_checksums(checksums: dict[str, str]) -> dict[str, str]:
 def is_remote_destination(dst: Any) -> bool:
     protocol = getattr(dst, "protocol", None)
     if protocol is not None:
-        return protocol != "file"
+        return bool(protocol != "file")
     value = str(dst)
     return "://" in value and not value.startswith("file:")
 
 
 def has_async_transfer_api(dst: Any) -> bool:
-    return inspect.iscoroutinefunction(
-        getattr(dst, "exists", None)
-    ) and inspect.iscoroutinefunction(getattr(dst, "write_bytes", None))
+    try:
+        exists = getattr(dst, "exists", None)
+        write_bytes = getattr(dst, "write_bytes", None)
+    except UnsupportedProtocolError:
+        return False
+    return inspect.iscoroutinefunction(exists) and inspect.iscoroutinefunction(write_bytes)
 
 
 def has_write_api(dst: Any) -> bool:
-    return callable(getattr(dst, "write_bytes", None))
+    try:
+        return callable(getattr(dst, "write_bytes", None))
+    except UnsupportedProtocolError:
+        return False
 
 
 def run_sync_maybe(value: Any) -> Any:

{asanypath-2.1.0 → asanypath-2.2.0}/src/asanypath/_version.py

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