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

moat/kv/__init__.py

@@ -1,19 +1,18 @@
 # pylint: disable=W0703,C0103
 from __future__ import annotations
+import contextlib
 
 __path__ = __import__("pkgutil").extend_path(__path__, __name__)
 
 try:
-    import warning
-    import pkg_resources  # part of setuptools
-
-    with warnings.filterwarnings("ignore"):
-        _version = pkg_resources.require("moat.kv")[0].version
-    del pkg_resources
-    del warnings
+    from importlib.metadata import version
 
+    _version = version("moat.kv")
     _version_tuple = tuple(int(x) for x in _version.split("."))
 
 except Exception:  # pragma: no cover
     _version = "0.0.1"
     _version_tuple = (0, 0, 1)
+
+with contextlib.suppress(NameError):
+    del version

moat/kv/_cfg.yaml

@@ -21,12 +21,11 @@ modules:
   prefix: !P :.moat.kv.code.module
 runner: # for moat.kv.runner.RunnerRoot
   # storage for runnable commands
-  prefix: !P :.moat.kv.run"
+  prefix: !P :.moat.kv.run
   # storage for runner states
-  state: !P :.moat.kv.state"
+  state: !P :.moat.kv.state
 
   name: "run"
-  # Serf event name, suffixed by subpath
 
   start_delay: 1
   # time to wait between job starts. Not optional.
@@ -56,9 +55,7 @@ server:
   # default
   mqtt:
     uri: "mqtt://localhost:1883"
-  serf:
-    host: "localhost"
-    port: 7373
+    codec: std-msgpack
 
   # event message path/topic prefix
   root: !P moat.kv
@@ -79,10 +76,10 @@ server:
   ping:
     cycle: 10
     gap: 2
-    # asyncserf.Actor config timing for server sync
+    # asyncactor config timing for server sync
   # ping also controls minimum server startup time
   delete:
-    # asyncserf.Actor config timing for deletion
+    # asyncactor config timing for deletion
     cycle: 100
     gap: 10
     version: 1

moat/kv/actor/__init__.py

@@ -2,6 +2,7 @@
 This module implements a :class:`asyncactor.Actor` which works on top of
 a MoaT-KV client.
 """
+
 from __future__ import annotations
 
 from asyncactor import Actor
@@ -71,7 +72,7 @@ class ActorState:
         self.msg = msg
 
     def __repr__(self):
-        return "<%s:%r>" % (self.__class__.__name__, self.msg)
+        return f"<{self.__class__.__name__}:{self.msg!r}>"
 
 
 class BrokenState(ActorState):

moat/kv/actor/deletor.py

@@ -8,9 +8,12 @@ from __future__ import annotations
 import weakref
 from collections import deque
 
-import anyio
 from asyncactor import Actor, PingEvent, TagEvent
 from asyncactor.backend import get_transport
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import anyio
 
 TAGS = 4
 

moat/kv/auth/__init__.py

@@ -61,17 +61,20 @@ The server process is:
 
 from __future__ import annotations
 
-import io
 from importlib import import_module
 
 import jsonschema
 from moat.util import NotGiven, Path, attrdict, split_arg, yload
 
-from ..client import Client, NoData
-from ..exceptions import NoAuthModuleError
-from ..model import Entry
-from ..server import ServerClient, StreamCommand
-from ..types import ACLFinder, NullACL
+from moat.kv.client import Client, NoData
+from moat.kv.exceptions import NoAuthModuleError
+from moat.kv.types import ACLFinder, NullACL
+import contextlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.kv.server import ServerClient, StreamCommand
+    from moat.kv.model import Entry
 
 # Empty schema
 null_schema = {"type": "object", "additionalProperties": False}
@@ -211,7 +214,7 @@ class BaseClientAuth(_AuthLoaded):
         """
         Authorizes this record with the server.
         """
-        try:
+        with contextlib.suppress(NoData):
             await client._request(
                 action="auth",
                 typ=self._auth_method,
@@ -220,8 +223,6 @@ class BaseClientAuth(_AuthLoaded):
                 ident=self.ident,
                 data=self.auth_data(),
             )
-        except NoData:
-            pass
 
     def auth_data(self):
         """
@@ -293,7 +294,7 @@ class BaseClientAuthMaker(_AuthLoaded):
 
     async def send(self, client: Client, _kind="user"):
         """Send this user to the server."""
-        try:
+        with contextlib.suppress(NoData):
             await client._request(
                 "auth_set",
                 iter=False,
@@ -303,8 +304,6 @@ class BaseClientAuthMaker(_AuthLoaded):
                 chain=self._chain,
                 data=self.send_data(),
             )
-        except NoData:
-            pass
 
     def send_data(self):
         return {}
@@ -340,7 +339,7 @@ class BaseServerAuth(_AuthLoaded):
         jsonschema.validate(instance=data.get("data", {}), schema=type(self).schema)
 
     def aux_conv(self, data: Entry, root: Entry):
-        from ..types import ConvNull
+        from moat.kv.types import ConvNull
 
         try:
             data = data["conv"].data["key"]

moat/kv/auth/_test.py

@@ -11,7 +11,6 @@ import logging
 
 log = logging.getLogger(__name__)
 
-from ..client import Client
 from . import (
     BaseClientAuth,
     BaseClientAuthMaker,
@@ -20,6 +19,10 @@ from . import (
     null_client_login,
     null_server_login,
 )
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.kv.client import Client
 
 
 def load(typ: str, *, make: bool = False, server: bool):

moat/kv/auth/password.py

@@ -9,10 +9,8 @@ from __future__ import annotations
 
 import nacl.secret
 
-from ..client import Client, NoData
-from ..exceptions import AuthFailedError
-from ..model import Entry
-from ..server import StreamCommand
+from moat.kv.client import Client, NoData
+from moat.kv.exceptions import AuthFailedError
 from . import (
     BaseClientAuth,
     BaseClientAuthMaker,
@@ -21,6 +19,12 @@ from . import (
     null_client_login,
     null_server_login,
 )
+import contextlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.kv.server import StreamCommand
+    from moat.kv.model import Entry
 
 
 def load(typ: str, *, make: bool = False, server: bool):
@@ -57,6 +61,8 @@ async def pack_pwd(client, password, length):
 async def unpack_pwd(client, password):
     """Server side: extract password"""
     box = nacl.secret.SecretBox(client.dh_key)
+    if isinstance(password, memoryview):
+        password = bytes(password)
     pwd = box.decrypt(password)
     return pwd
     # TODO check with Argon2
@@ -164,10 +170,8 @@ class ClientUserMaker(BaseClientAuthMaker):
         # There's no reason to send the password hash back
         self = cls(_initial=_initial)
         self._name = m.name
-        try:
+        with contextlib.suppress(AttributeError):
             self._chain = m.chain
-        except AttributeError:
-            pass
         return self
 
     async def send(self, client: Client, _kind="user", **msg):  # pylint: disable=unused-argument,arguments-differ

moat/kv/backend/mqtt.py

@@ -4,16 +4,12 @@ from contextlib import asynccontextmanager
 
 import anyio
 from moat.mqtt.client import MQTTClient
-from moat.mqtt.codecs import NoopCodec
 from moat.util import NotGiven
 
 from . import Backend
 
 logger = logging.getLogger(__name__)
 
-# Simply setting connect=asyncserf.serf_client interferes with mocking
-# when testing.
-
 
 class MqttMessage:
     def __init__(self, topic, payload):
@@ -39,11 +35,11 @@ class MqttBackend(Backend):
                 await C.disconnect()
 
     @asynccontextmanager
-    async def monitor(self, *topic):
+    async def monitor(self, *topic, codec=NotGiven):
         topic = "/".join(str(x) for x in topic)
         logger.info("Monitor %s start", topic)
         try:
-            async with self.client.subscription(topic) as sub:
+            async with self.client.subscription(topic, codec=codec) as sub:
 
                 async def sub_get(sub):
                     async for msg in sub:
@@ -58,12 +54,12 @@ class MqttBackend(Backend):
         else:
             logger.info("Monitor %s end", topic)
 
-    def send(self, *topic, payload):  # pylint: disable=invalid-overridden-method
+    def send(self, *topic, payload, **kw):  # pylint: disable=invalid-overridden-method
         """
         Send this payload to this topic.
         """
         # client.publish is also async, pass-thru
-        return self.client.publish("/".join(str(x) for x in topic), message=payload)
+        return self.client.publish("/".join(str(x) for x in topic), message=payload, **kw)
 
 
 @asynccontextmanager

moat/kv/client.py

@@ -7,13 +7,13 @@ Main entry point: :func:`open_client`.
 from __future__ import annotations
 
 import logging
-import os
 import socket
-from contextlib import AsyncExitStack, asynccontextmanager
+from contextlib import AsyncExitStack, asynccontextmanager, suppress
 from inspect import iscoroutine
 
 import anyio
 from asyncscope import Scope, main_scope, scope
+from moat.lib.codec import get_codec
 from moat.util import (  # pylint: disable=no-name-in-module
     CFG,
     DelayedRead,
@@ -28,11 +28,11 @@ from moat.util import (  # pylint: disable=no-name-in-module
     create_queue,
     ensure_cfg,
     gen_ssl,
-    gen_ident,al_lower,
+    gen_ident,
+    al_lower,
     num2byte,
 )
 
-from .codec import packer, stream_unpacker
 from .exceptions import (
     CancelledError,
     ClientAuthMethodError,
@@ -50,13 +50,6 @@ ClosedResourceError = anyio.ClosedResourceError
 __all__ = ["NoData", "ManyData", "open_client", "client_scope", "StreamedRequest"]
 
 
-class AsyncValueEvent(ValueEvent):
-    def cancel(self):
-        if self.scope is not None:
-            self.scope.cancel()
-        super().set_error(CancelledError())
-
-
 class NoData(ValueError):
     """No reply arrived"""
 
@@ -264,10 +257,8 @@ class StreamedRequest:
         except (anyio.BrokenResourceError, anyio.ClosedResourceError, EOFError):
             pass
         else:
-            try:
+            with suppress(ServerClosedError):
                 await self.aclose()
-            except ServerClosedError:
-                pass
 
     async def wait_started(self):
         await self._started.wait()
@@ -281,10 +272,8 @@ class StreamedRequest:
             if self._open:
                 msg = dict(action="stop", task=self.seq)
                 # self._client.logger.debug("SendC %s", msg)
-                try:
+                with suppress(ServerClosedError, anyio.BrokenResourceError):
                     await self._client._request(**msg, _async=True)
-                except (ServerClosedError, anyio.BrokenResourceError):
-                    pass
                 # ignore the reply
         finally:
             self.qr.close_sender()
@@ -301,7 +290,7 @@ class _SingleReply:
     def __init__(self, conn, seq, params):
         self._conn = conn
         self.seq = seq
-        self.q = AsyncValueEvent()
+        self.q = ValueEvent()
         self._params = params
 
     async def set(self, msg):
@@ -401,6 +390,7 @@ class Client:
         ensure_cfg("moat.kv")
         self._cfg = combine_dict(cfg, CFG["kv"], cls=attrdict)
         self.config = ClientConfig(self)
+        self.codec = get_codec("std-msgpack")
 
         self._seq = 0
         self._handlers = {}
@@ -484,26 +474,24 @@ class Client:
                 raise ServerClosedError("Disconnected")
 
             try:
-                p = packer(params)
+                p = self.codec.encode(params)
             except TypeError as e:
                 raise ValueError(f"Unable to pack: {params!r}") from e
             await sock.send(p)
 
     async def _reader(self, *, evt=None):
         """Main loop for reading"""
-        unpacker = stream_unpacker()
-
         with anyio.CancelScope():
             # XXX store the scope so that the redaer may get cancelled?
             if evt is not None:
                 await evt.set()
             try:
                 while True:
-                    for msg in unpacker:
+                    for msg in self.codec:
                         # self.logger.debug("Recv %s", msg)
                         try:
                             await self._handle_msg(msg)
-                        except ClosedResourceError as exc:
+                        except (ClosedResourceError,EOFError) as exc:
                             logger.warning("Reader closed in handler", exc_info=exc)
                             return
 
@@ -518,7 +506,7 @@ class Client:
                         return  # closed by us
                     if len(buf) == 0:  # Connection was closed.
                         raise ServerClosedError("Connection closed by peer")
-                    unpacker.feed(buf)
+                    self.codec.feed(buf)
 
             except BaseException as exc:
                 logger.warning("Reader died: %r", exc, exc_info=exc)
@@ -554,7 +542,7 @@ class Client:
         Any other keywords are forwarded to the server.
         """
         if self._handlers is None:
-            raise ClosedResourceError()
+            raise ClosedResourceError
         if seq is None:
             act = "action"
             self._seq += 1
@@ -612,7 +600,7 @@ class Client:
 
             async with client._stream("update", path=P("private.storage"),
                     stream=True) as req:
-                with MsgReader("/tmp/msgs.pack") as f:
+                with MsgReader("/tmp/msgs.pack",codec="std-cbor") as f:
                     for msg in f:
                         await req.send(msg)
             # … or …
@@ -647,17 +635,12 @@ class Client:
             yield res
         except BaseException as exc:
             if stream:
-                try:
+                with suppress(anyio.ClosedResourceError):
                     await res.send(error=repr(exc))
-                except anyio.ClosedResourceError:
-                    pass
             raise
         finally:
-            with anyio.fail_after(2, shield=True):
-                try:
-                    await res.aclose()
-                except anyio.ClosedResourceError:
-                    pass
+            with anyio.fail_after(2, shield=True), suppress(anyio.ClosedResourceError):
+                await res.aclose()
 
     async def _run_auth(self, auth=None):
         """
@@ -684,7 +667,7 @@ class Client:
         This async context manager handles the actual TCP connection to
         the MoaT-KV server.
         """
-        hello = AsyncValueEvent()
+        hello = ValueEvent()
         self._handlers[0] = hello
 
         cfg = self._cfg["conn"]
@@ -737,10 +720,8 @@ class Client:
                     yield self
                 finally:
                     # Clean up our hacked config
-                    try:
+                    with suppress(AttributeError):
                         del self._config
-                    except AttributeError:
-                        pass
                     self.config = ClientConfig(self)
         finally:
             self._socket = None
@@ -1007,7 +988,7 @@ class Client:
         """
         return self._stream(action="msg_monitor", topic=topic, raw=raw)
 
-    def msg_send(self, topic: tuple[str], data=None, raw: bytes = None):
+    def msg_send(self, topic: tuple[str], data=None, raw: bytes | None = None):
         """
         Tunnel a user-tagged message. This sends the message
         to all active callers of :meth:`msg_monitor` which use the same topic.

moat/kv/code.py

@@ -5,6 +5,7 @@ so that it can be called easily.
 "Code" consists of either Python modules or single procedures.
 
 """
+
 from __future__ import annotations
 
 import logging
@@ -15,6 +16,7 @@ import anyio
 from moat.util import NotGiven, P, make_module, make_proc
 
 from .obj import ClientEntry, ClientRoot
+import contextlib
 
 logger = logging.getLogger(__name__)
 
@@ -81,10 +83,8 @@ class ModuleEntry(ClientEntry):
         await super().set_value(value)
         if value is NotGiven:
             self._module = None
-            try:
+            with contextlib.suppress(KeyError):
                 del sys.modules[self.name]
-            except KeyError:
-                pass
             return
 
         try:

moat/kv/command/data.py

@@ -6,6 +6,7 @@ import time
 
 import asyncclick as click
 from moat.util import MsgReader, NotGiven, P, PathLongener, attr_args, yprint
+from moat.util.times import ts2iso
 
 from moat.kv.client import StreamedRequest
 from moat.kv.data import add_dates, data_get, node_attr
@@ -244,8 +245,8 @@ async def monitor(obj, state, only, path_only, add_date, ignore):
                         # value has been deleted
                         continue
             if flushing:
-                r["time"] = time.time()
-                r["_time"] = datetime.datetime.now().isoformat(sep=" ", timespec="milliseconds")
+                r["time"] = ts = time.time()
+                r["_time"] = ts2iso(ts)
             yprint(r, stream=obj.stdout)
             print("---", file=obj.stdout)
             if flushing:
@@ -258,7 +259,7 @@ async def monitor(obj, state, only, path_only, add_date, ignore):
 @click.pass_obj
 async def update(obj, infile):
     """Send a list of updates to a MoaT-KV subtree"""
-    async with MsgReader(path=infile) as reader:
+    async with MsgReader(path=infile, codec="std-msgpack") as reader:
         async for msg in reader:
             if not hasattr(msg, "path"):
                 continue

moat/kv/command/dump/__init__.py

@@ -6,19 +6,17 @@ import sys
 from collections.abc import Mapping
 
 import asyncclick as click
-from moat.mqtt.codecs import MsgPackCodec
 from moat.util import (
-    MsgReader,
     MsgWriter,
     P,
     Path,
-    PathLongener,
     load_subgroup,
     yload,
     yprint,
 )
 
-from moat.kv.codec import unpacker
+from moat.util.mqtt import unpacker
+from moat.util.msgpack import StdMsgpack
 
 
 @load_subgroup(short_help="Local data mangling", sub_pre="dump")
@@ -42,7 +40,7 @@ async def init(node, file):
     Using this command, followed by "moat kv server -l <outfile> <node>", is
     equivalent to running "moat kv server -i 'Initial data' <node>.
     """
-    async with MsgWriter(path=file) as f:
+    async with MsgWriter(path=file, codec="std-msgpack") as f:
         await f(
             dict(
                 chain=dict(node=node, tick=1, prev=None),
@@ -93,29 +91,31 @@ async def msg_(obj, path):
     be = obj.cfg.server.backend
     kw = obj.cfg.server[be]
 
-    async with get_backend(be)(**kw) as conn:
-        async with conn.monitor(*path) as stream:
-            async for msg in stream:
-                v = vars(msg)
-                if isinstance(v.get("payload"), (bytearray, bytes)):
-                    t = msg.topic
-                    v = unpacker(v["payload"])
-                    v = _unpacker(v)
-                    if v is None:
-                        continue
-                    if not isinstance(v, Mapping):
-                        v = {"_data": v}
-                    v["_topic"] = Path.build(t)
-                else:
-                    v["_type"] = type(msg).__name__
-
-                v["_timestamp"] = datetime.datetime.now().isoformat(
-                    sep=" ",
-                    timespec="milliseconds",
-                )
-
-                yprint(v, stream=obj.stdout)
-                print("---", file=obj.stdout)
+    async with (
+        get_backend(be)(**kw) as conn,
+        conn.monitor(*path) as stream,
+    ):
+        async for msg in stream:
+            v = vars(msg)
+            if isinstance(v.get("payload"), (bytearray, bytes)):
+                t = msg.topic
+                v = unpacker(v["payload"])
+                v = _unpacker(v)
+                if v is None:
+                    continue
+                if not isinstance(v, Mapping):
+                    v = {"_data": v}
+                v["_topic"] = Path.build(t)
+            else:
+                v["_type"] = type(msg).__name__
+
+            v["_timestamp"] = datetime.datetime.now().isoformat(
+                sep=" ",
+                timespec="milliseconds",
+            )
+
+            yprint(v, stream=obj.stdout)
+            print("---", file=obj.stdout)
 
 
 @cli.command("post")
@@ -137,7 +137,7 @@ async def post_(obj, path):
     be = obj.cfg.server.backend
     kw = obj.cfg.server[be]
 
-    async with get_backend(be)(codec=MsgPackCodec, **kw) as conn:
+    async with get_backend(be)(codec=StdMsgpack(), **kw) as conn:
         for d in yload(sys.stdin, multi=True):
             topic = d.pop("_topic", path)
             await conn.send(*topic, payload=d)

moat/kv/command/internal.py

@@ -6,6 +6,7 @@ from collections.abc import Mapping
 import asyncclick as click
 from moat.util import P, PathLongener, yprint
 from range_set import RangeSet
+import contextlib
 
 
 @click.group(short_help="Control internal state.")  # pylint: disable=undefined-variable
@@ -173,10 +174,8 @@ async def dump(obj, path):
         yy = y
         for p in path:
             yy = yy.setdefault(p, {})
-        try:
+        with contextlib.suppress(KeyError):
             yy["_"] = r["value"]
-        except KeyError:
-            pass
     yprint(y, stream=obj.stdout)
 
 

moat/kv/command/job.py

@@ -223,8 +223,7 @@ async def list_(obj, state, state_only, table, as_dict):
                         st = "-stopped-"
                     else:
                         st = " | ".join(
-                            "%s %s"
-                            % (
+                            "{} {}".format(
                                 Path.build(e.subpath)
                                 if e._path[-2] == ee._path[-1]
                                 else Path.build(ee.subpath),

moat/kv/command/type.py

@@ -5,6 +5,7 @@ import json
 
 import asyncclick as click
 from moat.util import NotGiven, P, Path, PathLongener, yload, yprint
+import contextlib
 
 
 @click.group()  # pylint: disable=undefined-variable
@@ -134,10 +135,8 @@ async def match(obj, path, type_, delete, raw):  # pylint: disable=redefined-bui
             yy = y
             for p in path:
                 yy = yy.setdefault(p, {})
-            try:
+            with contextlib.suppress(KeyError):
                 yy["_"] = r["value"]
-            except KeyError:
-                pass
         yprint(y, stream=obj.stdout)
         return
 
@@ -194,8 +193,6 @@ async def list(obj, path):  # pylint: disable=redefined-builtin
         yy = y
         for p in path:
             yy = yy.setdefault(p, {})
-        try:
+        with contextlib.suppress(KeyError):
             yy["_"] = r["value"]
-        except KeyError:
-            pass
     yprint(y, stream=obj.stdout)