The Root Class

# delta/shares.py — the root class (trimmed excerpt)

class DataShare:
    """The root class. A child overrides what its data needs; the server never
    special-cases a child."""

    kind = "share"

    def __init__(self, name, *, app=config.MEMBER, readers=None, writers=None, apps=None,
                 cache=True, description="", options=None, repo_root=None):
        if not name or set(name) - _SHARE_NAME_CHARS:
            raise ValueError(f"bad share name {name!r}")
        self.name = name
        self.app = app
        self.readers = Policy(readers)
        self.writers = Policy(writers)
        self.apps = list(apps) if apps else ["*"]
        ...

    @property
    def id(self):
        return self.name if self.app == config.MEMBER else f"{self.app}/{self.name}"

    def writable(self):
        return False

    # -- the vocabulary a child may override --
    def stat(self, rel):
        raise NotFound(f"{self.id} has no path {rel!r}")

    def file(self, rel, params=None):
        raise NotFound(f"{self.id} serves no file {rel!r}")

    def listdir(self, rel, recursive=False):
        raise NotFound(f"{self.id} lists nothing at {rel!r}")

    def validator(self, op, params):
        return None

    def api(self, op, params):
        raise NotFound(f"{self.id} has no operation {op!r}")

    def derive(self, entry, kind, params):
        return None

    def _no_file_writes(self):
        if self.writable():  # a child whose only write is the call
            return Forbidden(f"{self.id} takes no file writes: its owner writes through a call")
        return Forbidden(f"{self.id} is read-only")

    def write_path(self, rel):
        raise self._no_file_writes()

    def call(self, op, params, body, *, caller, app, request_id):
        raise Forbidden(f"{self.id} takes no write call")

# A root class whose defaults refuse, two children, and a server that never asks which child it holds.
import os
import tempfile
from dataclasses import dataclass


class Refused(Exception):
    pass


class Missing(Exception):
    pass


@dataclass
class Entry:
    rel: str
    size: int
    mtime_ns: int
    ino: int

    @property
    def etag(self):
        return f'"{self.size:x}-{self.mtime_ns:x}-{self.ino:x}"'


class Share:
    """The root: every read answers 'nothing here', every write is refused."""

    def __init__(self, name):
        self.name = name

    def file(self, rel):
        raise Missing(f"{self.name} serves no file {rel!r}")

    def api(self, op, params):
        raise Missing(f"{self.name} has no operation {op!r}")

    def writable(self):
        return False

    def write(self, rel, data):
        raise Refused(f"{self.name} is read-only")


class TreeShare(Share):
    """A plain folder: files only, and never one outside the root."""

    def __init__(self, name, root):
        super().__init__(name)
        self.root = os.path.realpath(root)

    def file(self, rel):
        if ".." in rel.split("/"):
            raise Refused("'..' is not a path component this share follows")
        path = os.path.realpath(os.path.join(self.root, rel))
        if not path.startswith(self.root + "/") or not os.path.isfile(path):
            raise Missing(f"{self.name} has no file {rel!r}")
        st = os.stat(path)
        return Entry(rel, st.st_size, st.st_mtime_ns, st.st_ino)


class CounterShare(Share):
    """A share with no files at all: one read API, answered from memory."""

    def __init__(self, name):
        super().__init__(name)
        self.hits = 0

    def api(self, op, params):
        if op != "hits":
            return super().api(op, params)
        self.hits += 1
        return {"hits": self.hits}


def serve(share, verb, arg):
    """The server: one dispatch, no isinstance, no special case per child."""
    try:
        if verb == "file":
            entry = share.file(arg)
            return 200, {"rel": entry.rel, "etag": entry.etag}
        if verb == "api":
            return 200, share.api(arg, {})
        if verb == "write":
            share.write(arg, b"")
        return 400, {"error": "bad_request"}
    except Missing as exc:
        return 404, {"error": "not_found", "detail": str(exc)}
    except Refused as exc:
        return 403, {"error": "forbidden", "detail": str(exc)}


if __name__ == "__main__":
    with tempfile.TemporaryDirectory() as tmp:
        with open(os.path.join(tmp, "notes.txt"), "w") as f:
            f.write("hello")
        tree, counter = TreeShare("tree", tmp), CounterShare("counter")
        print(serve(tree, "file", "notes.txt"))       # 200 with an etag
        print(serve(tree, "file", "../etc/passwd"))   # 403, refused by name
        print(serve(counter, "api", "hits"))          # 200 {'hits': 1}
        print(serve(counter, "file", "anything"))     # 404 from the root default
        print(serve(tree, "write", "notes.txt"))      # 403, read-only by default