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

build/lib/moat/kv/command/log.py

@@ -1,53 +0,0 @@
-# command line interface
-from __future__ import annotations
-
-import asyncclick as click
-from moat.util import yprint
-
-
-@click.group(short_help="Manage logging.")  # pylint: disable=undefined-variable
-async def cli():
-    """
-    This subcommand controls a server's logging.
-    """
-    pass
-
-
-@cli.command()
-@click.option("-i", "--incremental", is_flag=True, help="Don't write the initial state")
-@click.argument("path", nargs=1)
-@click.pass_obj
-async def dest(obj, path, incremental):
-    """
-    Log changes to a file.
-
-    Any previously open log (on the server you talk to) is closed as soon
-    as the new one is opened and ready.
-    """
-    res = await obj.client._request("log", path=path, fetch=not incremental)
-    if obj.meta:
-        yprint(res, stream=obj.stdout)
-
-
-@cli.command()
-@click.option("-f", "--full", is_flag=1, help="Also dump internal state")
-@click.argument("path", nargs=1)
-@click.pass_obj
-async def save(obj, path, full):
-    """
-    Write the server's current state to a file.
-    """
-    res = await obj.client._request("save", path=path, full=full)
-    if obj.meta:
-        yprint(res, stream=obj.stdout)
-
-
-@cli.command()
-@click.pass_obj
-async def stop(obj):
-    """
-    Stop logging changes.
-    """
-    res = await obj.client._request("log")  # no path == stop
-    if obj.meta:
-        yprint(res, stream=obj.stdout)

build/lib/moat/kv/command/server.py

@@ -1,114 +0,0 @@
-# command line interface
-from __future__ import annotations
-
-import asyncclick as click
-
-from moat.kv.server import Server
-
-
-@click.command(short_help="Run the MoaT-KV server.")  # pylint: disable=undefined-variable
-@click.option(
-    "-l",
-    "--load",
-    type=click.Path(readable=True, exists=True, allow_dash=False),
-    default=None,
-    help="Event log to preload.",
-)
-@click.option(
-    "-s",
-    "--save",
-    type=click.Path(writable=True, allow_dash=False),
-    default=None,
-    help="Event log to write to.",
-    hidden=True,
-)
-@click.option(
-    "-i",
-    "--incremental",
-    default=None,
-    help="Save incremental changes, not the complete state",
-    hidden=True,
-)
-@click.option(
-    "-I",
-    "--init",
-    default=None,
-    help="Initial value to set the root to. Use only when setting up "
-    "a cluster for the first time!",
-    hidden=True,
-)
-@click.option(
-    "-e",
-    "--eval",
-    "eval_",
-    is_flag=True,
-    help="The 'init' value shall be evaluated.",
-    hidden=True,
-)
-@click.option(
-    "-a",
-    "--auth",
-    "--authoritative",
-    is_flag=True,
-    help="Data in this file is complete: mark anything missing as known even if not.",
-)
-@click.option(
-    "-f",
-    "--force",
-    is_flag=True,
-    help="Force 'successful' startup even if data are missing.",
-)
-@click.argument("name", nargs=1)
-@click.argument("nodes", nargs=-1)
-@click.pass_obj
-async def cli(obj, name, load, save, init, incremental, eval_, auth, force, nodes):
-    """
-    This command starts a MoaT-KV server. It defaults to connecting to the local Serf
-    agent.
-
-    All MoaT-KV servers must have a unique name. Its uniqueness cannot be
-    verified reliably.
-
-    One server in your network needs either an initial datum, or a copy of
-    a previously-saved MoaT-KV state. Otherwise, no client connections will
-    be accepted until synchronization with the other servers in your MoaT-KV
-    network is complete.
-
-    This command requires a unique NAME argument. The name identifies this
-    server on the network. Never start two servers with the same name!
-
-    You can force the server to fetch its data from a specific node, in
-    case some data are corrupted. (This should never be necessary.)
-
-    A server will refuse to start up as long as it knows about missing
-    entries. Use the 'force' flag to disable that. You should disable
-    any clients which use this server until the situation is resolved!
-
-    An auhthoritative server doesn't have missing data in its storage by
-    definition. This flag is used in the 'run' script when loading from a
-    file.
-    """
-
-    kw = {}
-    if eval_:
-        kw["init"] = eval(init)  # pylint: disable=eval-used
-    elif init == "-":
-        kw["init"] = None
-    elif init is not None:
-        kw["init"] = init
-
-    from moat.util import as_service
-
-    if load and nodes:
-        raise click.UsageError("Either read from a file or fetch from a node. Not both.")
-    if auth and force:
-        raise click.UsageError("Using both '-a' and '-f' is redundant. Choose one.")
-
-    async with as_service(obj) as evt:
-        s = Server(name, cfg=obj.cfg["kv"], **kw)
-        if load is not None:
-            await s.load(path=load, local=True, authoritative=auth)
-        if nodes:
-            await s.fetch_data(nodes, authoritative=auth)
-
-        await s.serve(log_path=save, log_inc=incremental, force=force, ready_evt=evt)

build/lib/moat/kv/command/type.py

@@ -1,201 +0,0 @@
-# command line interface
-from __future__ import annotations
-
-import json
-
-import asyncclick as click
-from moat.util import NotGiven, P, Path, PathLongener, yload, yprint
-
-
-@click.group()  # pylint: disable=undefined-variable
-async def cli():
-    """Manage types and type matches. Usage: … type …"""
-    pass
-
-
-@cli.command()
-@click.option("-s", "--script", type=click.File(mode="w", lazy=True), help="Save the script here")
-@click.option("-S", "--schema", type=click.File(mode="w", lazy=True), help="Save the schema here")
-@click.option("-y", "--yaml", "yaml_", is_flag=True, help="Write schema as YAML. Default: JSON.")
-@click.argument("path", type=P, nargs=1)
-@click.pass_obj
-async def get(obj, path, script, schema, yaml_):
-    """Read type checker information"""
-    if not len(path):
-        raise click.UsageError("You need a non-empty path.")
-    res = await obj.client._request(
-        action="get_internal",
-        path=Path("type") + path,
-        iter=False,
-        nchain=obj.meta,
-    )
-    try:
-        r = res.value
-    except AttributeError:
-        raise click.UsageError(f"No data at {Path('type') + path}") from None
-
-    if not obj.meta:
-        res = res.value
-    if script:
-        script.write(r.pop("code"))
-    if schema:
-        if yaml_:
-            yprint(r.pop("schema"), stream=schema)
-        else:
-            json.dump(r.pop("schema"), schema)
-    yprint(res, stream=obj.stdout)
-
-
-@cli.command("set")
-@click.option("-g", "--good", multiple=True, help="Example for passing values")
-@click.option("-b", "--bad", multiple=True, help="Example for failing values")
-@click.option("-d", "--data", type=click.File(mode="r"), help="Load metadata from this YAML file.")
-@click.option("-s", "--script", type=click.File(mode="r"), help="File with the checking script")
-@click.option("-S", "--schema", type=click.File(mode="r"), help="File with the JSON schema")
-@click.option("-y", "--yaml", "yaml_", is_flag=True, help="load the schema as YAML. Default: JSON")
-@click.argument("path", type=P, nargs=1)
-@click.pass_obj
-async def set_(obj, path, good, bad, script, schema, yaml_, data):
-    """Write type checker information."""
-    if not len(path):
-        raise click.UsageError("You need a non-empty path.")
-
-    if data:
-        msg = yload(data)
-    else:
-        msg = {}
-    chain = NotGiven
-    if "value" in msg:
-        chain = msg.get("chain", NotGiven)
-        msg = msg["value"]
-
-    msg.setdefault("good", [])
-    msg.setdefault("bad", [])
-    for x in good:
-        msg["good"].append(eval(x))  # pylint: disable=eval-used
-    for x in bad:
-        msg["bad"].append(eval(x))  # pylint: disable=eval-used
-
-    if "code" in msg:
-        if script:
-            raise click.UsageError("Duplicate script")
-    elif script:
-        msg["code"] = script.read()
-
-    if "schema" in msg:
-        raise click.UsageError("Missing schema")
-    elif schema:
-        if yaml_:
-            msg["schema"] = yload(schema)
-        else:
-            msg["schema"] = json.load(schema)
-
-    if "schema" not in msg and "code" not in msg:
-        raise click.UsageError("I need a schema, Python code, or both.")
-
-    if len(msg["good"]) < 2:
-        raise click.UsageError("Missing known-good test values (at least two)")
-    if not msg["bad"]:
-        raise click.UsageError("Missing known-bad test values")
-
-    res = await obj.client._request(
-        action="set_internal",
-        value=msg,
-        path=Path("type") + path,
-        iter=False,
-        nchain=obj.meta,
-        **({} if chain is NotGiven else {"chain": chain}),
-    )
-    if obj.meta:
-        yprint(res, stream=obj.stdout)
-
-
-@cli.command()
-@click.option("-R", "--raw", is_flag=True, help="Print just the path.")
-@click.option("-t", "--type", "type_", help="Type path to link to.")
-@click.option("-d", "--delete", help="Use to delete this mapping.")
-@click.argument("path", type=P, nargs=1)
-@click.pass_obj
-async def match(obj, path, type_, delete, raw):  # pylint: disable=redefined-builtin
-    """Match a type to a path (read, if no type given; list if empty path)"""
-    if not len(path):
-        if raw or type_ or delete:
-            raise click.UsageError("No options allowed when dumping the match tree..")
-        y = {}
-        pl = PathLongener()
-        async for r in await obj.client._request(
-            "get_tree_internal",
-            path=Path("match") + path,
-            iter=True,
-            nchain=0,
-        ):
-            pl(r)
-            path = r["path"]
-            yy = y
-            for p in path:
-                yy = yy.setdefault(p, {})
-            try:
-                yy["_"] = r["value"]
-            except KeyError:
-                pass
-        yprint(y, stream=obj.stdout)
-        return
-
-    if type_ and delete:
-        raise click.UsageError("You can't both set and delete a path.")
-    if raw and (type_ or delete):
-        raise click.UsageError("You can only print the raw path when reading a match.")
-
-    if delete:
-        res = await obj.client._request(action="delete_internal", path=Path("type") + path)
-        if obj.meta:
-            yprint(res, stream=obj.stdout)
-        return
-
-    msg = {}
-    if type_:
-        msg["type"] = P(type_)
-        act = "set_internal"
-    elif delete:
-        act = "delete_internal"
-    else:
-        act = "get_internal"
-    res = await obj.client._request(
-        action=act,
-        value=msg,
-        path=Path("match") + path,
-        iter=False,
-        nchain=obj.meta,
-    )
-    if obj.meta:
-        yprint(res, stream=obj.stdout)
-    elif type_ or delete:
-        pass
-    else:
-        print(" ".join(str(x) for x in res.type), file=obj.stdout)
-
-
-@cli.command()
-@click.argument("path", type=P, nargs=1)
-@click.pass_obj
-async def list(obj, path):  # pylint: disable=redefined-builtin
-    """Dump type data"""
-
-    y = {}
-    pl = PathLongener()
-    async for r in await obj.client._request(
-        "get_tree_internal",
-        path=Path("type") + path,
-        iter=True,
-        nchain=0,
-    ):
-        pl(r)
-        path = r["path"]
-        yy = y
-        for p in path:
-            yy = yy.setdefault(p, {})
-        try:
-            yy["_"] = r["value"]
-        except KeyError:
-            pass
-    yprint(y, stream=obj.stdout)

build/lib/moat/kv/config.py

@@ -1,46 +0,0 @@
-"""
-An online-updated config store
-
-"""
-
-from __future__ import annotations
-
-try:
-    from contextlib import asynccontextmanager
-except ImportError:  # pragma: no cover
-    from async_generator import asynccontextmanager
-
-import logging
-
-from .exceptions import ServerClosedError, ServerError
-from .obj import ClientEntry, ClientRoot
-
-logger = logging.getLogger(__name__)
-
-
-class ConfigEntry(ClientEntry):
-    @classmethod
-    def child_type(cls, name):  # pragma: no cover
-        logger.warning("Online config sub-entries are ignored")
-        return ClientEntry
-
-    async def set_value(self, value):
-        await self.root.client.config._update(self._name, value)
-
-
-class ConfigRoot(ClientRoot):
-    CFG = "config"
-
-    @classmethod
-    def child_type(cls, name):
-        return ConfigEntry
-
-    @asynccontextmanager
-    async def run(self):
-        try:
-            async with super().run() as x:
-                yield x
-        except ServerClosedError:  # pragma: no cover
-            pass
-        except ServerError:  # pragma: no cover
-            logger.exception("No config data")

build/lib/moat/kv/data.py

@@ -1,216 +0,0 @@
-"""
-Data access
-"""
-from __future__ import annotations
-
-import datetime
-import os
-import sys
-import time
-from collections.abc import Mapping
-
-from moat.util import NotGiven, Path, attrdict, process_args, yprint
-
-
-def add_dates(d):
-    """
-    Given a dict with int/float entries that might conceivably be dates,
-    add ``_*`` with a textual representation.
-    """
-
-    t = time.time()
-    start = t - 366 * 24 * 3600
-    stop = t + 366 * 24 * 3600
-
-    def _add(d):
-        if isinstance(d, (list, tuple)):
-            for dd in d:
-                _add(dd)
-            return
-        if not isinstance(d, Mapping):
-            return
-        for k, v in list(d.items()):
-            if isinstance(k, str) and k.startswith("_"):
-                continue
-            if not isinstance(v, (int, float)):
-                _add(v)
-                continue
-            if start <= v <= stop:
-                d[f"_{k}"] = datetime.datetime.fromtimestamp(v).isoformat(
-                    sep=" ",
-                    timespec="milliseconds",
-                )
-
-    _add(d)
-
-
-async def data_get(
-    obj,
-    path,
-    *,
-    recursive=True,
-    as_dict="_",
-    maxdepth=-1,
-    mindepth=0,
-    empty=False,
-    raw=False,
-    internal=False,
-    path_mangle=None,
-    item_mangle=None,
-    add_date=False,
-):
-    """Generic code to dump a subtree.
-
-    `path_mangle` accepts a path and the as_dict parameter. It should
-    return the new path. This is used for e.g. prefixing the path with a
-    device name. Returning ``None`` causes the entry to be skipped.
-    """
-    if path_mangle is None:
-        path_mangle = lambda x: x
-    if item_mangle is None:
-
-        async def item_mangle(x):  # pylint: disable=function-redefined
-            return x
-
-    if recursive:
-        kw = {}
-        if maxdepth is not None and maxdepth >= 0:
-            kw["max_depth"] = maxdepth
-        if mindepth:
-            kw["min_depth"] = mindepth
-        if empty:
-            kw["empty"] = True
-        if obj.meta:
-            kw.setdefault("nchain", obj.meta)
-        y = {}
-        if internal:
-            res = await obj.client._request(action="get_tree_internal", path=path, iter=True, **kw)
-        else:
-            res = obj.client.get_tree(path, **kw)
-        async for r in res:
-            r = await item_mangle(r)
-            if r is None:
-                continue
-            r.pop("seq", None)
-            path = r.pop("path")
-            path = path_mangle(path)
-            if path is None:
-                continue
-            if add_date and "value" in r:
-                add_dates(r.value)
-
-            if as_dict is not None:
-                yy = y
-                for p in path:
-                    yy = yy.setdefault(p, {})
-                try:
-                    yy[as_dict] = r if obj.meta else r.value
-                except AttributeError:
-                    if empty:
-                        yy[as_dict] = None
-            else:
-                if raw:
-                    y = path
-                else:
-                    y = {}
-                    try:
-                        y[path] = r if obj.meta else r.value
-                    except AttributeError:
-                        if empty:
-                            y[path] = None
-                        else:
-                            continue
-                yprint([y], stream=obj.stdout)
-
-        if as_dict is not None:
-            if maxdepth:
-
-                def simplex(d):
-                    for k, v in d.items():
-                        if isinstance(v, dict):
-                            d[k] = simplex(d[k])
-                    if as_dict in d and d[as_dict] is None:
-                        if len(d) == 1:
-                            return None
-                        else:
-                            del d[as_dict]
-                    return d
-
-                y = simplex(y)
-            yprint(y, stream=obj.stdout)
-        return  # end "if recursive"
-
-    res = await obj.client.get(path, nchain=obj.meta)
-    if not obj.meta:
-        try:
-            res = res.value
-        except AttributeError:
-            if obj.debug:
-                print("No data at", path, file=sys.stderr)
-            return
-
-    if not raw:
-        yprint(res, stream=obj.stdout)
-    elif isinstance(res, bytes):
-        os.write(obj.stdout.fileno(), res)
-    else:
-        obj.stdout.write(str(res))
-    pass  # end get
-
-
-def res_get(res, attr: Path, **kw):  # pylint: disable=redefined-outer-name
-    """
-    Get a node's value and access the dict items beneath it.
-
-    The node value must be an attrdict.
-    """
-    val = res.get("value", None)
-    if val is None:
-        return None
-    return val._get(attr, **kw)
-
-
-def res_update(res, attr: Path, value=None, **kw):  # pylint: disable=redefined-outer-name
-    """
-    Set a node's sub-item's value, possibly merging dicts.
-    Entries set to 'NotGiven' are deleted.
-
-    The node value must be an attrdict.
-
-    Returns the new value.
-    """
-    val = res.get("value", attrdict())
-    return val._update(attr, value=value, **kw)
-
-
-async def node_attr(obj, path, res=None, chain=None, **kw):
-    """
-    Sub-attr setter.
-
-    Args:
-        obj: command object
-        path: address of the node to change
-        res: old node, if it has been read already
-        chain: change chain of node, copied from res if clear
-        **kw: the results of `attr_args`
-
-    Returns the result of setting the attribute.
-    """
-    if res is None:
-        res = await obj.client.get(path, nchain=obj.meta or 2)
-    if chain is None:
-        try:
-            chain = res.chain
-        except AttributeError:
-            pass
-    try:
-        val = res.value
-    except AttributeError:
-        chain = None
-        val = NotGiven
-    val = process_args(val, **kw)
-    if val is NotGiven:
-        res = await obj.client.delete(path, nchain=obj.meta, chain=chain)
-    else:
-        res = await obj.client.set(path, value=val, nchain=obj.meta, chain=chain)
-    return res