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

moat/kv/server.py

@@ -1,15 +1,16 @@
 # Local server
 from __future__ import annotations
 
-import io
 import os
 import signal
 import time
+from collections.abc import Mapping
 
 import anyio
 from anyio.abc import SocketAttribute
 from asyncscope import scope
 from moat.util import DelayedRead, DelayedWrite, create_queue, ensure_cfg
+from moat.lib.codec import get_codec
 
 try:
     from contextlib import asynccontextmanager
@@ -17,10 +18,9 @@ except ImportError:
     from async_generator import asynccontextmanager
 
 import logging
-from collections.abc import Mapping
 from functools import partial
 from pprint import pformat
-from typing import Any
+from typing import Any, TYPE_CHECKING
 
 from asyncactor import (
     Actor,
@@ -55,7 +55,6 @@ from . import _version_tuple
 from . import client as moat_kv_client  # needs to be mock-able
 from .actor.deletor import DeleteActor
 from .backend import get_backend
-from .codec import packer, stream_unpacker, unpacker
 from .exceptions import (
     ACLError,
     CancelledError,
@@ -68,6 +67,10 @@ from .exceptions import (
 )
 from .model import Node, NodeEvent, NodeSet, UpdateEvent, Watcher
 from .types import ACLFinder, ACLStepper, ConvNull, NullACL, RootEntry
+import contextlib
+
+if TYPE_CHECKING:
+    import io
 
 Stream = anyio.abc.ByteStream
 
@@ -75,9 +78,6 @@ ClosedResourceError = anyio.ClosedResourceError
 
 _client_nr = 0
 
-SERF_MAXLEN = 450
-SERF_LEN_DELTA = 15
-
 
 def max_n(a, b):
     if a is None:
@@ -228,10 +228,8 @@ class StreamCommand:
                 await self.send(error=repr(exc))
             finally:
                 with anyio.move_on_after(2, shield=True):
-                    try:
+                    with contextlib.suppress(anyio.BrokenResourceError):
                         await self.send(state="end")
-                    except anyio.BrokenResourceError:
-                        pass
 
         else:
             res = await self.run(**kw)
@@ -553,62 +551,64 @@ class SCmd_watch(StreamCommand):
         min_depth = msg.get("min_depth", 0)
         empty = msg.get("empty", False)
 
-        async with Watcher(entry) as watcher:
-            async with anyio.create_task_group() as tg:
-                tock = client.server.tock
-                shorter = PathShortener(entry.path)
-                if msg.get("fetch", False):
-
-                    async def orig_state():
-                        kv = {"max_depth": max_depth, "min_depth": min_depth}
-
-                        async def worker(entry, acl):
-                            if entry.data is NotGiven and not empty:
-                                return
-                            if entry.tock < tock:
-                                res = entry.serialize(
-                                    chop_path=client._chop_path,
-                                    nchain=nchain,
-                                    conv=conv,
-                                )
-                                shorter(res)
-                                if not acl.allows("r"):
-                                    res.pop("value", None)
-                                await self.send(**res)
-
-                            if not acl.allows("e"):
-                                raise StopAsyncIteration
-                            if not acl.allows("x"):
-                                acl.block("r")
-
-                        await entry.walk(worker, acl=acl, **kv)
-                        await self.send(state="uptodate")
-
-                    tg.start_soon(orig_state)
-
-                async for m in watcher:
-                    ml = len(m.entry.path) - len(msg.path)
-                    if ml < min_depth:
-                        continue
-                    if max_depth >= 0 and ml > max_depth:
-                        continue
-                    a = acl
-                    for p in getattr(m, "path", [])[shorter.depth :]:
-                        if not a.allows("e"):
-                            break
+        async with (
+            Watcher(entry) as watcher,
+            anyio.create_task_group() as tg,
+        ):
+            tock = client.server.tock
+            shorter = PathShortener(entry.path)
+            if msg.get("fetch", False):
+
+                async def orig_state():
+                    kv = {"max_depth": max_depth, "min_depth": min_depth}
+
+                    async def worker(entry, acl):
+                        if entry.data is NotGiven and not empty:
+                            return
+                        if entry.tock < tock:
+                            res = entry.serialize(
+                                chop_path=client._chop_path,
+                                nchain=nchain,
+                                conv=conv,
+                            )
+                            shorter(res)
+                            if not acl.allows("r"):
+                                res.pop("value", None)
+                            await self.send(**res)
+
+                        if not acl.allows("e"):
+                            raise StopAsyncIteration
                         if not acl.allows("x"):
-                            a.block("r")
-                        a = a.step(p)
-                    else:
-                        res = m.entry.serialize(
-                            chop_path=client._chop_path,
-                            nchain=nchain,
-                            conv=conv,
-                        )
-                        shorter(res)
-                        if not a.allows("r"):
-                            res.pop("value", None)
-                        await self.send(**res)
+                            acl.block("r")
+
+                    await entry.walk(worker, acl=acl, **kv)
+                    await self.send(state="uptodate")
+
+                tg.start_soon(orig_state)
+
+            async for m in watcher:
+                ml = len(m.entry.path) - len(msg.path)
+                if ml < min_depth:
+                    continue
+                if max_depth >= 0 and ml > max_depth:
+                    continue
+                a = acl
+                for p in getattr(m, "path", [])[shorter.depth :]:
+                    if not a.allows("e"):
+                        break
+                    if not acl.allows("x"):
+                        a.block("r")
+                    a = a.step(p)
+                else:
+                    res = m.entry.serialize(
+                        chop_path=client._chop_path,
+                        nchain=nchain,
+                        conv=conv,
+                    )
+                    shorter(res)
+                    if not a.allows("r"):
+                        res.pop("value", None)
+                    await self.send(**res)
 
 
 class SCmd_msg_monitor(StreamCommand):
@@ -621,6 +621,7 @@ class SCmd_msg_monitor(StreamCommand):
     multiline = True
 
     async def run(self):
+        codec = get_codec("std-msgpack")
         msg = self.msg
         raw = msg.get("raw", False)
         topic = msg.topic
@@ -642,7 +643,7 @@ class SCmd_msg_monitor(StreamCommand):
                     res["raw"] = resp.payload
                 else:
                     try:
-                        res["data"] = unpacker(resp.payload)
+                        res["data"] = codec.decode(resp.payload)
                     except Exception as exc:
                         res["raw"] = resp.payload
                         res["error"] = repr(exc)
@@ -716,10 +717,10 @@ class ServerClient:
             if fn is None:
                 fn = StreamCommand(self, msg)
                 if needAuth and not getattr(fn, "noAuth", False):
-                    raise NoAuthError()
+                    raise NoAuthError
             else:
                 if needAuth and not getattr(fn, "noAuth", False):
-                    raise NoAuthError()
+                    raise NoAuthError
                 fn = partial(self._process, fn, msg)
             if evt is not None:
                 evt.set()
@@ -1069,7 +1070,7 @@ class ServerClient:
             assert "data" not in msg
             data = msg.raw
         else:
-            data = packer(msg.data)
+            data = self.codec.encode(msg.data)
         await self.server.backend.send(*topic, payload=data)
 
     async def cmd_delete_tree(self, msg):
@@ -1173,7 +1174,7 @@ class ServerClient:
             if "tock" not in msg:
                 msg["tock"] = self.server.tock
             try:
-                await self.stream.send(packer(msg))
+                await self.stream.send(self.codec.encode(msg))
             except ClosedResourceError:
                 self.logger.info("ERO%d %r", self._client_nr, msg)
                 self._send_lock = None
@@ -1189,7 +1190,7 @@ class ServerClient:
 
     async def run(self):
         """Main loop for this client connection."""
-        unpacker_ = stream_unpacker()  # pylint: disable=redefined-outer-name
+        self.codec = get_codec("std-msgpack")  # pylint: disable=redefined-outer-name
 
         async with anyio.create_task_group() as tg:
             self.tg = tg
@@ -1225,7 +1226,7 @@ class ServerClient:
             await self.send(msg)
 
             while True:
-                for msg in unpacker_:
+                for msg in self.codec:
                     seq = None
                     try:
                         seq = msg.seq
@@ -1263,7 +1264,7 @@ class ServerClient:
                 if len(buf) == 0:  # Connection was closed.
                     self.logger.debug("EOF %d", self._client_nr)
                     break
-                unpacker_.feed(buf)
+                self.codec.feed(buf)
 
             tg.cancel_scope.cancel()
 
@@ -1350,7 +1351,7 @@ class _RecoverControl:
 
 class Server:
     """
-    This is the MoaT-KV server. It manages connections to the Serf/MQTT server,
+    This is the MoaT-KV server. It manages connections to the MQTT server,
     the MoaT-KV clients, and (optionally) logs all changes to a file.
 
     Args:
@@ -1379,7 +1380,8 @@ class Server:
     ports = None
     _tock = 0
 
-    def __init__(self, name: str, cfg: dict = None, init: Any = NotGiven):
+    def __init__(self, name: str, cfg: dict | None = None, init: Any = NotGiven):
+        self.codec = get_codec("std-msgpack")
         self.root = RootEntry(self, tock=self.tock)
         from moat.util import CFG
 
@@ -1408,16 +1410,16 @@ class Server:
         # connected clients
         self._clients = set()
 
-        # cache for partial messages
-        self._part_len = SERF_MAXLEN - SERF_LEN_DELTA - len(self.node.name)
-        self._part_seq = 0
-        self._part_cache = dict()
-
+        # running saver tasks
         self._savers = []
 
         # This is here, not in _run_del, because _del_actor needs to be accessible early
         self._del_actor = DeleteActor(self)
 
+        # backwards compat
+        self._part_cache = dict()
+        self._part_unpacker = get_codec("std-msgpack").decode
+
     @property
     def node_cache(self):
         """
@@ -1514,7 +1516,7 @@ class Server:
 
     async def _set_tock(self):
         if self._actor is not None and self._ready.is_set():
-            await self._actor.set_value((self._tock, self.node.tick))
+            await self._actor.set_value([self._tock, self.node.tick])
 
     async def del_check(self, value):
         """
@@ -1568,8 +1570,7 @@ class Server:
         if "tick" not in msg:
             msg["tick"] = self.node.tick
         self.logger.debug("Send %s: %r", action, msg)
-        for m in self._pack_multiple(msg):
-            await self.backend.send(*self.cfg.server.root, action, payload=m)
+        await self.backend.send(*self.cfg.server.root, action, payload=msg)
 
     async def watcher(self):
         """
@@ -1832,37 +1833,6 @@ class Server:
                 self._del_actor.add_deleted(self._delete_also_nodes)
                 self._delete_also_nodes = NodeSet()
 
-    def _pack_multiple(self, msg):
-        """"""
-        # protect against mistakenly encoded multi-part messages
-        # TODO use a msgpack extension instead
-        if isinstance(msg, Mapping):
-            i = 0
-            while (f"_p{i}") in msg:
-                i += 1
-            j = i
-            while i:
-                i -= 1
-                msg[f"_p{i + 1}"] = msg[f"_p{i}"]
-            if j:
-                msg["_p0"] = ""
-
-        p = packer(msg)
-        pl = self._part_len
-        if len(p) > SERF_MAXLEN:
-            # Owch. We need to split this thing.
-            self._part_seq = seq = self._part_seq + 1
-            i = 0
-            while i >= 0:
-                i += 1
-                px, p = p[:pl], p[pl:]
-                if not p:
-                    i = -i
-                px = {"_p0": (self.node.name, seq, i, px)}
-                yield packer(px)
-            return
-        yield p
-
     def _unpack_multiple(self, msg):
         """
         Undo the effects of _pack_multiple.
@@ -1885,7 +1855,7 @@ class Server:
                     return None
                 p = b"".join(s)
                 del self._part_cache[(nn, seq)]
-                msg = unpacker(p)
+                msg = self._part_unpacker(p)
                 msg["_p0"] = ""
 
             i = 0
@@ -1907,15 +1877,21 @@ class Server:
         """
         cmd = getattr(self, "user_" + action)
         try:
-            async with self.backend.monitor(*self.cfg.server.root, action) as stream:
+            async with self.backend.monitor(
+                *self.cfg.server.root,
+                action,
+                codec=self.codec,
+            ) as stream:
                 if delay is not None:
                     await delay.wait()
 
                 async for resp in stream:
-                    msg = unpacker(resp.payload)
+                    msg = resp.payload
+
                     msg = self._unpack_multiple(msg)
                     if not msg:  # None, empty, whatever
                         continue
+
                     self.logger.debug("Recv %s: %r", action, msg)
                     try:
                         with anyio.fail_after(15):
@@ -2406,8 +2382,8 @@ class Server:
 
     async def load(
         self,
-        path: str = None,
-        stream: io.IOBase = None,
+        path: str | None = None,
+        stream: io.IOBase | None = None,
         local: bool = False,
         authoritative: bool = False,
     ):
@@ -2425,8 +2401,10 @@ class Server:
             raise RuntimeError("This server already has data.")
         elif not local and self.node.tick is None:
             raise RuntimeError("This server is not yet operational.")
-        async with MsgReader(path=path, stream=stream) as rdr:
+        async with MsgReader(path=path, stream=stream, codec="std-msgpack") as rdr:
             async for m in rdr:
+                if m is None:
+                    continue
                 if "value" in m:
                     longer(m)
                     if "tock" in m:
@@ -2472,15 +2450,15 @@ class Server:
         await writer(msg)  # XXX legacy
         await self.root.walk(saver, full=full)
 
-    async def save(self, path: str = None, stream=None, full=True):
+    async def save(self, path: str | None = None, stream=None, full=True):
         """Save the current state to ``path`` or ``stream``."""
         shorter = PathShortener([])
-        async with MsgWriter(path=path, stream=stream) as mw:
+        async with MsgWriter(path=path, stream=stream, codec="std-msgpack") as mw:
             await self._save(mw, shorter, full=full)
 
     async def save_stream(
         self,
-        path: str = None,
+        path: str | None = None,
         stream: anyio.abc.Stream = None,
         save_state: bool = False,
         done: ValueEvent = None,
@@ -2504,7 +2482,7 @@ class Server:
         """
         shorter = PathShortener([])
 
-        async with MsgWriter(path=path, stream=stream) as mw:
+        async with MsgWriter(path=path, stream=stream, codec="std-msgpack") as mw:
             msg = await self.get_state(nodes=True, known=True, deleted=True)
             # await mw({"info": msg})
             await mw(msg)  # XXX legacy
@@ -2557,7 +2535,7 @@ class Server:
 
     async def _saver(
         self,
-        path: str = None,
+        path: str | None = None,
         stream=None,
         done: ValueEvent = None,
         save_state=False,
@@ -2582,7 +2560,9 @@ class Server:
                 with anyio.CancelScope(shield=True):
                     sd.set()
 
-    async def run_saver(self, path: str = None, stream=None, save_state=False, wait: bool = True):
+    async def run_saver(
+        self, path: str | None = None, stream=None, save_state=False, wait: bool = True
+    ):
         """
         Start a task that continually saves to disk.
 

moat/kv/types.py

@@ -110,7 +110,7 @@ class MatchEntry(MetaEntry):
         elif isinstance(value.type, str):
             value.type = P(value.type)
         elif not isinstance(value.type, (Path, list, tuple)):
-            raise ValueError("Type of %r is not a list" % (value.type,))
+            raise ValueError(f"Type of {value.type!r} is not a list")
         try:
             self.metaroot["type"].follow(value.type, create=False)
         except KeyError:
@@ -306,8 +306,9 @@ class CodecEntry(Entry):
                         f"failed decoder at {self.path} on {v!r} with {exc!r}",
                     ) from exc
                 else:
-                    if r != w:
-                        raise ValueError(f"Decoding at {self.path}: {v!r} got {r!r}, not {w!r}")
+                    pass  # float, list/tuple, and similar nonsense
+#                   if r != w:
+#                       raise ValueError(f"Decoding at {self.path}: {v!r} got {r!r}, not {w!r}")
 
         if value is not None and value.encode is not None:
             if not value["out"]:
@@ -321,8 +322,9 @@ class CodecEntry(Entry):
                         f"failed encoder at {self.path} on {v!r} with {exc!r}",
                     ) from exc
                 else:
-                    if r != w:
-                        raise ValueError(f"Encoding at {self.path}: {v!r} got {r!r}, not {w!r}")
+                    pass  # float, list/tuple, and similar nonsense
+#                   if r != w:
+#                       raise ValueError(f"Encoding at {self.path}: {v!r} got {r!r}, not {w!r}")
 
         await super().set(value)
         self._enc = enc
@@ -364,7 +366,7 @@ class ConvEntry(MetaEntry):
             if isinstance(value.codec, str):
                 value.codec = P(value.codec)
             elif not isinstance(value.codec, (Path, list, tuple)):
-                raise ValueError("Codec %r is not a list" % (value.codec,))
+                raise ValueError(f"Codec {value.codec!r} is not a list")
             try:
                 self.metaroot["codec"].follow(value.codec, create=False)
             except KeyError:

{moat_kv-0.70.24.dist-info → moat_kv-0.71.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moat-kv
-Version: 0.70.24
+Version: 0.71.6
 Summary: A distributed no-master key-value store
 Author-email: Matthias Urlichs <matthias@urlichs.de>
 Project-URL: homepage, https://m-o-a-t.org
@@ -19,26 +19,27 @@ Classifier: Topic :: Home Automation
 Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: LICENSE.APACHE2
+License-File: LICENSE.MIT
 License-File: LICENSE.txt
 Requires-Dist: asyncclick>7.99
 Requires-Dist: trio>=0.22
 Requires-Dist: anyio>=4
 Requires-Dist: range_set>=0.2
 Requires-Dist: attrs>=22
-Requires-Dist: asyncserf>=0.16
-Requires-Dist: asyncactor>=0.24
+Requires-Dist: asyncactor~=0.26.3
 Requires-Dist: asyncscope>=0.10.4
 Requires-Dist: jsonschema>=2.5
 Requires-Dist: ruyaml>=0.89
 Requires-Dist: PyNaCl>=1.3
 Requires-Dist: moat-lib-diffiehellman~=0.13.4
+Requires-Dist: moat-link
 Requires-Dist: psutil
 Requires-Dist: simpleeval>=0.9.10
-Requires-Dist: moat-mqtt~=0.42.3
+Requires-Dist: moat-mqtt~=0.42.4
 Requires-Dist: moat-util~=0.56.4
 Requires-Dist: exceptiongroup; python_version < "3.11"
-Provides-Extra: dev
-Requires-Dist: moat-src>=0.5.0; extra == "dev"
 Dynamic: license-file
 
 =======

moat_kv-0.71.6.dist-info/RECORD

@@ -0,0 +1,47 @@
+moat/kv/__init__.py,sha256=an570v034lNp7TNb23T501SM7WNmfeXl2ztGuodG_hg,444
+moat/kv/_cfg.yaml,sha256=j_rLFRiK1xbj_nzlI1AbzLDhq2pXWrM4M_lr6BH-rSc,2174
+moat/kv/_main.py,sha256=SgI4ef8AQDOC4N4pLRiyaiSiFIzN-J337WIcuC7DPOY,2234
+moat/kv/client.py,sha256=qxhhGtfxbcR0MN2dcQzcTga9UBAr9-zRRrMscqeTpVE,34207
+moat/kv/code.py,sha256=QtXHx09Hh9mxSA8m0z1KAFUEDqR0gpTII5g8MlJ8mbI,6427
+moat/kv/config.py,sha256=cWJ1m8PRwzzapsin1XSDjRtYJCgNN6g7gA9q48luDV8,1093
+moat/kv/data.py,sha256=85N2W_pDVRgBn7l9AGdDZHvuHrIPGlbxzgXi_3S0DSI,5924
+moat/kv/errors.py,sha256=cjX0e184EC10HvQ7UOkWdWmc1A8jPr983IFR8UkaI8U,17089
+moat/kv/exceptions.py,sha256=4gRsYa6kuBy1qFYiBUYElup_cvOe7QgPQtryHAYphzo,1849
+moat/kv/model.py,sha256=K2GVQlaFXbwf2JCl-bZi55MTCHFSK7jgomjI7APRIJw,33282
+moat/kv/runner.py,sha256=6vpChgCjiWHAjc2u0bbOOQ8cT5KB-f4uBnQb8MgH9wk,41826
+moat/kv/server.py,sha256=fwQZNzyJAhqR01d__3hUmEoAD3kgmRfSG0KdESezqpQ,94108
+moat/kv/types.py,sha256=UgUOrF-NUZq2lgKWgUwMdrfPkLIFxdxe-jyYdxeRyVk,14186
+moat/kv/actor/__init__.py,sha256=i560uy9WLE4SmOXWcXKjFKNKZdRR51jOwWg7cSASVRo,2131
+moat/kv/actor/deletor.py,sha256=F-pb0jHddhmqLp65G7vbZ_QIxXu5ZF0UBzHWKRgN45U,4537
+moat/kv/auth/__init__.py,sha256=m1x3tyAIxhaF5jSVC-wEJkntBAG2uERvgN0wRTLnp2w,12572
+moat/kv/auth/_test.py,sha256=k-cHh4m22XuVdXjBN3XAqL5zkH8nKDriEbxH25Tuj10,4404
+moat/kv/auth/password.py,sha256=wwKrynFPKcJept3IPCWCDLSyTF298NdSBABgCn0htqY,6474
+moat/kv/auth/root.py,sha256=lW-_hgQp3ZIzAAe4iBl0rdMU-pFuHIC6ObA3rdFXxkk,1303
+moat/kv/backend/__init__.py,sha256=f5nIOWD2zml2YiaBNXtEOzC7SEGgwDFJMB8YzRISJ0A,1689
+moat/kv/backend/mqtt.py,sha256=KSerkVN4MHhzjFprZMraTk56Hj0Hx1vev9xfYoKST2A,2009
+moat/kv/command/__init__.py,sha256=9_8wL9Scv8_Cs8HJyJHGvx1vwXErsuvlsAqNZLcJQR0,8
+moat/kv/command/acl.py,sha256=wSdlzKBjWIFX3IxCdLcG3ZqjvtX8KPtqe38ibyU2VDo,4665
+moat/kv/command/auth.py,sha256=vP22ZIBMjRdUxN4_ELKiDgIE5ZqdMxs1ky1WDVUx50M,7149
+moat/kv/command/code.py,sha256=ycGBoKBB0Gse3Tt9h9WvgiIZVe3Yg-x92RRjfCCCXVQ,8066
+moat/kv/command/codec.py,sha256=8GqOl-oxWFM2D1Fm9Iheot2AmS_SsOYfqfbbde3qvQY,6028
+moat/kv/command/data.py,sha256=HcLMMcAnyMBH4iH8X0hZiBgmsnV1yppOlg26zB9R72A,8400
+moat/kv/command/error.py,sha256=XqHmVJgBGjr6XOozi23wEjiTqPopD1CzkIeR1a3Z_vY,4350
+moat/kv/command/internal.py,sha256=KnteLPA9SIYk1e2AaN9yWt9r52QvlJCpDEwYcH6hJVI,7404
+moat/kv/command/job.py,sha256=QIiaK0c08CyB-SMjgoWLqa6N3cXQvds0i_w01Q6Jm5I,13590
+moat/kv/command/log.py,sha256=ycdtMgiBw2DaCu0yu6tpWKPLlQ33ZZemXsfwZrCzRGg,1350
+moat/kv/command/server.py,sha256=Hl_6FFq322c5KjJCKxH1nCrxo-h0VEwH4IOMbVeUBN4,3392
+moat/kv/command/type.py,sha256=bQrbJzVo-KWFC69ywA4EsuE_Gp0IT_YpYrgtU6yaW1g,6214
+moat/kv/command/dump/__init__.py,sha256=VLSN8MNHwAe44dmOwieUhzdaPuWCJf5p3XVkMh6PibI,3918
+moat/kv/mock/__init__.py,sha256=XWqHDWWWbXL61GgIFxxz0ciu2nW2Ba1uKm1J5ZTUuBw,2595
+moat/kv/mock/mqtt.py,sha256=b9pzbwQBmTX2eSiSgNO7nh2-7l8-0TT8n2GxinQ-1l0,5213
+moat/kv/mock/tracer.py,sha256=qLEIn9gdlYUypyRYD8O8SbM8ye8XR4xtBl3otP6uNLs,2058
+moat/kv/obj/__init__.py,sha256=OaQ7PsvvhRhd_H7KUM15nGeApckkCyOv7Xf4llqkzi0,19792
+moat/kv/obj/command.py,sha256=PzMQOEsXRKjKU3WvFtq1QaPJYBk6oWScKIrA-hAD5vg,7426
+moat_kv-0.71.6.dist-info/licenses/LICENSE,sha256=ZSyHhIjRRWNh4Iw_hgf9e6WYkqFBA9Fczk_5PIW1zIs,185
+moat_kv-0.71.6.dist-info/licenses/LICENSE.APACHE2,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+moat_kv-0.71.6.dist-info/licenses/LICENSE.MIT,sha256=Pm2uVV65J4f8gtHUg1Vnf0VMf2Wus40_nnK_mj2vA0s,1046
+moat_kv-0.71.6.dist-info/licenses/LICENSE.txt,sha256=L5vKJLVOg5t0CEEPpW9-O_0vzbP0PEjEF06tLvnIDuk,541
+moat_kv-0.71.6.dist-info/METADATA,sha256=OzfZkMKKGMmZtkvfnziwUBR6bbN9VJo7cdmVhXcDMxQ,3376
+moat_kv-0.71.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+moat_kv-0.71.6.dist-info/top_level.txt,sha256=pcs9fl5w5AB5GVi4SvBqIVmFrkRwQkVw_dEvW0Q0cSA,5
+moat_kv-0.71.6.dist-info/RECORD,,

{moat_kv-0.70.24.dist-info → moat_kv-0.71.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3.post20250321)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

moat_kv-0.71.6.dist-info/licenses/LICENSE

@@ -0,0 +1,3 @@
+This software is made available under the terms of *either* of the
+licenses found in LICENSE.APACHE2 or LICENSE.MIT. Contributions to are
+made under the terms of *both* these licenses.