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

moat/kv/model.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import weakref
 from collections import defaultdict
 from logging import getLogger
-from typing import Any, List
+from typing import Any
 
 from moat.util import NotGiven, Path, attrdict, create_queue
 from range_set import RangeSet
@@ -39,9 +39,7 @@ class Node:
     tick: int = None
     _present: RangeSet = None  # I have these as valid data. Superset of ``._deleted``.
     _deleted: RangeSet = None  # I have these as no-longer-valid data
-    _reported: RangeSet = (
-        None  # somebody else reported these missing data for this node
-    )
+    _reported: RangeSet = None  # somebody else reported these missing data for this node
     _superseded: RangeSet = None  # I know these once existed, but no more.
     entries: dict = None
     tock: int = 0  # tock when node was last observed
@@ -371,7 +369,7 @@ class NodeEvent:
 
     """
 
-    def __init__(self, node: Node, tick: int = None, prev: "NodeEvent" = None):
+    def __init__(self, node: Node, tick: int = None, prev: NodeEvent = None):
         self.node = node
         if tick is None:
             tick = node.tick
@@ -524,13 +522,15 @@ class NodeEvent:
             self.prev = cls.deserialize(msg["prev"], cache=cache)
         return self
 
-    def attach(self, prev: "NodeEvent" = None, server=None):
+    def attach(self, prev: NodeEvent = None, server=None):
         """Copy this node, if necessary, and attach a filtered `prev` chain to it"""
         if prev is not None:
             prev = prev.filter(self.node, server=server)
         if self.prev is not None or prev is not None:
             self = NodeEvent(  # pylint: disable=self-cls-assignment
-                node=self.node, tick=self.tick, prev=prev
+                node=self.node,
+                tick=self.tick,
+                prev=prev,
             )
         return self
 
@@ -538,9 +538,7 @@ class NodeEvent:
 class UpdateEvent:
     """Represents an event which updates something."""
 
-    def __init__(
-        self, event: NodeEvent, entry: "Entry", new_value, old_value=NotGiven, tock=None
-    ):
+    def __init__(self, event: NodeEvent, entry: Entry, new_value, old_value=NotGiven, tock=None):
         self.event = event
         self.entry = entry
         self.new_value = new_value
@@ -611,10 +609,10 @@ class UpdateEvent:
 class Entry:
     """This class represents one key/value pair"""
 
-    _parent: "Entry" = None
+    _parent: Entry = None
     name: str = None
-    _path: List[str] = None
-    _root: "Entry" = None
+    _path: list[str] = None
+    _root: Entry = None
     chain: NodeEvent = None
     SUBTYPE = None
     SUBTYPES = {}
@@ -622,7 +620,7 @@ class Entry:
 
     monitors = None
 
-    def __init__(self, name: str, parent: "Entry", tock=None):
+    def __init__(self, name: str, parent: Entry, tock=None):
         self.name = name
         self._sub = {}
         self.monitors = set()
@@ -632,7 +630,7 @@ class Entry:
             parent._add_subnode(self)
             self._parent = weakref.ref(parent)
 
-    def _add_subnode(self, child: "Entry"):
+    def _add_subnode(self, child: Entry):
         self._sub[child.name] = child
 
     def __hash__(self):
@@ -904,9 +902,7 @@ class Entry:
                 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("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:
@@ -934,9 +930,7 @@ class Entry:
             n.seen(t, self)
         await self.updated(evt)
 
-    async def walk(
-        self, proc, acl=None, max_depth=-1, min_depth=0, _depth=0, full=False
-    ):
+    async def walk(self, proc, acl=None, max_depth=-1, min_depth=0, _depth=0, full=False):
         """
         Call coroutine ``proc`` on this node and all its children).
 
@@ -960,9 +954,7 @@ class Entry:
             if k is None and not full:
                 continue
             a = acl.step(k) if acl is not None else None
-            await v.walk(
-                proc, acl=a, max_depth=max_depth, min_depth=min_depth, _depth=_depth
-            )
+            await v.walk(proc, acl=a, max_depth=max_depth, min_depth=min_depth, _depth=_depth)
 
     def serialize(self, chop_path=0, nchain=2, conv=None):
         """Serialize this entry for msgpack.

moat/kv/runner.py

@@ -3,6 +3,7 @@ This module's job is to run code, resp. to keep it running.
 
 
 """
+from __future__ import annotations
 
 import time
 from collections.abc import Mapping
@@ -131,6 +132,7 @@ for _c in (
 
 _CLASSES["NotGiven"] = NotGiven  # ellipsis
 
+
 class CallAdmin:
     """
     This class collects some standard tasks which async MoaT-KV-embedded
@@ -169,9 +171,9 @@ class CallAdmin:
         """Called by the runner to actually execute the code."""
         self._logger.debug("Start %s with %s", self._runner._path, self._runner.code)
         async with (
-                anyio.create_task_group() as tg,
-                AsyncExitStack() as stack,
-                ):
+            anyio.create_task_group() as tg,
+            AsyncExitStack() as stack,
+        ):
             self._stack = stack
             self._taskgroup = tg
             self._runner.scope = sc = tg.cancel_scope
@@ -249,7 +251,7 @@ class CallAdmin:
             path = self._path
         r = await self._err.record_error("run", path, **kw)
         await self._err.root.wait_chain(r.chain)
-        raise ErrorRecorded()
+        raise ErrorRecorded
 
     async def open_context(self, ctx):
         return await self._stack.enter_async_context(ctx)
@@ -294,9 +296,7 @@ class CallAdmin:
                         async with slf.client.watch(path, **kw) as watcher:
                             yield watcher
                     else:
-                        raise RuntimeError(
-                            f"What should I do with a path marked {path.mark !r}?"
-                        )
+                        raise RuntimeError(f"What should I do with a path marked {path.mark!r}?")
 
                 with anyio.CancelScope() as sc:
                     slf.scope = sc
@@ -318,9 +318,7 @@ class CallAdmin:
                             elif msg.get("state", "") == "uptodate":
                                 slf.admin._n_watch_seen += 1
                                 if slf.admin._n_watch_seen == slf.admin._n_watch:
-                                    await slf.runner.send_event(
-                                        ReadyMsg(slf.admin._n_watch_seen)
-                                    )
+                                    await slf.runner.send_event(ReadyMsg(slf.admin._n_watch_seen))
 
             def cancel(slf):
                 if slf.scope is None:
@@ -361,7 +359,7 @@ class CallAdmin:
         if path.mark == "r":
             return await self.send(path, value)
         elif path.mark:
-            raise RuntimeError(f"What should I do with a path marked {path.mark !r}")
+            raise RuntimeError(f"What should I do with a path marked {path.mark!r}")
 
         if isinstance(path, (tuple, list)):
             path = Path.build(path)
@@ -556,7 +554,9 @@ class RunnerEntry(AttrClientEntry):
                     raise RuntimeError(f"already running on {state.node}")
                 code = self.root.code.follow(self.code, create=False)
                 data = combine_dict(
-                    self.data or {}, {} if code.value is NotGiven else code.value.get("default", {}), deep=True
+                    self.data or {},
+                    {} if code.value is NotGiven else code.value.get("default", {}),
+                    deep=True,
                 )
 
                 if code.is_async:
@@ -574,9 +574,7 @@ class RunnerEntry(AttrClientEntry):
 
                 await state.save(wait=True)
                 if state.node != state.root.name:
-                    raise RuntimeError(
-                        "Rudely taken away from us.", state.node, state.root.name
-                    )
+                    raise RuntimeError("Rudely taken away from us.", state.node, state.root.name)
 
                 data["_self"] = calls = CallAdmin(self, state, data)
                 res = await calls._run(code, data)
@@ -600,7 +598,11 @@ class RunnerEntry(AttrClientEntry):
             c, self._comment = self._comment, None
             with anyio.move_on_after(5, shield=True):
                 r = await self.root.err.record_error(
-                    "run", self._path, exc=exc, data=self.data, comment=c
+                    "run",
+                    self._path,
+                    exc=exc,
+                    data=self.data,
+                    comment=c,
                 )
                 if r is not None:
                     await self.root.err.wait_chain(r.chain)
@@ -803,7 +805,9 @@ class StateEntry(AttrClientEntry):
         self.node = None
         self.backoff = min(20, self.backoff + 1)
         await self.root.runner.err.record_error(
-            "run", self.runner._path, message="Runner restarted"
+            "run",
+            self.runner._path,
+            message="Runner restarted",
         )
         await self.save()
 
@@ -848,7 +852,7 @@ class StateEntry(AttrClientEntry):
             return
         elif self.node is None or n == self.root.runner.name:
             # Owch. Our job got taken away from us.
-            run._comment = f"Cancel: Node set to {self.node !r}"
+            run._comment = f"Cancel: Node set to {self.node!r}"
             run.scope.cancel()
         elif n is not None:
             logger.warning(
@@ -918,7 +922,8 @@ class StateRoot(MirrorRoot):
                 await self.update(val)
             else:
                 await self.client.msg_send(
-                    "run", {"group": self.runner.group, "time": t, "node": self.name}
+                    "run",
+                    {"group": self.runner.group, "time": t, "node": self.name},
                 )
 
 
@@ -961,9 +966,7 @@ class _BaseRunnerRoot(ClientRoot):
             cfg_ = client._cfg["runner"]
         else:
             cfg_ = combine_dict(cfg, client._cfg["runner"])
-        return await super().as_handler(
-            client, subpath=subpath, _subpath=subpath, cfg=cfg_, **kw
-        )
+        return await super().as_handler(client, subpath=subpath, _subpath=subpath, cfg=cfg_, **kw)
 
     async def run_starting(self):
         from .code import CodeRoot
@@ -984,7 +987,10 @@ class _BaseRunnerRoot(ClientRoot):
 
     async def _state_runner(self):
         self.state = await StateRoot.as_handler(
-            self.client, cfg=self._cfg, subpath=self._x_subpath, key="state"
+            self.client,
+            cfg=self._cfg,
+            subpath=self._x_subpath,
+            key="state",
         )
 
     @property
@@ -1014,7 +1020,7 @@ class _BaseRunnerRoot(ClientRoot):
 
         Its job is to control which tasks are started.
         """
-        raise RuntimeError("You want to override me." "")
+        raise RuntimeError("You want to override me.")
 
     async def trigger_rescan(self):
         """Tell the _run_actor task to rescan our job list prematurely"""
@@ -1096,9 +1102,7 @@ class AnyRunnerRoot(_BaseRunnerRoot):
     def __init__(self, *a, **kw):
         super().__init__(*a, **kw)
         self.group = (
-            P(self.client.config.server["root"]) + P(self._cfg["name"])
-            | "any"
-            | self._path[-1]
+            P(self.client.config.server["root"]) + P(self._cfg["name"]) | "any" | self._path[-1]
         )
 
     def get_node(self, name):
@@ -1116,7 +1120,10 @@ class AnyRunnerRoot(_BaseRunnerRoot):
         Monitor the Actor state, run a :meth:`_run_now` subtask whenever we're 'it'.
         """
         async with ClientActor(
-            self.client, self.name, topic=self.group, cfg=self._cfg["actor"]
+            self.client,
+            self.name,
+            topic=self.group,
+            cfg=self._cfg["actor"],
         ) as act:
             self._act = act
 
@@ -1176,7 +1183,7 @@ class AnyRunnerRoot(_BaseRunnerRoot):
         self._stale_times.append(cur)
         if self._stale_times[0] > cur - self.max_age:
             return
-        if len(self._stale_times) <= 2*self._cfg["actor"]["n_hosts"]+1:
+        if len(self._stale_times) <= 2 * self._cfg["actor"]["n_hosts"] + 1:
             return
         cut = self._stale_times.pop(0)
 
@@ -1278,9 +1285,7 @@ class SingleRunnerRoot(_BaseRunnerRoot):
         async with anyio.create_task_group() as tg:
             age_q = create_queue(1)
 
-            async with ClientActor(
-                self.client, self.name, topic=self.group, cfg=self._cfg
-            ) as act:
+            async with ClientActor(self.client, self.name, topic=self.group, cfg=self._cfg) as act:
                 self._act = act
                 tg.start_soon(self._age_notifier, age_q)
                 await self.spawn(self._run_now)
@@ -1330,9 +1335,7 @@ class AllRunnerRoot(SingleRunnerRoot):
     def __init__(self, *a, **kw):
         super().__init__(*a, **kw)
         self.group = (
-            P(self.client.config.server["root"]) + P(self._cfg["name"])
-            | "all"
-            | self._path[-1]
+            P(self.client.config.server["root"]) + P(self._cfg["name"]) | "all" | self._path[-1]
         )
 
     async def _state_runner(self):