pathlib-next 0.8.2__tar.gz → 0.8.3__tar.gz

{pathlib_next-0.8.2 → pathlib_next-0.8.3}/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.8.3] - 2026-07-18
+
+### Changed
+- **`AsyncsshSftpBackend` default `max_concurrency` raised 8 → 16.** A 128-file
+  loopback recursive-copy/rm sweep of `mc ∈ {1,2,4,8,16}` (median of 3) showed
+  recursive copy improving monotonically with concurrency (mc=8→16 ≈3% faster on
+  top of mc=1→8 ≈1.13x) and recursive remove flat within noise, with 16
+  fastest-or-tied and well inside asyncssh's SFTP request window. Exposed as
+  `AsyncsshSftpBackend.DEFAULT_MAX_CONCURRENCY`; pass `max_concurrency=` to
+  override. Loopback evidence only — a high-latency remote link may warrant a
+  different value; 16 is a safe modest default, not a tuned optimum.
+
 ## [0.8.2] - 2026-07-18
 
 ### Fixed
@@ -495,7 +507,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 - Sync error handling.
 - Generic Path Protocol based pathlib implementation for URI paths with file access support for sftp, http, file schemes.
 
-[Unreleased]: https://github.com/jose-pr/pathlib_next/compare/v0.8.2...HEAD
+[Unreleased]: https://github.com/jose-pr/pathlib_next/compare/v0.8.3...HEAD
+[0.8.3]: https://github.com/jose-pr/pathlib_next/compare/v0.8.2...v0.8.3
 [0.8.2]: https://github.com/jose-pr/pathlib_next/compare/v0.8.1...v0.8.2
 [0.8.1]: https://github.com/jose-pr/pathlib_next/compare/v0.8.0...v0.8.1
 [0.8.0]: https://github.com/jose-pr/pathlib_next/compare/v0.7.0...v0.8.0

{pathlib_next-0.8.2 → pathlib_next-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathlib_next
-Version: 0.8.2
+Version: 0.8.3
 Summary: Generic Path Protocol based pathlib
 Project-URL: Homepage, https://github.com/jose-pr/pathlib_next/
 Project-URL: Documentation, https://jose-pr.github.io/pathlib_next/

{pathlib_next-0.8.2 → pathlib_next-0.8.3}/docs/benchmarks.md

@@ -142,6 +142,16 @@ Legend: `p` = `paramiko`, `a` = `asyncssh`.
   was fastest at `7.6068s`, with `4` at `14.2806s` and `8` at `13.3736s`.
   Treat this as workload-specific follow-up evidence, not as a default tuning
   decision.
+- **2026-07-18 (0.8.3): `AsyncsshSftpBackend` default `max_concurrency` raised
+  8 → 16.** A cleaner 128-file loopback sweep of `mc ∈ {1,2,4,8,16}` (median of
+  3, py3.14) showed recursive copy improving *monotonically* with concurrency
+  (mc=1 `1.66s` → mc=8 `1.47s` ≈ 1.13x → mc=16 `1.42s`, a further ≈3%), and
+  recursive remove flat within noise (median spread `0.498`..`0.551`, mc=16
+  marginally best). This supersedes the earlier "mc=1 fastest" loopback reading
+  (from the older code path / a different venv). 16 stays within asyncssh's SFTP
+  request window. **Loopback only** — no per-op latency; a high-latency remote
+  link may favour higher concurrency still, so 16 is a safe modest default, not
+  a tuned optimum. Override per backend via `AsyncsshSftpBackend(max_concurrency=…)`.
 - `python benchmarks/bench.py syncer` on the same local run reported
   PathSyncer copy of 128 local files at `0.4524s`, dry-run at `0.0534s`, and
   remove-missing plus copy at `0.9260s`. This suggests metadata reuse may be

{pathlib_next-0.8.2 → pathlib_next-0.8.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pathlib_next"
-version = "0.8.2"
+version = "0.8.3"
 authors = [{ name = "Jose A" }]
 description = "Generic Path Protocol based pathlib"
 readme = "README.md"

{pathlib_next-0.8.2 → pathlib_next-0.8.3}/src/pathlib_next/uri/schemes/sftp/_asyncssh.py

@@ -482,14 +482,28 @@ class AsyncsshSftpBackend(BaseSftpBackend):
     #: real-world OpenSSH v3 servers, or the standard opcode against v5/v6).
     supports_hardlink = True
 
+    #: Default bound on concurrent SFTP requests during a recursive copy/rm.
+    #: 16 (raised from 8 in 0.8.3): a 128-file loopback sweep of mc in
+    #: {1,2,4,8,16} (median of 3, 3.14) showed recursive copy improving
+    #: monotonically with concurrency -- mc=1 -> mc=8 ~1.13x, mc=8 -> mc=16 a
+    #: further ~3% -- with recursive rm flat (spread within run-to-run noise) and
+    #: mc=16 fastest-or-tied for both. 16 stays well inside asyncssh's SFTP
+    #: request window, so the extra in-flight requests carry no overload risk.
+    #: NOTE: loopback evidence only (no per-op network latency); a high-latency
+    #: remote link may favour even higher concurrency, but 16 is a safe, modest
+    #: default. Override per-backend via ``max_concurrency=``.
+    DEFAULT_MAX_CONCURRENCY = 16
+
     def __init__(
         self,
         connect_opts: "dict[str, _ty.Any] | None" = None,
         *,
-        max_concurrency: int = 8,
+        max_concurrency: "int | None" = None,
         sftp_version: int = 4,
         ssh_config=_DEFAULT_SSH_CONFIG,
     ):
+        if max_concurrency is None:
+            max_concurrency = self.DEFAULT_MAX_CONCURRENCY
         self.connect_opts = {} if connect_opts is None else dict(connect_opts)
         if "config" not in self.connect_opts:
             if ssh_config is None:

{pathlib_next-0.8.2 → pathlib_next-0.8.3}/tests/test_sftp_asyncssh.py

@@ -293,9 +293,12 @@ def test_asyncssh_backend_has_max_concurrency():
     assert backend.max_concurrency == 16
 
 
-def test_asyncssh_backend_max_concurrency_defaults_to_8():
+def test_asyncssh_backend_max_concurrency_defaults_to_16():
+    # Raised from 8 to 16 in 0.8.3 (loopback recursive-copy sweep); see
+    # DEFAULT_MAX_CONCURRENCY's rationale in _asyncssh.py.
     backend = backend_mod.AsyncsshSftpBackend()
-    assert backend.max_concurrency == 8
+    assert backend.max_concurrency == 16
+    assert backend.max_concurrency == backend_mod.AsyncsshSftpBackend.DEFAULT_MAX_CONCURRENCY
     assert "config" not in backend.connect_opts
 
 
@@ -757,3 +760,14 @@ def test_sftppath_rm_recursive_uses_concurrent_helper(monkeypatch):
     assert recorded["kwargs"]["max_concurrency"] == 6
     assert recorded["kwargs"]["missing_ok"] is True
     assert recorded["kwargs"]["on_error"](ValueError("ignored"), src) is True
+
+
+# --- default max_concurrency -------------------------------------------------
+
+
+def test_explicit_max_concurrency_overrides_default():
+    backend = backend_mod.AsyncsshSftpBackend({"config": None}, max_concurrency=4)
+    assert backend.max_concurrency == 4
+    # 0 is honored as given (the async helpers clamp to >=1 at use time via
+    # `max(1, max_concurrency)`), not silently replaced by the default.
+    assert backend_mod.AsyncsshSftpBackend({"config": None}, max_concurrency=1).max_concurrency == 1