moat-kv 0.71.0__py3-none-any.whl → 0.71.7__py3-none-any.whl

moat/kv/data.py

@@ -1,6 +1,7 @@
 """
 Data access
 """
+
 from __future__ import annotations
 
 import datetime
@@ -10,6 +11,8 @@ import time
 from collections.abc import Mapping
 
 from moat.util import NotGiven, Path, attrdict, process_args, yprint
+from moat.util.times import ts2iso
+import contextlib
 
 
 def add_dates(d):
@@ -36,10 +39,7 @@ def add_dates(d):
                 _add(v)
                 continue
             if start <= v <= stop:
-                d[f"_{k}"] = datetime.datetime.fromtimestamp(v).isoformat(
-                    sep=" ",
-                    timespec="milliseconds",
-                )
+                d[f"_{k}"] = ts2iso(v)
 
     _add(d)
 
@@ -66,7 +66,10 @@ async def data_get(
     device name. Returning ``None`` causes the entry to be skipped.
     """
     if path_mangle is None:
-        path_mangle = lambda x: x
+
+        def path_mangle(x):
+            return x
+
     if item_mangle is None:
 
         async def item_mangle(x):  # pylint: disable=function-redefined
@@ -199,10 +202,8 @@ async def node_attr(obj, path, res=None, chain=None, **kw):
     if res is None:
         res = await obj.client.get(path, nchain=obj.meta or 2)
     if chain is None:
-        try:
+        with contextlib.suppress(AttributeError):
             chain = res.chain
-        except AttributeError:
-            pass
     try:
         val = res.value
     except AttributeError:

moat/kv/errors.py

@@ -89,10 +89,11 @@ from weakref import WeakValueDictionary
 
 import anyio
 from moat.util import Cache, NotGiven, Path
+from moat.lib.codec import get_codec
 
-from .codec import packer
 from .exceptions import ServerError
 from .obj import AttrClientEntry, ClientEntry, ClientRoot
+import contextlib
 
 logger = logging.getLogger(__name__)
 
@@ -148,9 +149,11 @@ class ErrorEntry(AttrClientEntry):
     def __init__(self, *a, **kw):
         super().__init__(*a, **kw)
         self.node, self.tock = self.subpath[-2:]
+        if isinstance(self.path,list):
+            self.path=Path.build(self.path)
 
     def __repr__(self):
-        return "<%s: %s %s: %s>" % (
+        return "<{}: {} {}: {}>".format(
             self.__class__.__name__,
             "/".join(str(x) for x in self.subpath),
             self.subsystem,
@@ -231,10 +234,11 @@ class ErrorEntry(AttrClientEntry):
         try:
             r = await res.save()
         except TypeError:
+            codec = get_codec("std-msgpack")
             for k in res.ATTRS:
                 v = getattr(res, k, None)
                 try:
-                    packer(v)
+                    codec.encode(v)
                 except TypeError:
                     setattr(res, k, repr(v))
             r = await res.save()
@@ -404,6 +408,7 @@ class ErrorRoot(ClientRoot):
         must be filled and stored by the caller.
         """
 
+        path=Path.build(path)
         err = self._active[subsystem].get(path, None)
         if err is not None:
             return err
@@ -486,7 +491,7 @@ class ErrorRoot(ClientRoot):
         severity=0,
         message=None,
         force: bool = False,
-        comment: str = None,
+        comment: str | None = None,
     ):
         """An exception has occurred for this subtype and path.
 
@@ -505,6 +510,8 @@ class ErrorRoot(ClientRoot):
         if not force and hasattr(rec, "severity") and rec.severity < severity:
             return rec
 
+        if isinstance(path,list):
+            path=Path.build(path)
         rec.severity = severity
         rec.subsystem = subsystem
         rec.path = path
@@ -544,10 +551,8 @@ class ErrorRoot(ClientRoot):
         if rec is not entry:
             return
 
-        try:
+        with contextlib.suppress(KeyError):
             del (self._done if entry.resolved else self._active)[entry.subsystem][entry.path]
-        except KeyError:
-            pass
 
     def _push(self, entry):
         if entry.subsystem is None or entry.path is None:
@@ -558,4 +563,7 @@ class ErrorRoot(ClientRoot):
             self._latest.keep(entry)
         else:
             dest = self._active
-        dest[entry.subsystem][entry.path] = entry
+        path=entry.path
+        if isinstance(path,list):
+            path=Path.build(path)
+        dest[entry.subsystem][path] = entry

moat/kv/mock/__init__.py

@@ -1,28 +1,18 @@
 # from asyncclick.testing import CliRunner
 from __future__ import annotations
-import io
 import logging
-import shlex
 import socket
-import sys
-from pathlib import Path
 
 import attr
-from asyncscope import main_scope, scope
+from asyncscope import scope
 from moat.src.test import run  # pylint:disable=import-error,no-name-in-module
 from moat.util import (  # pylint:disable=no-name-in-module
     CFG,
-    OptCtx,
-    attrdict,
     combine_dict,
     ensure_cfg,
-    list_ext,
-    load_ext,
-    wrap_main,
-    yload,
 )
 
-from moat.kv.client import _scoped_client, client_scope
+from moat.kv.client import _scoped_client
 
 logger = logging.getLogger(__name__)
 try:

moat/kv/model.py

@@ -25,7 +25,7 @@ class NodeDataSkipped(Exception):
         self.node = node
 
     def __repr__(self):
-        return "<%s:%s>" % (self.__class__.__name__, self.node)
+        return f"<{self.__class__.__name__}:{self.node}>"
 
 
 ConvNull = None  # imported later, if/when needed
@@ -60,9 +60,8 @@ class Node:
             self.entries = {}
             cache[name] = self
         else:
-            if tick is not None:
-                if self.tick is None or self.tick < tick:
-                    self.tick = tick
+            if tick is not None and (self.tick is None or self.tick < tick):
+                self.tick = tick
         return self
 
     # pylint: disable=unused-argument
@@ -102,7 +101,7 @@ class Node:
         return item in self.entries
 
     def __repr__(self):
-        return "<%s: %s @%s>" % (self.__class__.__name__, self.name, self.tick)
+        return f"<{self.__class__.__name__}: {self.name} @{self.tick}>"
 
     def seen(self, tick, entry=None, local=False):
         """An event with this tick was in the entry's chain.
@@ -316,13 +315,10 @@ class NodeSet(defaultdict):
                 self[n] = r
 
     def __repr__(self):
-        return "%s(%s)" % (type(self).__name__, dict.__repr__(self))
+        return f"{type(self).__name__}({dict.__repr__(self)})"
 
     def __bool__(self):
-        for v in self.values():
-            if v:
-                return True
-        return False
+        return any(v for v in self.values())
 
     def serialize(self):
         d = dict()
@@ -369,7 +365,7 @@ class NodeEvent:
 
     """
 
-    def __init__(self, node: Node, tick: int = None, prev: NodeEvent = None):
+    def __init__(self, node: Node, tick: int | None = None, prev: NodeEvent = None):
         self.node = node
         if tick is None:
             tick = node.tick
@@ -553,7 +549,7 @@ class UpdateEvent:
             res = ""
         else:
             res = repr(self.event) + ": "
-        return "<%s:%s%s: %s→%s>" % (
+        return "<{}:{}{}: {}→{}>".format(
             self.__class__.__name__,
             res,
             repr(self.entry),
@@ -792,14 +788,14 @@ class Entry:
 
     def __repr__(self):
         try:
-            res = "<%s:%s" % (self.__class__.__name__, self.path)
+            res = f"<{self.__class__.__name__}:{self.path}"
             if self.chain is not None:
-                res += "@%s" % (repr(self.chain),)
+                res += f"@{self.chain!r}"
             if self.data is not None:
-                res += " =%s" % (repr(self.data),)
+                res += f" ={self.data!r}"
             res += ">"
         except Exception as exc:
-            res = "<%s:%s" % (self.__class__.__name__, str(exc))
+            res = f"<{self.__class__.__name__}:{exc!s}"
         return res
 
     @property
@@ -876,7 +872,8 @@ class Entry:
             raise RuntimeError("huh?")
 
         if evt.event == self.chain:
-            if self._data != evt.new_value:
+            if False and self._data != evt.new_value:
+                # codec diffs due to wrong accurracy
                 logger.error(
                     "Diff %r: has\n%r\nbut should have\n%r\n",
                     evt.event,
@@ -897,21 +894,20 @@ class Entry:
             logger.info("New: %s :%s: %r", evt.event, evt.tock, evt_val)
             return
 
-        if self._data is not NotGiven:
-            if not (self.chain < evt.event):
+        if self._data is not NotGiven and not (self.chain < evt.event):
+            if not loading:
+                logger.warning("*** inconsistency ***")
+                logger.warning("Node: %s", self.path)
+                logger.warning("Current: %s :%s: %r", self.chain, self.tock, self._data)
+                logger.warning("New: %s :%s: %r", evt.event, evt.tock, evt_val)
+            if evt.tock < self.tock:
                 if not loading:
-                    logger.warning("*** inconsistency ***")
-                    logger.warning("Node: %s", self.path)
-                    logger.warning("Current: %s :%s: %r", self.chain, self.tock, self._data)
-                    logger.warning("New: %s :%s: %r", evt.event, evt.tock, evt_val)
-                if evt.tock < self.tock:
-                    if not loading:
-                        logger.warning("New value ignored")
-                    # also mark the new event's chain as superseded
-                    server.drop_old_event(self.chain, evt.event)
-                    return
-                if not loading:
-                    logger.warning("New value used")
+                    logger.warning("New value ignored")
+                # also mark the new event's chain as superseded
+                server.drop_old_event(self.chain, evt.event)
+                return
+            if not loading:
+                logger.warning("New value used")
 
         if chk is not None and evt_val is not NotGiven:
             chk.check_value(evt_val, self)
@@ -1030,9 +1026,9 @@ class Watcher:
 
     root: Entry = None
     q = None
-    q_len = 100
+    q_len = 10000
 
-    def __init__(self, root: Entry, full: bool = False, q_len: int = None):
+    def __init__(self, root: Entry, full: bool = False, q_len: int | None = None):
         self.root = root
         self.full = full
         if q_len is not None:

moat/kv/obj/__init__.py

@@ -2,6 +2,7 @@
 Object interface to moat.kv data
 
 """
+
 from __future__ import annotations
 
 import heapq
@@ -27,6 +28,7 @@ from moat.util import (
     ensure_cfg,
     CFG,
 )
+import contextlib
 
 __all__ = ["ClientEntry", "AttrClientEntry", "ClientRoot"]
 
@@ -364,10 +366,8 @@ class AttrClientEntry(ClientEntry):
             if value is not NotGiven and k in value:
                 setattr(self, k, value[k])
             else:
-                try:
+                with contextlib.suppress(AttributeError):
                     delattr(self, k)
-                except AttributeError:
-                    pass
 
     def get_value(self, skip_none=False, skip_empty=False):
         """

moat/kv/obj/command.py

@@ -149,10 +149,10 @@ def std_command(cli, *a, **kw):
                                 else:
                                     vv = "-"
                             elif isinstance(vv, dict):
-                                vv = " ".join("%s=%s" % (x, y) for x, y in sorted(vv.items()))
-                            print("%s %s %s" % (k, kk, vv), file=obj.stdout)
+                                vv = " ".join(f"{x}={y}" for x, y in sorted(vv.items()))
+                            print(f"{k} {kk} {vv}", file=obj.stdout)
                     else:
-                        print("%s %s" % (k, v), file=obj.stdout)
+                        print(f"{k} {v}", file=obj.stdout)
             if not cnt and ctx.obj.debug:
                 print("exists, no data", file=sys.stderr)
         else:

moat/kv/runner.py

@@ -3,11 +3,12 @@ This module's job is to run code, resp. to keep it running.
 
 
 """
+
 from __future__ import annotations
 
 import time
 from collections.abc import Mapping
-from contextlib import AsyncExitStack, asynccontextmanager
+from contextlib import AsyncExitStack, asynccontextmanager, suppress
 from weakref import ref
 
 import anyio
@@ -418,10 +419,8 @@ class CallAdmin:
                             if "topic" in msg:
                                 # pylint:disable=attribute-defined-outside-init
                                 chg = cls(msg.get("raw", None))
-                                try:
+                                with suppress(AttributeError):
                                     chg.value = msg.data
-                                except AttributeError:
-                                    pass
                                 chg.path = Path.build(msg.topic)
                                 await self.runner.send_event(chg)
 
@@ -535,7 +534,7 @@ class RunnerEntry(AttrClientEntry):
         self._logger = logger_for(self._path)
 
     def __repr__(self):
-        return "<%s %r:%r>" % (self.__class__.__name__, self.subpath, self.code)
+        return f"<{self.__class__.__name__} {self.subpath!r}:{self.code!r}>"
 
     @property
     def state(self):