moat-kv 0.70.24__py3-none-any.whl → 0.71.6__py3-none-any.whl

build/lib/moat/kv/types.py

@@ -1,513 +0,0 @@
-from __future__ import annotations
-import logging
-import weakref
-
-import jsonschema
-from moat.util import NotGiven, P, Path, make_proc, singleton
-
-from .exceptions import ACLError, ClientError
-from .model import Entry
-
-logger = logging.getLogger(__name__)
-
-# TYPES
-
-
-class MetaEntry(Entry):
-    def __init__(self, *a, **k):
-        super().__init__(*a, **k)
-        self._metaroot = self.parent._metaroot
-
-    @property
-    def metaroot(self):
-        "Stores a link to the meta root because some do need it."
-        return self._metaroot()
-
-
-class TypeEntry(Entry):
-    """I am a type-checking node."""
-
-    _code = None
-    _schema = None
-
-    def check_value(self, value, entry=None, **kv):
-        self.parent.check_value(value, entry=entry, **kv)
-        if self._schema is not None:
-            jsonschema.validate(instance=value, schema=self._schema)
-        if self._code is not None:
-            self._code(value, entry=entry, data=self._data, **kv)
-
-    async def set(self, value):
-        code = None
-        schema = None
-        if value is not NotGiven and (
-            value.get("code", None) is not None or value.get("schema", None) is not None
-        ):
-            schema = value.get("schema", None)
-            if value.get("code", None) is None:
-                code = None
-            else:
-                code = make_proc(value.code, ("value",), self.path)
-            if len(value.good) < 2:
-                raise RuntimeError("Must have check-good values")
-            if not value.bad:
-                raise RuntimeError("Must have check-bad values")
-            for v in value["good"]:
-                self.parent.check_value(v)
-                try:
-                    if schema is not None:
-                        jsonschema.validate(instance=v, schema=schema)
-                    if code is not None:
-                        code(v, entry=None)
-                except Exception:
-                    raise ValueError(f"failed on good value {v!r}")
-            for v in value["bad"]:
-                self.parent.check_value(v)
-                try:
-                    if schema is not None:
-                        jsonschema.validate(instance=v, schema=schema)
-                    if code is not None:
-                        code(v, entry=None)
-                except Exception:
-                    pass
-                else:
-                    raise ValueError(f"did not fail on {v!r}")
-
-        await super().set(value)
-        self._code = code
-        self._schema = schema
-
-
-TypeEntry.SUBTYPE = TypeEntry
-
-
-class TypeRoot(Entry):
-    """I am the root of MoaT-KV's type hierarchy."""
-
-    SUBTYPE = TypeEntry
-
-    async def set(self, value):
-        if value is not NotGiven:
-            raise ValueError("This node can't have data.")
-
-    def check_value(self, value, entry=None, **kv):
-        pass
-
-
-# MATCH (for types)
-
-
-class MatchEntry(MetaEntry):
-    """I represent a match from a path to a type.
-
-    My data requires a "type" attribute that's a path in the "type"
-    hierarchy that's next to my MatchRoot.
-    """
-
-    async def set(self, value):
-        if value is NotGiven:
-            pass
-        elif isinstance(value.type, str):
-            value.type = P(value.type)
-        elif not isinstance(value.type, (Path, list, tuple)):
-            raise ValueError("Type of %r is not a list" % (value.type,))
-        try:
-            self.metaroot["type"].follow(value.type, create=False)
-        except KeyError:
-            logger.exception("Type %r doesn't exist", value.type)
-            raise ClientError("This type does not exist")
-        # crashes if nonexistent
-        await super().set(value)
-
-
-MatchEntry.SUBTYPE = MatchEntry
-
-
-class NodeFinder:
-    """A generic object that can walk down a possibly-wildcard-equipped path.
-
-    Example: given a path `one.two.three` and a root `bar` with subtree `bar.#.three`,
-    `NodeFinder(bar).step(one).step(two).step(three)` will return the node
-    at `bar.#.three` (assuming that nothing more specific hangs off `bar`).
-    """
-
-    def __init__(self, meta):
-        if isinstance(meta, list):
-            self.steps = meta
-        else:
-            self.steps = ((meta, False),)
-
-    def step(self, name, new=False):
-        steps = []
-        for node, keep in self.steps:
-            if name in node:
-                steps.append((node[name], False))
-            if name is None:
-                continue
-            if "+" in node:
-                steps.append((node["+"], False))
-            if "#" in node:
-                steps.append((node["#"], True))
-            if keep:
-                steps.append((node, True))
-            # Nodes found with '#' stay on the list
-            # so that they can match multiple entries.
-        # if not steps:
-        #    raise KeyError(name)
-        if new:
-            return type(self)(steps, **self.copy_args)
-        else:
-            self.steps = steps
-            return self
-
-    @property
-    def copy_args(self):
-        return {}
-
-    @property
-    def result(self):
-        for node, _keep in self.steps:
-            if node._data is not NotGiven:
-                return node
-        return None
-
-
-class ACLFinder(NodeFinder):
-    """A NodeFinder which expects ACL strings as elements"""
-
-    _block = ""
-
-    @property
-    def copy_args(self):
-        return {"blocked": self._block}
-
-    def __init__(self, acl, blocked=None):
-        if isinstance(acl, ACLFinder):
-            if blocked is None:
-                blocked = acl._block
-            acl = acl.steps
-        super().__init__(acl)
-        if blocked is not None:
-            self._block = blocked
-
-    def allows(self, x):
-        if x in self._block:
-            return False
-
-        r = self.result
-        if r is None:
-            return True
-        return x in r.data
-
-    def block(self, c):
-        if c not in self._block:
-            self._block += c
-
-    def check(self, x):
-        if not self.allows(x):
-            raise ACLError(self.result, x)
-
-
-class ACLStepper(ACLFinder):
-    """An ACLFinder which returns a copy of itself at every `step`."""
-
-    def step(self, name, new=True):
-        return super().step(name, new=new)
-
-
-@singleton
-class NullACL(ACLStepper):
-    """This singleton represents an ACL that never checks anything."""
-
-    result = "-"
-
-    def __init__(self):  # pylint: disable=super-init-not-called
-        pass
-
-    def allows(self, x):
-        return x != "a"
-
-    def check(self, x):
-        return
-
-    def block(self, c):
-        pass
-
-    def step(self, name, new=None):
-        return self
-
-
-class MetaPathEntry(MetaEntry):
-    def _find_node(self, entry):
-        """Search for the most-specific match.
-
-        Match entries whose values are missing are not considered.
-        """
-        f = NodeFinder(self)
-        for n in entry.path:
-            f.step(n)
-        return f.result
-
-
-class MatchRoot(MetaPathEntry):
-    """I am the root of MoaT-KV's type hierarchy."""
-
-    SUBTYPE = MatchEntry
-
-    async def set(self, value):
-        if value is not None:
-            raise ValueError("This node can't have data.")
-
-    def check_value(self, value, entry, **kv):
-        """Check this value for this entry against my match hierarchy"""
-        match = self._find_node(entry)
-        if match is None:
-            return
-        typ = self.parent["type"].follow(match._data["type"])
-        return typ.check_value(value, entry=entry, match=match, **kv)
-
-
-class CodecEntry(Entry):
-    """I am a codec."""
-
-    _enc = None
-    _dec = None
-
-    def enc_value(self, value, entry=None, **kv):
-        if self._enc is not None:
-            try:
-                value = self._enc(value, entry=entry, data=self._data, **kv)
-            except TypeError:
-                if value is not None:
-                    raise
-        return value
-
-    def dec_value(self, value, entry=None, **kv):
-        if self._dec is not None:
-            try:
-                value = self._dec(value, entry=entry, data=self._data, **kv)
-            except TypeError:
-                if value is not None:
-                    raise
-        return value
-
-    async def set(self, value):
-        enc = None
-        dec = None
-        if value is not None and value.decode is not None:
-            if not value["in"]:
-                raise RuntimeError("Must have tests for decoding")
-            dec = make_proc(value.decode, ("value",), self.path)
-            for v, w in value["in"]:
-                try:
-                    r = dec(v)
-                except Exception as exc:
-                    raise ValueError(
-                        f"failed decoder at {self.path} on {v!r} with {exc!r}",
-                    ) from exc
-                else:
-                    if r != w:
-                        raise ValueError(f"Decoding at {self.path}: {v!r} got {r!r}, not {w!r}")
-
-        if value is not None and value.encode is not None:
-            if not value["out"]:
-                raise RuntimeError("Must have tests for encoding")
-            enc = make_proc(value.encode, ("value",), self.path)
-            for v, w in value["out"]:
-                try:
-                    r = enc(v)
-                except Exception as exc:
-                    raise ValueError(
-                        f"failed encoder at {self.path} on {v!r} with {exc!r}",
-                    ) from exc
-                else:
-                    if r != w:
-                        raise ValueError(f"Encoding at {self.path}: {v!r} got {r!r}, not {w!r}")
-
-        await super().set(value)
-        self._enc = enc
-        self._dec = dec
-
-
-CodecEntry.SUBTYPE = CodecEntry
-
-
-class CodecRoot(Entry):
-    """I am the root of MoaT-KV's codec hierarchy."""
-
-    SUBTYPE = CodecEntry
-
-    async def set(self, value):
-        if value is not None:
-            raise ValueError("This node can't have data.")
-
-    def check_value(self, value, entry=None, **kv):
-        pass
-
-
-# CONV (for codecs)
-
-
-class ConvEntry(MetaEntry):
-    """I represent a converter from a path to a type.
-
-    My data requires a "codec" attribute that's a path in the "codecs"
-    hierarchy that's next to my Root.
-    """
-
-    async def set(self, value):
-        if value is not NotGiven:
-            # can't run a nonexistent value through a codec
-
-            if not hasattr(value, "codec"):
-                raise ValueError("Duh? " + repr(value))
-            if isinstance(value.codec, str):
-                value.codec = P(value.codec)
-            elif not isinstance(value.codec, (Path, list, tuple)):
-                raise ValueError("Codec %r is not a list" % (value.codec,))
-            try:
-                self.metaroot["codec"].follow(value.codec, create=False)
-            except KeyError:
-                logger.warning("Codec %r does not exist (yet?)", value.codec)
-                # raise ClientError("This codec does not exist")
-                # don't raise here
-        await super().set(value)
-
-
-ConvEntry.SUBTYPE = ConvEntry
-
-
-class ConvNull:
-    """I am a dummy translator"""
-
-    @staticmethod
-    def enc_value(value, **_kw):
-        return value
-
-    @staticmethod
-    def dec_value(value, **_kw):
-        return value
-
-
-ConvNull = ConvNull()
-
-
-class ConvName(MetaPathEntry):
-    """I am a named tree for conversion entries."""
-
-    SUBTYPE = ConvEntry
-
-    async def set(self, value):
-        if value is not None:
-            raise ValueError("This node can't have data.")
-
-    def enc_value(self, value, entry, **kv):
-        """Check this value for this entry against my converter hierarchy"""
-        conv = self._find_node(entry)
-        if conv is None:
-            return value
-        codec = self.metaroot["codec"].follow(conv._data["codec"])
-        return codec.enc_value(value, entry=entry, conv=conv, **kv)
-
-    def dec_value(self, value, entry, **kv):
-        """Check this value for this entry against my converter hierarchy"""
-        conv = self._find_node(entry)
-        if conv is None:
-            return value
-        codec = self.metaroot["codec"].follow(conv._data["codec"])
-        return codec.dec_value(value, entry=entry, conv=conv, **kv)
-
-
-class ConvRoot(MetaEntry):
-    SUBTYPE = ConvName
-
-    async def set(self, value):
-        if value is not None:
-            raise ValueError("This node can't have data.")
-
-
-class AclEntry(MetaPathEntry):
-    """I represent an ACL.
-
-    My data must be a string of ACLish characters.
-    """
-
-    async def set(self, value):
-        if value is NotGiven:
-            pass
-        elif not isinstance(value, str):
-            raise ValueError("ACL is not a string")
-        await super().set(value)
-
-
-AclEntry.SUBTYPE = AclEntry
-
-
-class AclName(AclEntry):
-    """I am a named tree for ACL entries."""
-
-    SUBTYPE = AclEntry
-
-    async def check(self, entry, typ):
-        acl = self._find_node(entry)
-        if acl is None:
-            return None
-        return typ in acl.value
-
-
-class AclRoot(MetaEntry):
-    SUBTYPE = AclName
-
-    async def set(self, value):
-        if value is not None:
-            raise ValueError("This node can't have data.")
-
-
-class DelRoot(Entry):
-    SUBTYPE = None
-
-    async def set(self, value):
-        await super().set(value)
-        await self.root.server.del_check(value)
-
-
-class ActorRoot(Entry):
-    SUBTYPE = None
-    SUBTYPES = {"del": DelRoot}
-
-
-# ROOT
-
-
-class MetaRootEntry(Entry):  # not MetaEntry
-    """I am the special node off the MoaT-KV root that's named ``None``."""
-
-    SUBTYPES = {
-        "type": TypeRoot,
-        "match": MatchRoot,
-        "acl": AclRoot,
-        "codec": CodecRoot,
-        "conv": ConvRoot,
-        "actor": ActorRoot,
-    }
-
-    def __init__(self, *a, **k):
-        super().__init__(*a, **k)
-        self._metaroot = weakref.ref(self)
-
-
-Entry.SUBTYPES[None] = MetaRootEntry
-
-
-class RootEntry(Entry):
-    """I am the root of the MoaT-KV data tree."""
-
-    def __init__(self, server, *a, **k):
-        super().__init__("ROOT", None, *a, **k)
-        self._server = weakref.ref(server)
-
-    @property
-    def server(self):
-        return self._server()
-
-    SUBTYPES = {None: MetaRootEntry}

debian/moat-kv/usr/lib/python3/dist-packages/docs/source/conf.py

@@ -1,201 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# Documentation build configuration file, created by
-# sphinx-quickstart on Sat Jan 21 19:11:14 2017.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#
-import os
-import sys
-
-# So autodoc can import our package
-sys.path.insert(0, os.path.abspath("../.."))
-
-# Warn about all references to unknown targets
-nitpicky = True
-# Except for these ones, which we expect to point to unknown targets:
-nitpick_ignore = [
-    # Format is ("sphinx reference type", "string"), e.g.:
-    ("py:obj", "bytes-like"),
-    ("py:class", "RangeSet"),
-    ("py:class", "Any"),
-]
-
-autodoc_inherit_docstrings = False
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#
-# needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.intersphinx",
-    "sphinx.ext.coverage",
-    "sphinx.ext.napoleon",
-    "sphinxcontrib_trio",
-]
-
-intersphinx_mapping = {
-    "python": ("https://docs.python.org/3", None),
-    "trio": ("https://trio.readthedocs.io/en/stable", None),
-}
-
-autodoc_member_order = "bysource"
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = []
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-#
-# source_suffix = ['.rst', '.md']
-source_suffix = ".rst"
-
-# The master toctree document.
-master_doc = "index"
-
-# General information about the project.
-project = "MoaT-KV"
-copyright = "The MoaT-KV authors"
-author = "The MoaT-KV authors"
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-import pkg_resources
-
-version = pkg_resources.get_distribution("moat.kv")._version
-
-# The full version, including alpha/beta/rc tags.
-release = version
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-# This patterns also effect to html_static_path and html_extra_path
-exclude_patterns = []
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = "sphinx"
-
-# The default language for :: blocks
-highlight_language = "python3"
-
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = False
-
-
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-#
-# html_theme = 'alabaster'
-
-# We have to set this ourselves, not only because it's useful for local
-# testing, but also because if we don't then RTD will throw away our
-# html_theme_options.
-import sphinx_rtd_theme
-
-html_theme = "sphinx_rtd_theme"
-html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-#
-html_theme_options = {
-    # default is 2
-    # show deeper nesting in the RTD theme's sidebar TOC
-    # https://stackoverflow.com/questions/27669376/
-    # I'm not 100% sure this actually does anything with our current
-    # versions/settings...
-    "navigation_depth": 4,
-    "logo_only": True,
-}
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ["_static"]
-
-
-# -- Options for HTMLHelp output ------------------------------------------
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = "moat.kv-doc"
-
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-    # The paper size ('letterpaper' or 'a4paper').
-    #
-    # 'papersize': 'letterpaper',
-    # The font size ('10pt', '11pt' or '12pt').
-    #
-    # 'pointsize': '10pt',
-    # Additional stuff for the LaTeX preamble.
-    #
-    # 'preamble': '',
-    # Latex figure (float) alignment
-    #
-    # 'figure_align': 'htbp',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-#  author, documentclass [howto, manual, or own class]).
-latex_documents = [
-    (master_doc, "moat.kv.tex", "Trio Documentation", author, "manual"),
-]
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [(master_doc, "moat.kv", "MoaT-KV Documentation", [author], 1)]
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-#  dir menu entry, description, category)
-texinfo_documents = [
-    (
-        master_doc,
-        "moat.kv",
-        "MoaT-KV Documentation",
-        author,
-        "MoaT-KV",
-        "A distributed no-master key-value store",
-        "Miscellaneous",
-    ),
-]