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

build/lib/moat/kv/code.py

@@ -1,236 +0,0 @@
-"""
-This module locally stores code that's been uploaded to MoaT-KV
-so that it can be called easily.
-
-"Code" consists of either Python modules or single procedures.
-
-"""
-from __future__ import annotations
-
-import logging
-import sys
-from functools import partial
-
-import anyio
-from moat.util import NotGiven, P, make_module, make_proc
-
-from .obj import ClientEntry, ClientRoot
-
-logger = logging.getLogger(__name__)
-
-
-class EmptyCode(Exception):
-    """
-    There is no code here.
-    """
-
-    pass
-
-
-class ModuleRoot(ClientRoot):
-    """
-    Modules are stored at ``(*PREFIX,*name)``.
-    The prefix defaults to ``("code","module")``.
-
-    The module code is stored textually. Content that is not UTF-8 is TODO.
-    """
-
-    CFG = "modules"
-
-    err: ErrorRoot = None  # noqa: F821
-
-    @classmethod
-    def child_type(cls, name):
-        return ModuleEntry
-
-    async def run_starting(self):
-        from .errors import ErrorRoot
-
-        self.err = await ErrorRoot.as_handler(self.client)
-        await super().run_starting()
-
-    async def add(self, path, code=None):
-        """
-        Add or replace this code at this location.
-        """
-        # test-compile the code for validity
-        if code is None:
-            return await self.remove(path)
-
-        make_module(code, path)
-
-        r = await self.client.set(self._path + path, value=dict(code=code), nchain=2)
-        await self.wait_chain(r.chain)
-
-    async def remove(self, path):
-        """
-        Remove code at this location.
-        """
-        entry = self.follow(self._path + path, create=False)
-        return await entry.delete()
-
-
-class ModuleEntry(ClientEntry):
-    _module = None
-
-    @property
-    def name(self):
-        return ".".join(self.subpath)
-
-    async def set_value(self, value):
-        await super().set_value(value)
-        if value is NotGiven:
-            self._module = None
-            try:
-                del sys.modules[self.name]
-            except KeyError:
-                pass
-            return
-
-        try:
-            c = self.value.code
-            if not isinstance(c, str):
-                raise RuntimeError("Not a string, cannot compile")
-            m = make_module(c, self.subpath)
-        except Exception as exc:
-            self._module = None
-            logger.warning("Could not compile @%r", self.subpath)
-            await self.root.err.record_error(
-                "compile",
-                self.subpath,
-                exc=exc,
-                message="compiler error",
-            )
-        else:
-            await self.root.err.record_working("compile", self.subpath)
-            self._module = m
-
-
-class CodeRoot(ClientRoot):
-    """
-    This class represents the root of a code storage hierarchy. Ideally
-    there should only be one, but you can configure more.
-
-    You typically don't create this class directly; instead, call
-    :meth:`CodeRoot.as_handler`::
-
-        code = await CodeRoot.as_handler(client, your_config.get("code-storage",{})
-
-    The prefix defaults to ``("code","proc")``.
-
-    Configuration:
-
-    Arguments:
-      prefix (list): Where to store the code in MoaT-KV.
-        The default is ``('.moat','kv','code','proc')``.
-
-    The code is stored as a dict.
-
-    Arguments:
-      code: the actual code to run. It is parsed as a function body; be
-        aware that multi-line strings will be indented more than you'd like.
-      async: flag whether the code should run asynchronously.
-        True: yes, None (default): no, False: run in a separate thread.
-      vars: array of names to be used as named arguments.
-
-    All arguments are mandatory and should be named.
-    Extra arguments will be available in the "kw" dict.
-
-    """
-
-    CFG = "codes"
-
-    err = None
-
-    @classmethod
-    def child_type(cls, name):
-        return CodeEntry
-
-    async def run_starting(self):
-        from .errors import ErrorRoot
-
-        self.err = await ErrorRoot.as_handler(self.client)
-        await super().run_starting()
-
-    async def add(self, path, code=None, *, is_async=None, variables=()):
-        """
-        Add or replace this code at this location.
-        """
-        if code is NotGiven:
-            return await self.remove(path)
-
-        # test-compile the code for validity
-        make_proc(code, variables, path, use_async=is_async)
-
-        r = await self.client.set(
-            self._path + path,
-            value=dict(code=code, is_async=is_async, vars=variables),
-            nchain=2,
-        )
-        await self.wait_chain(r.chain)
-
-    async def remove(self, path):
-        """Drop this code"""
-        r = await self.client.set(*self._path, *path, value=None, nchain=2)
-        await self.wait_chain(r.chain)
-
-    def __call__(self, name, *a, **kw):
-        if isinstance(name, str):
-            name = name.split(".")
-        c = self
-        for k in name:
-            c = c[k]
-        if c is self:
-            raise RuntimeError("Empty code names don't make sense")
-        return c(*a, **kw)
-
-
-class CodeEntry(ClientEntry):
-    _code = None
-    is_async = None
-
-    def __init__(self, *a, **kv):
-        self.reload_event = anyio.Event()
-        super().__init__(*a, *kv)
-
-    @property
-    def name(self):
-        return P(self.subpath)
-
-    async def set_value(self, value):
-        await super().set_value(value)
-        if value is NotGiven:
-            self._code = None
-            return
-
-        try:
-            v = self.value
-            c = v["code"]
-            a = v.get("is_async", None)
-            p = make_proc(c, v.get("vars", ()), self.subpath, use_async=a)
-        except Exception as exc:
-            logger.warning("Could not compile @%s", self.subpath)
-            await self.root.err.record_error(
-                "compile",
-                self.subpath,
-                exc=exc,
-                message="compiler error",
-            )
-            self._code = None
-        else:
-            await self.root.err.record_working("compile", self.subpath)
-            self._code = p
-            self.is_async = a
-            self.reload_event.set()
-            self.reload_event = anyio.Event()
-
-    def __call__(self, *a, **kw):
-        if self._code is None:
-            raise EmptyCode(self._path)
-        if self.is_async is False:
-            proc = self._code
-            if kw:
-                proc = partial(proc, **kw)
-            return anyio.to_thread.run_sync(proc, *a)
-
-        return self._code(*a, **kw)

build/lib/moat/kv/codec.py

@@ -1,11 +0,0 @@
-"""
-This module contains helper functions for packing+unpacking of single messages,
-plus an unpacker factory for streams.
-"""
-
-# compatibility
-from __future__ import annotations
-
-from moat.util import *  # noqa: F403
-
-__all__ = ["packer", "unpacker", "stream_unpacker"]  # noqa: F405

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

@@ -1 +0,0 @@
-# empty

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

@@ -1,180 +0,0 @@
-# command line interface
-from __future__ import annotations
-
-import sys
-
-import asyncclick as click
-from moat.util import P, Path, yprint
-
-from moat.kv.data import data_get
-
-ACL = set("rwdcxena")
-# read, write, delete, create, access, enumerate
-
-
-@click.group()  # pylint: disable=undefined-variable
-async def cli():
-    """Manage ACLs. Usage: … acl …"""
-    pass
-
-
-@cli.command("list")
-@click.pass_obj
-async def list_(obj):
-    """List ACLs."""
-    res = await obj.client._request(
-        action="enum_internal",
-        path=("acl",),
-        iter=False,
-        nchain=obj.meta,
-        empty=True,
-    )
-    yprint(res if obj.meta else res.result, stream=obj.stdout)
-
-
-@cli.command()
-@click.option(
-    "-d",
-    "--as-dict",
-    default=None,
-    help="Structure as dictionary. The argument is the key to use "
-    "for values. Default: return as list",
-)
-@click.argument("name", nargs=1)
-@click.argument("path", nargs=1)
-@click.pass_obj
-async def dump(obj, name, path, as_dict):
-    """Dump a complete (or partial) ACL."""
-    path = P(path)
-    await data_get(obj, Path("acl", name, path), internal=True, as_dict=as_dict)
-
-
-@cli.command()
-@click.argument("name", nargs=1)
-@click.argument("path", nargs=1)
-@click.pass_obj
-async def get(obj, name, path):
-    """Read an ACL.
-
-    This command does not test a path. Use "… acl test …" for that.
-    """
-    path = P(path)
-    if not len(path):
-        raise click.UsageError("You need a non-empty path.")
-    res = await obj.client._request(
-        action="get_internal",
-        path=("acl", name) + path,
-        iter=False,
-        nchain=obj.meta,
-    )
-
-    if not obj.meta:
-        try:
-            res = res.value
-        except KeyError:
-            if obj.debug:
-                print("No value.", file=sys.stderr)
-            return
-    yprint(res, stream=obj.stdout)
-
-
-@cli.command(name="set")
-@click.option(
-    "-a",
-    "--acl",
-    default="+x",
-    help="The value to set. Start with '+' to add, '-' to remove rights.",
-)
-@click.argument("name", nargs=1)
-@click.argument("path", nargs=1)
-@click.pass_obj
-async def set_(obj, acl, name, path):
-    """Set or change an ACL."""
-
-    path = P(path)
-    if not len(path):
-        raise click.UsageError("You need a non-empty path.")
-    if len(acl) > 1 and acl[0] in "+-":
-        mode = acl[0]
-        acl = acl[1:]
-    else:
-        mode = "x"
-    acl = set(acl)
-
-    if acl - ACL:
-        raise click.UsageError(f"You're trying to set an unknown ACL flag: {acl - ACL!r}")
-
-    res = await obj.client._request(
-        action="get_internal",
-        path=("acl", name) + path,
-        iter=False,
-        nchain=3 if obj.meta else 1,
-    )
-    ov = set(res.get("value", ""))
-    if ov - ACL:
-        print(f"Warning: original ACL contains unknown: {ov - acl!r}", file=sys.stderr)
-
-    if mode == "-" and not acl:
-        res = await obj.client._request(
-            action="delete_internal",
-            path=("acl", name) + path,
-            iter=False,
-            chain=res.chain,
-        )
-        v = "-"
-
-    else:
-        if mode == "+":
-            v = ov + acl
-        elif mode == "-":
-            v = ov - acl
-        else:
-            v = acl
-        res = await obj.client._request(
-            action="set_internal",
-            path=("acl", name) + path,
-            value="".join(v),
-            iter=False,
-            chain=res.get("chain", None),
-        )
-
-    if obj.meta:
-        res = {
-            "old": "".join(ov),
-            "new": "".join(v),
-            "chain": res.chain,
-            "tock": res.tock,
-        }
-        yprint(res, stream=obj.stdout)
-    else:
-        res = {"old": "".join(ov), "new": "".join(v)}
-        yprint(res, stream=obj.stdout)
-
-
-@cli.command()
-@click.option("-m", "--mode", default=None, help="Mode letter to test.")
-@click.option("-a", "--acl", default=None, help="ACL to test. Default: current")
-@click.argument("path", nargs=1)
-@click.pass_obj
-async def test(obj, path, acl, mode):
-    """Test which ACL entry matches a path"""
-    path = P(path)
-    if not len(path):
-        raise click.UsageError("You need a non-empty path.")
-
-    if mode is not None and len(mode) != 1:
-        raise click.UsageError("Mode must be one letter.")
-    res = await obj.client._request(
-        action="test_acl",
-        path=path,
-        iter=False,
-        nchain=obj.meta,
-        **({} if mode is None else {"mode": mode}),
-        **({} if acl is None else {"acl": acl}),
-    )
-    if obj.meta:
-        yprint(res, stream=obj.stdout)
-    elif isinstance(res.access, bool):
-        print("+" if res.access else "-", file=obj.stdout)
-    else:
-        print(res.access, file=obj.stdout)

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

@@ -1,261 +0,0 @@
-# command line interface
-from __future__ import annotations
-
-import asyncclick as click
-from moat.util import NotGiven, Path, split_arg, yprint
-
-from moat.kv.auth import gen_auth, loader
-
-
-@click.group(short_help="Manage authorization")  # pylint: disable=undefined-variable
-@click.option("-m", "--method", default=None, help="Affect/use this auth method")
-@click.pass_obj
-async def cli(obj, method):
-    """Manage authorization. Usage: … auth METHOD command…. Use '.' for 'all methods'."""
-    a = await obj.client._request(action="auth_info")
-    a = a.get("value", None)
-    if a is not None:
-        a = a["current"]
-    obj.auth_current = a
-    if method is None:
-        obj.auth = a or (await one_auth(obj))
-    else:
-        if method == "-":
-            method = None
-        obj.auth = method
-
-
-async def enum_auth(obj):
-    """List all configured auth types."""
-    if obj.get("auth", None) is not None:
-        yield obj.auth
-        return
-    # TODO create a method for this
-    res = await obj.client._request(
-        action="enum_internal",
-        path=Path("auth"),
-        iter=False,
-        with_data=False,
-        empty=True,
-        nchain=0,
-    )
-    for r in res.result:
-        print(r)
-        yield r
-
-
-async def one_auth(obj):
-    """Return the current auth method (from the command line or as used by the server)."""
-    if obj.get("auth", None) is not None:
-        return obj.auth
-    auth = None
-    async for a in enum_auth(obj):
-        if auth is not None:
-            raise click.UsageError("You need to set the auth method")
-        auth = a
-    if auth is None:
-        raise click.UsageError("You need to set the auth method")
-    return auth
-
-
-async def enum_typ(obj, kind="user", ident=None, nchain=0):
-    """List all known auth entries of a kind."""
-    async for auth in enum_auth(obj):
-        if ident is not None:
-            res = await obj.client._request(
-                action="auth_list",
-                typ=auth,
-                kind=kind,
-                ident=ident,
-                iter=False,
-                nchain=nchain,
-            )
-            yield res
-        else:
-            async with obj.client._stream(
-                action="auth_list",
-                typ=auth,
-                kind=kind,
-                nchain=nchain,
-            ) as res:
-                async for r in res:
-                    yield r
-
-
-@cli.command("list")
-@click.pass_obj
-async def list_(obj):
-    """List known auth methods"""
-    async for auth in enum_auth(obj):
-        print(auth, file=obj.stdout)
-
-
-@cli.command()
-@click.option("-s", "--switch", is_flag=True, help="Switch to a different auth method")
-@click.pass_obj
-async def init(obj, switch):
-    """Setup authorization"""
-    if obj.auth_current is not None and not switch:
-        raise click.UsageError("Authentication is already set up")
-
-    await obj.client._request(action="set_auth_typ", typ=obj.auth)
-    if obj.debug >= 0:
-        if obj.auth:
-            print("Authorization switched to", obj.auth, file=obj.stdout)
-        else:
-            print("Authorization turned off.", file=obj.stdout)
-
-
-@cli.group()
-async def user():
-    """Manage users."""
-    pass
-
-
-@user.command("list")
-@click.option(
-    "-v",
-    "--verbose",
-    is_flag=True,
-    help="Print complete results. Default: just the names",
-)
-@click.pass_obj  # pylint: disable=function-redefined
-async def list_user(obj, verbose):
-    """List all users (raw data)."""
-    async for r in enum_typ(obj, nchain=obj.meta):
-        if obj.meta or verbose:
-            if obj.debug < 2:
-                del r["seq"]
-                del r["tock"]
-            yprint(r, stream=obj.stdout)
-        else:
-            print(r.ident, file=obj.stdout)
-
-
-@user.command()
-@click.argument("ident", nargs=1)
-@click.pass_obj
-async def get(obj, ident):
-    """Retrieve a user (processed)."""
-    lv = loader(await one_auth(obj), "user", make=True, server=False)
-    if obj.DEBUG:
-        lv._length = 16
-
-    u = await lv.recv(obj.client, ident, _initial=False)
-    yprint(u.export(), stream=obj.stdout)
-
-
-@user.command()
-@click.argument("args", nargs=-1)
-@click.pass_obj
-async def add(obj, args):
-    """Add a user."""
-    await add_mod_user(obj, args, None)
-
-
-@user.command()
-@click.option("-n", "--new", is_flag=True, help="New: ignore previous content")
-@click.argument("ident", nargs=1)
-@click.argument("type", nargs=1)
-@click.argument("key", nargs=1)
-@click.argument("args", nargs=-1)
-@click.pass_obj
-async def param(obj, new, ident, type, key, args):  # pylint: disable=redefined-builtin
-    """Set user parameters for auth, conversion, etc."""
-    auth = await one_auth(obj)
-    u = loader(auth, "user", make=True, server=False)
-    if obj.DEBUG:
-        u._length = 16
-    # ou = await u.recv(obj.client, ident, _initial=False)  # unused
-    res = await obj.client._request(
-        action="get_internal",
-        path=("auth", auth, "user", ident, type),
-        iter=False,
-        nchain=3,
-    )
-
-    kw = res.get("value", NotGiven)
-    if new or kw is NotGiven:
-        kw = {}
-        res.chain = None
-    if key == "-":
-        if args:
-            raise click.UsageError("You can't set params when deleting")
-        res = await obj.client._request(
-            action="delete_internal",
-            path=("auth", auth, "user", ident, type),
-            iter=False,
-            chain=res.chain,
-        )
-
-    else:
-        kw["key"] = key
-
-        for a in args:
-            split_arg(a, kw)
-
-        res = await obj.client._request(
-            action="set_internal",
-            path=("auth", auth, "user", ident, type),
-            iter=False,
-            chain=res.chain,
-            value=kw,
-        )
-    if obj.meta:
-        # res.ident = ident
-        # res.type = type
-        yprint(res, stream=obj.stdout)
-    else:
-        print(ident, type, key, file=obj.stdout)
-
-
-@user.command()
-@click.argument("ident", nargs=1)
-@click.argument("args", nargs=-1)
-@click.pass_obj
-async def mod(obj, ident, args):
-    """Change a user."""
-    await add_mod_user(obj, args, ident)
-
-
-async def add_mod_user(obj, args, modify):
-    auth = await one_auth(obj)
-    u = loader(auth, "user", make=True, server=False)
-    if obj.DEBUG:
-        u._length = 16
-    if modify:
-        ou = await u.recv(obj.client, modify, _initial=False)
-        kw = ou.export()
-    else:
-        kw = {}
-    for a in args:
-        split_arg(a, kw)
-
-    u = u.build(kw, _initial=False)
-    if modify is None or u.ident != modify:
-        u._chain = None  # new user
-    else:
-        u._chain = ou._chain
-    res = await u.send(obj.client)
-    if obj.meta:
-        res.ident = u.ident
-        yprint(res, stream=obj.stdout)
-    else:
-        print(u.ident, file=obj.stdout)
-
-
-@user.command(name="auth")
-@click.option(
-    "-a",
-    "--auth",
-    type=str,
-    default="root",
-    help="Auth params. =file or 'type param=value…' Default: root",
-)
-@click.pass_obj
-async def auth_(obj, auth):
-    """Test user authorization."""
-    user = gen_auth(auth)  # pylint: disable=redefined-outer-name
-    await user.auth(obj.client)
-    if obj.debug > 0:
-        print("OK.", file=obj.stdout)