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

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

@@ -7,6 +7,64 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.8.2] - 2026-07-18
+
+### Fixed
+- **`SftpPath` could not be imported or used with an asyncssh-only install
+  (no `paramiko`).** `uri/schemes/sftp/__init__.py` imported `._paramiko`
+  eagerly at module load, and `_asyncssh.py` imported the
+  `_DEFAULT_SSH_CONFIG` sentinel from `._paramiko`, so merely importing
+  `SftpPath` (or the `AsyncsshSftpBackend`) required `paramiko` even when the
+  caller only wanted the asyncssh backend from the `sftp-async` extra. The
+  paramiko-free bits (the sentinel + config-path normalization) moved to a new
+  `_sshconfig` module, and the paramiko `SftpBackend` is now imported lazily
+  (via `_probe_paramiko`, mirroring `_probe_asyncssh`) only when actually
+  selected. `SftpBackend`/`_DEFAULT_SSH_CONFIG` remain importable from the
+  scheme package (PEP 562 `__getattr__`) for backward compatibility.
+  `PATHLIB_NEXT_SFTP_BACKEND=paramiko` (or `auto` with neither library) now
+  raises a clear `ImportError` naming the missing extra instead of a bare
+  `ModuleNotFoundError` at import time. Regression test added
+  (`test_sftp_scheme_imports_and_resolves_without_paramiko`, runs in a
+  paramiko-masked subprocess).
+
+## [0.8.1] - 2026-07-16
+
+### Fixed
+- **`LocalPath.walk()`/`rm()` raised `TypeError: cannot unpack non-iterable
+  DirEntry object` on Python 3.11/3.12.** Those stdlib versions define their
+  own `pathlib.Path._scandir()` (returning raw `os.scandir()` `DirEntry`
+  objects), which sits ahead of this project's `_scandir()` in `LocalPath`'s
+  MRO and silently shadowed it -- breaking the `(name, FileStat|None)`
+  contract `walk()`/`glob()`/`rm()` expect. `LocalPath` now defines its own
+  `_scandir()` explicitly, reusing each `DirEntry`'s cached `lstat()` so the
+  perf win from `_scandir()` unification is preserved. On 3.12+, stdlib
+  `pathlib.Path` also defines its own `walk()` ahead of ours in the MRO, and
+  that stdlib `walk()` treats `self._scandir()`'s return value as a context
+  manager (`with scandir_it:`) -- our own `_scandir()` is a plain generator,
+  so stdlib's `walk()` raised `TypeError: 'generator' object does not
+  support the context manager protocol` even with the override above.
+  `LocalPath` now also overrides `walk()` explicitly, routing to this
+  project's own implementation regardless of Python version. Introduced in
+  0.8.0 (`8cdbefa`), exposed on the CI 3.11/3.12 legs.
+- **`Test No-Extras` CI job was red.** `tests/test_smoke.py` unconditionally
+  constructed an `http://`/`sftp://` `UriPath` in two tests, requiring
+  `requests`/`paramiko` even though the no-extras job installs neither; a
+  third test wrongly assumed `S3Path` requires `boto3` to register (it only
+  needs `botocore`, imported lazily inside a method). The two hard tests now
+  `pytest.importorskip` their extra; the `S3Path` check now probes for
+  `botocore`. Introduced in 0.8.0 (`94bd545`/`8cdbefa`), fixed with the
+  expected skip count (2) verified in a real no-extras venv.
+- **Importable on a clean Python 3.9 install.** `pathlib_next.utils` used
+  `typing.ParamSpec` (3.10+), falling back to `typing_extensions.ParamSpec` and
+  then to a bare `typing.TypeVar`. A `TypeVar` has no `.args`, so the
+  `*args: K.args` annotations raised `AttributeError: 'TypeVar' object has no
+  attribute 'args'` at import time, making `import pathlib_next` fail on 3.9
+  whenever `typing_extensions` was absent. Since `typing_extensions` is not a
+  runtime dependency, this broke a plain `pip install pathlib_next` on 3.9. The
+  final fallback is now a minimal `ParamSpec` shim providing `.args`/`.kwargs`,
+  so no runtime dependency is added and 3.10+ keeps using `typing.ParamSpec`
+  unchanged.
+
 ## [0.8.0] - 2026-07-13
 
 ### Added
@@ -437,7 +495,10 @@ 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.7.0...HEAD
+[Unreleased]: https://github.com/jose-pr/pathlib_next/compare/v0.8.2...HEAD
+[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
 [0.7.0]: https://github.com/jose-pr/pathlib_next/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/jose-pr/pathlib_next/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/jose-pr/pathlib_next/compare/v0.4.1...v0.5.0

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathlib_next
-Version: 0.8.0
+Version: 0.8.2
 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.0 → pathlib_next-0.8.2}/pyproject.toml

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

{pathlib_next-0.8.0 → pathlib_next-0.8.2}/src/pathlib_next/fspath.py

@@ -11,6 +11,7 @@ import types as _types
 import typing as _ty
 
 from . import path as _proto
+from .utils.stat import FileStat as _FileStat
 
 # pathlib.Path.stat()/chmod() only accept follow_symlinks= on 3.10+; below
 # that, LocalPath (which inherits them directly from pathlib.Path via MRO,
@@ -84,6 +85,36 @@ class LocalPath(
 
     __slots__ = ()
 
+    def _scandir(self):
+        # On 3.11+, `pathlib.Path._scandir()` (stdlib, ahead of ours in the
+        # MRO via WindowsPath/PosixPath) shadows `_proto.Path._scandir()`
+        # and returns `os.scandir(self)` directly -- an iterator of raw
+        # `os.DirEntry`, not this project's `(name, FileStat|None)` tuples.
+        # walk()/glob() expect the latter, so re-assert our own contract
+        # here regardless of what stdlib does in a given version. DirEntry's
+        # own cached lstat (`follow_symlinks=False`, matching walk()'s
+        # default) is reused instead of a fresh stat() round trip.
+        for entry in _os.scandir(self):
+            try:
+                stat = _FileStat.from_stat(entry.stat(follow_symlinks=False))
+            except OSError:
+                stat = None
+            yield entry.name, stat
+
+    def walk(self, top_down=True, on_error=None, follow_symlinks=False):
+        # 3.12+ stdlib `pathlib.Path.walk()` sits ahead of ours in the MRO
+        # and would otherwise win here. Its implementation calls
+        # `self._scandir()` expecting stdlib's own context-manager-capable
+        # `os.scandir(self)` return value ("with scandir_it:") -- our
+        # `_scandir()` override above is a plain generator, so stdlib's
+        # `walk()` breaks on it (`TypeError: 'generator' object does not
+        # support the context manager protocol`). Route explicitly to our
+        # own `walk()` (which drives `_scandir()` correctly) regardless of
+        # which one the MRO would otherwise resolve to.
+        return _proto.Path.walk(
+            self, top_down=top_down, on_error=on_error, follow_symlinks=follow_symlinks
+        )
+
     def stat(self, *, follow_symlinks=True):
         # pathlib.Path.stat() (next in MRO via WindowsPath/PosixPath) only
         # accepts follow_symlinks= on 3.10+; below that, lstat() is the

{pathlib_next-0.8.0 → pathlib_next-0.8.2}/src/pathlib_next/uri/schemes/sftp/__init__.py

@@ -32,7 +32,9 @@ class BaseSftpBackend(object):
     def client(self, source: Source): ...
 
 
-from ._paramiko import _DEFAULT_SSH_CONFIG, SftpBackend as SftpBackend  # noqa: E402
+# The default-config sentinel is paramiko-free (lives in `_sshconfig`) so
+# importing this scheme never pulls paramiko in just to have the sentinel.
+from ._sshconfig import _DEFAULT_SSH_CONFIG
 
 
 # --- backend selection -----------------------------------------------------
@@ -41,10 +43,18 @@ from ._paramiko import _DEFAULT_SSH_CONFIG, SftpBackend as SftpBackend  # noqa:
 # UriPath backend propagation works, unchanged) > `SftpPath._default_backend_cls`
 # class attribute > `PATHLIB_NEXT_SFTP_BACKEND` env var > auto-detect
 # (asyncssh if importable, else paramiko).
+#
+# BOTH backends are imported lazily (`_probe_asyncssh`/`_probe_paramiko`): merely
+# importing this scheme -- which happens for every `sftp:` URL and for
+# `from ...sftp import SftpPath` -- must not require *either* SSH library. In
+# particular an asyncssh-only install (the `sftp-async` extra, no paramiko) must
+# be able to import and use `SftpPath`; eagerly importing `._paramiko` here broke
+# exactly that.
 
 _ENV_VAR = "PATHLIB_NEXT_SFTP_BACKEND"
-_BACKEND_REGISTRY: "dict[str, type[BaseSftpBackend]]" = {"paramiko": SftpBackend}
+_BACKEND_REGISTRY: "dict[str, type[BaseSftpBackend]]" = {}
 _asyncssh_probed = False
+_paramiko_probed = False
 _resolved_backend_cls: "type[BaseSftpBackend] | None" = None
 
 
@@ -64,47 +74,79 @@ def _probe_asyncssh() -> None:
     _BACKEND_REGISTRY["asyncssh"] = AsyncsshSftpBackend
 
 
+def _probe_paramiko() -> None:
+    # Symmetric with `_probe_asyncssh`: only import paramiko when it is actually
+    # needed (paramiko selected, or auto-detect with asyncssh unavailable), so an
+    # asyncssh-only install never imports paramiko.
+    global _paramiko_probed
+    if _paramiko_probed:
+        return
+    _paramiko_probed = True
+    try:
+        from ._paramiko import SftpBackend
+    except ImportError:
+        return
+    _BACKEND_REGISTRY["paramiko"] = SftpBackend
+
+
 def _resolve_default_backend_cls(reload: bool = False) -> "type[BaseSftpBackend]":
     global _resolved_backend_cls
     if not reload and _resolved_backend_cls is not None:
         return _resolved_backend_cls
     value = _os.environ.get(_ENV_VAR, "auto")
     if value == "paramiko":
+        _probe_paramiko()
+        if "paramiko" not in _BACKEND_REGISTRY:
+            raise ImportError(
+                f"{_ENV_VAR}=paramiko but the paramiko package is not "
+                "installed -- install the 'sftp' extra, or unset "
+                f"{_ENV_VAR} to auto-detect (uses asyncssh if available)."
+            )
         cls = _BACKEND_REGISTRY["paramiko"]
-    else:
+    elif value == "asyncssh":
         _probe_asyncssh()
-        if value == "auto":
-            cls = _BACKEND_REGISTRY.get("asyncssh") or _BACKEND_REGISTRY["paramiko"]
-        elif value == "asyncssh":
-            if "asyncssh" not in _BACKEND_REGISTRY:
-                # Fail loud -- a silent fallback to paramiko would hide a
-                # deployment misconfiguration (asyncssh extra not installed
-                # where the operator explicitly asked for it).
-                raise ImportError(
-                    f"{_ENV_VAR}=asyncssh but the asyncssh package is not "
-                    "installed -- install the 'sftp-async' extra, or unset "
-                    f"{_ENV_VAR} to auto-detect (falls back to paramiko)."
-                )
-            cls = _BACKEND_REGISTRY["asyncssh"]
-        else:
-            raise ValueError(
-                f"{_ENV_VAR}={value!r} is not a recognized SFTP backend "
-                f"(expected one of {sorted({'auto', *_BACKEND_REGISTRY})!r})"
+        if "asyncssh" not in _BACKEND_REGISTRY:
+            # Fail loud -- a silent fallback to paramiko would hide a
+            # deployment misconfiguration (asyncssh extra not installed
+            # where the operator explicitly asked for it).
+            raise ImportError(
+                f"{_ENV_VAR}=asyncssh but the asyncssh package is not "
+                "installed -- install the 'sftp-async' extra, or unset "
+                f"{_ENV_VAR} to auto-detect (falls back to paramiko)."
+            )
+        cls = _BACKEND_REGISTRY["asyncssh"]
+    elif value == "auto":
+        _probe_asyncssh()
+        if "asyncssh" not in _BACKEND_REGISTRY:
+            _probe_paramiko()
+        cls = _BACKEND_REGISTRY.get("asyncssh") or _BACKEND_REGISTRY.get("paramiko")
+        if cls is None:
+            raise ImportError(
+                "no SFTP backend available -- install the 'sftp-async' "
+                "(asyncssh) or 'sftp' (paramiko) extra."
             )
+    else:
+        raise ValueError(
+            f"{_ENV_VAR}={value!r} is not a recognized SFTP backend "
+            "(expected one of 'auto', 'asyncssh', 'paramiko')"
+        )
     _resolved_backend_cls = cls
     return cls
 
 
 def __getattr__(name: str):
-    # PEP 562 lazy module attribute: `from .sftp import AsyncsshSftpBackend`
-    # (or `sftp.AsyncsshSftpBackend`) only imports asyncssh at the point
-    # it's actually referenced -- importing `pathlib_next.uri.schemes.sftp`
-    # itself (which happens for every `sftp:` URL, regardless of which
-    # backend ends up selected) must not eagerly import asyncssh.
+    # PEP 562 lazy module attributes: referencing `AsyncsshSftpBackend`,
+    # `SftpBackend` (paramiko), or `_DEFAULT_SSH_CONFIG` via
+    # `from .sftp import ...` imports the relevant backend only at that point --
+    # importing the scheme module itself pulls in neither SSH library.
     if name == "AsyncsshSftpBackend":
         from ._asyncssh import AsyncsshSftpBackend
 
         return AsyncsshSftpBackend
+    if name == "SftpBackend":
+        from ._paramiko import SftpBackend
+
+        return SftpBackend
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 

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

@@ -15,7 +15,7 @@ import asyncssh as _asyncssh
 from ... import Source
 from ....utils.stat import FileStat
 from . import BaseSftpBackend
-from ._paramiko import _DEFAULT_SSH_CONFIG
+from ._sshconfig import _DEFAULT_SSH_CONFIG
 
 # --- shared background event loop -------------------------------------
 # asyncssh is asyncio-only end to end (connect(), every SFTPClient method,

{pathlib_next-0.8.0 → pathlib_next-0.8.2}/src/pathlib_next/uri/schemes/sftp/_paramiko.py

@@ -9,20 +9,11 @@ from .... import utils as _utils
 from ... import Source
 from . import BaseSftpBackend
 
-
-_DEFAULT_SSH_CONFIG = object()
-
-
-def _normalize_config_paths(
-    ssh_config: "object",
-) -> "tuple[str, ...] | None":
-    if ssh_config is _DEFAULT_SSH_CONFIG:
-        return (str(_pathlib.Path.home() / ".ssh" / "config"),)
-    if ssh_config is None:
-        return None
-    if isinstance(ssh_config, (str, _pathlib.PurePath)):
-        return (str(ssh_config),)
-    return tuple(str(path) for path in ssh_config)
+# The sentinel + path normalization are paramiko-free and now live in
+# ``_sshconfig`` so the asyncssh backend and the scheme ``__init__`` can use them
+# without importing paramiko. Re-exported here for backward compatibility (older
+# code did ``from ._paramiko import _DEFAULT_SSH_CONFIG``).
+from ._sshconfig import _DEFAULT_SSH_CONFIG, _normalize_config_paths
 
 
 @_utils.LRU

pathlib_next-0.8.2/src/pathlib_next/uri/schemes/sftp/_sshconfig.py

@@ -0,0 +1,34 @@
+"""Backend-agnostic SSH-config helpers (no paramiko/asyncssh import).
+
+The default-config sentinel and path normalization live here, separate from
+``_paramiko.py``, so the asyncssh backend and the scheme's ``__init__`` can
+reference them **without importing paramiko**. Only the actual config *parsing*
+(``_load_ssh_config``/``_lookup_ssh_config`` in ``_paramiko.py``) needs
+``paramiko.SSHConfig``; the sentinel and the "which files" logic do not.
+"""
+
+from __future__ import annotations
+
+import pathlib as _pathlib
+
+#: Sentinel meaning "use the default SSH config location(s)". A bare ``object()``
+#: so it is distinct from ``None`` (explicitly no config) and from any real path.
+#: Shared by both backends; kept paramiko-free on purpose (see module docstring).
+_DEFAULT_SSH_CONFIG = object()
+
+
+def _normalize_config_paths(
+    ssh_config: "object",
+) -> "tuple[str, ...] | None":
+    """Resolve an ``ssh_config`` argument to a tuple of file paths, or ``None``.
+
+    ``_DEFAULT_SSH_CONFIG`` -> the user's ``~/.ssh/config``; ``None`` -> no config;
+    a str/path -> that one file; an iterable -> those files. No paramiko needed.
+    """
+    if ssh_config is _DEFAULT_SSH_CONFIG:
+        return (str(_pathlib.Path.home() / ".ssh" / "config"),)
+    if ssh_config is None:
+        return None
+    if isinstance(ssh_config, (str, _pathlib.PurePath)):
+        return (str(ssh_config),)
+    return tuple(str(path) for path in ssh_config)

{pathlib_next-0.8.0 → pathlib_next-0.8.2}/src/pathlib_next/utils/__init__.py

@@ -6,12 +6,29 @@ from email.utils import parsedate as _parsedate
 from threading import RLock
 
 try:
-    ParamSpec = _ty.ParamSpec
+    ParamSpec = _ty.ParamSpec  # 3.10+
 except AttributeError:
     try:
         from typing_extensions import ParamSpec
     except ImportError:
-        ParamSpec = _ty.TypeVar
+
+        class ParamSpec(_ty.TypeVar, _root=True):
+            """Minimal `ParamSpec` stand-in for 3.9 without `typing_extensions`.
+
+            Only the `.args` / `.kwargs` attributes are needed: they appear in
+            annotations that must merely *evaluate*, and a plain `TypeVar` has
+            neither. `typing_extensions` is not a runtime dependency, so the
+            fallback keeps a bare 3.9 install importable.
+            """
+
+            @property
+            def args(self):
+                return self
+
+            @property
+            def kwargs(self):
+                return self
+
 
 K = ParamSpec("K")
 V = _ty.TypeVar("V")

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

@@ -137,6 +137,13 @@ def _reset_backend_resolution(monkeypatch):
 
 from pathlib_next.uri.schemes import sftp as sftp_pkg  # noqa: E402
 
+import importlib.util as _importutil  # noqa: E402
+
+_HAS_PARAMIKO = _importutil.find_spec("paramiko") is not None
+_needs_paramiko = pytest.mark.skipif(
+    not _HAS_PARAMIKO, reason="paramiko not installed (asyncssh-only install)"
+)
+
 
 def test_resolve_default_backend_auto_prefers_asyncssh(monkeypatch):
     monkeypatch.delenv(sftp_pkg._ENV_VAR, raising=False)
@@ -144,6 +151,7 @@ def test_resolve_default_backend_auto_prefers_asyncssh(monkeypatch):
     assert cls is backend_mod.AsyncsshSftpBackend
 
 
+@_needs_paramiko
 def test_resolve_default_backend_explicit_paramiko(monkeypatch):
     monkeypatch.setenv(sftp_pkg._ENV_VAR, "paramiko")
     cls = sftp_pkg._resolve_default_backend_cls(reload=True)
@@ -164,7 +172,6 @@ def test_resolve_default_backend_invalid_value_raises(monkeypatch):
 
 def test_resolve_default_backend_asyncssh_unavailable_raises_importerror(monkeypatch):
     monkeypatch.setenv(sftp_pkg._ENV_VAR, "asyncssh")
-    monkeypatch.setitem(sftp_pkg._BACKEND_REGISTRY, "paramiko", sftp_pkg.SftpBackend)
     monkeypatch.delitem(sftp_pkg._BACKEND_REGISTRY, "asyncssh", raising=False)
     monkeypatch.setattr(sftp_pkg, "_asyncssh_probed", True)  # skip the real probe
     with pytest.raises(ImportError, match="sftp-async"):
@@ -172,13 +179,16 @@ def test_resolve_default_backend_asyncssh_unavailable_raises_importerror(monkeyp
 
 
 def test_resolve_default_backend_result_is_cached(monkeypatch):
-    monkeypatch.setenv(sftp_pkg._ENV_VAR, "paramiko")
-    first = sftp_pkg._resolve_default_backend_cls(reload=True)
+    # asyncssh first (always available in this test module), then flip the env
+    # and confirm no-reload returns the cached asyncssh result.
     monkeypatch.setenv(sftp_pkg._ENV_VAR, "asyncssh")
+    first = sftp_pkg._resolve_default_backend_cls(reload=True)
+    monkeypatch.setenv(sftp_pkg._ENV_VAR, "auto")
     second = sftp_pkg._resolve_default_backend_cls()  # no reload -- cached
-    assert first is second is sftp_pkg.SftpBackend
+    assert first is second is backend_mod.AsyncsshSftpBackend
 
 
+@_needs_paramiko
 def test_default_backend_cls_class_attribute_wins_over_env(monkeypatch):
     monkeypatch.setenv(sftp_pkg._ENV_VAR, "asyncssh")
 
@@ -191,6 +201,42 @@ def test_default_backend_cls_class_attribute_wins_over_env(monkeypatch):
     assert isinstance(backend, sftp_pkg.SftpBackend)
 
 
+def test_sftp_scheme_imports_and_resolves_without_paramiko():
+    """Regression: an asyncssh-only install (no paramiko) must still import
+    SftpPath and auto-resolve to the asyncssh backend.
+
+    Runs in a subprocess with ``paramiko`` masked (blocked in sys.modules) so the
+    guard holds even in a CI env where paramiko happens to be installed. Before
+    the fix, ``uri/schemes/sftp/__init__`` imported ``._paramiko`` eagerly, so
+    merely importing ``SftpPath`` raised ModuleNotFoundError without paramiko.
+    """
+    import subprocess
+    import sys
+    import textwrap
+
+    script = textwrap.dedent(
+        """
+        import sys
+        # Make `import paramiko` fail, simulating an asyncssh-only install.
+        sys.modules["paramiko"] = None
+        from pathlib_next.uri.schemes.sftp import SftpPath
+        from pathlib_next.uri.schemes import sftp as pkg
+        sp = SftpPath("sftp://root@h:22/etc/hosts")
+        assert sp.source.host == "h" and sp.path == "/etc/hosts"
+        cls = pkg._resolve_default_backend_cls(reload=True)
+        assert cls.__name__ == "AsyncsshSftpBackend", cls
+        print("OK")
+        """
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, result.stderr
+    assert "OK" in result.stdout
+
+
 def test_explicit_backend_kwarg_wins_over_everything(monkeypatch):
     monkeypatch.setenv(sftp_pkg._ENV_VAR, "asyncssh")
     explicit = backend_mod.AsyncsshSftpBackend()
@@ -219,6 +265,7 @@ def test_asyncssh_backend_supports_lchmod_and_hardlink():
     assert backend.supports_hardlink is True
 
 
+@_needs_paramiko
 def test_paramiko_backend_does_not_support_lchmod_or_hardlink():
     assert sftp_pkg.SftpBackend.supports_lchmod is False
     assert sftp_pkg.SftpBackend.supports_hardlink is False

{pathlib_next-0.8.0 → pathlib_next-0.8.2}/tests/test_smoke.py

@@ -4,6 +4,8 @@ These are the snippets from README.md's Quick start and examples/example.py
 that don't touch the network. On Python 3.9 this file is expected to fail
 until the Python 3.9 compatibility work lands.
 """
+import pytest
+
 import pathlib_next
 from pathlib_next import Path, glob
 from pathlib_next.mempath import MemPath
@@ -27,6 +29,7 @@ def test_readme_local_path():
 
 
 def test_readme_http_path_construct_only():
+    pytest.importorskip("requests")
     http_path = UriPath("http://example.com/data.txt")
     assert http_path.source.scheme == "http"
 
@@ -80,6 +83,7 @@ def test_example_uripath_norm():
 
 
 def test_example_uripath_sftp_join():
+    pytest.importorskip("paramiko")
     sftp_root = UriPath("sftp://root@sftpexample/")
     sftp_root.as_posix()
     authkeys = sftp_root / "root/.ssh/authorized_keys"
@@ -104,16 +108,21 @@ def test_optional_schemes_presence_or_absence():
     except ImportError:
         assert not hasattr(schemes, "HttpPath")
 
-    # Check sftp
-    try:
-        import paramiko  # noqa: F401
-        assert hasattr(schemes, "SftpPath")
-    except ImportError:
-        assert not hasattr(schemes, "SftpPath")
+    # Check sftp: as of 0.8.2 importing SftpPath no longer requires an SSH
+    # backend (paramiko/asyncssh) -- those are resolved lazily at USE time. The
+    # scheme is a UriPath, so its import gate is `uritools` (the `uri` extra);
+    # SftpPath is present exactly when that is importable. Using it without any
+    # SSH backend installed is what raises (covered by the backend-selection
+    # tests), not importing it.
+    import importlib.util as _importutil
+
+    _has_uri = _importutil.find_spec("uritools") is not None
+    assert hasattr(schemes, "SftpPath") == _has_uri
 
-    # Check s3
+    # Check s3 -- S3Path only needs botocore at import time (boto3 itself is
+    # a lazy import inside S3Backend.client()), so that's what gates it.
     try:
-        import boto3  # noqa: F401
+        import botocore  # noqa: F401
         assert hasattr(schemes, "S3Path")
     except ImportError:
         assert not hasattr(schemes, "S3Path")

{pathlib_next-0.8.0 → pathlib_next-0.8.2}/tests/test_utils.py

@@ -1,3 +1,8 @@
+import pathlib
+import subprocess
+import sys
+import textwrap
+
 import pytest
 
 from pathlib_next import utils
@@ -306,3 +311,59 @@ def test_detect_format_does_not_peek_when_extension_is_conclusive():
     assert _detect_format("a.tar", _boom) == "tar"
 
 
+
+
+@pytest.mark.skipif(
+    sys.version_info >= (3, 10),
+    reason="the ParamSpec fallback is only reachable on 3.9 (3.10+ has typing.ParamSpec)",
+)
+def test_paramspec_fallback_importable_without_typing_extensions():
+    # Regression: on Python 3.9 `typing.ParamSpec` does not exist, so the module
+    # falls back to `typing_extensions.ParamSpec` and, failing that, to a local
+    # shim. The old fallback was a bare `TypeVar`, which has no `.args`, so the
+    # `*args: K.args` annotations raised `AttributeError: 'TypeVar' object has no
+    # attribute 'args'` at import. It went unnoticed because every dev/CI env had
+    # `typing_extensions` installed transitively -- but it is not a runtime
+    # dependency, so a clean 3.9 install of the package could not import it.
+    #
+    # 3.9-only by nature, not by convenience: `Generic[K, V]` on 3.9 rejects a
+    # plain object ("Parameters to generic types must be types"), so the shim must
+    # subclass `TypeVar` -- and `TypeVar` stopped being subclassable in 3.12. The
+    # branch is unreachable on 3.10+ anyway, since `typing.ParamSpec` exists there.
+    #
+    # Runs in a subprocess with `typing_extensions` blocked so the fallback is
+    # exercised for real rather than mocked.
+    probe = textwrap.dedent(
+        """
+        import builtins
+
+        _real_import = builtins.__import__
+
+        def _blocked(name, *a, **k):
+            if name == "typing_extensions":
+                raise ImportError("emulating an env without typing_extensions")
+            return _real_import(name, *a, **k)
+
+        builtins.__import__ = _blocked
+
+        from pathlib_next.utils import LRU, K
+
+        assert K.args is not None, "ParamSpec fallback lost .args"
+        assert K.kwargs is not None, "ParamSpec fallback lost .kwargs"
+        lru = LRU(lambda x: x * 2, maxsize=4)
+        assert lru(21) == 42
+        assert lru(21) == 42
+        lru.invalidate(21)
+        assert lru(21) == 42
+        print("FALLBACK_OK")
+        """
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", probe],
+        capture_output=True,
+        text=True,
+        cwd=pathlib.Path(utils.__file__).parents[3],
+    )
+    assert "FALLBACK_OK" in result.stdout, (
+        f"fallback import failed:\nstdout={result.stdout}\nstderr={result.stderr}"
+    )