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

moat/kv/command/auth.py

@@ -0,0 +1,261 @@
+# 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)

moat/kv/command/code.py

@@ -0,0 +1,293 @@
+# command line interface
+from __future__ import annotations
+
+import sys
+
+import asyncclick as click
+from moat.util import (
+    NotGiven,
+    P,
+    Path,
+    PathLongener,
+    attr_args,
+    process_args,
+    yload,
+    yprint,
+)
+
+
+@click.group(invoke_without_command=True)  # pylint: disable=undefined-variable
+@click.argument("path", nargs=1, type=P)
+@click.pass_context
+async def cli(ctx, path):
+    """Manage code stored in MoaT-KV."""
+    obj = ctx.obj
+    obj.path = obj.cfg["kv"]["codes"]["prefix"] + path
+    obj.codepath = path
+
+    if ctx.invoked_subcommand is None:
+        pl = PathLongener(path)
+        async for res in obj.client.get_tree(obj.path, long_path=False):
+            pl(res)
+            print(Path(*res.path), res.value.info, file=obj.stdout)
+
+
+@cli.command()
+@click.option("-s", "--script", type=click.File(mode="w", lazy=True), help="Save the code here")
+@click.pass_obj
+async def get(obj, script):
+    """Read a code entry"""
+    if not len(obj.codepath):
+        raise click.UsageError("You need a non-empty path.")
+
+    res = await obj.client._request(action="get_value", path=obj.path, iter=False, nchain=obj.meta)
+    if "value" not in res:
+        if obj.debug:
+            print("No entry here.", file=sys.stderr)
+        sys.exit(1)
+    if not obj.meta:
+        res = res.value
+    if script:
+        code = res.pop("code", None)
+        if code is not None:
+            print(code, file=script)
+    yprint(res, stream=obj.stdout)
+
+
+@cli.command("set")
+@click.option(
+    "-a/-A",
+    "--async/--sync",
+    "async_",
+    is_flag=True,
+    help="The code is async / sync (default: async)",
+    default=True,
+)
+@click.option("-t", "--thread", is_flag=True, help="The code should run in a worker thread")
+@click.option("-s", "--script", type=click.File(mode="r"), help="File with the code")
+@click.option("-i", "--info", type=str, help="one-liner info about the code")
+@click.option("-d", "--data", type=click.File(mode="r"), help="load the metadata (YAML)")
+@attr_args
+@click.pass_obj
+async def set_(obj, thread, script, data, async_, info, **kw):
+    """Save Python code.
+
+    The code may have inputs. You specify the inputs and their default
+    values with '-v VAR VALUE' (string), '-p VAR PATH' (MoaT-KV path), or
+    '-e VAR EXPR' (simple Python expression). Use '-e VAR -' to state that
+    VAR shall not have a default value, and '-e VAR /' to delete VAR from
+    the list of inputs entirely.
+    """
+    if thread:
+        async_ = False
+    elif not async_:
+        async_ = None
+
+    if not len(obj.codepath):
+        raise click.UsageError("You need a non-empty path.")
+    path = obj.path
+
+    if data:
+        msg = yload(data)
+    else:
+        msg = await obj.client.get(path, nchain=3)
+    chain = NotGiven
+    if "value" in msg:
+        chain = msg.get("chain", NotGiven)
+        msg = msg["value"]
+    if async_ is not None or "is_async" not in msg:
+        msg["is_async"] = async_
+
+    if info is not None:
+        msg["info"] = info
+
+    if script:
+        msg["code"] = script.read()
+    elif "code" not in msg:
+        raise click.UsageError("Missing script")
+
+    if "vars" in msg:
+        vs = set(msg["vars"])
+    else:
+        vs = set()
+    vd = msg.setdefault("default", {})
+
+    vd = process_args(vd, vs=vs, **kw)
+    msg["vars"] = list(vs)
+    msg["default"] = vd
+
+    kv = {}
+    if chain is not NotGiven:
+        kv["chain"] = chain
+
+    res = await obj.client.set(obj.path, value=msg, nchain=obj.meta, **kv)
+    if obj.meta:
+        yprint(res, stream=obj.stdout)
+
+
+# disabled for now
+@cli.group("module", hidden=True)
+async def mod():
+    """
+    Change the code of a module stored in MoaT-KV
+    """
+
+
+@mod.command("get")
+@click.option("-s", "--script", type=click.File(mode="w", lazy=True), help="Save the code here")
+@click.argument("path", nargs=1)
+@click.pass_obj  # pylint: disable=function-redefined
+async def get_mod(obj, path, script):
+    """Read a module entry"""
+    path = P(path)
+    if not len(path):
+        raise click.UsageError("You need a non-empty path.")
+    res = await obj.client._request(
+        action="get_value",
+        path=obj.cfg["kv"]["modules"]["prefix"] + path,
+        iter=False,
+        nchain=obj.meta,
+    )
+    if not obj.meta:
+        res = res.value
+
+    code = res.pop("code", None)
+    if code is not None:
+        code = code.rstrip("\n \t") + "\n"
+        if script:
+            print(code, file=script)
+        else:
+            res["code"] = code
+
+    yprint(res, stream=obj.stdout)
+
+
+@mod.command("set")
+@click.option("-s", "--script", type=click.File(mode="r"), help="File with the module's code")
+@click.option("-d", "--data", type=click.File(mode="r"), help="load the metadata (YAML)")
+@click.argument("path", nargs=1)  # pylint: disable=function-redefined
+@click.pass_obj
+async def set_mod(obj, path, script, data):
+    """Save a Python module to MoaT-KV."""
+    path = P(path)
+    if not len(path):
+        raise click.UsageError("You need a non-empty path.")
+
+    if data:
+        msg = yload(data)
+    else:
+        msg = {}
+    chain = None
+    if "value" in msg:
+        chain = msg.get("chain", None)
+        msg = msg["value"]
+
+    if "code" not in msg:
+        if script:
+            raise click.UsageError("Duplicate script")
+    else:
+        if not script:
+            raise click.UsageError("Missing script")
+        msg["code"] = script.read()
+
+    res = await obj.client.set(
+        *obj.cfg["kv"]["modules"]["prefix"],
+        *path,
+        value=msg,
+        iter=False,
+        nchain=obj.meta,
+        chain=chain,
+    )
+    if obj.meta:
+        yprint(res, stream=obj.stdout)
+
+
+@cli.command("list")
+@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.option(
+    "-m",
+    "--maxdepth",
+    type=int,
+    default=None,
+    help="Limit recursion depth. Default: whole tree",
+)
+@click.option(
+    "-M",
+    "--mindepth",
+    type=int,
+    default=None,
+    help="Starting depth. Default: whole tree",
+)
+@click.option("-f", "--full", is_flag=True, help="print complete entries.")
+@click.option("-s", "--short", is_flag=True, help="print shortened entries.")
+@click.pass_obj
+async def list_(obj, as_dict, maxdepth, mindepth, full, short):
+    """
+    List code entries.
+
+    Be aware that the whole subtree will be read before anything is
+    printed if you use the `--as-dict` option.
+    """
+
+    if (full or as_dict) and short:
+        raise click.UsageError("'-f'/'-d' and '-s' are incompatible.")
+    kw = {}
+    if maxdepth is not None:
+        kw["max_depth"] = maxdepth
+    if mindepth is not None:
+        kw["min_depth"] = mindepth
+    y = {}
+    async for r in obj.client.get_tree(obj.path, nchain=obj.meta, **kw):
+        r.pop("seq", None)
+        path = r.pop("path")
+        if not full:
+            if "info" not in r.value:
+                r.value.info = f"<{len(r.value.code.splitlines())} lines>"
+            del r.value["code"]
+
+        if short:
+            print(path, "::", r.value.info)
+            continue
+
+        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:
+                continue
+        else:
+            y = {}
+            try:
+                y[path] = r if obj.meta else r.value
+            except AttributeError:
+                continue
+            yprint([y], stream=obj.stdout)
+
+    if as_dict is not None:
+        yprint(y, stream=obj.stdout)
+    return
+
+
+@cli.command()
+@click.pass_obj
+async def delete(obj):
+    """Remove a code entry"""
+    res = await obj.client.get(obj.path, nchain=3)
+    if "value" not in res:
+        res.info = "Does not exist."
+    else:
+        res = await obj.client.delete(obj.path, chain=res.chain)
+        res.info = "Deleted."
+
+    if obj.meta:
+        yprint(res, stream=obj.stdout)
+    elif obj.debug:
+        print(res.info, file=obj.stdout)