pathlib-next 0.6.0__tar.gz → 0.7.0__tar.gz

{pathlib_next-0.6.0 → pathlib_next-0.7.0}/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-07-11
+
+### Added (Phase 7b new schemes, optional extras)
+- `dav:`/`davs:` scheme (`pathlib_next.uri.schemes.webdav.DavPath`):
+  extends `HttpPath` with WebDAV (RFC 4918) PROPFIND for real stat/listdir
+  metadata (replacing HTML-index scraping) and PUT/DELETE/MKCOL/MOVE for
+  full read/write access. Requests go to the equivalent `http:`/`https:`
+  URL; `as_uri()` still reports `dav:`/`davs:`. Reuses the `http` extra,
+  no new dependency. `rmdir()` is recursive by WebDAV spec, unlike
+  `pathlib.Path.rmdir()`'s "must be empty" contract -- documented, not
+  silent.
+- `s3:` scheme (`pathlib_next.uri.schemes.s3.S3Path`,
+  `s3://bucket/key/path`): read/write/list via `boto3`. New `s3` extra.
+  S3 has no real directories -- `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.
+  `rename()` uses server-side `copy_object`+`delete_object` (same-bucket
+  only) instead of the generic download+upload+delete `move()` fallback.
+
 ## [0.6.0] - 2026-07-11
 
 ### Added (Phase 7a new schemes, stdlib-only, no new deps)
@@ -235,7 +254,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.6.0...HEAD
+[Unreleased]: https://github.com/jose-pr/pathlib_next/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/jose-pr/pathlib_next/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/jose-pr/pathlib_next/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/jose-pr/pathlib_next/compare/v0.4.1...v0.5.0
 [0.4.1]: https://github.com/jose-pr/pathlib_next/compare/v0.4.0...v0.4.1

{pathlib_next-0.6.0 → pathlib_next-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathlib_next
-Version: 0.6.0
+Version: 0.7.0
 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/
@@ -26,6 +26,9 @@ Requires-Dist: bs4; extra == 'http'
 Requires-Dist: htmllistparse; extra == 'http'
 Requires-Dist: requests; extra == 'http'
 Requires-Dist: uritools; extra == 'http'
+Provides-Extra: s3
+Requires-Dist: boto3; extra == 's3'
+Requires-Dist: uritools; extra == 's3'
 Provides-Extra: sftp
 Requires-Dist: paramiko; extra == 'sftp'
 Requires-Dist: uritools; extra == 'sftp'

{pathlib_next-0.6.0 → pathlib_next-0.7.0}/docs/divergences.md

@@ -20,6 +20,8 @@ The divergences below apply to `Uri`/`UriPath` and `MemPath`.
 | `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 | N/A -- pure extension. |
 | `PathSyncer` / `Query` / `Source` | N/A | Our own extensions | N/A -- pure extensions, no pathlib equivalent. |
+| `DavPath.rmdir()` | `pathlib.Path.rmdir()` requires the directory to be empty, raises `OSError` otherwise | WebDAV `DELETE` on a collection is recursive by spec (RFC 4918) -- deletes non-empty collections too | Not our choice -- inherent to the WebDAV protocol's `DELETE` semantics; no separate "delete if empty" verb exists to build an empty-check on top of. **Caution**, not a feature. |
+| `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", unlike `DavPath.rmdir()` above) | S3 has no native directory concept -- this is the same prefix convention the AWS console itself uses for an empty "folder". |
 
 ## Explicitly out of scope (not implemented on `Pathname`/`Path`)
 

{pathlib_next-0.6.0 → pathlib_next-0.7.0}/docs/guides/schemes.md

@@ -6,17 +6,17 @@ meaningful for a read-only scheme) -- everything else (name/suffix parsing,
 `glob()`, `walk()`, `copy()`, ...) is derived from these primitives and
 works identically across all of them.
 
-| Capability | `LocalPath` | `file:` (`FileUri`) | `mem:` (`MemPath`) | `http(s):` (`HttpPath`) | `sftp:` (`SftpPath`) | `data:` (`DataUri`) | `ftp(s):` (`FtpPath`) | `zip:` (`ZipUri`) | `tar:` (`TarUri`) |
-| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
-| Read (`read_text`/`read_bytes`/`open`) | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
-| Write (`write_text`/`write_bytes`/`open("w")`) | Yes | Yes | Yes | No | Yes | No | Yes | New entries only, local outer archive only | No |
-| List (`iterdir`) | Yes | Yes | Yes | Yes (scrapes an HTML index) | Yes | No (`NotADirectoryError`) | Yes (MLSD, falls back to NLST) | Yes | Yes |
-| Stat (`stat`, `exists`, `is_dir`, `is_file`, ...) | Yes | Yes | Yes | Yes (via `HEAD`, falls back to `GET`) | Yes | Yes (`st_size` from decoded payload) | Yes (MLSD, falls back to SIZE for files) | Yes | Yes |
-| `mkdir` | Yes | Yes | Yes | No | Yes | No | Yes | Local outer archive only (zero-length `name/` entry) | No |
-| Delete (`unlink`/`rmdir`/`rm`) | Yes | Yes | Yes | No | Yes | No | Yes | No | No |
-| `rename` | Yes | Yes | No (`move()` falls back to copy+unlink) | No | Yes | No | Yes | No | No |
-| `chmod` | Yes | Yes | No | No | Yes (no `follow_symlinks=False`; paramiko has no `lchmod`) | No | Yes (`SITE CHMOD`, server-dependent) | No | No |
-| Extra required | none | none | none | `http` | `sftp` | none (stdlib) | none (stdlib `ftplib`) | none (stdlib `zipfile`) | none (stdlib `tarfile`) |
+| Capability | `LocalPath` | `file:` (`FileUri`) | `mem:` (`MemPath`) | `http(s):` (`HttpPath`) | `sftp:` (`SftpPath`) | `data:` (`DataUri`) | `ftp(s):` (`FtpPath`) | `zip:` (`ZipUri`) | `tar:` (`TarUri`) | `dav(s):` (`DavPath`) | `s3:` (`S3Path`) |
+| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
+| Read (`read_text`/`read_bytes`/`open`) | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes | Yes |
+| Write (`write_text`/`write_bytes`/`open("w")`) | Yes | Yes | Yes | No | Yes | No | Yes | New entries only, local outer archive only | No | Yes | Yes |
+| List (`iterdir`) | Yes | Yes | Yes | Yes (scrapes an HTML index) | Yes | No (`NotADirectoryError`) | Yes (MLSD, falls back to NLST) | Yes | Yes | Yes (PROPFIND) | Yes (prefix + delimiter emulation) |
+| Stat (`stat`, `exists`, `is_dir`, `is_file`, ...) | Yes | Yes | Yes | Yes (via `HEAD`, falls back to `GET`) | Yes | Yes (`st_size` from decoded payload) | Yes (MLSD, falls back to SIZE for files) | Yes | Yes | Yes (PROPFIND) | Yes (`is_dir` is prefix emulation) |
+| `mkdir` | Yes | Yes | Yes | No | Yes | No | Yes | Local outer archive only (zero-length `name/` entry) | No | Yes (MKCOL) | Yes (zero-byte `key/` marker object) |
+| Delete (`unlink`/`rmdir`/`rm`) | Yes | Yes | Yes | No | Yes | No | Yes | No | No | Yes (`rmdir` is recursive, see notes) | Yes (`rmdir` requires empty prefix) |
+| `rename` | Yes | Yes | No (`move()` falls back to copy+unlink) | No | Yes | No | Yes | No | No | Yes (MOVE) | Yes (server-side `copy_object`+delete, same bucket) |
+| `chmod` | Yes | Yes | No | No | Yes (no `follow_symlinks=False`; paramiko has no `lchmod`) | No | Yes (`SITE CHMOD`, server-dependent) | No | No | No | No |
+| Extra required | none | none | none | `http` | `sftp` | none (stdlib) | none (stdlib `ftplib`) | none (stdlib `zipfile`) | none (stdlib `tarfile`) | `http` (reused) | `s3` |
 
 Notes:
 
@@ -57,6 +57,22 @@ Notes:
   works when the outer archive is itself a local `file:` URI; every other
   outer scheme is read-only. `tar:` (with transparent `.tar.gz`/`.tar.bz2`/
   `.tar.xz` decompression) is read-only regardless of the outer scheme.
+- **`dav(s):`** is WebDAV (RFC 4918) layered on `HttpPath` -- PROPFIND
+  replaces HTML-index scraping for real stat/listdir metadata, and PUT/
+  DELETE/MKCOL/MOVE give it full write support (unlike plain `http(s):`).
+  Requests go out over the equivalent `http:`/`https:` URL; `as_uri()`
+  still reports `dav:`/`davs:`. Reuses the `http` extra, no new dependency.
+  **Caution:** `rmdir()` maps to WebDAV `DELETE`, which is recursive by
+  spec -- unlike `pathlib.Path.rmdir()`, it does not require the
+  collection to be empty first.
+- **`s3:`** (`s3://bucket/key/path`) has no real directories: `is_dir()`
+  is prefix emulation (any object key under `"<path>/"`), and `mkdir()`
+  creates a zero-byte `"<path>/"` marker object (the same convention the
+  AWS console itself uses for an empty "folder") -- `rmdir()` requires no
+  other keys under that prefix (pathlib's "must be empty" semantics, unlike
+  `dav:`'s recursive `DELETE`). A single `boto3` client is cached per
+  backend (documented thread-safe, unlike `sftp:`/`ftp:`'s per-thread
+  connection pools).
 - See [Divergences from pathlib](../divergences.md) for the "explicitly out
   of scope" list (`resolve`, `symlink_to`, `owner`, `expanduser`, ...) that
   applies uniformly across every non-`LocalPath` implementation.

{pathlib_next-0.6.0 → pathlib_next-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pathlib_next"
-version = "0.6.0"
+version = "0.7.0"
 authors = [{ name = "Jose A" }]
 description = "Generic Path Protocol based pathlib"
 readme = "README.md"
@@ -19,6 +19,7 @@ dependencies = []
 uri = ["uritools"]
 http = ["requests", "pathlib_next[uri]", 'htmllistparse', 'bs4']
 sftp = ["paramiko", "pathlib_next[uri]"]
+s3 = ["boto3", "pathlib_next[uri]"]
 dev = ['build', 'twine', 'hatchling', 'pytest', 'pytest-cov']
 docs = ['mkdocs', 'mkdocs-material', 'mkdocstrings[python]']
 

{pathlib_next-0.6.0 → pathlib_next-0.7.0}/src/pathlib_next/uri/schemes/__init__.py

@@ -8,7 +8,15 @@ try:
     from .http import HttpPath as HttpPath
 except ImportError:
     pass
+try:
+    from .webdav import DavPath as DavPath
+except ImportError:
+    pass
 try:
     from .sftp import SftpPath as SftpPath
 except ImportError:
     pass
+try:
+    from .s3 import S3Path as S3Path
+except ImportError:
+    pass

pathlib_next-0.7.0/src/pathlib_next/uri/schemes/s3.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import io as _io
+import typing as _ty
+
+import botocore.exceptions as _botoexc
+
+from ... import utils as _utils
+from ...utils.stat import FileStat
+from .. import Source, Uri, UriPath
+
+
+class BaseS3Backend(object):
+    """Protocol for obtaining a `boto3` S3 client. Subclass this to plug in
+    custom credential/session handling (e.g. tests mock it directly, no
+    real AWS account needed); `S3Backend` is the real implementation."""
+
+    __slots__ = ()
+
+    @_utils.notimplemented
+    def client(self): ...
+
+
+class S3Backend(BaseS3Backend):
+    """Lazily creates+caches a `boto3` S3 client. Unlike `sftp.py`'s/
+    `ftp.py`'s per-thread connection pools, a single `boto3` client is
+    reused across threads -- it's documented as thread-safe."""
+
+    __slots__ = ("client_kwargs", "_client")
+
+    def __init__(self, **client_kwargs):
+        self.client_kwargs = client_kwargs
+        self._client = None
+
+    def client(self):
+        if self._client is None:
+            import boto3
+
+            self._client = boto3.client("s3", **self.client_kwargs)
+        return self._client
+
+
+def _is_not_found(error: _botoexc.ClientError) -> bool:
+    code = error.response.get("Error", {}).get("Code")
+    return code in ("404", "NoSuchKey", "NotFound")
+
+
+class _S3WriteStream(_io.BytesIO):
+    def __init__(self, path: "S3Path"):
+        super().__init__()
+        self._path = path
+
+    def close(self):
+        if not self.closed:
+            self._path._client.put_object(
+                Bucket=self._path.bucket, Key=self._path.key, Body=self.getvalue()
+            )
+        super().close()
+
+
+class S3Path(UriPath):
+    """`s3:` scheme (`s3://bucket/key/path`): read/write/list via `boto3`.
+    Requires the `s3` extra. S3 has no real directories -- `is_dir()` is
+    prefix emulation (any object key under `"<path>/"`), and `mkdir()`
+    creates a zero-byte `"<path>/"` marker object (the same convention the
+    AWS console itself uses for an empty "folder"); see
+    `docs/divergences.md`. `rename()` uses server-side `copy_object` +
+    `delete_object` (same-bucket only) instead of the generic
+    download+upload+delete `move()` fallback."""
+
+    __SCHEMES = ("s3",)
+    __slots__ = ()
+
+    if _ty.TYPE_CHECKING:
+        backend: BaseS3Backend
+
+    def _initbackend(self):
+        return S3Backend()
+
+    @property
+    def bucket(self) -> str:
+        return self.source.host
+
+    @property
+    def key(self) -> str:
+        return self.path.lstrip("/")
+
+    @property
+    def _client(self):
+        return self.backend.client()
+
+    def stat(self, *, follow_symlinks=True):
+        key = self.key
+        if key == "":
+            try:
+                self._client.head_bucket(Bucket=self.bucket)
+            except _botoexc.ClientError as error:
+                raise FileNotFoundError(self) from error
+            return FileStat(is_dir=True)
+        try:
+            head = self._client.head_object(Bucket=self.bucket, Key=key)
+            return FileStat(
+                st_size=head["ContentLength"],
+                st_mtime=int(head["LastModified"].timestamp()),
+                is_dir=False,
+            )
+        except _botoexc.ClientError as error:
+            if not _is_not_found(error):
+                raise
+        # Not an object at this exact key -- emulate a directory: any
+        # object under the "<key>/" prefix means this is a "directory".
+        resp = self._client.list_objects_v2(
+            Bucket=self.bucket, Prefix=f"{key}/", MaxKeys=1
+        )
+        if resp.get("KeyCount", 0) > 0:
+            return FileStat(is_dir=True)
+        raise FileNotFoundError(self)
+
+    def _listdir(self):
+        prefix = f"{self.key}/" if self.key else ""
+        seen = set()
+        paginator = self._client.get_paginator("list_objects_v2")
+        for page in paginator.paginate(
+            Bucket=self.bucket, Prefix=prefix, Delimiter="/"
+        ):
+            for common in page.get("CommonPrefixes", []):
+                name = common["Prefix"][len(prefix) :].rstrip("/")
+                if name and name not in seen:
+                    seen.add(name)
+                    yield name
+            for obj in page.get("Contents", []):
+                name = obj["Key"][len(prefix) :]
+                if name and name not in seen:
+                    seen.add(name)
+                    yield name
+
+    def _open(self, mode="r", buffering=-1):
+        if "r" in mode:
+            try:
+                resp = self._client.get_object(Bucket=self.bucket, Key=self.key)
+            except _botoexc.ClientError as error:
+                raise FileNotFoundError(self) from error
+            return _io.BytesIO(resp["Body"].read())
+        if mode not in ("w", "x"):
+            raise NotImplementedError(f"open(mode={mode!r})")
+        if mode == "x" and self.exists():
+            raise FileExistsError(self)
+        return _S3WriteStream(self)
+
+    def _mkdir(self, mode):
+        if self.exists():
+            raise FileExistsError(self)
+        self._client.put_object(Bucket=self.bucket, Key=f"{self.key}/", Body=b"")
+
+    def unlink(self, missing_ok=False):
+        if not missing_ok and not self.exists():
+            raise FileNotFoundError(self)
+        # delete_object() is idempotent (no error for a missing key) --
+        # the exists() check above is what actually enforces missing_ok.
+        self._client.delete_object(Bucket=self.bucket, Key=self.key)
+
+    def rmdir(self):
+        marker = f"{self.key}/"
+        resp = self._client.list_objects_v2(Bucket=self.bucket, Prefix=marker, MaxKeys=2)
+        contents = resp.get("Contents", [])
+        if any(obj["Key"] != marker for obj in contents):
+            raise OSError(f"Directory not empty: {self}")
+        self._client.delete_object(Bucket=self.bucket, Key=marker)
+
+    def rename(self, target: "S3Path | Uri | str"):
+        if not isinstance(target, Uri):
+            target = Uri(self.parent, target)
+        dest_key = target.path.lstrip("/")
+        self._client.copy_object(
+            Bucket=self.bucket,
+            Key=dest_key,
+            CopySource={"Bucket": self.bucket, "Key": self.key},
+        )
+        self._client.delete_object(Bucket=self.bucket, Key=self.key)

pathlib_next-0.7.0/src/pathlib_next/uri/schemes/webdav.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import io as _io
+import stat as _stat
+import urllib.parse as _urlparse
+import xml.etree.ElementTree as _ET
+
+import uritools as _uritools
+
+from ... import utils as _utils
+from ...utils.stat import FileStat
+from .. import Uri
+from .http import HttpPath
+
+_NS = {"D": "DAV:"}
+
+_PROPFIND_BODY = b"""<?xml version="1.0" encoding="utf-8"?>
+<D:propfind xmlns:D="DAV:">
+  <D:prop>
+    <D:resourcetype/>
+    <D:getcontentlength/>
+    <D:getlastmodified/>
+  </D:prop>
+</D:propfind>"""
+
+
+def _parse_response(elem) -> "tuple[str, bool, int, str]":
+    href = elem.findtext("D:href", namespaces=_NS) or ""
+    prop = elem.find("D:propstat/D:prop", _NS)
+    resourcetype = prop.find("D:resourcetype", _NS) if prop is not None else None
+    is_dir = (
+        resourcetype is not None
+        and resourcetype.find("D:collection", _NS) is not None
+    )
+    size_text = prop.findtext("D:getcontentlength", namespaces=_NS) if prop is not None else None
+    size = int(size_text) if size_text else 0
+    lm = prop.findtext("D:getlastmodified", namespaces=_NS) if prop is not None else None
+    return _urlparse.unquote(href), is_dir, size, lm
+
+
+class _DavWriteStream(_io.BytesIO):
+    def __init__(self, path: "DavPath"):
+        super().__init__()
+        self._path = path
+
+    def close(self):
+        if not self.closed:
+            resp = self._path.backend.request(
+                "PUT", self._path._wire_uri(), data=self.getvalue()
+            )
+            resp.raise_for_status()
+        super().close()
+
+
+class DavPath(HttpPath):
+    """`dav:`/`davs:` scheme: WebDAV (RFC 4918) over HTTP(S). Extends
+    `HttpPath` with PROPFIND (stat/listdir -- real directory metadata,
+    replacing `HttpPath`'s HTML-index scraping) and PUT/DELETE/MKCOL/MOVE
+    (full write support). Requests go to the equivalent `http:`/`https:`
+    URL (`_wire_uri()`); `as_uri()` still reports `dav:`/`davs:`. Reuses
+    `HttpPath`'s `HttpBackend` (session + requests_args) and the `http`
+    extra -- no new dependency.
+
+    Caution: `rmdir()` maps to WebDAV `DELETE`, which is recursive by
+    spec (RFC 4918) -- unlike `pathlib.Path.rmdir()`, it does NOT require
+    the collection to be empty first.
+    """
+
+    __SCHEMES = ("dav", "davs")
+    __slots__ = ()
+
+    def _wire_uri(self) -> str:
+        scheme = "https" if self.source.scheme == "davs" else "http"
+        return _uritools.uricompose(
+            scheme=scheme,
+            userinfo=self.source.userinfo,
+            host=self.source.host,
+            port=self.source.port,
+            path=self.path,
+            query=self.query or None,
+            fragment=self.fragment or None,
+        )
+
+    def _propfind(self, depth="0"):
+        resp = self.backend.request(
+            "PROPFIND",
+            self._wire_uri(),
+            headers={"Depth": depth, "Content-Type": "application/xml"},
+            data=_PROPFIND_BODY,
+        )
+        if resp.status_code == 404:
+            raise FileNotFoundError(self)
+        if resp.status_code == 403:
+            raise PermissionError(self)
+        resp.raise_for_status()
+        return _ET.fromstring(resp.content)
+
+    def stat(self, *, follow_symlinks=True):
+        root = self._propfind(depth="0")
+        responses = root.findall("D:response", _NS)
+        if not responses:
+            raise FileNotFoundError(self)
+        _href, is_dir, size, lm = _parse_response(responses[0])
+        return FileStat(st_size=size, st_mtime=_utils.parsedate(lm), is_dir=is_dir)
+
+    def is_dir(self):
+        # Shadow HttpPath.is_dir()'s _isdir-slot cache (never populated by
+        # our stat() override) -- derive from stat() like any other scheme.
+        return _stat.S_ISDIR(self._st_mode() or 0)
+
+    def is_file(self):
+        return _stat.S_ISREG(self._st_mode() or 0)
+
+    def _listdir(self):
+        root = self._propfind(depth="1")
+        self_path = _urlparse.urlsplit(self._wire_uri()).path.rstrip("/")
+        for elem in root.findall("D:response", _NS):
+            href, _is_dir, _size, _lm = _parse_response(elem)
+            href_path = _urlparse.urlsplit(href).path.rstrip("/")
+            if not href_path or href_path == self_path:
+                continue  # the "." entry describing self, per RFC 4918
+            name = href_path.rsplit("/", 1)[-1]
+            if name:
+                yield name
+
+    def iterdir(self):
+        # Reinstate the plain name+_make_child_relpath contract (HttpPath
+        # overrides this to expect FileEntry-like objects from _listdir(),
+        # which ours doesn't return).
+        for name in self._listdir():
+            yield self._make_child_relpath(name)
+
+    def _open(self, mode="r", buffering=-1):
+        if "r" in mode:
+            buffer_size = _io.DEFAULT_BUFFER_SIZE if buffering < 0 else buffering
+            req = self.backend.request("GET", self._wire_uri(), stream=True)
+            resp = req.raw
+            resp.auto_close = False
+            return (
+                resp
+                if buffer_size == 0
+                else _io.BufferedReader(resp, buffer_size=buffer_size)
+            )
+        if mode not in ("w", "x"):
+            raise NotImplementedError(f"open(mode={mode!r})")
+        if mode == "x" and self.exists():
+            raise FileExistsError(self)
+        return _DavWriteStream(self)
+
+    def _mkdir(self, mode):
+        resp = self.backend.request("MKCOL", self._wire_uri())
+        if resp.status_code == 409:
+            raise FileNotFoundError(self)
+        if resp.status_code in (405, 501):
+            raise FileExistsError(self)
+        resp.raise_for_status()
+
+    def unlink(self, missing_ok=False):
+        resp = self.backend.request("DELETE", self._wire_uri())
+        if resp.status_code == 404:
+            if missing_ok:
+                return
+            raise FileNotFoundError(self)
+        resp.raise_for_status()
+
+    def rmdir(self):
+        self.unlink()
+
+    def rename(self, target: "DavPath | Uri | str"):
+        if not isinstance(target, Uri):
+            target = Uri(self.parent, target)
+        dest = self.with_path(target.path)._wire_uri()
+        resp = self.backend.request(
+            "MOVE", self._wire_uri(), headers={"Destination": dest, "Overwrite": "F"}
+        )
+        if resp.status_code == 404:
+            raise FileNotFoundError(self)
+        if resp.status_code == 412:
+            raise FileExistsError(target)
+        resp.raise_for_status()

pathlib_next-0.7.0/tests/test_s3.py

@@ -0,0 +1,210 @@
+"""Unit-only S3 tests: a fake boto3-shaped client via BaseS3Backend, no
+real AWS account. Covers prefix-emulated directories, list_objects_v2
+paging shape, and copy_object+delete_object rename.
+"""
+import datetime
+import io
+
+import pytest
+
+botocore = pytest.importorskip("botocore")
+import botocore.exceptions as _botoexc
+
+from pathlib_next.uri.schemes.s3 import BaseS3Backend, S3Path
+
+
+def _client_error(code):
+    return _botoexc.ClientError({"Error": {"Code": code, "Message": code}}, "Operation")
+
+
+class _Paginator:
+    def __init__(self, client):
+        self._client = client
+
+    def paginate(self, **kwargs):
+        yield self._client.list_objects_v2(**kwargs)
+
+
+class _FakeS3Client:
+    def __init__(self):
+        self.objects = {}  # key -> bytes
+
+    def head_bucket(self, Bucket):
+        return {}
+
+    def head_object(self, Bucket, Key):
+        if Key not in self.objects:
+            raise _client_error("404")
+        data = self.objects[Key]
+        return {
+            "ContentLength": len(data),
+            "LastModified": datetime.datetime(2026, 1, 1, 12, 0, 0),
+        }
+
+    def list_objects_v2(self, Bucket, Prefix="", Delimiter=None, MaxKeys=None):
+        contents = []
+        common = set()
+        for key in sorted(self.objects):
+            if not key.startswith(Prefix):
+                continue
+            rest = key[len(Prefix) :]
+            if Delimiter and Delimiter in rest:
+                common.add(Prefix + rest.split(Delimiter, 1)[0] + Delimiter)
+            else:
+                contents.append({"Key": key})
+        if MaxKeys:
+            contents = contents[:MaxKeys]
+        result = {"KeyCount": len(contents) + len(common)}
+        if contents:
+            result["Contents"] = contents
+        if common:
+            result["CommonPrefixes"] = [{"Prefix": p} for p in sorted(common)]
+        return result
+
+    def get_paginator(self, name):
+        assert name == "list_objects_v2"
+        return _Paginator(self)
+
+    def get_object(self, Bucket, Key):
+        if Key not in self.objects:
+            raise _client_error("NoSuchKey")
+        return {"Body": io.BytesIO(self.objects[Key])}
+
+    def put_object(self, Bucket, Key, Body):
+        self.objects[Key] = Body if isinstance(Body, bytes) else bytes(Body)
+
+    def delete_object(self, Bucket, Key):
+        self.objects.pop(Key, None)
+
+    def copy_object(self, Bucket, Key, CopySource):
+        self.objects[Key] = self.objects[CopySource["Key"]]
+
+
+class _FakeBackend(BaseS3Backend):
+    def __init__(self):
+        self._client = _FakeS3Client()
+
+    def client(self):
+        return self._client
+
+
+def _s3(uri, backend=None):
+    return S3Path(uri, backend=backend or _FakeBackend())
+
+
+def test_scheme_dispatch():
+    assert isinstance(_s3("s3://bucket/a"), S3Path)
+
+
+def test_bucket_and_key():
+    p = _s3("s3://bucket/docs/readme.txt")
+    assert p.bucket == "bucket"
+    assert p.key == "docs/readme.txt"
+
+
+def test_stat_file():
+    backend = _FakeBackend()
+    backend._client.objects["docs/readme.txt"] = b"hello world"
+    st = _s3("s3://bucket/docs/readme.txt", backend).stat()
+    assert st.st_size == 11
+    assert not st.is_dir()
+
+
+def test_stat_dir_via_prefix():
+    backend = _FakeBackend()
+    backend._client.objects["docs/readme.txt"] = b"hello"
+    assert _s3("s3://bucket/docs", backend).stat().is_dir()
+
+
+def test_stat_root_is_dir():
+    assert _s3("s3://bucket/", _FakeBackend()).stat().is_dir()
+
+
+def test_stat_missing_raises_file_not_found():
+    with pytest.raises(FileNotFoundError):
+        _s3("s3://bucket/missing.txt", _FakeBackend()).stat()
+
+
+def test_listdir_root_and_nested():
+    backend = _FakeBackend()
+    backend._client.objects["docs/readme.txt"] = b"x"
+    backend._client.objects["docs/sub/file.txt"] = b"y"
+    backend._client.objects["top.txt"] = b"z"
+    root = _s3("s3://bucket/", backend)
+    assert sorted(root._listdir()) == ["docs", "top.txt"]
+    docs = _s3("s3://bucket/docs", backend)
+    assert sorted(docs._listdir()) == ["readme.txt", "sub"]
+
+
+def test_read_bytes():
+    backend = _FakeBackend()
+    backend._client.objects["a.txt"] = b"hello"
+    assert _s3("s3://bucket/a.txt", backend).read_bytes() == b"hello"
+
+
+def test_read_missing_raises_file_not_found():
+    with pytest.raises(FileNotFoundError):
+        _s3("s3://bucket/missing.txt", _FakeBackend()).read_bytes()
+
+
+def test_write_bytes_uploads_via_put_object_on_close():
+    backend = _FakeBackend()
+    _s3("s3://bucket/new.txt", backend).write_bytes(b"new content")
+    assert backend._client.objects["new.txt"] == b"new content"
+
+
+def test_mkdir_creates_marker_object():
+    backend = _FakeBackend()
+    _s3("s3://bucket/newdir", backend).mkdir()
+    assert "newdir/" in backend._client.objects
+
+
+def test_mkdir_existing_raises_file_exists():
+    backend = _FakeBackend()
+    backend._client.objects["newdir/"] = b""
+    with pytest.raises(FileExistsError):
+        _s3("s3://bucket/newdir", backend).mkdir()
+
+
+def test_unlink_deletes_object():
+    backend = _FakeBackend()
+    backend._client.objects["a.txt"] = b"x"
+    _s3("s3://bucket/a.txt", backend).unlink()
+    assert "a.txt" not in backend._client.objects
+
+
+def test_unlink_missing_without_missing_ok_raises():
+    with pytest.raises(FileNotFoundError):
+        _s3("s3://bucket/missing.txt", _FakeBackend()).unlink()
+
+
+def test_unlink_missing_ok():
+    _s3("s3://bucket/missing.txt", _FakeBackend()).unlink(missing_ok=True)
+
+
+def test_rmdir_empty_deletes_marker():
+    backend = _FakeBackend()
+    backend._client.objects["dir/"] = b""
+    _s3("s3://bucket/dir", backend).rmdir()
+    assert "dir/" not in backend._client.objects
+
+
+def test_rmdir_non_empty_raises_oserror():
+    backend = _FakeBackend()
+    backend._client.objects["dir/"] = b""
+    backend._client.objects["dir/file.txt"] = b"x"
+    with pytest.raises(OSError):
+        _s3("s3://bucket/dir", backend).rmdir()
+
+
+def test_rename_uses_copy_then_delete():
+    backend = _FakeBackend()
+    backend._client.objects["a.txt"] = b"content"
+    _s3("s3://bucket/a.txt", backend).rename("b.txt")
+    assert backend._client.objects.get("b.txt") == b"content"
+    assert "a.txt" not in backend._client.objects
+
+
+def test_chmod_not_implemented():
+    with pytest.raises(NotImplementedError):
+        _s3("s3://bucket/a.txt").chmod(0o644)

pathlib_next-0.7.0/tests/test_webdav.py

@@ -0,0 +1,250 @@
+"""Unit-only WebDAV tests: a fake `requests`-like session plugged into the
+real `HttpBackend`, no real server. Covers PROPFIND-based stat/listdir and
+PUT/DELETE/MKCOL/MOVE.
+"""
+import io
+
+import pytest
+
+requests = pytest.importorskip("requests")
+
+from pathlib_next.uri.schemes.http import HttpBackend
+from pathlib_next.uri.schemes.webdav import DavPath
+
+
+class _FakeResponse:
+    def __init__(self, status_code=200, content=b"", headers=None):
+        self.status_code = status_code
+        self.content = content
+        self.headers = headers or {}
+        self.raw = io.BytesIO(content)
+        self.is_redirect = False
+
+    def raise_for_status(self):
+        if self.status_code >= 400:
+            raise requests.HTTPError(str(self.status_code))
+
+    def close(self):
+        pass
+
+
+class _FakeSession:
+    def __init__(self):
+        self.calls = []
+        self.responses = {}
+
+    def request(self, method, url, **kwargs):
+        self.calls.append((method, url, kwargs))
+        if method == "PROPFIND":
+            key = (method, url, kwargs.get("headers", {}).get("Depth"))
+        else:
+            key = (method, url)
+        resp = self.responses.get(key)
+        if resp is None:
+            return _FakeResponse(404)
+        return resp() if callable(resp) else resp
+
+
+def _dav(uri, session=None):
+    return DavPath(uri, backend=HttpBackend(session or _FakeSession(), {}))
+
+
+_MULTISTATUS_FILE = b"""<?xml version="1.0"?>
+<D:multistatus xmlns:D="DAV:">
+  <D:response>
+    <D:href>/docs/readme.txt</D:href>
+    <D:propstat>
+      <D:prop>
+        <D:resourcetype/>
+        <D:getcontentlength>11</D:getcontentlength>
+        <D:getlastmodified>Mon, 01 Jan 2026 12:00:00 GMT</D:getlastmodified>
+      </D:prop>
+      <D:status>HTTP/1.1 200 OK</D:status>
+    </D:propstat>
+  </D:response>
+</D:multistatus>"""
+
+_MULTISTATUS_DIR = b"""<?xml version="1.0"?>
+<D:multistatus xmlns:D="DAV:">
+  <D:response>
+    <D:href>/docs/</D:href>
+    <D:propstat>
+      <D:prop>
+        <D:resourcetype><D:collection/></D:resourcetype>
+        <D:getlastmodified>Mon, 01 Jan 2026 12:00:00 GMT</D:getlastmodified>
+      </D:prop>
+      <D:status>HTTP/1.1 200 OK</D:status>
+    </D:propstat>
+  </D:response>
+</D:multistatus>"""
+
+_MULTISTATUS_LISTING = b"""<?xml version="1.0"?>
+<D:multistatus xmlns:D="DAV:">
+  <D:response>
+    <D:href>/docs/</D:href>
+    <D:propstat>
+      <D:prop>
+        <D:resourcetype><D:collection/></D:resourcetype>
+      </D:prop>
+      <D:status>HTTP/1.1 200 OK</D:status>
+    </D:propstat>
+  </D:response>
+  <D:response>
+    <D:href>/docs/readme.txt</D:href>
+    <D:propstat>
+      <D:prop>
+        <D:resourcetype/>
+        <D:getcontentlength>11</D:getcontentlength>
+      </D:prop>
+      <D:status>HTTP/1.1 200 OK</D:status>
+    </D:propstat>
+  </D:response>
+  <D:response>
+    <D:href>/docs/sub/</D:href>
+    <D:propstat>
+      <D:prop>
+        <D:resourcetype><D:collection/></D:resourcetype>
+      </D:prop>
+      <D:status>HTTP/1.1 200 OK</D:status>
+    </D:propstat>
+  </D:response>
+</D:multistatus>"""
+
+
+def test_scheme_dispatch():
+    assert isinstance(_dav("dav://host/docs/readme.txt"), DavPath)
+
+
+def test_wire_uri_translates_scheme():
+    assert _dav("dav://host/a")._wire_uri() == "http://host/a"
+    assert _dav("davs://host/a")._wire_uri() == "https://host/a"
+
+
+def test_stat_file():
+    session = _FakeSession()
+    session.responses[("PROPFIND", "http://host/docs/readme.txt", "0")] = _FakeResponse(
+        207, _MULTISTATUS_FILE
+    )
+    st = _dav("dav://host/docs/readme.txt", session).stat()
+    assert st.st_size == 11
+    assert not st.is_dir()
+
+
+def test_stat_dir():
+    session = _FakeSession()
+    session.responses[("PROPFIND", "http://host/docs/", "0")] = _FakeResponse(
+        207, _MULTISTATUS_DIR
+    )
+    assert _dav("dav://host/docs/", session).stat().is_dir()
+
+
+def test_stat_missing_raises_file_not_found():
+    with pytest.raises(FileNotFoundError):
+        _dav("dav://host/missing.txt").stat()
+
+
+def test_is_dir_is_file():
+    session = _FakeSession()
+    session.responses[("PROPFIND", "http://host/docs/", "0")] = _FakeResponse(
+        207, _MULTISTATUS_DIR
+    )
+    session.responses[("PROPFIND", "http://host/docs/readme.txt", "0")] = _FakeResponse(
+        207, _MULTISTATUS_FILE
+    )
+    root = _dav("dav://host/docs/", session)
+    assert root.is_dir()
+    assert not root.is_file()
+    f = _dav("dav://host/docs/readme.txt", session)
+    assert f.is_file()
+    assert not f.is_dir()
+
+
+def test_listdir():
+    session = _FakeSession()
+    session.responses[("PROPFIND", "http://host/docs/", "1")] = _FakeResponse(
+        207, _MULTISTATUS_LISTING
+    )
+    p = _dav("dav://host/docs/", session)
+    assert sorted(p._listdir()) == ["readme.txt", "sub"]
+
+
+def test_iterdir_yields_children():
+    session = _FakeSession()
+    session.responses[("PROPFIND", "http://host/docs/", "1")] = _FakeResponse(
+        207, _MULTISTATUS_LISTING
+    )
+    p = _dav("dav://host/docs/", session)
+    assert sorted(c.name for c in p.iterdir()) == ["readme.txt", "sub"]
+
+
+def test_open_read_downloads_via_get():
+    session = _FakeSession()
+    session.responses[("GET", "http://host/docs/readme.txt")] = _FakeResponse(
+        200, b"hello world"
+    )
+    p = _dav("dav://host/docs/readme.txt", session)
+    assert p.read_bytes() == b"hello world"
+
+
+def test_open_write_uploads_via_put_on_close():
+    session = _FakeSession()
+    session.responses[("PUT", "http://host/docs/new.txt")] = _FakeResponse(201)
+    p = _dav("dav://host/docs/new.txt", session)
+    p.write_bytes(b"new content")
+    method, url, kwargs = session.calls[-1]
+    assert method == "PUT"
+    assert kwargs["data"] == b"new content"
+
+
+def test_mkdir_sends_mkcol():
+    session = _FakeSession()
+    session.responses[("MKCOL", "http://host/docs/newdir")] = _FakeResponse(201)
+    p = _dav("dav://host/docs/newdir", session)
+    p._mkdir(0o777)
+    assert session.calls[-1][:2] == ("MKCOL", "http://host/docs/newdir")
+
+
+def test_mkdir_existing_raises_file_exists():
+    session = _FakeSession()
+    session.responses[("MKCOL", "http://host/docs/newdir")] = _FakeResponse(405)
+    p = _dav("dav://host/docs/newdir", session)
+    with pytest.raises(FileExistsError):
+        p._mkdir(0o777)
+
+
+def test_unlink_sends_delete():
+    session = _FakeSession()
+    session.responses[("DELETE", "http://host/docs/readme.txt")] = _FakeResponse(204)
+    p = _dav("dav://host/docs/readme.txt", session)
+    p.unlink()
+    assert session.calls[-1][:2] == ("DELETE", "http://host/docs/readme.txt")
+
+
+def test_unlink_missing_ok():
+    session = _FakeSession()
+    session.responses[("DELETE", "http://host/missing.txt")] = _FakeResponse(404)
+    _dav("dav://host/missing.txt", session).unlink(missing_ok=True)
+
+
+def test_unlink_missing_without_missing_ok_raises():
+    session = _FakeSession()
+    session.responses[("DELETE", "http://host/missing.txt")] = _FakeResponse(404)
+    p = _dav("dav://host/missing.txt", session)
+    with pytest.raises(FileNotFoundError):
+        p.unlink()
+
+
+def test_rename_sends_move_with_destination_header():
+    session = _FakeSession()
+    session.responses[("MOVE", "http://host/docs/a.txt")] = _FakeResponse(201)
+    p = _dav("dav://host/docs/a.txt", session)
+    p.rename("b.txt")
+    method, url, kwargs = session.calls[-1]
+    assert method == "MOVE"
+    assert kwargs["headers"]["Destination"] == "http://host/docs/b.txt"
+
+
+def test_chmod_not_implemented():
+    p = _dav("dav://host/docs/a.txt")
+    with pytest.raises(NotImplementedError):
+        p.chmod(0o644)