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

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

@@ -5,6 +5,52 @@ 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.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 +778,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.9.1...HEAD
+[Unreleased]: https://github.com/jose-pr/pathlib-next/compare/v0.9.2...HEAD
+[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.2}/PKG-INFO

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

@@ -61,7 +61,7 @@ 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. |
 | `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.** |

{pathlib_next-0.9.1 → pathlib_next-0.9.2}/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.2}/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.2"
 authors = [{ name = "Jose A" }]
 description = "Generic Path Protocol based pathlib"
 readme = "README.md"

{pathlib_next-0.9.1 → pathlib_next-0.9.2}/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:
@@ -154,7 +165,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 +218,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

{pathlib_next-0.9.1 → pathlib_next-0.9.2}/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.2}/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.2}/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
 
@@ -854,8 +880,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.2}/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.2}/src/pathlib_next/uri/__init__.py

@@ -432,7 +432,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))
@@ -717,6 +726,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.2}/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.2}/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.2}/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)

{pathlib_next-0.9.1 → pathlib_next-0.9.2}/tests/test_mempath.py

@@ -153,3 +153,84 @@ def test_rmdir_nonempty_raises():
     (root / "d" / "f.txt").write_text("x")
     with pytest.raises(FileExistsError):
         (root / "d").rmdir()
+
+
+# --- 2026-08-16: open("w") over a directory destroyed the whole subtree ---
+
+
+def test_open_w_on_directory_raises_and_keeps_the_tree():
+    backend = MemPathBackend()
+    root = MemPath("/", backend=backend)
+    (root / "dir").mkdir()
+    (root / "dir" / "child.txt").write_text("hi")
+
+    with pytest.raises(IsADirectoryError):
+        MemPath("dir", backend=backend).write_text("clobber")
+
+    # The whole point of the fix: the tree survives the refused write.
+    assert isinstance(backend["dir"], dict)
+    assert (root / "dir" / "child.txt").read_text() == "hi"
+
+
+def test_open_w_on_root_raises_instead_of_creating_an_empty_key():
+    backend = MemPathBackend()
+    with pytest.raises(IsADirectoryError):
+        MemPath("/", backend=backend).write_text("clobber")
+    assert backend == {}
+
+
+def test_open_a_on_root_raises_instead_of_creating_an_empty_key():
+    backend = MemPathBackend()
+    with pytest.raises(IsADirectoryError):
+        MemPath("/", backend=backend)._open("a")
+    assert backend == {}
+
+
+def test_open_w_still_truncates_an_existing_file():
+    # Guard against over-correcting: only directories are refused.
+    root = MemPath("/")
+    (root / "f.txt").write_text("original")
+    (root / "f.txt").write_text("new")
+    assert (root / "f.txt").read_text() == "new"
+
+
+# --- 2026-08-16: a path routed *through* a file raised TypeError ---
+
+
+def test_exists_through_a_file_segment_is_false():
+    backend = MemPathBackend()
+    MemPath("file.txt", backend=backend).write_text("x")
+    # Used to raise TypeError: a bytes-like object is required, not 'str'.
+    assert MemPath("file.txt/sub", backend=backend).exists() is False
+    assert MemPath("file.txt/sub/deeper", backend=backend).exists() is False
+    assert MemPath("file.txt/sub", backend=backend).is_dir() is False
+
+
+def test_stat_through_a_file_segment_raises_notadirectoryerror():
+    backend = MemPathBackend()
+    MemPath("file.txt", backend=backend).write_text("x")
+    with pytest.raises(NotADirectoryError):
+        MemPath("file.txt/sub", backend=backend).stat()
+
+
+def test_open_through_a_file_segment_raises_notadirectoryerror():
+    backend = MemPathBackend()
+    MemPath("file.txt", backend=backend).write_text("x")
+    with pytest.raises(NotADirectoryError):
+        MemPath("file.txt/sub", backend=backend).read_text()
+
+
+def test_mkdir_parents_under_a_file_raises_notadirectoryerror():
+    backend = MemPathBackend()
+    MemPath("file.txt", backend=backend).write_text("x")
+    with pytest.raises(NotADirectoryError):
+        MemPath("file.txt/sub", backend=backend).mkdir(parents=True)
+
+
+def test_notadirectoryerror_names_the_offending_ancestor():
+    backend = MemPathBackend()
+    MemPath("a", backend=backend).mkdir()
+    MemPath("a/f.txt", backend=backend).write_text("x")
+    with pytest.raises(NotADirectoryError) as excinfo:
+        MemPath("a/f.txt/sub", backend=backend).stat()
+    assert str(excinfo.value.args[0]) == "a/f.txt"

{pathlib_next-0.9.1 → pathlib_next-0.9.2}/tests/test_parity_io.py

@@ -248,8 +248,8 @@ def test_copy_progress_hook_monotonic_and_reaches_total(tmp_path):
 def test_copy_progress_hook_not_called_without_callback_and_no_behavior_change(
     tmp_path,
 ):
-    # No callback => identical behavior/content to plain shutil.copyfileobj
-    # (Phase 1's "no behavior change" requirement).
+    # No callback => identical behavior/content to plain shutil.copyfileobj:
+    # the hook must not cost anything when it is not used.
     root = pathlib_next.LocalPath(tmp_path)
     data = b"hello world" * 1000
     (root / "src.bin").write_bytes(data)
@@ -278,7 +278,7 @@ def test_copy_progress_hook_fires_on_path_copy(tmp_path):
 
 
 def test_copy_recursive_progress_hook_reports_per_file_identity(tmp_path):
-    # Phase 2: recursive copy must report per-file identity alongside byte
+    # A recursive copy must report per-file identity alongside byte
     # progress -- not just an anonymous byte stream.
     root = pathlib_next.LocalPath(tmp_path)
     src = root / "src"
@@ -495,3 +495,23 @@ def test_local_chown_no_op_needs_no_privileges(tmp_path):
     f.chown()
     f.chown(-1, -1)
     assert f.read_text() == "x"
+
+
+@pytest.mark.skipif(hasattr(os, "chown"), reason="platforms without os.chown only")
+@pytest.mark.parametrize("uid", [1000, "someuser"])
+def test_local_chown_unsupported_platform_raises_notimplementederror(tmp_path, uid):
+    # shutil.chown() exists on Windows while os.chown does not, so the
+    # mutation path used to leak AttributeError for an int id and a
+    # misleading "no such user" LookupError for a name (there is no pwd
+    # module, so every name misses). docs/divergences.md promises
+    # NotImplementedError, which is what every other unsupported capability
+    # in this library raises.
+    root = pathlib_next.LocalPath(tmp_path)
+    f = root / "f.txt"
+    f.write_text("x")
+    with pytest.raises(NotImplementedError):
+        f.chown(uid=uid)
+    with pytest.raises(NotImplementedError):
+        f.chown(gid=uid)
+    with pytest.raises(NotImplementedError):
+        f.chown(uid=uid, follow_symlinks=False)

{pathlib_next-0.9.1 → pathlib_next-0.9.2}/tests/test_pathname.py

@@ -165,3 +165,125 @@ def test_root_drive_anchor_relative(cls):
     p = cls("a/b")
     assert p.root == ""
     assert p.anchor == ""
+
+
+# --- 2026-08-16: equality + is_relative_to str/object agreement ---
+
+
+@pytest.mark.parametrize("cls", IMPLS)
+def test_equality_is_by_value_not_identity(cls):
+    # `Pathname` used to define no __eq__ at all, so any subclass that
+    # didn't hand-write one (MemPath, and every downstream Track A class)
+    # compared by identity.
+    assert cls("a/b") == cls("a/b")
+    assert cls("a/b") != cls("a/c")
+    assert cls("a/b") is not cls("a/b")
+
+
+@pytest.mark.parametrize("cls", IMPLS)
+def test_hash_matches_equality(cls):
+    assert hash(cls("a/b")) == hash(cls("a/b"))
+    assert len({cls("a/b"), cls("a/b"), cls("a/c")}) == 2
+    assert {cls("a/b"): 1}[cls("a/b")] == 1
+
+
+@pytest.mark.parametrize("cls", IMPLS)
+def test_equality_against_a_foreign_type_is_false_not_an_error(cls):
+    assert (cls("a/b") == object()) is False
+    assert (cls("a/b") != object()) is True
+
+
+@pytest.mark.parametrize("cls", IMPLS)
+@pytest.mark.parametrize("path,other", [("a/b", "a"), ("a/b/c", "a/b"), ("a", "a")])
+def test_is_relative_to_str_and_object_agree_with_stdlib(cls, path, other):
+    expected = pathlib.PurePosixPath(path).is_relative_to(other)
+    assert expected is True  # sanity: the oracle really does say True
+    assert cls(path).is_relative_to(cls(other)) is expected
+    # The str form used to join `other` onto `self` instead of parsing it
+    # standalone, so it answered False where the object form answered True.
+    assert cls(path).is_relative_to(other) is expected
+
+
+@pytest.mark.parametrize("cls", IMPLS)
+@pytest.mark.parametrize("path,other", [("a/b", "b"), ("a/b", "c"), ("ab/c", "a")])
+def test_is_relative_to_negative_str_and_object_agree_with_stdlib(cls, path, other):
+    expected = pathlib.PurePosixPath(path).is_relative_to(other)
+    assert expected is False
+    assert cls(path).is_relative_to(cls(other)) is expected
+    assert cls(path).is_relative_to(other) is expected
+
+
+def test_mempath_is_relative_to_str_keeps_the_backend():
+    # with_segments(), not type(self)(other): the bare constructor hands
+    # MemPath a fresh empty backend, which is the kind of per-instance
+    # state a generic normalization must not drop.
+    from pathlib_next.mempath import MemPathBackend
+
+    backend = MemPathBackend()
+    p = MemPath("a/b", backend=backend)
+    assert p.is_relative_to("a") is True
+    assert p.with_segments("a").backend is backend
+
+
+def test_generic_pathname_subclass_gets_working_equality():
+    """A minimal Track A subclass -- the shape `docs/guides/extending.md`
+    documents -- must get equality (and therefore is_relative_to) without
+    hand-writing __eq__."""
+    from pathlib_next.path import Pathname
+
+    class Toy(Pathname):
+        __slots__ = ("_segments",)
+
+        def __init__(self, *segments):
+            parts = []
+            for segment in segments:
+                if isinstance(segment, Pathname):
+                    parts.extend(segment.segments)
+                else:
+                    parts.append(segment)
+            self._segments = "/".join(parts).split("/")
+
+        @property
+        def segments(self):
+            return self._segments
+
+        @property
+        def parts(self):
+            return tuple(self._segments)
+
+        @property
+        def parent(self):
+            return self.with_segments(*self._segments[:-1])
+
+        def with_segments(self, *segments):
+            return type(self)(*segments)
+
+        def relative_to(self, other):
+            raise NotImplementedError()
+
+        def as_uri(self):
+            return "toy:" + self.as_posix()
+
+    assert Toy("a", "b") == Toy("a/b")
+    assert Toy("a/b") != Toy("a/c")
+    assert len({Toy("a/b"), Toy("a/b")}) == 1
+    assert Toy("a/b").is_relative_to(Toy("a")) is True
+    assert Toy("a/b").is_relative_to("a") is True
+    assert Toy("a/b").is_relative_to("c") is False
+
+
+def test_localpath_keeps_stdlib_equality_semantics():
+    """`pathlib.PurePath` precedes `Pathname` in the fspath MRO, so the new
+    default must NOT displace stdlib's (case-folding, cross-subclass)
+    equality there."""
+    from pathlib_next.fspath import LocalPath, _BaseFSPathname
+    from pathlib_next.path import Pathname
+
+    for cls in (LocalPath, PosixPathname):
+        names = [k.__name__ for k in cls.__mro__]
+        assert names.index("PurePath") < names.index("Pathname")
+        assert cls.__eq__ is not Pathname.__eq__
+        assert cls.__eq__ is pathlib.PurePath.__eq__
+
+    assert issubclass(PosixPathname, _BaseFSPathname)
+    assert LocalPath("a/b") == pathlib.Path("a/b")

{pathlib_next-0.9.1 → pathlib_next-0.9.2}/tests/test_properties.py

@@ -161,6 +161,21 @@ def test_is_relative_to_matches_pure_posix_path(segs):
     u, pp = Uri(path_str), pathlib.PurePosixPath(path_str)
     u_parent, pp_parent = Uri(parent_str), pathlib.PurePosixPath(parent_str)
     assert u.is_relative_to(u_parent) == pp.is_relative_to(pp_parent) == True
+    # The str form must agree with the object form: it used to anchor
+    # `other` at self's root (Uri(self, _ROOT, other)) and answer False for
+    # every *relative* self.
+    assert u.is_relative_to(parent_str) == pp.is_relative_to(parent_str) == True
+
+
+@given(segs=nonempty_segments_list)
+@settings(max_examples=200)
+def test_is_relative_to_str_matches_pure_posix_path_for_unrelated_other(segs):
+    # The negative direction of the same oracle: a str `other` that is not a
+    # prefix must answer False for both, relative and absolute self alike.
+    other_str = _posix(["zzz-unrelated"])
+    for path_str in (_posix(segs), "/" + _posix(segs)):
+        u, pp = Uri(path_str), pathlib.PurePosixPath(path_str)
+        assert u.is_relative_to(other_str) == pp.is_relative_to(other_str)
 
 
 # --- uritools oracle: one-pass parse/compose fast paths ---

{pathlib_next-0.9.1 → pathlib_next-0.9.2}/tests/test_sftp.py

@@ -315,9 +315,16 @@ def test_sftp_backend_connect_and_client():
         transport = backend.transport(source)
         assert transport is mock_transport
         mock_ssh.set_missing_host_key_policy.assert_called_with("policy")
-        mock_ssh.connect.assert_called_with(
-            timeout=10, hostname="host", port=2222, username="user", password="pass"
-        )
+        # Assert the arguments this test is ABOUT, not the whole call: the
+        # backend also merges the developer's real ~/.ssh/config, so a machine
+        # with an `identityfile` entry adds `key_filename=` and an exact-call
+        # assertion fails there while passing on a key-less CI runner.
+        connect_kwargs = mock_ssh.connect.call_args.kwargs
+        assert connect_kwargs["timeout"] == 10
+        assert connect_kwargs["hostname"] == "host"
+        assert connect_kwargs["port"] == 2222
+        assert connect_kwargs["username"] == "user"
+        assert connect_kwargs["password"] == "pass"
 
         # Test client()
         client = backend.client(source)

{pathlib_next-0.9.1 → pathlib_next-0.9.2}/tests/test_sync.py

@@ -547,7 +547,7 @@ def test_sync_symlink_preserve_cross_backend_unsupported_target_raises(
     tmp_path,
 ):
     # SFTP source (supports symlink_to) -> MemPath target (does not):
-    # the documented Phase 1 behavior is NotImplementedError through
+    # the documented behavior is NotImplementedError surfaced through
     # ignore_error/hook(), not a silent skip or crash.
     backend = _FakeSymlinkBackend()
     source = _fake_sftp("sftp://host/link.txt", backend=backend)