pathlib-next 0.9.4__tar.gz → 0.9.5__tar.gz

{pathlib_next-0.9.4 → pathlib_next-0.9.5}/CHANGELOG.md

@@ -7,6 +7,41 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.9.5] - 2026-09-16
+
+### Fixed
+- **Archive member names are normalized**, so the same member is reachable
+  however the archive was written and whichever format it is. A leading
+  `./` (what `tar -C dir .`, `TarFile.add(arcname=".")` and
+  `shutil.make_archive` put on every member), empty segments (`a//b`) and
+  interior `.`/`..` (`a/./b`, `a/b/../c`) now resolve to one name for
+  listing and lookup alike. Previously only `tar:` stripped a leading `./`:
+  a zip written that way listed as empty and none of its members could be
+  read under any spelling, while a name such as `d//e.txt` was readable but
+  absent from listings.
+
+### Changed
+- **A drive- or backslash-shaped member name is no longer dropped.**
+  `C:drive.txt` and `a\b` are ordinary filenames on POSIX, and an archive
+  written there may contain them; they were silently absent from every
+  listing and unreadable on every platform. The rule they were failing is a
+  *destination* rule, and now lives where the joining happens:
+  `Path.copy(recursive=True)` refuses a child name that would not stay
+  inside its target (`ValueError` through `ignore_error`), which is what
+  `PathSyncer` and `utils.unpack_archive()` already did per destination.
+  Copying such a member onto a Windows path is still refused; copying it to
+  a POSIX path, a `MemPath` or another archive now works.
+- **A member name that escapes the archive root** (`../x`, `/abs`, a
+  `..` with nothing left to consume) has no name inside the archive: it was
+  already never listed, and is now never readable either. Such a member
+  used to be hidden from listings while `read_bytes()` still returned it
+  under its raw name. (Writing to one already failed and created nothing;
+  that is unchanged.) A `..` that stays inside is resolved rather than
+  rejected (`pkg/../ok.txt` reads `ok.txt`), and when two spellings
+  normalize to one name the later member wins, as in `zipfile`/`tarfile`.
+- **`Uri`'s RFC 3986 dot-segment removal is documented** as a divergence
+  from `pathlib` (`docs/divergences.md`); the behaviour is unchanged.
+
 ## [0.9.4] - 2026-09-16
 
 ### Fixed
@@ -1269,7 +1304,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.4...HEAD
+[Unreleased]: https://github.com/jose-pr/pathlib-next/compare/v0.9.5...HEAD
+[0.9.5]: https://github.com/jose-pr/pathlib-next/compare/v0.9.4...v0.9.5
 [0.9.4]: https://github.com/jose-pr/pathlib-next/compare/v0.9.3...v0.9.4
 [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

{pathlib_next-0.9.4 → pathlib_next-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pathlib-next
-Version: 0.9.4
+Version: 0.9.5
 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.4 → pathlib_next-0.9.5}/docs/divergences.md

@@ -80,6 +80,9 @@ these operations itself always keeps its own implementation.
 | `str()`/`repr()` of `github:`/`gitlab:`/`git:` paths | N/A (no pathlib equivalent) | The **whole** userinfo is redacted, not just the part after `:` as for other schemes. `as_uri()` (unsanitized) still returns it. | The token is commonly the bare userinfo (`TOKEN@host`), the one part other schemes keep, so it reached logs and tracebacks. |
 | `Path.exists()` / `is_*()` on a stat error other than "not found" | pathlib 3.9-3.12 re-raise errors outside ENOENT/ENOTDIR/EBADF/ELOOP (e.g. `PermissionError`); 3.13+ return `False` | Every `OSError`/`ValueError` from `stat()` returns `False` on every Python version, including `LocalPath.exists()` on 3.9-3.12. | One rule across backends and versions, matching current pathlib. |
 | `PathSyncer` directory → file/symlink type change | N/A (closest: `rsync`, which will not delete a non-empty directory without `--delete`/`--force`) | With `remove_missing=False`, a non-empty target directory is not replaced when the source entry at that name became a file or symlink: `IsADirectoryError` goes through `ignore_error` (`SyncEvent.TypeMismatch`) and the directory is kept. Empty directories, or `remove_missing=True`, are replaced. | `remove_missing=False` means "never delete target-only data"; replacing the directory silently deleted its whole subtree. |
+| `Path.copy(recursive=True)` child names | `shutil.copytree` joins whatever the listing yields | A child name that would not stay inside `target` is refused with `ValueError` through `ignore_error`: `..`, and `\`/`:`/a trailing dot when the target reads names with Windows rules. | The names come from listings the destination does not control (an archive, an HTTP index, an object-store key); on a Windows target `"C:x"` joins to a drive-relative path outside the destination entirely. `PathSyncer` and `utils.unpack_archive()` already applied this per destination. |
+| Archive member names | N/A (`zipfile`/`tarfile` expose the raw name as written) | Normalized as POSIX relative paths for every format: a leading `./`, empty segments and interior `.`/`..` resolve, so one member has one name and listings and lookups agree; the raw spelling still addresses it, and the later of two members that normalize alike wins. A name that escapes the root (`../x`, `/abs`) has no name inside the archive at all, while a drive- or backslash-shaped name is a normal member (an ordinary POSIX filename) that only a Windows destination refuses to receive. | The same file was reachable or not depending on how the writer spelled it: a zip written by `shutil.make_archive`-style `./` prefixes listed as empty, and zip and tar disagreed about identical archives. |
+| `Uri` path dot segments | `pathlib` keeps `..` lexically (`PurePosixPath("a/../b")` is `a/../b`) | `Uri` removes dot segments as RFC 3986 requires of a URI reference, in the constructor and in `/`-joins: `Uri("a/../b")` is `b`, `Uri("http://h/x") / "a/../b"` is `http://h/x/b`, and `Uri("a/b/..")` is `a/`. A leading `..` that would pass the root is kept, not resolved. `MemPath` follows `pathlib` instead. | A URI is resolved, not spelled: `..` in a URI reference has a defined meaning that servers, caches and proxies already apply, so keeping it lexically would address a different resource than the same string typed into a browser. |
 | Nested archive URIs | N/A | Each leading archive scheme in `<archive-uri>` consumes one `!/` (`zip:zip:file:///outer.zip!/inner.zip!/x.txt`); a member name containing `!/` is written `%21/`. Nested archives are read-only. | The first `!/` was always taken as the separator, so an archive inside an archive could not be addressed. |
 | Object-store key that is both an object and a prefix | N/A (a filesystem entry has one type) | `iterdir()`/`walk()`/`copy(recursive=True)` on `s3:`/`gs:`/`az:` show only the object (`x`), matching `stat()`'s exact-object precedence; the subtree under `x/` is not listed. | Listings used to keep the directory and drop the object, contradicting `stat()`. |
 | `HttpPath.iterdir()` on a file | pathlib raises `NotADirectoryError` | Raises `NotADirectoryError` for a non-HTML response, without downloading it. An HTML file cannot be told apart from an index page and lists as empty. | HTTP has no directory type; the response content type is the only signal. |

{pathlib_next-0.9.4 → pathlib_next-0.9.5}/docs/guides/schemes.md

@@ -205,9 +205,17 @@ The `<archive-uri>` is any absolute URI with an explicit scheme, so
 - An archive inside an archive is addressed by nesting
   (`zip:zip:file:///outer.zip!/inner.zip!/x.txt`) and is read-only; a `!/`
   inside a member name is written `%21/`.
-- Members whose names would escape a destination (`..`, absolute or drive
-  paths) are never listed. Exception types are the POSIX ones on every
-  platform.
+- Member names are normalized as POSIX relative paths, the same way for
+  every format: `./x`, `a//b`, `a/./b` and `a/b/../c` all resolve, so a
+  member lists and reads under one name however the archive was written
+  (`tar -C dir .` and `shutil.make_archive` prefix every member with `./`).
+  The spelling as written still works.
+- Members whose names would escape the archive (`..` past the root, or an
+  absolute path) have no name inside it: never listed, never readable. A
+  name that merely a Windows destination would misread -- `C:drive.txt`, or
+  one containing `\` -- is a normal member, since both are ordinary
+  filenames on POSIX; copying or extracting it onto a Windows path is what
+  refuses it. Exception types are the POSIX ones on every platform.
 
 ## Git hosting
 

{pathlib_next-0.9.4 → pathlib_next-0.9.5}/pyproject.toml

@@ -13,7 +13,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.4"
+version = "0.9.5"
 authors = [{ name = "Jose A" }]
 description = "Generic Path Protocol based pathlib"
 readme = "README.md"

{pathlib_next-0.9.4 → pathlib_next-0.9.5}/src/pathlib_next/AGENTS.md

@@ -114,6 +114,13 @@ silently absent and `from pathlib_next.uri import UriPath` raises
       the same file (or a case-insensitive alias) → `OSError(EINVAL)`.
     - The source is opened before the target is touched; a failed stream
       removes the partial target.
+    - A recursive copy refuses any child name that would not stay inside
+      `target` — `..`, and `\`/`:`/a trailing dot when the target reads
+      names with Windows rules (`utils.is_windows_flavoured()`). The names
+      come from a listing the destination does not control (an archive, a
+      remote index, an object-store key), and on a Windows target `"C:x"`
+      joins to a drive-relative path outside it. Raised as `ValueError`
+      through `ignore_error`, per child, like any other child failure.
     - `follow_symlinks=False` on a symlink recreates the link
       (`NotImplementedError` if either side cannot).
     - `preserve_metadata=True` copies permission bits only, and only a mode the
@@ -481,15 +488,30 @@ chained (their text can carry credentials).
   - One shared handle per archive (keyed by the real local path, or the outer
     URI), released when no path references it. A non-local outer is read into
     memory.
-  - Members named with `..`, an absolute path or a drive are never listed.
-    Exception types are POSIX on every platform.
+  - **Member names are normalized POSIX relative paths**, whatever the
+    writer emitted and whichever format: a leading `./` (`tar -C dir .`,
+    `shutil.make_archive`), empty segments (`a//b`) and interior `.`/`..`
+    (`a/./b`, `a/b/../c`) resolve, so one member has one name and a listing
+    and a lookup always agree. The spelling as written still addresses the
+    member. A name that would leave the root -- `../x`, `/abs`, or a `..`
+    with nothing to spend it on -- has no name inside the archive: it is
+    never listed, never readable, and cannot be written (the write fails and
+    creates nothing). A name only a *Windows destination* would misread
+    (`C:drive.txt`, `a\b`) IS a member, because it is an ordinary POSIX
+    filename; refusing to join it is the destination's rule, applied by
+    whatever writes there (see `copy()` below, `PathSyncer`,
+    `unpack_archive()`). `zipfile` itself rewrites `\` to `/`, so a
+    backslash name only survives in a tar. When two spellings normalize to one name the
+    later member wins, as in `zipfile`/`tarfile`. Exception types are POSIX on every
+    platform.
   - Writes: zip only, and only with a local `file:` outer (else
     `NotImplementedError`). `"w"`/`"x"`/`"r+"`, `mkdir()`, `unlink()`,
     `rmdir()`, `rename()` (same archive; replaces like POSIX `rename`);
     parents must exist; `"a"` unsupported. Every mutation replaces the archive
     atomically (temp file + `os.replace`) and keeps other members' metadata,
-    the comment and any prefix bytes. `tar:` (plain, gz, bz2, xz) is
-    read-only; `./` member prefixes are dropped.
+    the comment and any prefix bytes. A write uses the normalized name; a
+    name that escapes the root fails and creates nothing.
+    `tar:` (plain, gz, bz2, xz) is read-only.
 
 ## CLI (`uripath`, `pathlib_next.tools.uripath`)
 

{pathlib_next-0.9.4 → pathlib_next-0.9.5}/src/pathlib_next/path.py

@@ -1180,8 +1180,27 @@ class Path(Pathname, Chmod, Stat, BinaryOpen):
                     raise FileExistsError(target)
             else:
                 target.mkdir()
+            windows_target = _utils.is_windows_flavoured(target)
             for child in children:
                 try:
+                    # The names come from a listing the destination does not
+                    # control (an archive, a remote index, an object-store
+                    # key), so one that is not a single component inside
+                    # `target` must never be joined onto it: on a Windows
+                    # target "C:x" joins to a drive-relative path outside it
+                    # entirely, and so does "a\\b". Reported through
+                    # `ignore_error` like any other per-child failure, not
+                    # silently skipped. `PathSyncer` and
+                    # `utils.unpack_archive()` apply the same rule per
+                    # destination; an archive listing keeps such names,
+                    # because they are ordinary filenames on POSIX.
+                    if not _utils.is_safe_child_name(
+                        child.name, windows=windows_target
+                    ):
+                        raise ValueError(
+                            f"refusing unsafe child name {child.name!r} "
+                            f"under {target}"
+                        )
                     child.copy(
                         target / child.name,
                         overwrite=overwrite,

{pathlib_next-0.9.4 → pathlib_next-0.9.5}/src/pathlib_next/uri/schemes/archive/_base.py

@@ -17,26 +17,68 @@ from ..file import FileUri
 
 _SEP = "!/"
 _SCHEME_RE = _re.compile(r"^[a-zA-Z][a-zA-Z0-9+.\-]*:")
-_MEMBER_SEP_RE = _re.compile(r"[/\\]")
-_DRIVE_RE = _re.compile(r"^[a-zA-Z]:")
 # Every scheme an `ArchiveUri` class registers (see `archive/__init__.py`).
 _ARCHIVE_SCHEMES = ("zip", "tar", "archive", "archive+zip", "archive+tar")
 
 
 def _is_safe_member_name(name: str) -> bool:
-    """Whether archive member `name` stays inside the archive root once its
-    parts are joined onto a destination (e.g. by a recursive `copy()`).
-
-    Both `/` and `\\` count as separators here -- only here: lookups keep
-    the raw member name, since `\\` is a legal filename character on POSIX.
-    Rejects absolute names, empty/`.`/`..` parts and drive-qualified parts
-    (`C:x`, `C:..`); a trailing `/` (a directory marker) is allowed."""
+    """Whether archive member `name` is a usable relative path inside the
+    archive: every part a real name, none of them escaping the root.
+
+    Only the rules that hold on every platform are applied here, because an
+    archive has no platform of its own: `\\`, `:` and trailing dots are
+    ordinary filename characters on POSIX, and an archive written there may
+    legitimately contain `C:drive.txt` or `a\\b`. Refusing to *join* such a
+    name onto a destination that reads it differently is the destination's
+    rule, and is applied per target where the joining happens --
+    `Path.copy(recursive=True)`, `PathSyncer` and `utils.unpack_archive()`
+    each check `is_safe_child_name(..., windows=is_windows_flavoured(dest))`.
+    A trailing `/` (a directory marker) is allowed."""
     if name.endswith("/"):
         name = name[:-1]
-    return all(
-        is_safe_child_name(part) and not _DRIVE_RE.match(part)
-        for part in _MEMBER_SEP_RE.split(name)
-    )
+    return all(is_safe_child_name(part) for part in name.split("/"))
+
+
+def _normalize_member_name(name: str) -> "str | None":
+    """`name` as a normalized POSIX relative path, or None if it does not
+    stay inside the archive root.
+
+    A member name is a relative path, and writers spell it several ways for
+    the same file: `./x` (`tar -C dir .`, `TarFile.add(arcname=".")`,
+    `shutil.make_archive`), `a//b`, `a/./b`, `a/b/../c`. Normalizing it the
+    way a URI reference resolves -- RFC 3986 dot-segment removal, with empty
+    segments dropped -- gives one member one name, so a listing and a lookup
+    agree however the archive was written, and the same spelling addresses
+    the same member in a zip and in a tar.
+
+    A name that would leave the root has no normalized form inside the
+    archive and is rejected (None): absolute (`/abs`), or with more `..`
+    than parts to spend them on. `..` that stays inside is resolved
+    (`pkg/../ok.txt` is `ok.txt`). A drive-shaped part (`C:x`) is NOT
+    rejected here: it is a legal POSIX filename, and only a destination
+    that reads names with Windows rules is endangered by it -- see
+    `_is_safe_member_name`. A trailing `/` (a directory marker) is kept, and
+    the archive root itself normalizes to "".
+    """
+    if name.startswith("/"):
+        return None
+    directory = name.endswith("/")
+    parts: "list[str]" = []
+    for part in name.split("/"):
+        if part in ("", "."):
+            continue
+        if part == "..":
+            if not parts:
+                return None  # escapes the archive root
+            parts.pop()
+            continue
+        parts.append(part)
+    normalized = "/".join(parts)
+    if not normalized:
+        return ""  # the archive root ("", ".", "./", "a/..")
+    if not _is_safe_member_name(normalized):
+        return None
+    return normalized + "/" if directory else normalized
 
 
 def _nesting_depth(archive_uri: str) -> int:
@@ -368,18 +410,52 @@ class ArchiveUri(UriPath):
         )
         return f"{self.source.scheme}:{outer_uri}{_SEP}{inner}{tail}"
 
+    def _member_index(self):
+        """Normalized member name -> the key the backend knows it by.
+
+        Built from `backend.names()` on every call, as the old raw scan was.
+        A member whose name escapes the root is left out entirely, so an
+        unsafe member ('../x', '/abs', 'C:x') can be neither listed nor
+        looked up. When two spellings normalize to one name, the later entry
+        wins -- what `zipfile` and `tarfile` do with duplicates themselves.
+        """
+        index = {}
+        for raw in self.backend.names():
+            normalized = _normalize_member_name(raw)
+            if not normalized:  # None (escapes) or "" (the root itself)
+                continue
+            index[normalized] = raw
+        return index
+
     def _names(self):
-        return self.backend.names()
+        return list(self._member_index())
+
+    def _raw_name(self, name: str) -> str:
+        """The backend's own key for a normalized name (the name itself when
+        the archive spells it canonically, or holds no such member yet)."""
+        return self._member_index().get(name, name)
+
+    @property
+    def _member(self) -> "str | None":
+        """This path as a normalized member name, or None if it escapes."""
+        return _normalize_member_name(self.path)
+
+    def _member_for_write(self) -> str:
+        member = self._member
+        if member is None:
+            raise ValueError(f"member name escapes the archive root: {self.path!r}")
+        return member
 
     def _listdir(self):
-        if self.path and not self.stat().is_dir():
+        member = self._member
+        if member is None:
+            raise FileNotFoundError(self)
+        if member and not self.stat().is_dir():
             raise NotADirectoryError(_errno.ENOTDIR, "Not a directory", str(self))
-        prefix = f"{self.path}/" if self.path else ""
+        prefix = f"{member}/" if member else ""
         seen = set()
         for name in self._names():
-            # An unsafe member ('../x', '/abs', 'C:x', ...) is never listed:
-            # a caller joining a listed name onto a destination must stay in it.
-            if not name.startswith(prefix) or not _is_safe_member_name(name):
+            if not name.startswith(prefix):
                 continue
             rest = name[len(prefix) :]
             if not rest:
@@ -390,16 +466,18 @@ class ArchiveUri(UriPath):
                 yield child
 
     def stat(self, *, follow_symlinks=True):
-        path = self.path
+        path = self._member
+        if path is None:
+            raise FileNotFoundError(self)
         if path == "":
             return FileStat(is_dir=True)
-        names = self._names()
-        if path in names:
-            return self.backend.member_stat(path)
+        index = self._member_index()
+        if path in index:
+            return self.backend.member_stat(index[path])
         dirmarker = f"{path}/"
-        if dirmarker in names:
-            return self.backend.member_stat(dirmarker)
-        if any(n.startswith(dirmarker) for n in names):
+        if dirmarker in index:
+            return self.backend.member_stat(index[dirmarker])
+        if any(n.startswith(dirmarker) for n in index):
             return FileStat(is_dir=True)
         raise FileNotFoundError(self)
 
@@ -441,8 +519,11 @@ class ArchiveUri(UriPath):
         )
 
     def _read_member(self):
+        member = self._member
+        if member is None:
+            raise FileNotFoundError(self)
         try:
-            return self.backend.read_member(self.path)
+            return self.backend.read_member(self._raw_name(member))
         except KeyError as error:
             if self._is_dir_member():
                 raise IsADirectoryError(
@@ -457,7 +538,9 @@ class ArchiveUri(UriPath):
         if "r" in mode:
             # Read-modify-write: what is written reaches the archive on close.
             data = self._read_member().read()
-            return _ArchiveWriteStream(self.backend, self.path, initial=data)
+            return _ArchiveWriteStream(
+                self.backend, self._raw_name(self._member_for_write()), initial=data
+            )
         if mode not in ("w", "x"):
             raise NotImplementedError(f"open(mode={mode!r})")
         if self._is_dir_member():
@@ -465,38 +548,39 @@ class ArchiveUri(UriPath):
         if mode == "x" and self.exists():
             raise FileExistsError(self)
         self._check_parent()
-        return _ArchiveWriteStream(self.backend, self.path)
+        return _ArchiveWriteStream(self.backend, self._member_for_write())
 
     def _mkdir(self, mode):
         self._require_writable()
         if self.exists():
             raise FileExistsError(self)
         self._check_parent()
-        self.backend.write_member(f"{self.path}/", b"")
+        self.backend.write_member(f"{self._member_for_write()}/", b"")
 
     def unlink(self, missing_ok=False):
         self._require_writable()
-        path = self.path
-        if path not in self._names():
+        path = self._member_for_write()
+        index = self._member_index()
+        if path not in index:
             if self._is_dir_member():
                 raise IsADirectoryError(_errno.EISDIR, "Is a directory", str(self))
             if missing_ok:
                 return
             raise FileNotFoundError(self)
-        self.backend.delete_member(path)
+        self.backend.delete_member(index[path])
 
     def rmdir(self):
         self._require_writable()
-        path = self.path
+        path = self._member_for_write()
         marker = f"{path}/"
-        names = self._names()
-        if any(n != marker and n.startswith(marker) for n in names):
+        index = self._member_index()
+        if any(n != marker and n.startswith(marker) for n in index):
             raise OSError(_errno.ENOTEMPTY, "Directory not empty", str(self))
-        if marker not in names:
-            if path in names:
+        if marker not in index:
+            if path in index:
                 raise NotADirectoryError(_errno.ENOTDIR, "Not a directory", str(self))
             raise FileNotFoundError(self)
-        self.backend.delete_member(marker)
+        self.backend.delete_member(index[marker])
 
     def _same_location(self, other: Uri) -> bool:
         # Every archive URI has the same bare "zip:"/"tar:" authority, so the
@@ -516,26 +600,31 @@ class ArchiveUri(UriPath):
         # Returns the new path, as pathlib does.
         self._require_writable()
         target = self._rename_target(target)
-        old_path = self.path
-        new_path = target.path.lstrip("/")
-        names = self._names()
+        old_path = self._member_for_write()
+        new_path = _normalize_member_name(target.path.lstrip("/"))
+        if not new_path:
+            raise ValueError(f"member name escapes the archive root: {target.path!r}")
+        index = self._member_index()
+        names = list(index)
         marker = f"{old_path}/"
         new_marker = f"{new_path}/"
         renamed = self._from_parsed_parts(self.source, new_path, "", "")
-        if old_path in names:
+        if old_path in index:
             if new_path == old_path:
                 return renamed
             if any(n.startswith(new_marker) for n in names):
                 raise IsADirectoryError(_errno.EISDIR, "Is a directory", str(target))
-            self.backend.rename_member(old_path, new_path)
+            self.backend.rename_member(index[old_path], new_path)
         elif any(n.startswith(marker) for n in names):
             if new_marker == marker:
                 return renamed
-            if new_path in names:
+            if new_path in index:
                 raise NotADirectoryError(_errno.ENOTDIR, "Not a directory", str(target))
             if any(n != new_marker and n.startswith(new_marker) for n in names):
                 raise OSError(_errno.ENOTEMPTY, "Directory not empty", str(target))
-            self.backend.rename_member(marker, new_marker)
+            # A directory can be implicit (no marker entry of its own), so
+            # fall back to the marker itself rather than indexing.
+            self.backend.rename_member(index.get(marker, marker), new_marker)
         else:
             raise FileNotFoundError(self)
         return renamed