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

moat/kv/command/auth.py

@@ -1,258 +0,0 @@
-# command line interface
-
-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
-    pass
-
-
-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

@@ -1,306 +0,0 @@
-# command line interface
-
-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, vars_, eval_, path_, async_, info):
-    """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, vars_, eval_, path_, vs=vs)
-    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)