pathapi-uri 0.1.0__py3-none-any.whl

uripath/schemes/_dav.py

@@ -0,0 +1,459 @@
+from __future__ import annotations
+
+import errno as _errno
+import os as _os
+import typing as _ty
+import urllib.parse as _urlparse
+import xml.etree.ElementTree as _ET
+
+from pathapi import FileStat
+from pathapi import providers as _providers
+from pathapi.providers import check_follow
+from .._uri import URI
+from ..source import compose_uri
+from . import _httpdate
+from pathapi.http import (
+    drop_body,
+    os_error,
+    peer_text,
+    raise_for_status,
+    read_limited,
+    server_size,
+    split_userinfo,
+    translate_errors,
+)
+from ._http._headers import _IDENTITY_ENCODING
+from ._http._path import HTTPURIPath
+from ._http._streams import _EXCLUSIVE_CREATE, _UploadStream, _response_reader
+
+_NS = {"D": "DAV:"}
+_MULTISTATUS = "{DAV:}multistatus"
+
+_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 _found_props(elem) -> "list":
+    """The `<D:prop>` elements of every successful `<D:propstat>` of a
+    `<D:response>`. RFC 4918 groups properties into one propstat per status
+    (200 for found, 404 for missing) in no fixed order, so reading only the
+    first one could read the 404 group; a propstat with no status counts."""
+    props = []
+    for propstat in elem.findall("D:propstat", _NS):
+        code = _status_code(propstat.findtext("D:status", namespaces=_NS))
+        prop = propstat.find("D:prop", _NS)
+        if prop is not None and (code is None or 200 <= code < 300):
+            props.append(prop)
+    return props
+
+
+def _find_prop(props, name: str):
+    for prop in props:
+        found = prop.find(name, _NS)
+        if found is not None:
+            return found
+    return None
+
+
+def _parse_response(elem) -> "tuple[str, bool, int, str]":
+    href = elem.findtext("D:href", namespaces=_NS) or ""
+    props = _found_props(elem)
+    resourcetype = _find_prop(props, "D:resourcetype")
+    is_dir = (
+        resourcetype is not None and resourcetype.find("D:collection", _NS) is not None
+    )
+    size_elem = _find_prop(props, "D:getcontentlength")
+    # A missing, non-numeric or negative length is no size.
+    size = server_size(size_elem.text if size_elem is not None else None) or 0
+    lm_elem = _find_prop(props, "D:getlastmodified")
+    lm = lm_elem.text if lm_elem is not None else None
+    # Still percent-encoded: decoding before `urlsplit()` would read a
+    # literal "#" or "?" in a name as URL syntax.
+    return href, is_dir, size, lm
+
+
+def _decoded_segments(path: str) -> "list[str]":
+    """The decoded segments of a percent-encoded URL path, a trailing slash
+    ignored. A segment that was `%2F` stays one segment. Undecodable bytes
+    are kept (`surrogateescape`) as the URI layer keeps them."""
+    return [
+        _urlparse.unquote(segment, errors="surrogateescape")
+        for segment in path.rstrip("/").split("/")
+    ]
+
+
+def _status_code(text: "str | None") -> "int | None":
+    # "HTTP/1.1 423 Locked"
+    parts = (text or "").split()
+    if len(parts) >= 2 and parts[1].isdigit():
+        return int(parts[1])
+    return None
+
+
+def _multistatus_failures(content: bytes) -> "list[tuple[str, int]] | None":
+    """`(href, status)` of every failed member of a 207 reply, or `None`
+    when the body is not a parseable multistatus."""
+    try:
+        root = _ET.fromstring(content)
+    except _ET.ParseError:
+        return None
+    failures = []
+    for response in root.findall("D:response", _NS):
+        href = _urlparse.unquote(response.findtext("D:href", namespaces=_NS) or "")
+        statuses = [response.findtext("D:status", namespaces=_NS)] + [
+            propstat.findtext("D:status", namespaces=_NS)
+            for propstat in response.findall("D:propstat", _NS)
+        ]
+        for text in statuses:
+            code = _status_code(text)
+            if code is not None and code >= 400:
+                failures.append((href, code))
+                break
+    return failures
+
+
+def _raise_for_multistatus(resp, path) -> None:
+    """RFC 4918 9.6.1/9.9.4: DELETE and MOVE answer 207 when a member of
+    the collection could not be processed -- a partial failure, not a
+    success."""
+    failures = _multistatus_failures(read_limited(resp, path))
+    if failures == []:
+        return
+    detail = (
+        ", ".join(
+            f"{peer_text(href, 200)} (HTTP {code})" for href, code in failures[:10]
+        )
+        + (f" and {len(failures) - 10} more" if len(failures) > 10 else "")
+        if failures
+        else "unparseable 207 Multi-Status reply"
+    )
+    message = f"Partial failure for {path}: {detail}"
+    if failures and all(code in (401, 403, 423) for _href, code in failures):
+        raise PermissionError(_errno.EACCES, message)
+    raise OSError(_errno.EIO, message)
+
+
+class _DAVWriteStream(_UploadStream):
+    def __init__(self, path: "DAVURIPath", exclusive: bool = False):
+        super().__init__(path)
+        # `exclusive` (mode "x"): see `HTTPWriteStream`.
+        self._exclusive = exclusive
+        self._ready = True
+
+    def _upload(self, data):
+        # 409: an intermediate collection is missing (RFC 4918 9.7.1).
+        statuses = {409: FileNotFoundError}
+        extra = {}
+        if self._exclusive:
+            statuses[412] = FileExistsError
+            extra = _EXCLUSIVE_CREATE
+        path = self._path
+        path._dav_request(
+            path.backend.write_method, data=data, statuses=statuses, **extra
+        )
+
+
+class DAVURIPath(HTTPURIPath):
+    """`dav:`/`davs:` scheme: WebDAV (RFC 4918) over HTTP(S). Extends
+    `HTTPURIPath` with PROPFIND (stat/listdir -- real directory metadata,
+    replacing `HTTPURIPath`'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
+    `HTTPURIPath`'s `HTTPBackend` (transport + settings) -- no new dependency.
+
+    `rmdir()` enforces pathlib's "must be empty" contract with a depth-1
+    PROPFIND before DELETE (WebDAV `DELETE` is recursive by spec, RFC 4918,
+    unlike `pathlib.Path.rmdir()`). The native recursive DELETE is still
+    available -- and cheaper than the base class's client-side walk -- via
+    `rm(recursive=True)`, overridden below to issue a single request.
+    """
+
+    __SCHEMES = ("dav", "davs")
+    __slots__ = ()
+
+    def _wire_uri(self) -> str:
+        # Keeps the userinfo: `HTTPBackend.request` strips it from the URL it sends and
+        # turns it into `auth=`. Direct string assembly, not uricompose(), as this runs on
+        # every request and every part is this instance's own parsed state (`_compose_uri`).
+        scheme = "https" if self.source.scheme == "davs" else "http"
+        return compose_uri(
+            scheme,
+            self.source.userinfo,
+            self.source.host,
+            self.source.port,
+            self.path,
+            str(self.query) or None,
+            self.fragment or None,
+        )
+
+    def _dav_request(self, method, *, statuses=None, keep=False, **kwargs):
+        """Send `method` to this resource with pathlib exception types:
+        `statuses` maps a status code to the exception class raised for it
+        (called with `self`), ahead of `translate_errors`' generic
+        mapping; a 207 to DELETE/MOVE raises for its failed members; 423
+        Locked is a PermissionError. The body of the reply is dropped (see
+        `drop_body`) unless `keep`, when the caller reads it."""
+        statuses = {
+            404: FileNotFoundError,
+            401: PermissionError,
+            403: PermissionError,
+            423: PermissionError,
+            **(statuses or {}),
+        }
+        with translate_errors(self):
+            resp = self.backend.request(method, self._wire_uri(), stream=True, **kwargs)
+            try:
+                error = statuses.get(resp.status)
+                if error is not None:
+                    if isinstance(error, type):
+                        # `(errno, strerror, filename)`, as pathlib raises it.
+                        raise os_error(error, self)
+                    raise error(self)
+                if resp.status == 207 and method in ("DELETE", "MOVE"):
+                    _raise_for_multistatus(resp, self)
+                raise_for_status(resp)
+            except BaseException:
+                drop_body(resp)
+                raise
+        if not keep:
+            drop_body(resp)
+        return resp
+
+    def _propfind(self, depth="0"):
+        return self._propfind_reply(depth)[0]
+
+    def _propfind_reply(self, depth: str) -> "tuple[_ET.Element, str]":
+        """The `<D:multistatus>` element of a PROPFIND reply, and the URL
+        that answered it (not this path's own after a redirect)."""
+        resp = self._dav_request(
+            "PROPFIND",
+            headers={"Depth": depth, "Content-Type": "application/xml"},
+            data=_PROPFIND_BODY,
+            keep=True,
+        )
+        body = read_limited(resp, self)
+        try:
+            root = _ET.fromstring(body)
+        except _ET.ParseError:
+            root = None
+        if root is None or root.tag != _MULTISTATUS:
+            # A non-WebDAV endpoint or proxy answering 200 with HTML or other XML: an I/O error,
+            # so `exists()`/`is_dir()` report False instead of leaking a SyntaxError subclass,
+            # and a login page is not an empty directory.
+            raise OSError(_errno.EIO, f"Invalid PROPFIND response for {self}")
+        return root, resp.url or self._wire_uri()
+
+    def stat(self, *, follow_symlinks=True, walk_up_last_modified=False):
+        # `walk_up_last_modified` has nothing to do: the reply carries the
+        # modification time.
+        hint = self._pop_stat_hint()
+        if hint is not None:
+            return hint
+        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=_httpdate.parsedate(lm), is_dir=is_dir)
+
+    def _scandir(self):
+        # One PROPFIND (Depth: 1) already carries type/size/mtime for every
+        # child -- reuse it instead of `iterdir()` + a stat per child.
+        root, answered = self._propfind_reply("1")
+        collection = _urlparse.urlsplit(answered)
+        # Compared segment by segment, decoded: the wire path is
+        # percent-encoded, so a directory named "my dir" otherwise listed
+        # itself as a child.
+        here = _decoded_segments(collection.path)
+        host = (collection.hostname or "").lower()
+        base = collection._replace(
+            path=collection.path.rstrip("/") + "/", query="", fragment=""
+        ).geturl()
+        selves = []
+        members = []
+        replies = 0
+        for elem in root.findall("D:response", _NS):
+            replies += 1
+            href, is_dir, size, lm = _parse_response(elem)
+            if not href.strip():
+                continue
+            try:
+                # Split first, decode after: a literal "#"/"?" in a name
+                # arrives encoded and must stay part of the name. Resolved
+                # against the collection, as RFC 4918 8.3 reads a reference.
+                where = _urlparse.urlsplit(_urlparse.urljoin(base, href.strip()))
+            except ValueError:
+                continue
+            if (where.hostname or "").lower() != host:
+                continue
+            segments = _decoded_segments(where.path)
+            if segments == here:
+                selves.append(is_dir)
+            elif segments[:-1] == here:
+                # A direct member only: a deeper one (a server that ignores
+                # the Depth) or one elsewhere is not listed here.
+                members.append((segments[-1], is_dir, size, lm))
+        if replies and not (selves or members):
+            raise OSError(
+                _errno.EIO,
+                f"The PROPFIND reply for {self} names neither the collection "
+                "nor any member of it",
+            )
+        if selves and not any(selves):
+            # The "." entry describing self, per RFC 4918. A Depth:1
+            # PROPFIND on a non-collection answers with only this entry,
+            # which read as an empty directory.
+            raise NotADirectoryError(
+                _errno.ENOTDIR, _os.strerror(_errno.ENOTDIR), str(self)
+            )
+        for name, is_dir, size, lm in members:
+            # The href is untrusted: an entry such as `%2E%2E/` decodes to
+            # "..", which let a recursive copy write outside its destination.
+            if _providers.is_safe_child_name(name):
+                yield name, FileStat(
+                    st_size=size, st_mtime=_httpdate.parsedate(lm), is_dir=is_dir
+                )
+
+    def _listdir(self):
+        for name, _stat_ in self._scandir():
+            yield name
+
+    def _open(self, mode="r", buffering=-1):
+        if mode == "r":
+            req = self._get(self._wire_uri(), headers=_IDENTITY_ENCODING)
+            content_type = req.headers.get("Content-Type", "")
+            if content_type.split(";")[0].strip().lower() == "text/html":
+                # GET on a collection is server-defined (RFC 4918 9.4) and
+                # usually an HTML index, which was read back as content.
+                # Only an HTML answer pays the PROPFIND that tells them apart.
+                try:
+                    is_dir = self.stat().is_dir()
+                except OSError:
+                    is_dir = False
+                if is_dir:
+                    req.close()
+                    raise IsADirectoryError(
+                        _errno.EISDIR, _os.strerror(_errno.EISDIR), str(self)
+                    )
+            return _response_reader(self, req, buffering)
+        if mode not in ("w", "x"):
+            raise NotImplementedError(f"open(mode={mode!r})")
+        if mode == "x":
+            self._ensure_missing()
+        return _DAVWriteStream(self, exclusive=mode == "x")
+
+    def _mkdir(self, mode):
+        self._dav_request(
+            "MKCOL",
+            statuses={
+                409: FileNotFoundError,
+                405: FileExistsError,
+                501: FileExistsError,
+            },
+        )
+
+    def unlink(self, missing_ok=False):
+        # WebDAV DELETE on a collection is recursive (RFC 4918), and pathlib's unlink()
+        # never removes a directory: check with a Depth:0 PROPFIND first. The recursive
+        # DELETE stays available as `rm(recursive=True)`.
+        try:
+            root = self._propfind(depth="0")
+        except FileNotFoundError:
+            if missing_ok:
+                return
+            raise
+        responses = root.findall("D:response", _NS)
+        if responses and _parse_response(responses[0])[1]:
+            raise IsADirectoryError(
+                _errno.EISDIR, _os.strerror(_errno.EISDIR), str(self)
+            )
+        self._delete(missing_ok=missing_ok)
+
+    def _delete(self, missing_ok=False):
+        # The raw DELETE, with no collection guard: `rmdir()` has already
+        # verified an empty directory before calling it.
+        try:
+            self._dav_request("DELETE")
+        except FileNotFoundError:
+            if not missing_ok:
+                raise
+
+    def rmdir(self):
+        # A PROPFIND Depth:1 on a non-collection returns only its own "." entry, which
+        # _scandir() filters, so a *file* looks like an empty directory to _listdir() and
+        # rmdir() would DELETE it. stat(), not is_dir(): a missing path is FileNotFoundError.
+        if not self.stat().is_dir():
+            raise NotADirectoryError(
+                _errno.ENOTDIR, _os.strerror(_errno.ENOTDIR), str(self)
+            )
+        for _ in self._listdir():
+            raise OSError(_errno.ENOTEMPTY, "Directory not empty", str(self))
+        self._delete()
+
+    def rm(
+        self,
+        /,
+        recursive: bool = False,
+        missing_ok: bool = False,
+        ignore_error: "bool | _ty.Callable[[Exception, DAVURIPath], bool]" = False,
+        *,
+        follow_symlinks=False,
+        follow_binds=False,
+    ):
+        # A collection holds no symlinks or bindings: the policies are
+        # checked and have nothing to decide.
+        check_follow("follow_symlinks", follow_symlinks)
+        check_follow("follow_binds", follow_binds)
+        if not recursive:
+            return super().rm(
+                recursive=recursive,
+                missing_ok=missing_ok,
+                ignore_error=ignore_error,
+                follow_symlinks=follow_symlinks,
+                follow_binds=follow_binds,
+            )
+        # WebDAV DELETE is recursive by spec (RFC 4918): one request here
+        # replaces the base implementation's client-side stat+walk+unlink.
+        try:
+            try:
+                self._dav_request("DELETE")
+            except FileNotFoundError:
+                if not missing_ok:
+                    raise
+        except Exception as error:
+            onerror = (
+                ignore_error
+                if callable(ignore_error)
+                else (lambda _e, _p: bool(ignore_error))
+            )
+            if not onerror(error, self):
+                raise
+
+    def rename(self, target: "DAVURIPath | URI | str"):
+        target = self._rename_target(target)
+        # The new path carries the target's own query, not this path's: a
+        # signature or token in the query is good for the source only.
+        moved = self._from_parsed_parts(
+            self.source, target.path, target.query, target.fragment
+        )
+        # No userinfo in the header: the credentials already travel as `auth=` and a
+        # header value ends up in server and proxy logs. No fragment either: a server
+        # does not resolve it.
+        dest = split_userinfo(moved.with_fragment("")._wire_uri())[0]
+        self._dav_request(
+            "MOVE",
+            headers={"Destination": dest, "Overwrite": "F"},
+            statuses={
+                # 409: the destination's parent collection is missing.
+                409: lambda _self: os_error(FileNotFoundError, target),
+                412: lambda _self: os_error(FileExistsError, target),
+            },
+        )
+        # pathlib returns the new path.
+        return moved

uripath/schemes/_delegate.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import contextlib as _contextlib
+import typing as _ty
+
+from pathapi.protocols import supports as _supports
+
+from ._path import URIPath
+
+
+def _scandir(self):
+    with self._delegated():
+        yield from self._core_path._scandir()
+
+
+def _listdir(self):
+    for name, _stat in self._scandir():
+        yield name
+
+
+def _forward(name: str):
+    """A method that calls the core path's method of the same name, with the
+    errors it raises naming this path."""
+
+    def method(self, *args, **kwargs):
+        with self._delegated():
+            return getattr(self._core_path, name)(*args, **kwargs)
+
+    method.__name__ = name
+    return method
+
+
+#: Every hook a scheme may delegate, by name; `_DELEGATED` of the class says
+#: which of them it does, so a hook the core path lacks stays unimplemented.
+_FORWARDERS: "dict[str, object]" = {
+    name: _forward(name)
+    for name in (
+        "_open",
+        "_mkdir",
+        "unlink",
+        "rmdir",
+        "chmod",
+        "_chown",
+        "_utime",
+        "_symlink_to",
+        "readlink",
+        "_write_batch",
+        "_same_filesystem",
+        "_node_key",
+    )
+}
+_FORWARDERS["_scandir"] = _scandir
+_FORWARDERS["_listdir"] = _listdir
+
+
+class DelegatingURIPath(URIPath):
+    """A `URIPath` whose I/O is done by a core path that needs no URI.
+
+    A scheme names the hooks it hands over in `_DELEGATED` and builds the core
+    path for its URI in `_make_core()`; everything about URIs (parsing,
+    joining, backends, the text of the path) stays here. The core path is made
+    once per instance and used for every call, and an `OSError` it raises names
+    this path, not the core one."""
+
+    __slots__ = ("_core",)
+    _DELEGATED: "_ty.Sequence[str]" = ()
+    #: Whether an `OSError` of the core path is rewritten to name this path; a
+    #: core path that is itself the user's file (`LocalPath`) keeps its own.
+    _RELABEL = True
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        for name in cls.__dict__.get("_DELEGATED", ()):
+            if name not in cls.__dict__:
+                setattr(cls, name, _FORWARDERS[name])
+
+    def _make_core(self):
+        """The core path this URI names."""
+        raise NotImplementedError
+
+    @property
+    def _core_path(self):
+        core = self._core
+        if core is None:
+            core = self._core = self._make_core()
+        return core
+
+    @_contextlib.contextmanager
+    def _delegated(self, *extra: "tuple[str, str]"):
+        """Runs a call of the core path; an `OSError` that names the core path
+        (or a pair of `extra` `(core text, this text)`) names this one."""
+        if not self._RELABEL:
+            yield
+            return
+        try:
+            yield
+        except OSError as error:
+            core = str(self._core_path)
+            names = {**({core: str(self)} if core else {}), **dict(extra)}
+            _relabel(error, names)
+            raise
+
+    def _supports(self, protocol):
+        """What the core path supports, for a protocol this class has a hook for;
+        `None` (the class's own answer, which is no) for one it has not."""
+        if not _supports(type(self), protocol):
+            return None
+        return _supports(self._core_path, protocol)
+
+    def stat(self, *, follow_symlinks=True):
+        hint = self._pop_stat_hint()
+        if hint is not None and not (follow_symlinks and hint.is_symlink()):
+            return hint
+        with self._delegated():
+            return self._core_path.stat(follow_symlinks=follow_symlinks)
+
+
+def _relabel(error: OSError, names: "dict[str, str]") -> None:
+    for attribute in ("filename", "filename2"):
+        value = getattr(error, attribute)
+        if value in names:
+            setattr(error, attribute, names[value])
+    if any(isinstance(arg, str) and arg in names for arg in error.args):
+        error.args = tuple(
+            names[arg] if isinstance(arg, str) and arg in names else arg
+            for arg in error.args
+        )

uripath/schemes/_elsewhere.py

@@ -0,0 +1,102 @@
+"""Schemes that other distributions provide.
+
+`uripath` knows their names. A path of one of these schemes builds, joins,
+compares and prints like any other, and the first operation that needs the
+server raises an `ImportError` that names what to install.
+"""
+
+from __future__ import annotations
+
+from ._path import URIPath
+
+#: Scheme -> (the distribution that provides it, its import name, what to run
+#: to get it). A name listed here is known without the distribution: a path of
+#: it is built, and its I/O raises an `ImportError` naming what to install. An
+#: installed distribution registers its own class (an entry point of
+#: `uripath.schemes`), which is found first.
+SCHEMES = {
+    "sftp": (
+        "sftppath",
+        "sftppath",
+        'pip install "sftppath[paramiko]" (or "sftppath[asyncssh]")',
+    ),
+    "s3": (
+        "objpath",
+        "objpath",
+        'pip install "objpath[s3]"',
+    ),
+    "gs": (
+        "objpath",
+        "objpath",
+        'pip install "objpath[gs]"',
+    ),
+    "az": (
+        "objpath",
+        "objpath",
+        'pip install "objpath[az]"',
+    ),
+    "repo": ("repopath", "repopath", "pip install repopath"),
+    "github": ("repopath", "repopath", "pip install repopath"),
+    "gitlab": ("repopath", "repopath", "pip install repopath"),
+}
+
+#: The schemes of that table whose userinfo is an access token and not a user
+#: name: `str()` and `repr()` of a `Source` show none of it. Known here, and
+#: not only to the distribution that provides them, so that no display form of a
+#: `Source` shows a token before that distribution is loaded.
+TOKEN_SCHEMES = frozenset({"repo", "github", "gitlab"})
+
+
+def not_installed(scheme: str) -> ImportError:
+    """The `ImportError` for a scheme another distribution provides."""
+    distribution, package, install = SCHEMES[scheme]
+    return ImportError(
+        f"the {scheme!r} scheme is provided by the {distribution} distribution: "
+        f"{install}",
+        name=package,
+    )
+
+
+def _unavailable(name: str):
+    """A hook of `URIPath` that does the one thing a path of a missing scheme
+    can do about I/O."""
+
+    def hook(self, *args, **kwargs):
+        raise not_installed(self.source.scheme.lower())
+
+    hook.__name__ = name
+    return hook
+
+
+class ProvidedElsewhere(URIPath):
+    """The class of a path whose scheme another distribution provides and that is
+    not installed. It registers no scheme: an installed distribution registers
+    its own class, which is found first. Every primitive of `URIPath` raises
+    the `ImportError` of `not_installed()`, so each operation derived from one
+    does too."""
+
+    __slots__ = ()
+    #: The keyword arguments of the real class are that distribution's to name.
+    _OPTIONS = None
+
+    def _initbackend(self):
+        raise not_installed(self.source.scheme.lower())
+
+
+for _name in (
+    "stat",
+    "_open",
+    "_listdir",
+    "_scandir",
+    "unlink",
+    "_mkdir",
+    "rmdir",
+    "rename",
+    "chmod",
+    "_chown",
+    "_utime",
+    "readlink",
+    "_symlink_to",
+):
+    setattr(ProvidedElsewhere, _name, _unavailable(_name))
+del _name