pathlib-next 0.9.1__tar.gz → 0.9.3__tar.gz

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/CHANGELOG.md

@@ -5,6 +5,97 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [Unreleased]
+
+## [0.9.3] - 2026-08-16
+
+### Fixed
+- **A `str` destination to `rename()`/`symlink_to()` was re-parsed as a URI,
+  so part of it was silently discarded.** Every scheme resolved the
+  destination by feeding it back through the URI parser
+  (`Uri(self.parent, target)` for `rename()`, `type(self)(target)` inside
+  `Path.symlink_to()`). That reads a **decoded filesystem path** as URI
+  syntax: everything from a `?` or `#` onward became a query/fragment and was
+  dropped, `%xx` was percent-decoded, and a relative destination whose first
+  segment ended in `:` was read as a *scheme*. Measured against a real SFTP
+  server (TrueNAS 26.0.0-BETA.1):
+
+  | call | file/link actually produced |
+  | --- | --- |
+  | `rename(".../rn?b.txt")` | `.../rn` |
+  | `rename(".../rn%20b.txt")` | `.../rn b.txt` |
+  | `symlink_to(".../cache?v=2")` | link points at `.../cache` |
+  | `rename("C:/Temp/x.txt")` | `/Temp/x.txt` (`C:` taken as a scheme) |
+
+  Nothing raised. When something already occupied the truncated name the call
+  instead failed with a bare `OSError: Failure`, so the symptom was either
+  silent misplacement or an unexplained error depending on what happened to
+  be there. Downstream, `pytruenas`'s documented
+  `client.path(x).symlink_to(y)` route created a wrong link, and
+  `PathSyncer`'s `symlink_mode="preserve"` (which hands `symlink_to()` the
+  raw target string `readlink()` returned) mirrored such a link to the wrong
+  place.
+
+  A `str` destination is now taken as an already-decoded path — `?`, `#`,
+  `%` and `:` are ordinary filename characters — via the new
+  `Uri._from_decoded_path()`, one implementation shared by
+  `Uri._rename_target()` (used by `SftpPath`, `FtpPath`, `DavPath`,
+  `S3Path`, `GsPath`, `AzPath` and `ArchiveUri`) and by
+  `UriPath._symlink_target()`, an override of a new `Path._symlink_target()`
+  hook. Relative destinations keep their existing meaning: a `rename()`
+  destination is a sibling, a `symlink_to()` target is stored verbatim and
+  stays relative. The string is **not** percent-encoded on the way in, so a
+  destination that legitimately contains a literal `%20` — or a path object
+  built by a consumer that already encoded it — is not encoded twice.
+  `readlink()`, `unlink()`, `rmdir()` and `hardlink_to()` never had this
+  defect. `copy()`/`move()` are deliberately unchanged: their `str`
+  destination is still parsed as a URI, which is what makes a cross-scheme
+  `copy("s3://bucket/key")` work. See `docs/divergences.md`.
+
+## [0.9.2] - 2026-08-16
+
+### Fixed
+- **`MemPath.open("w")` on an existing directory raised nothing and destroyed
+  the tree.** `_open()` assigned over whatever was already at the name, so
+  `MemPath("dir").write_text(...)` replaced a directory and everything under
+  it with a file — silently, in the class the docs present as the reference
+  exemplar for extending this library, and the class used as a mock
+  filesystem in tests. It now raises `IsADirectoryError`, as `pathlib` does.
+  The same guard covers the virtual root for every mode, which used to grow a
+  bogus `""` key in the backend on `"w"`/`"a"`.
+- **A `MemPath` routed *through* a file raised `TypeError`.**
+  `_parent_container()` walked ancestors with `path not in parent`, which on a
+  `bytearray` ancestor evaluates `"seg" not in bytearray`. That `TypeError`
+  sails past the `OSError` guard in `Stat._st_mode()`, so even
+  `MemPath("file.txt/sub").exists()` crashed instead of returning `False` —
+  a routine shape in glob/walk and in `mkdir(parents=True)`. It now raises
+  `NotADirectoryError` naming the offending ancestor.
+- **`Pathname` had no `__eq__`/`__hash__`, so subclasses compared by
+  identity.** Every pure subclass that didn't hand-write equality — including
+  `MemPath`, and any downstream class subclassing `Path` directly — was
+  unusable as a dict key or set member, and `is_relative_to()` (which decides
+  via `==` against freshly built parents) always returned `False` without
+  raising. There is now a default keyed on
+  `(type(self), tuple(self.segments))`. `LocalPath`, `PosixPathname` and
+  `WindowsPathname` are unaffected — `pathlib.PurePath` precedes `Pathname` in
+  their MRO and keeps its own equality — as is `Uri`, which defines one.
+- **`is_relative_to()` normalized a `str` argument by joining it onto
+  `self`.** `Pathname` used `cls(self, other)` and `Uri` used
+  `Uri(self, _ROOT, other)`, so `Uri("a/b").is_relative_to("a")` compared
+  against `"a/b/a"` / `"/a"` and answered `False` while
+  `Uri("a/b").is_relative_to(Uri("a"))` answered `True` — the str and object
+  forms of the same call disagreed. Both now parse `other` standalone, as
+  CPython does. The generic side uses `self.with_segments(other)` so a
+  subclass's per-instance state (`MemPath`'s backend) survives the
+  normalization. `Uri("http://h/a/b").is_relative_to("/a")` is still `True`.
+- **`LocalPath.chown()` leaked `AttributeError`/`LookupError` on Windows.**
+  `shutil.chown` exists there while `os.chown` does not, so an int id raised
+  `AttributeError` and a name raised a misleading `LookupError: no such user`
+  (with no `pwd` module, every name misses whether or not the user exists).
+  It now raises `NotImplementedError`, which `docs/divergences.md` already
+  promised and which every other unsupported capability here raises. The
+  all-unchanged no-op still succeeds.
+
 ## [0.9.1] - 2026-08-04
 
 ### Added
@@ -732,7 +823,9 @@ 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.9.1...HEAD
+[Unreleased]: https://github.com/jose-pr/pathlib-next/compare/v0.9.3...HEAD
+[0.9.3]: https://github.com/jose-pr/pathlib-next/compare/v0.9.2...v0.9.3
+[0.9.2]: https://github.com/jose-pr/pathlib-next/compare/v0.9.1...v0.9.2
 [0.9.1]: https://github.com/jose-pr/pathlib-next/compare/v0.9.0...v0.9.1
 [0.8.6]: https://github.com/jose-pr/pathlib-next/compare/v0.8.5...v0.8.6
 [0.8.5]: https://github.com/jose-pr/pathlib-next/compare/v0.8.4...v0.8.5

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: pathlib-next
-Version: 0.9.1
+Version: 0.9.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.9.1 → pathlib_next-0.9.3}/docs/divergences.md

@@ -61,8 +61,9 @@ these operations itself always keeps its own implementation.
 | `Path.move(target, ...)` | Not in `pathlib` at all | Our own extension: tries `rename()`, falls back to copy+unlink | N/A -- pure extension, no pathlib method to diverge from. |
 | `Path.rm(recursive=, missing_ok=, ignore_error=)` | Not in `pathlib` (closest: `shutil.rmtree`) | Our own extension. Recursive removal deletes bottom-up and uses non-following stat/listing metadata, so a symlink to a directory is unlinked rather than traversed. | N/A -- pure extension. Non-following recursive deletion avoids deleting through symlinked directory targets and lets backends with metadata-rich listings remove trees without a stat round trip per child. |
 | `Path.symlink_to(target, target_is_directory=False, *, force=False)` | `pathlib.Path.symlink_to(target, target_is_directory=False)` -- raises `FileExistsError` if anything already exists at the link path | Adds a keyword-only `force=`. `force=False` (the default) is stdlib-exact. `force=True` unlinks an existing **non-directory** entry at the link path first, then creates the symlink; an existing *directory* is never removed and the underlying error propagates. Not atomic: no filesystem or transport offers "replace a symlink" as one operation, so the path briefly does not exist between the unlink and the symlink. | Additive extension (an extra optional kwarg, per the parity contract). No backend can offer this atomically, so every consumer was re-implementing the same unlink-then-symlink dance -- it is path semantics, not transport semantics, so it belongs at the `Path` layer where one implementation serves every backend. Backends implement only the `_symlink_to()` primitive (same `_mkdir`/`_open` shape) and get `force=` for free. Because no stdlib version accepts the keyword, `symlink_to` is in `_OPERATION_NAMES` so `LocalPath` honors it too. |
-| `Path.chown(uid=None, gid=None, *, follow_symlinks=True)` | Not in `pathlib` at all -- it has `owner()`/`group()` **readers** but no writer (the stdlib writers are `os.chown`/`shutil.chown`, which are functions over a path, not path methods) | Our own extension. `None` (default) leaves a field unchanged; `-1` is accepted as an alias for `None` (`os.chown`'s own sentinel); an `int` is a uid/gid and a `str` is a user/group name. A call where both fields are unchanged short-circuits without touching the backend. Implemented for `LocalPath`/`FileUri` (via `shutil.chown`, or `os.lchown` for `follow_symlinks=False`) and `SftpPath` (`setstat`); `NotImplementedError` elsewhere. | Ownership was the one permission attribute `stat()` could report (`st_uid`/`st_gid`) that nothing could write back. The valuable part is centralizing the **"unchanged" sentinel** on `Path` (`utils.as_owner()`): `os.chown` spells it `-1`, SFTP omits the field, other middlewares use `None` -- normalizing per-scheme would be three chances to disagree. Backends implement `_chown()` and receive an already-canonical pair. SFTPv3 sends uid/gid as one paired attribute, so `SftpPath` reads the current owner for whichever field is unchanged rather than guessing a value. |
+| `Path.chown(uid=None, gid=None, *, follow_symlinks=True)` | Not in `pathlib` at all -- it has `owner()`/`group()` **readers** but no writer (the stdlib writers are `os.chown`/`shutil.chown`, which are functions over a path, not path methods) | Our own extension. `None` (default) leaves a field unchanged; `-1` is accepted as an alias for `None` (`os.chown`'s own sentinel); an `int` is a uid/gid and a `str` is a user/group name. A call where both fields are unchanged short-circuits without touching the backend. Implemented for `LocalPath`/`FileUri` (via `shutil.chown`, or `os.lchown` for `follow_symlinks=False`) and `SftpPath` (`setstat`); `NotImplementedError` elsewhere -- including `LocalPath` on a platform without `os.chown` (Windows), where `shutil.chown` exists but cannot work. | Ownership was the one permission attribute `stat()` could report (`st_uid`/`st_gid`) that nothing could write back. The valuable part is centralizing the **"unchanged" sentinel** on `Path` (`utils.as_owner()`): `os.chown` spells it `-1`, SFTP omits the field, other middlewares use `None` -- normalizing per-scheme would be three chances to disagree. Backends implement `_chown()` and receive an already-canonical pair. SFTPv3 sends uid/gid as one paired attribute, so `SftpPath` reads the current owner for whichever field is unchanged rather than guessing a value. |
 | `Path.chmod(mode, ...)` accepting a `str` | `mode` must be an `int`; a `str` raises `TypeError` | Additionally accepts a `str`, parsed as **octal**: `"0755"`, `"755"` and `0o755` all mean the same thing. An optional `0o` prefix is allowed; any character outside `[0-7]` raises `ValueError` rather than being coerced. | The string form is how modes are written in `chmod(1)`, Ansible, Dockerfiles and shell scripts, so config-driven callers arrive holding one. Accepted only with an **explicit base 8** (`utils.as_mode()`), never a plain `int()`: `int("0755")` in decimal is 755 == `0o1363`, a different *and valid* mode, so a fallback to decimal would set plausible-but-wrong permissions with nothing raising -- which is exactly why stdlib refuses strings. Parsing in one shared helper is what makes the base non-negotiable across the five backends that implement `chmod` directly. |
+| A `str` destination to `rename()`/`symlink_to()` on a `UriPath` | `pathlib.Path.rename(str)`/`symlink_to(str)` take the string as a path, verbatim; a relative one is resolved against the **cwd** | The string is taken as an already-**decoded path**, never re-parsed as URI syntax: `?`, `#`, `%` and `:` are ordinary filename characters, so `rename("rn?b.txt")` renames to `rn?b.txt`. A relative `rename()` destination resolves against `self.parent` (sibling rename), since a URI has no cwd; a relative `symlink_to()` target is stored verbatim and stays relative, exactly as pathlib does. `copy()`/`move()` are unchanged -- their `str` destination is still parsed as a URI, which is what makes a cross-scheme `copy("s3://bucket/key")` work. | Restores pathlib parity on the two methods whose destination is unambiguously a path on the same host. Re-parsing it as a URI discarded everything from a `?`/`#` onward and percent-decoded the rest -- silently, so a rename landed on a different file and a symlink pointed somewhere else (measured against a real SFTP server, 0.9.3). Percent-encoding the string before parsing was rejected: it double-encodes a name that legitimately contains a literal `%20`, and it puts a copy of the safe set in every consumer. The parse is bypassed instead -- `Uri._from_decoded_path()`, one implementation for every scheme. |
 | `PathSyncer` / `Query` / `Source` | N/A | Our own extensions | N/A -- pure extensions, no pathlib equivalent. |
 | `PathSyncer(follow_symlinks=False).sync()` on a symlink source | N/A (no pathlib equivalent) | Previously always raised `NotImplementedError`. Now controlled by the new `symlink_mode` constructor kwarg (`"preserve"` default, `"reject"` opt-out): `"preserve"` creates a matching symlink on `target` with the same raw, unresolved target string `readlink()` returned (dangling links and relative targets included, never validated/resolved); `"reject"` restores the exact old unconditional-raise behavior. If `target` can't create symlinks at all (every backend except `LocalPath` and `SftpPath`), `"preserve"` also raises `NotImplementedError`, through the same `ignore_error`/`hook()` machinery as every other sync branch, not a silent skip. **This is a default-behavior change, not a pure extension** -- flagged here because existing callers relying on the old unconditional raise (e.g. to detect and skip symlinks) must now pass `symlink_mode="reject"` explicitly. | Faithful one-way tree mirroring needs symlinks preserved as symlinks by default, not silently dropped/erroring -- discovered via a real cross-host sync use case (hostctl). `follow_symlinks=True` (unchanged default) still resolves through symlinks during traversal, so this only affects callers who already opted into `follow_symlinks=False`. **User decision, 2026-07-28.** |
 | `S3Path` directories | N/A (pathlib directories are real filesystem entries) | `is_dir()` is prefix emulation (any object key under `"<path>/"`); `mkdir()` creates a zero-byte `"<path>/"` marker object; `rmdir()` requires no other keys under that prefix (pathlib-parity "must be empty"). If an exact object key and a `"<path>/"` prefix both exist, exact object operations such as `stat()` and `rm(recursive=True)` treat the path as the object first. | S3 has no native directory concept -- this is the same prefix convention the AWS console itself uses for an empty "folder". Exact-object precedence avoids deleting a prefix tree when the addressed path is a real object. |

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/docs/guides/extending.md

@@ -31,6 +31,16 @@ as_uri()        # a URI string identifying this path (can be a custom scheme)
 relative_to(other)          # or raise NotImplementedError if not meaningful
 ```
 
+Equality is **not** on that list: `Pathname` supplies a default `__eq__`/
+`__hash__` keyed on `(type(self), tuple(self.segments))`, so your class is
+usable as a dict key or set member, and the equality-based helpers
+(`is_relative_to()`, `parents` membership) work, without you writing
+anything. Override both together if your type needs a different identity
+-- e.g. case-insensitive segments, or one that also distinguishes the
+backing store two otherwise-identical paths point at. (`LocalPath` and the
+`*Pathname` classes don't use this default: `pathlib.PurePath` precedes
+`Pathname` in their MRO and keeps its own equality.)
+
 Optional I/O, implement whichever your resource actually supports -- leave
 the rest as the inherited `@notimplemented` stubs (derived helpers either
 fall back, e.g. `move()` falls back to copy+unlink when `rename()` isn't

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "hatchling.build"
 # `import pathlib_next`) -- a hyphen is not legal in a Python identifier.
 # Distribution name and import name differing is ordinary and intended.
 name = "pathlib-next"
-version = "0.9.1"
+version = "0.9.3"
 authors = [{ name = "Jose A" }]
 description = "Generic Path Protocol based pathlib"
 readme = "README.md"

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/AGENTS.md

@@ -26,6 +26,17 @@ pathlib_next`.
   (abstract), `match(pattern, *, case_sensitive=None)`,
   `full_match(pattern, *, case_sensitive=None)`, `as_posix()`,
   `has_glob_pattern()`. `as_uri()` is abstract on `Pathname` itself.
+  - `__eq__`/`__hash__` are supplied by default, keyed on
+    `(type(self), tuple(self.segments))` — exact type, so a subclass never
+    compares equal to its base. Classes mixing in `pathlib.PurePath`
+    (`PosixPathname`, `WindowsPathname`, `LocalPath`) keep stdlib's
+    equality instead, since `PurePath` precedes `Pathname` in their MRO;
+    `Uri` defines its own over `as_uri()`. Override both together if your
+    subclass needs a different identity.
+  - `is_relative_to(other)` parses a `str` `other` standalone, via
+    `self.with_segments(other)` — the same rule as CPython's
+    `self.with_segments(other)`, and it preserves per-instance state such
+    as `MemPath`'s backend.
 - **`Path(Pathname, Chmod, Stat, BinaryOpen)`** — base class for I/O paths.
   `Path(*args)` (the bare class, not a subclass) always constructs a
   `LocalPath` (`fspath.py`) — the real local filesystem. Adds:
@@ -62,15 +73,21 @@ pathlib_next`.
     equivalent. Removes a file or (with `recursive=True`) a directory tree;
     `ignore_error` (bool or predicate) controls whether an error during the
     walk is swallowed (predicate return `True`) or re-raised.
-  - `rename(target)` — not implemented by default.
+  - `rename(target)` — not implemented by default. On a `UriPath` a `str`
+    `target` is an already-**decoded path**, not URI syntax, and a relative
+    one is a sibling rename — see `Uri._rename_target()` under "URIs".
   - `_symlink_to(target, target_is_directory=False)` (not implemented by
     default) / `symlink_to(target, target_is_directory=False, *,
     force=False)` — same primitive/wrapper split as `_mkdir`/`mkdir`: a
     backend implements only `_symlink_to()` and receives an already
-    normalized path object (a `str` target is turned into one by the
-    wrapper, as `copy()`/`move()` do), then reads the raw target string the
+    normalized path object, then reads the raw target string the
     way its transport needs (`Uri.path` on the wire, `os.fspath()`
-    locally). `force=` is this library's extension: `False` is
+    locally). The `str`→path step is `_symlink_target(target)`, an
+    overridable hook: the default is `type(self)(target)`, and `UriPath`
+    overrides it so a link target is taken literally instead of being
+    re-parsed as a URI (a `?`/`#` in it is a filename character, not a
+    delimiter). A relative target is never anchored — it stays relative,
+    as in pathlib. `force=` is this library's extension: `False` is
     stdlib-exact, `True` unlinks an existing **non-directory** entry at the
     link path first (never a directory) and is **not** atomic. Listed in
     `_OPERATION_NAMES`, since no stdlib version accepts `force=`.
@@ -154,7 +171,10 @@ pathlib_next`.
   alias for it; an `int` is an id, a `str` is a name. `chown()` normalizes
   via `utils.as_owner()` and short-circuits when nothing would change, so
   `_chown()` always receives a canonical pair and only converts to its own
-  wire spelling (`-1` for `os.chown`, an omitted attr for SFTP).
+  wire spelling (`-1` for `os.chown`, an omitted attr for SFTP). On a
+  platform without `os.chown` (Windows) `LocalPath.chown()` raises
+  `NotImplementedError` for any real change; the all-unchanged no-op still
+  succeeds because it never reaches the backend.
 - **`io.BinaryOpen`** — `Protocol`. `_open(mode="r", buffering=-1) ->
   io.IOBase` (not implemented by default; must yield a **binary** stream).
   Derives `open(mode="r", buffering=-1, encoding=None, errors=None,
@@ -204,7 +224,10 @@ extra that depends on it).
   `suffix`, `stem`, `parent`. Methods: `as_uri(sanitize=False)` (sanitize
   strips password from userinfo before formatting), `with_source(source)`,
   `with_segments(*segments)`, `with_path(path)`, `with_query(query)`,
-  `with_fragment(fragment)`, `is_absolute()`, `is_relative_to(other)`,
+  `with_fragment(fragment)`, `is_absolute()`, `is_relative_to(other)`
+  (a `str` `other` is parsed standalone as `Uri(other)`, matching
+  `relative_to()`; an `other` with no authority is compatible with any
+  `self.source`, so `Uri("http://h/a/b").is_relative_to("/a")` is `True`),
   `relative_to(other, *, walk_up=False)`, `is_local()` (delegates to
   `Source.is_local()` — does a DNS lookup, cached per `Source`),
   `as_posix()` (`user@host:path` / `host:path` form when a source is
@@ -215,6 +238,18 @@ extra that depends on it).
   is the unambiguous accessor for "path on the URI's own host" — same
   `_host_filesystem_path` gate, but never falls back to local-path
   semantics. See `docs/divergences.md`.
+  Destination/target normalization (used by every scheme's `rename()` and
+  by `symlink_to()`): `_from_decoded_path(path)` builds a same-type URI
+  whose `.path` is `path` **verbatim** — an already-decoded path string,
+  not URI syntax, so `?`, `#`, `%` and `:` in it are ordinary filename
+  characters and only dot segments are normalized.
+  `_rename_target(target)` is what `rename()` calls: a `Uri` passes
+  through untouched, a `str` goes through `_from_decoded_path()` and, if
+  relative, is joined onto `self.parent` (sibling rename — a URI has no
+  cwd). `_symlink_target(target)` (overriding `Path`'s) is the same minus
+  the parent anchoring, so a relative link target stays relative.
+  `copy()`/`move()` deliberately still parse a `str` destination as a URI
+  — that is what makes a cross-scheme `copy("s3://bucket/key")` work.
 - **`UriPath(Uri, Path)`** — `Uri` + `Path` (I/O) + scheme dispatch.
   `UriPath(*uris, **options)` (the bare class) parses the URI and returns an
   instance of the concrete subclass registered for its scheme via

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/fspath.py

@@ -193,6 +193,15 @@ class LocalPath(
         # canonical form Chmod.chown() already normalized to, so the pair
         # passes straight through. os.chown's -1 sentinel never appears
         # here.
+        if not hasattr(_os, "chown"):
+            # shutil.chown() *exists* on Windows while os.chown does not, so
+            # without this the int form leaked `AttributeError: module 'os'
+            # has no attribute 'chown'` and the name form leaked
+            # `LookupError: no such user` -- actively misleading, since
+            # there is no `pwd` module for shutil._get_uid to consult, so
+            # every name "misses" whether or not the user exists.
+            # docs/divergences.md promises NotImplementedError here.
+            raise NotImplementedError("chown()")
         if not follow_symlinks:
             if not hasattr(_os, "lchown"):
                 raise NotImplementedError("chown(follow_symlinks=False)")

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/mempath.py

@@ -121,11 +121,19 @@ class MemPath(Path):
     def _parent_container(self) -> tuple[dict[str, bytearray], str]:
         parent = self.backend
         *ancestors, name = self.normalized
-        for path in ancestors:
+        for index, path in enumerate(ancestors):
             if path not in parent:
                 raise FileNotFoundError(self.parent)
-            else:
-                parent = parent[path]
+            parent = parent[path]
+            if not isinstance(parent, dict):
+                # An ancestor segment names a file. Without this the next
+                # iteration evaluates `"seg" not in bytearray` and raises
+                # TypeError, which sails past the OSError guards in
+                # stat()/exists()/is_dir() -- so even exists() crashed on a
+                # path merely routed through a file. NotADirectoryError is
+                # an OSError, which is what stdlib raises and what those
+                # guards already swallow.
+                raise NotADirectoryError(self.with_segments(*ancestors[: index + 1]))
 
         return parent, name
 
@@ -192,6 +200,11 @@ class MemPath(Path):
         # mode contract: "r"/"w" are required; "x"/"a" are supported here
         # as an extension. Anything else raises NotImplementedError.
         parent, name = self._parent_container()
+        if not name:
+            # An empty name is the virtual root, which stat() reports as a
+            # directory. Without this guard "w"/"a" created a bogus ""
+            # entry in the backend and "r" claimed FileNotFoundError.
+            raise IsADirectoryError(self)
         if mode == "r":
             if name not in parent:
                 raise FileNotFoundError(self)
@@ -200,6 +213,10 @@ class MemPath(Path):
                 raise IsADirectoryError(self)
             return io.BytesIO(content)
         elif mode == "w":
+            if isinstance(parent.get(name), dict):
+                # Truncating over a directory silently replaced the whole
+                # subtree with a file; stdlib raises IsADirectoryError.
+                raise IsADirectoryError(self)
             content = bytearray()
             parent[name] = content
             return MemBytesIO(content)

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/path.py

@@ -187,9 +187,35 @@ class Pathname(FsPathLike, _ty.Generic[_P]):
     def is_relative_to(self, other: _ty.Self | str):
         """Return True if the path is relative to another path or False."""
         cls = type(self)
-        other = other if isinstance(other, cls) else cls(self, other)
+        # with_segments(other), NOT cls(self, other): joining `other` under
+        # `self` first turned `MemPath("a/b").is_relative_to("a")` into a
+        # comparison against "a/b/a" and answered False, while the object
+        # form of the same call answered True. CPython parses `other`
+        # standalone (`self.with_segments(other)`) and so do we -- via
+        # with_segments rather than the bare constructor so per-instance
+        # state a subclass carries (MemPath's backend) survives.
+        other = other if isinstance(other, cls) else self.with_segments(other)
         return other == self or other in self.parents
 
+    def __eq__(self, other: object) -> bool:
+        """Compare by (exact type, segments).
+
+        The ABC previously defined no equality at all, so every pure
+        subclass that didn't hand-write one -- including `MemPath`, the
+        documented reference exemplar -- compared by identity. That made
+        `is_relative_to()` (which decides via `==`) silently return False
+        for every subclass, and broke paths as dict keys or set members.
+        `_BaseFSPathname`/`LocalPath` are unaffected: `pathlib.PurePath`
+        precedes `Pathname` in their MRO and keeps its own `__eq__`, as
+        does `Uri`, which defines one.
+        """
+        if type(self) is not type(other):
+            return NotImplemented
+        return tuple(self.segments) == tuple(other.segments)
+
+    def __hash__(self) -> int:
+        return hash((type(self), tuple(self.segments)))
+
     def __truediv__(self, key: _ty.Self | str) -> _ty.Self:
         try:
             return type(self)(self, key)
@@ -262,7 +288,7 @@ class Pathname(FsPathLike, _ty.Generic[_P]):
     def has_glob_pattern(self):
         """Return True if any of the path segments contain glob wildcards."""
         for segment in self.segments:
-            if _glob.WILDCARD_PATTERN.search(segment) != None:
+            if _glob.WILDCARD_PATTERN.search(segment) is not None:
                 return True
         return False
 
@@ -706,6 +732,17 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
         """
         ...
 
+    def _symlink_target(self, target: "_ty.Self | str") -> "_ty.Self":
+        """Normalize a `symlink_to()` target argument to a path object.
+
+        A `str` target is the **literal link target** -- whatever it says
+        is what gets stored, verbatim and unresolved, exactly as
+        `pathlib.Path.symlink_to()` does. Override this wherever
+        `type(self)(str)` would reinterpret the string instead of taking
+        it literally (`UriPath` does; see `UriPath._symlink_target`).
+        """
+        return type(self)(target) if isinstance(target, str) else target
+
     def symlink_to(
         self,
         target: "_ty.Self | str",
@@ -732,10 +769,12 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
         for.
         """
         # Normalize a str target to a path object, so the primitive only
-        # ever handles one type -- same `type(self)(target)` form as
-        # copy()/move() use for their destination, for consistency.
-        if isinstance(target, str):
-            target = type(self)(target)
+        # ever handles one type. Routed through `_symlink_target()` rather
+        # than inlining `type(self)(target)`: for a URI-backed path that
+        # constructor re-parses the string as URI syntax, which silently
+        # truncated a link target at a "?"/"#" and percent-decoded it (see
+        # `UriPath._symlink_target`).
+        target = self._symlink_target(target)
         if force:
             try:
                 self.unlink(missing_ok=True)
@@ -854,8 +893,6 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
         if isinstance(target, str):
             target = type(self)(target)
         src = self
-        if src is None:
-            return
 
         if target.exists():
             if overwrite:

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/protocols/fs.py

@@ -58,7 +58,7 @@ class Stat(_ty.Protocol):
         """
         Whether this path exists.
         """
-        return self._st_mode(follow_symlinks=follow_symlinks) != None
+        return self._st_mode(follow_symlinks=follow_symlinks) is not None
 
     def is_dir(self):
         """

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/uri/__init__.py

@@ -232,6 +232,50 @@ class Uri(Pathname):
         uri._init(source, path, query, fragment, **kwargs)
         return uri
 
+    def _from_decoded_path(self, path: str, /, **kwargs) -> "_ty.Self":
+        """Build a same-type URI whose `.path` is `path` verbatim.
+
+        `path` is an **already-decoded path string**, not URI syntax: `?`,
+        `#`, `%` and `:` are ordinary filename characters here. Only
+        path-level normalization (dot segments, exactly what `_parse_uri`
+        applies *after* decoding) is performed -- nothing is split off and
+        nothing is percent-decoded.
+
+        This is what a destination/target argument must go through.
+        Feeding such a string back into the URI parser (`Uri(path)`,
+        `type(self)(path)`) reads it as syntax: "a?b.txt" silently became
+        "a" plus a query, "a#b.txt" became "a" plus a fragment,
+        "a%20b.txt" became "a b.txt", and a relative "C:/Temp/x" became
+        scheme "c" plus "/Temp/x" -- so the wire call went to a different
+        file than the caller named, with no error. Percent-encoding the
+        string before parsing would fix the truncation but re-encode an
+        already-encoded name (a literal "%20" would come back as a space),
+        so the parse is bypassed instead of being fed encoded input.
+        """
+        return self._from_parsed_parts(
+            _NOSOURCE, _remove_dot_segments(path), None, None, **kwargs
+        )
+
+    def _rename_target(self, target: UriLike) -> "Uri":
+        """Normalize a `rename()`/`replace()` destination to a `Uri`.
+
+        A `str` is an already-decoded path (see `_from_decoded_path`), and
+        a relative one is resolved against `self.parent` -- the documented
+        sibling-rename semantics ("rename this to a new name in the same
+        directory"), not against `self` itself. A `Uri` (of any scheme
+        class) is taken as given; anything else keeps the pre-existing
+        `Uri(...)` conversion, which is already lossless for
+        `PurePath`/`os.PathLike` (they are percent-encoded on the way in
+        and decoded back out).
+        """
+        if isinstance(target, Uri):
+            return target
+        if isinstance(target, str):
+            target = self._from_decoded_path(target)
+        # target is a Uri by now, so this join re-uses `_load_parts`'
+        # existing right-to-left semantics without re-parsing anything.
+        return Uri(self.parent, target)
+
     @classmethod
     def _format_parsed_parts(
         cls,
@@ -432,7 +476,16 @@ class Uri(Pathname):
 
     def is_relative_to(self, other: UriLike):
         """Return True if the path is relative to another path or False."""
-        other = other if isinstance(other, Uri) else Uri(self, _ROOT, other)
+        # Uri(other), NOT Uri(self, _ROOT, other): anchoring a str `other`
+        # at self's root turned `Uri("a/b").is_relative_to("a")` into a
+        # comparison against "/a" and answered False, disagreeing with the
+        # object form of the same call. `relative_to()` below already
+        # parsed a str standalone; this matches it and CPython.
+        # The same-authority case still works: a standalone parse leaves
+        # `other.source` empty, which the guard below treats as compatible
+        # with any `self.source`, and the segment prefix compare is
+        # unaffected -- `Uri("http://h/a/b").is_relative_to("/a")` is True.
+        other = other if isinstance(other, Uri) else Uri(other)
         if not (
             (other.source == self.source)
             or not (bool(self.source) and bool(other.source))
@@ -682,6 +735,21 @@ class UriPath(Uri, Path):
         inst._init(source, self.path, self.query, self.fragment)
         return inst
 
+    def _symlink_target(self, target: "UriLike") -> "_ty.Self":
+        """`Path._symlink_target()` for URI-backed paths: a `str` target is
+        an already-decoded path, never URI syntax (see
+        `Uri._from_decoded_path`).
+
+        The default `type(self)(target)` ran the link target back through
+        the URI parser, so `symlink_to("/mnt/cache?v=2")` created a link
+        pointing at `/mnt/cache`. Unlike `_rename_target()` this never
+        anchors at `self.parent`: a symlink target is stored as given, so
+        a relative one stays relative.
+        """
+        if isinstance(target, str):
+            return self._from_decoded_path(target)
+        return target
+
     @_utils.notimplemented
     def _listdir(self) -> "_ty.Iterator[str]": ...
 
@@ -717,6 +785,3 @@ class UriPath(Uri, Path):
     def iterdir(self) -> "_ty.Iterator[Self]":
         for name, stat in self._scandir():
             yield self._make_child_relpath(name, stat_hint=stat)
-
-
-_ROOT = Uri("/")

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/archive/_base.py

@@ -283,8 +283,7 @@ class ArchiveUri(UriPath):
         # A plain str target is a sibling rename (relative to self's
         # parent), matching sftp.py's/ftp.py's rename() semantics.
         self._require_writable()
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         old_path = self.path
         new_path = target.path.lstrip("/")
         names = self._names()

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/az.py

@@ -282,8 +282,7 @@ class AzPath(UriPath):
                     raise
 
     def rename(self, target: "AzPath | Uri | str"):
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         dest_key = (
             self.with_segments(target).key
             if not isinstance(target, AzPath)

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/dav.py

@@ -212,8 +212,7 @@ class DavPath(HttpPath):
                 raise
 
     def rename(self, target: "DavPath | Uri | str"):
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         dest = self.with_path(target.path)._wire_uri()
         resp = self.backend.request(
             "MOVE", self._wire_uri(), headers={"Destination": dest, "Overwrite": "F"}

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/ftp.py

@@ -228,8 +228,7 @@ class FtpPath(UriPath):
     def rename(self, target: "FtpPath | Uri | str"):
         # A plain str target is a sibling rename (relative to self's
         # parent), matching sftp.py's rename() semantics.
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         self._ftpclient.rename(self.path, target.path)
 
     def chmod(self, mode: int | str, *, follow_symlinks: bool = True):

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/gs.py

@@ -247,8 +247,7 @@ class GsPath(UriPath):
                     raise
 
     def rename(self, target: "GsPath | Uri | str"):
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         dest_key = target.path.lstrip("/")
         source_blob = self._bucket.blob(self.key)
         self._bucket.copy_blob(source_blob, self._bucket, dest_key)

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/s3.py

@@ -254,8 +254,7 @@ class S3Path(UriPath):
                     raise
 
     def rename(self, target: "S3Path | Uri | str"):
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        target = self._rename_target(target)
         dest_key = target.path.lstrip("/")
         self._client.copy_object(
             Bucket=self.bucket,

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/uri/schemes/sftp/__init__.py

@@ -357,9 +357,11 @@ class SftpPath(UriPath):
         # "host:" for the sftp wire protocol, which only wants the raw path.
         # A plain str target is resolved relative to self's *parent*
         # (sibling rename -- "rename this file to a new name in the same
-        # directory"), not to self itself (which would join it as a child).
-        if not isinstance(target, Uri):
-            target = Uri(self.parent, target)
+        # directory"), not to self itself (which would join it as a child)
+        # -- and is taken as a literal path rather than re-parsed as a URI,
+        # which used to truncate "rn?b.txt" to "rn" on the wire (see
+        # `Uri._rename_target`).
+        target = self._rename_target(target)
         return self._sftpclient.rename(self.path, target.path)
 
     def _symlink_to(

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/uri/source.py

@@ -306,9 +306,7 @@ class Source(_ty.NamedTuple):
         types and treating `host` as local if ANY resolved address is.
         `netimps.resolve()` gained OS-resolver-chain support in 0.2.0 --
         before that it was dnspython-only, which is why this method
-        originally kept `socket.gethostbyname()` for this step (see
-        `.agents/findings/processed/2026-07-29_netimps_adoption_survey.md`
-        and the companion finding filed against `netimps` itself). The
+        originally kept `socket.gethostbyname()` for this step. The
         "is this address MINE" comparison uses `netimps.is_local_address()`,
         which enumerates real network interfaces
         (`netimps.get_interfaces()`) instead of the weaker

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/utils/glob.py

@@ -76,7 +76,7 @@ def glob(
     include_hidden = include_hidden or path.is_hidden()
     pattern = compile_pattern(path.name, case_sensitive) if path.name else ANY_PATTERN
 
-    name_is_pattern = WILDCARD_PATTERN.search(path.name) != None
+    name_is_pattern = WILDCARD_PATTERN.search(path.name) is not None
     wildcard_in_path = name_is_pattern or path.has_glob_pattern()
     parent = next(iter(path.parents), None)
 

{pathlib_next-0.9.1 → pathlib_next-0.9.3}/src/pathlib_next/utils/sync.py

@@ -187,7 +187,7 @@ class PathAndStat(object):
         return self._stat
 
     def exists(self):
-        return self.stat != None
+        return self.stat is not None
 
     def refresh(self, follow_symlink: bool):
         self._stat = FileStat.from_path(self.path, follow_symlink=follow_symlink)