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

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

@@ -7,6 +7,52 @@ 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)
+- `data:` scheme (RFC 2397, `pathlib_next.uri.schemes.data.DataUri`):
+  read-only, no backend/connection -- the entire file content is embedded
+  in the URI (`data:[<mediatype>][;base64],<data>`). `stat().st_size` is
+  the decoded payload length; `iterdir()` raises `NotADirectoryError`
+  (it's always a single file); write operations raise `NotImplementedError`.
+- `ftp:`/`ftps:` scheme (`pathlib_next.uri.schemes.ftp.FtpPath`): full
+  read/write/list access via stdlib `ftplib`, with a thread-keyed LRU
+  connection cache mirroring `sftp.py`. Listing/stat prefer MLSD (RFC
+  3659); servers without it fall back to NLST (listing) and SIZE
+  (file-only stat). Writes buffer in memory and upload via STOR/APPE on
+  `close()`. `chmod()` uses the common but non-standard `SITE CHMOD`
+  extension (may not be supported by every server).
+- `zip:`/`tar:` archive paths (`pathlib_next.uri.schemes.archive`):
+  `<scheme>:<archive-uri>!/<inner-path>` (Java-style `!/` separator,
+  URI form proposed to and confirmed by the user before implementation).
+  The archive half is itself any absolute URI with an explicit scheme, so
+  archives are readable straight off any other backend (`file:`, `http:`,
+  `sftp:`, `ftp:`, `data:`, ...). Read is supported for both schemes.
+  Write is `zip:`-only, and only for brand-new entries in a local (`file:`)
+  outer archive (overwriting/deleting/renaming an existing entry would
+  need a full-archive rewrite -- not implemented, raises
+  `NotImplementedError`). `tar:` auto-detects `.tar.gz`/`.tar.bz2`/`.tar.xz`
+  compression and is always read-only.
+
 ## [0.5.0] - 2026-07-11
 
 ### Fixed (critical -- found while writing Phase 6 examples)
@@ -208,7 +254,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 - Sync error handling.
 - Generic Path Protocol based pathlib implementation for URI paths with file access support for sftp, http, file schemes.
 
-[Unreleased]: https://github.com/jose-pr/pathlib_next/compare/v0.5.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
 [0.4.0]: https://github.com/jose-pr/pathlib_next/releases/tag/v0.4.0

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathlib_next
-Version: 0.5.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.5.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.7.0/docs/guides/schemes.md

@@ -0,0 +1,78 @@
+# Schemes
+
+Capability matrix for every built-in `Path`/`UriPath` implementation. A
+"No" means the method raises `NotImplementedError` (or, for `http:`, isn't
+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`) | `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:
+
+- **`file:`** is a thin `UriPath` wrapper around `LocalPath` -- it has
+  identical capabilities, just addressed by URI instead of a native path.
+- **`mem:` (`MemPath`)** isn't a `UriPath` at all -- it's a plain `Path`
+  subclass (Track A of [Extending](extending.md)), backed by nested dicts
+  (`MemPathBackend`). No `as_uri()` scheme is registered for it; construct
+  it directly via `MemPath(...)`.
+- **`http(s):`** is inherently read-only: there's no portable "create/
+  delete/rename a resource" over plain HTTP. Directory listing depends on
+  the server producing an Apache/nginx-style HTML index that
+  `htmllistparse` can parse (confirmed against Python's own
+  `http.server.SimpleHTTPRequestHandler`).
+- **`sftp:`** has the fullest capability set of the URI schemes (it's a
+  real remote filesystem protocol). Connections are cached per
+  `(backend, source, thread)` (see `pathlib_next.uri.schemes.sftp`).
+- **`data:`** (RFC 2397) has no server or connection at all -- the entire
+  "file" content lives in the URI string itself
+  (`data:[<mediatype>][;base64],<data>`). It's always a single file, never a
+  directory.
+- **`ftp(s):`** uses the same connection-cache pattern as `sftp:` (stdlib
+  `ftplib`, no extra required). Prefers MLSD (RFC 3659) for listing/stat --
+  gives type/size/modify in one round trip -- and falls back to NLST/SIZE on
+  servers that don't support it (that fallback path can't distinguish "file
+  doesn't exist" from "is a directory" for `stat()`, since SIZE only works on
+  files).
+- **`zip:`/`tar:`** address an entry *inside* an archive:
+  `zip:<archive-uri>!/<inner-path>` (Java-style `!/` separator, as in JAR
+  URLs / NIO `ZipFileSystem`). The `<archive-uri>` half is itself any
+  absolute URI with an explicit scheme -- `file:`, `http:`, `sftp:`,
+  `ftp:`, even `data:` -- so an archive is readable straight off any other
+  backend; `zip:file:///backups/site.zip!/index.html` and
+  `zip:sftp://host/nightly.zip!/index.html` both work the same way.
+  `segments`/`name`/`parent`/`glob()`/... all operate on the *inner* path.
+  Writing a brand-new entry (not overwriting/deleting/renaming an existing
+  one -- that would need a full-archive rewrite, not implemented) only
+  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.5.0 → pathlib_next-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pathlib_next"
-version = "0.5.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.7.0/src/pathlib_next/uri/schemes/__init__.py

@@ -0,0 +1,22 @@
+from .archive import TarUri as TarUri
+from .archive import ZipUri as ZipUri
+from .data import DataUri as DataUri
+from .file import FileUri as FileUri
+from .ftp import FtpPath as FtpPath
+
+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/archive.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+import io as _io
+import re as _re
+import tarfile as _tarfile
+import time as _time
+import zipfile as _zipfile
+
+from ...utils.stat import FileStat
+from .. import UriPath
+from .file import FileUri
+
+_SEP = "!/"
+_SCHEME_RE = _re.compile(r"^[a-zA-Z][a-zA-Z0-9+.\-]*:")
+
+
+def _split_archive_path(path: str) -> "tuple[str, str]":
+    """Split `<archive-uri>!/<inner-path>` (Java-style separator, as used
+    for JAR URLs / NIO ZipFileSystem) into its two halves. No separator (or
+    a bare trailing "!") means the archive root."""
+    if _SEP in path:
+        archive, inner = path.split(_SEP, 1)
+    elif path.endswith("!"):
+        archive, inner = path[:-1], ""
+    else:
+        archive, inner = path, ""
+    return archive, inner
+
+
+def _open_outer(archive_uri: str) -> "UriPath":
+    if not _SCHEME_RE.match(archive_uri):
+        raise ValueError(
+            f"Archive URI {archive_uri!r} has no scheme -- prefix it "
+            "explicitly, e.g. 'file:///path/to/archive.zip'."
+        )
+    return UriPath(archive_uri)
+
+
+class _ArchiveBackend:
+    """Lazily opens+caches the archive handle for one outer archive URI.
+    Shared by every `ArchiveUri` instance derived from the same one (backend
+    propagation is the existing `UriPath` machinery -- see `ArchiveUri._init`).
+    NOT deduplicated across independently-constructed top-level `UriPath(...)`
+    strings pointing at the same archive -- derive sibling members via `/`/
+    `joinpath` from a shared instance rather than reparsing the same archive
+    URI twice, especially for writable zips (two separate handles writing
+    the same underlying file can corrupt it)."""
+
+    __slots__ = ("outer", "_handle")
+
+    def __init__(self, outer: "UriPath"):
+        self.outer = outer
+        self._handle = None
+
+    def _open(self):
+        raise NotImplementedError
+
+    @property
+    def handle(self):
+        if self._handle is None:
+            self._handle = self._open()
+        return self._handle
+
+    @property
+    def writable(self) -> bool:
+        return False
+
+    def names(self) -> "list[str]":
+        raise NotImplementedError
+
+    def read_member(self, path: str):
+        raise NotImplementedError
+
+    def member_stat(self, path: str) -> FileStat:
+        raise NotImplementedError
+
+
+class _ZipBackend(_ArchiveBackend):
+    __slots__ = ()
+
+    @property
+    def writable(self) -> bool:
+        # Writing individual entries in place (via ZipFile.open(name, "w"))
+        # only works when we hold the archive open in "a" mode against a
+        # real seekable local file -- not for remote/embedded outer URIs.
+        return isinstance(self.outer, FileUri)
+
+    def _open(self):
+        if self.writable:
+            return _zipfile.ZipFile(str(self.outer.filepath), mode="a")
+        return _zipfile.ZipFile(_io.BytesIO(self.outer.read_bytes()), mode="r")
+
+    def names(self):
+        return self.handle.namelist()
+
+    def read_member(self, path):
+        return self.handle.open(path, "r")  # raises KeyError if missing
+
+    def write_member(self, path: str, data: bytes):
+        # zipfile only persists the central directory to disk when the
+        # *archive* (not just the entry) is closed -- close and drop the
+        # cached handle so both this backend's next operation and any
+        # independently-opened ZipUri see the write.
+        self.handle.writestr(path, data)
+        self.handle.close()
+        self._handle = None
+
+    def member_stat(self, path):
+        info = self.handle.getinfo(path)
+        mtime = int(_time.mktime((*info.date_time, 0, 0, -1))) if info.date_time else 0
+        return FileStat(st_size=info.file_size, st_mtime=mtime, is_dir=path.endswith("/"))
+
+
+class _TarBackend(_ArchiveBackend):
+    __slots__ = ()
+
+    def _open(self):
+        return _tarfile.open(fileobj=_io.BytesIO(self.outer.read_bytes()), mode="r:*")
+
+    def names(self):
+        return self.handle.getnames()
+
+    def read_member(self, path):
+        try:
+            member = self.handle.getmember(path)
+        except KeyError:
+            raise
+        f = self.handle.extractfile(member)
+        if f is None:
+            raise IsADirectoryError(path)
+        return f
+
+    def member_stat(self, path):
+        info = self.handle.getmember(path)
+        return FileStat(st_size=info.size, st_mtime=int(info.mtime), is_dir=info.isdir())
+
+
+class ArchiveUri(UriPath):
+    """Common base for `zip:`/`tar:` archive paths:
+    `<scheme>:<archive-uri>!/<inner-path>` (Java-style separator; the
+    `<archive-uri>` half is itself any absolute URI with an explicit scheme
+    -- `file:`, `http:`, `sftp:`, `ftp:`, ... -- so archives are readable
+    straight off any existing backend). `segments`/`name`/`parent`/`glob`/
+    ... all operate on the *inner* path; the outer archive handle is the
+    `backend` (`_ZipBackend`/`_TarBackend`), propagated through the normal
+    backend machinery to every path derived from this one."""
+
+    __slots__ = ()
+    _backend_cls: type = None
+
+    def _init(self, source, path, query, fragment, /, **kwargs):
+        backend = kwargs.get("backend", None) or self._backend
+        if backend is None:
+            # Fresh top-level construction (e.g. UriPath("zip:...!/...")) --
+            # `path` is still the raw "<archive-uri>!/<inner>" string.
+            archive_str, inner = _split_archive_path(path)
+            backend = self._backend_cls(_open_outer(archive_str))
+        else:
+            # Derived instance (with_segments/joinpath/_make_child_relpath)
+            # -- backend already known, `path` is already just the inner
+            # path (no "archive!/" prefix to strip).
+            inner = path
+        kwargs["backend"] = backend
+        super()._init(source, inner, query, fragment, **kwargs)
+
+    def as_uri(self, /, sanitize=False):
+        outer_uri = self.backend.outer.as_uri(sanitize=sanitize)
+        return f"{self.source.scheme}:{outer_uri}!/{self.path}"
+
+    def _names(self):
+        return self.backend.names()
+
+    def _listdir(self):
+        prefix = f"{self.path}/" if self.path else ""
+        seen = set()
+        for name in self._names():
+            if not name.startswith(prefix):
+                continue
+            rest = name[len(prefix) :]
+            if not rest:
+                continue
+            child = rest.split("/", 1)[0]
+            if child and child not in seen:
+                seen.add(child)
+                yield child
+
+    def stat(self, *, follow_symlinks=True):
+        path = self.path
+        if path == "":
+            return FileStat(is_dir=True)
+        names = self._names()
+        if path in names:
+            return self.backend.member_stat(path)
+        dirmarker = f"{path}/"
+        if dirmarker in names or any(n.startswith(dirmarker) for n in names):
+            return FileStat(is_dir=True)
+        raise FileNotFoundError(self)
+
+    def _open(self, mode="r", buffering=-1):
+        if "r" in mode:
+            try:
+                return self.backend.read_member(self.path)
+            except KeyError as error:
+                raise FileNotFoundError(self) from error
+        raise NotImplementedError(f"open(mode={mode!r}) on {self.source.scheme}:")
+
+
+class _ZipWriteStream(_io.BytesIO):
+    """Buffers a new entry's content in memory; on close(), writes it via
+    `writestr()` and flushes+reopens the archive (see
+    `_ZipBackend.write_member`)."""
+
+    def __init__(self, backend: "_ZipBackend", path: str):
+        super().__init__()
+        self._backend = backend
+        self._path = path
+
+    def close(self):
+        if not self.closed:
+            self._backend.write_member(self._path, self.getvalue())
+        super().close()
+
+
+class ZipUri(ArchiveUri):
+    """`zip:` scheme. Read/write: writing a new entry works when the outer
+    archive is a local `file:` URI (opened in `zipfile`'s "a" -- append --
+    mode, so existing entries are untouched); every other outer scheme is
+    read-only (fetched fully into memory first). Overwriting/deleting/
+    renaming an existing entry is not implemented (would require rewriting
+    the whole archive) -- only adding new entries and (for directories)
+    zero-length `"name/"` marker entries."""
+
+    __SCHEMES = ("zip",)
+    __slots__ = ()
+    _backend_cls = _ZipBackend
+
+    def _open(self, mode="r", buffering=-1):
+        if "r" in mode:
+            return super()._open(mode, buffering)
+        if not self.backend.writable:
+            raise NotImplementedError(
+                "zip: write support requires a local (file:) outer archive"
+            )
+        if mode not in ("w", "x"):
+            raise NotImplementedError(f"open(mode={mode!r})")
+        if mode == "x" and self.exists():
+            raise FileExistsError(self)
+        return _ZipWriteStream(self.backend, self.path)
+
+    def _mkdir(self, mode):
+        if not self.backend.writable:
+            raise NotImplementedError(
+                "zip: write support requires a local (file:) outer archive"
+            )
+        if self.exists():
+            raise FileExistsError(self)
+        self.backend.write_member(f"{self.path}/", b"")
+
+
+class TarUri(ArchiveUri):
+    """`tar:` scheme (also handles `.tar.gz`/`.tar.bz2`/`.tar.xz` via
+    `tarfile`'s auto-detected "r:*" mode). Read-only."""
+
+    __SCHEMES = ("tar",)
+    __slots__ = ()
+    _backend_cls = _TarBackend

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

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import io as _io
+import urllib.parse as _urlparse
+from base64 import b64decode as _b64decode
+
+from ...utils.stat import FileStat
+from .. import UriPath
+
+_DEFAULT_MEDIATYPE = "text/plain;charset=US-ASCII"
+
+
+class DataUri(UriPath):
+    """`data:` scheme (RFC 2397): a read-only "file" whose entire content is
+    embedded in the URI itself (`data:[<mediatype>][;base64],<data>`) -- no
+    filesystem, no directories, no backend/connection. Percent-encoded
+    reserved characters (`?`/`#`) in the payload are only decoded correctly
+    if the URI was built with them escaped, per RFC 2397/3986."""
+
+    __SCHEMES = ("data",)
+    __slots__ = ()
+
+    @property
+    def _header(self) -> str:
+        header, _, _ = self.path.partition(",")
+        return header
+
+    @property
+    def _is_base64(self) -> bool:
+        return self._header.rsplit(";", 1)[-1].strip().lower() == "base64"
+
+    @property
+    def mediatype(self) -> str:
+        header = self._header
+        if not header:
+            return _DEFAULT_MEDIATYPE
+        if self._is_base64:
+            header = header.rsplit(";", 1)[0]
+        return header or _DEFAULT_MEDIATYPE
+
+    def _content(self) -> bytes:
+        header, sep, data = self.path.partition(",")
+        if not sep:
+            raise FileNotFoundError(self)
+        if self._is_base64:
+            return _b64decode(_urlparse.unquote_to_bytes(data))
+        return _urlparse.unquote_to_bytes(data)
+
+    def stat(self, *, follow_symlinks=True):
+        return FileStat(st_size=len(self._content()), is_dir=False)
+
+    def _open(self, mode="r", buffering=-1):
+        if "r" not in mode:
+            raise NotImplementedError("data: URIs are read-only")
+        return _io.BytesIO(self._content())
+
+    def _listdir(self):
+        raise NotADirectoryError(self)