moat-kv-akumuli 0.8.3__tar.gz

moat-kv-akumuli-0.8.3/.gitignore

@@ -0,0 +1,8 @@
+/build/
+/.hypothesis/
+/.pybuild/
+/dist/
+__pycache__
+/*.egg-info/
+/.eggs/
+/debian/

moat-kv-akumuli-0.8.3/.pylintrc

@@ -0,0 +1,3 @@
+[MESSAGES CONTROL]
+disable=bad-continuation,invalid-name,unnecessary-pass,protected-access,fixme,broad-except,no-absolute-import,global-statement,C,R
+

moat-kv-akumuli-0.8.3/Makefile

@@ -0,0 +1,14 @@
+#!/usr/bin/make -f
+
+PACKAGE = moat-kv-akumuli
+MAKEINCL ?= $(shell python3 -mmoat src path)/make/py
+
+ifneq ($(wildcard $(MAKEINCL)),)
+include $(MAKEINCL)
+# availabe via https://github.com/moat-src
+
+else
+%:
+	@echo "Please fix 'python3 -mmoat src path'."
+	@exit 1
+endif

moat-kv-akumuli-0.8.3/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: moat-kv-akumuli
+Version: 0.8.3
+Summary: Akumuli storage connector for MoaT-KV
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat-kv-akumuli
+Keywords: MoaT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+
+===========
+DistAkumuli
+===========
+
+DistAkumuli is a simple link between Akumuli and DistKV.
+
+It will update an Akumuli series whenever a DistKV value changes.

moat-kv-akumuli-0.8.3/README.rst

@@ -0,0 +1,7 @@
+===========
+DistAkumuli
+===========
+
+DistAkumuli is a simple link between Akumuli and DistKV.
+
+It will update an Akumuli series whenever a DistKV value changes.

moat-kv-akumuli-0.8.3/TODO.rst

@@ -0,0 +1,3 @@
+* document basic usage
+
+* document command line

moat-kv-akumuli-0.8.3/USAGE.rst

@@ -0,0 +1,92 @@
+=====================
+Using MoaT-KV-Akumuli
+=====================
+
+Run "moat kv akumuli monitor server" to connect to the specified server.
+
+See "moat util cfg kv.akumuli" for configuration options.
+
+Data structure
+==============
+
+On disk, the path to the port is ".moat kv akumuli SERVER NAME…" by
+default. All attributes are also looked up in the higher nodes, so you can
+set per-type values easily.
+
+Attributes
+++++++++++
+
+* server: a dict with host and port. Set by ``moat kv akumuli server``.
+
+* metric: the Akumuli metric to use. Inherited.
+
+* keys: a dict with keys that a value shall have. Inherited.
+
+* src: An array. The path to the Moat-KV value which shall be stored.
+
+
+Command line
+============
+
+
+.. program:: moat kv akumuli
+
+The main entry point for this extension.
+
+
+.. program:: moat kv akumuli set
+
+Print or modify port settings.
+
+This is a shortcut for ``… attr`` that evaluates various attributes and
+lets you easily change more than one at a time.
+
+.. option:: -m, --metric METRIC
+
+   Set the metric to use in this subtree.
+   
+   This option cannot be used on top or server level.
+
+.. option:: -k, --key name=value
+
+   Add a key. An empty value deletes the key.
+
+   This option can be used more than once.
+
+.. option:: -s, --src "source path"
+
+   Set the value to record.
+
+   This option cannot be used on top or server level.
+
+.. option:: -e, --eval
+
+   The value of 'src' shall be evaluated.
+
+
+.. option:: path
+
+   The path to the node to be modified.
+
+
+.. program:: moat kv akumuli list
+
+Lists the names below of a subtree.
+
+.. option:: path
+
+   The path to the node to be shown.
+
+
+.. program:: moat kv akumuli get
+
+Displays the data at a node.
+
+.. option:: -r, --recursive
+
+   Lists the subtree starting here.
+
+.. option:: path
+
+   The path to the node to be shown.
+

moat-kv-akumuli-0.8.3/moat/kv/akumuli/_config.yaml

@@ -0,0 +1,7 @@
+kv:
+  akumuli:
+    prefix: !P :.moat.kv.akumuli
+    server_default:
+      host: localhost
+      port: 8282
+      delta: true

moat-kv-akumuli-0.8.3/moat/kv/akumuli/_main.py

@@ -0,0 +1,177 @@
+# command line interface
+
+import asyncclick as click
+from asyncakumuli import DS
+
+from moat.util import yprint, attrdict, NotGiven, as_service, P, attr_args
+from moat.kv.data import node_attr, data_get
+from moat.kv.obj.command import std_command
+
+from .model import AkumuliRoot
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+async def _prepare_cli(obj):
+    obj.data = await AkumuliRoot.as_handler(obj.client)
+
+
+cli = std_command(
+    click,
+    name="server",
+    sub_base=None,
+    sub_name=NotGiven,
+    id_name=None,
+    prepare=_prepare_cli,
+    aux=(
+        click.option("-h", "--host", help="Host name of this server.", type=str),
+        click.option("-p", "--port", help="Port of this server.", type=int),
+        click.option("-t", "--topic", help="Raw MQTT topic for ad-hoc logging.", type=P),
+    ),
+)
+
+@cli.command("dump")
+@click.option("-l","--one-line",is_flag=True,help="single line per entry")
+@click.pass_obj
+async def dump_(obj,one_line):
+    """Emit a server's (sub)state as a list / YAML file."""
+    if not one_line:
+        await data_get(obj, obj.server._path, recursive=True)
+        return
+    for n in obj.server.all_children:
+        if n is obj.server:
+            continue
+        print(n, file=obj.stdout)
+
+@cli.group("at", invoke_without_command=True, short_help="create/show/delete an entry")
+@click.argument("path", nargs=1, type=P)
+@click.pass_context
+async def at_cli(ctx, path):
+    obj = ctx.obj
+    if len(path) == 0 or None in path:
+        raise click.UsageError("Path cannot be empty or contain 'None'")
+    obj.subpath = path
+    obj.node = obj.server.follow(path)
+    if ctx.invoked_subcommand is None:
+        await data_get(obj, obj.server._path+obj.subpath, recursive=False)
+
+@at_cli.command("--help", hidden=True)
+@click.pass_context
+def help(ctx):
+    print(at_cli.get_help(ctx))
+
+@at_cli.command("dump")
+@click.pass_obj
+@click.option("-l","--one-line",is_flag=True,help="single line per entry")
+async def dump_at(obj,one_line):
+    """Emit a subtree as a list / YAML file."""
+    if one_line:
+        await data_get(obj, obj.server._path+obj.subpath, recursive=True)
+        return
+    for n in obj.node.all_children:
+        print(n, file=obj.stdout)
+
+@at_cli.command("add", short_help="Add an entry")
+@click.option("-f", "--force", is_flag=True, help="Allow replacing an existing entry?")
+@click.option("-m", "--mode", help="DS mode. Default: 'gauge'", default="gauge")
+@click.option(
+    "-a",
+    "--attr",
+    help="The attribute to fetch. Default: the stored value is used directly.",
+    default=":",
+    type=P,
+)
+@click.argument("source", nargs=1, type=P)
+@click.argument("series", nargs=1)
+@click.argument("tags", nargs=-1)
+@click.pass_obj
+async def add_(obj, source, mode, attr, series, tags, force):
+    """Add a series to Akumuli.
+    \b
+    path: the name of this copy command. Unique path, non-empty.
+    source: the element with the data. unique path, non-empty.
+    series: the Akumuli series to write to.
+    tags: any number of "name=value" Akumuli tags to use for the series.
+    """
+
+    if not force and obj.node.chain is not None:
+        raise click.UsageError("This node already exists. Use '--force' or 'set'.")
+    source = P(source)
+    mode = getattr(DS, mode)
+    tagged = {}
+
+    if not tags:
+        raise click.UsageError("You can't write to a series without tags")
+    for x in tags:
+        try:
+            k, v = x.split("=", 2)
+        except ValueError:
+            raise click.UsageError("Tags must be key=value") from None
+        tagged[k] = v
+
+    val = dict(source=source, series=series, tags=tagged, mode=mode.name)
+    if attr:
+        val["attr"] = attr
+    try:
+        res = (await obj.client.get(source)).value
+        if attr:
+            res = attrdict._get(res, attr)
+        if not isinstance(res,(int,float)):
+            raise ValueError(res)
+    except (AttributeError,KeyError):
+        raise click.UsageError("The value at %s does not exist." % (source,)) from None
+    except ValueError:
+        raise click.UsageError("The value at %s is not a number." % (source,)) from None
+
+    res = await obj.client.set(obj.server._path + obj.subpath, val)
+    if obj.meta:
+        yprint(res, stream=obj.stdout)
+
+
+@at_cli.command("delete")
+@click.pass_obj
+async def delete_(obj):
+    """Remove a series from Akumuli's copying.
+
+    \b
+    path: the name of the series. Unique path, non-empty.
+
+    The data set is not physically deleted (with Akumuli that's
+    impossible), but no new copying will happen.
+    """
+    res = await obj.client.delete(obj.server._path + obj.subpath, nchain=obj.meta or 1)
+    if not res.chain:
+        raise click.UsageError("This entry doesn't exist.")
+    if obj.meta:
+        yprint(res, stream=obj.stdout)
+
+
+@at_cli.command("set")
+@attr_args
+@click.pass_obj
+async def attr_(obj, vars_, eval_, path_):
+    """Modify a given akumuli series (copier).
+    """
+    if not vars_ and not eval_ and not path_:
+        return
+
+    res = await node_attr(obj, obj.server._path + obj.subpath, vars_, eval_, path_)
+    if obj.meta:
+        yprint(res, stream=obj.stdout)
+
+
+@cli.command()
+@click.pass_obj
+@click.argument("paths", nargs=-1, type=P)
+async def monitor(obj, paths):
+    """Stand-alone task to monitor a single Akumuli tree"""
+    from .task import task
+    from .model import AkumuliRoot
+
+    server = await AkumuliRoot.as_handler(obj.client)
+    await server.wait_loaded()
+
+    async with as_service(obj) as srv:
+        await task(obj.client, obj.cfg.kv.akumuli, server[obj.server._name], evt=srv, paths=paths)

moat-kv-akumuli-0.8.3/moat/kv/akumuli/model.py

@@ -0,0 +1,242 @@
+"""
+MoaT-KV client data model for Akumuli
+"""
+import anyio
+from collections.abc import Mapping
+
+from moat.util import NotGiven, attrdict, Path
+from moat.kv.obj import ClientEntry, ClientRoot, AttrClientEntry
+from moat.kv.errors import ErrorRoot
+from asyncakumuli import Entry, DS
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def _test_hook(e: Entry):  # pylint: disable=unused-argument
+    pass
+
+
+class _AkumuliBase(ClientEntry):
+    """
+    Forward ``_update_server`` calls to child entries.
+    """
+
+    _server = None
+
+    @property
+    def server(self):
+        return self.parent.server
+
+    async def set_value(self, val):  # pylint: disable=arguments-differ
+        await super().set_value(val)
+        if self.server is not None:
+            await self._update_server()
+
+    async def update_server(self):
+        await self.parent.update_server()
+
+    async def _update_server(self):
+        if not self.val_d(True, "present"):
+            return
+        await self.setup()
+        for k in self:
+            await k._update_server()
+
+    async def setup(self):
+        pass
+
+
+class AkumuliNode(_AkumuliBase, AttrClientEntry):
+    """
+    Base class for a node with data (possibly).
+    """
+    attr = None
+    mode = None
+    source = None
+    series = None
+    factor = 1
+    offset = 0
+    tags = None
+    t_min = None
+    ATTRS = ('source', 'attr', 'mode', 'series', 'tags', 't_min', 'factor', 'offset')
+
+    _work = None
+    _t_last = None
+    disabled = False
+
+    @property
+    def tg(self):
+        return self.parent.tg
+
+    def __str__(self):
+        return f"N {Path(*self.subpath[1:])} {Path(*self.source)} {Path(*self.attr)} {self.series} {' '.join('%s=%s' % (k,v) for k,v in self.tags.items())}"
+
+    def _update_disable(self, off):
+        self.disabled = off
+        for k in self:
+            k._update_disable(off)
+
+    async def with_output(self, evt, src, attr, series, tags, mode):
+        """
+        Task that monitors one entry and writes its value to Akumuli.
+        """
+        with anyio.CancelScope() as sc:
+            self._work = sc
+            async with self.client.watch(src, min_depth=0, max_depth=0, fetch=True) as wp:
+                evt.set()
+                async for msg in wp:
+                    try:
+                        val = msg.value
+                    except AttributeError:
+                        if msg.get("state", "") != "uptodate":
+                            await self.root.err.record_error(
+                                "akumuli",
+                                self.subpath,
+                                message="Missing value: {msg}",
+                                data={"path": self.subpath, "msg": msg},
+                            )
+                        continue
+                    if self.t_min is not None:
+                        t = anyio.current_time()
+                        if self._t_last is not None and self._t_last+self.t_min < t:
+                            continue
+                        self._t_last = t
+
+                    oval = val
+                    for k in attr:
+                        try:
+                            val = val[k]
+                        except KeyError:
+                            await self.root.err.record_error(
+                                "akumuli",
+                                self.subpath,
+                                data=dict(value=oval, attr=attr, message="Missing attr"),
+                            )
+                            continue
+
+                    val = val*self.factor+self.offset
+                    e = Entry(series=series, mode=mode, value=val, tags=tags)
+                    _test_hook(e)
+                    await self.server.put(e)
+                    await self.root.err.record_working("akumuli", self.subpath)
+
+    async def setup(self):
+        await super().setup()
+        if self._work is not None:
+            await self._work.cancel()
+            self._work = None
+        if self.server is None:
+            return
+
+        if self.value is NotGiven:
+            await self.root.err.record_working("akumuli", self.subpath, comment="deleted")
+            return
+        data = self.value_or({}, Mapping)
+
+        src = data.get("source", None)
+        series = data.get("series", None)
+        tags = data.get("tags", None)
+        attr = data.get("attr", ())
+        mode = data.get("mode", DS.gauge)
+
+        if src is None or len(src) == 0 or series is None or not tags or mode is None:
+            await self.root.err.record_error(
+                "akumuli", self.subpath, data=self.value, message="incomplete data"
+            )
+            return
+
+        if self.disabled:
+            return
+
+        if isinstance(mode, str):
+            mode = getattr(DS, mode, None)
+
+        evt = anyio.Event()
+        self.tg.start_soon(self.with_output, evt, src, attr, series, tags, mode)
+        await evt.wait()
+
+
+class AkumuliServer(_AkumuliBase, AttrClientEntry):
+    _server = None
+    host:str = None
+    port:int = None
+
+    topic:str = None
+
+    ATTRS=("topic",)
+    AUX_ATTRS=("host","port")
+
+    def __str__(self):
+        res = f"{self._name}: {self.host}:{self.port}"
+        if self.topic:
+            res += " Topic:"+str(self.topic)
+        return res
+
+    @classmethod
+    def child_type(cls, name):
+        return AkumuliNode
+
+    @property
+    def server(self):
+        return self._server
+
+    @property
+    def tg(self):
+        return self._server._distkv__tg
+
+    async def set_value(self, val):
+        if val is NotGiven:
+            return
+        self.host = val.get("server",{}).get("host",None)
+        self.port = val.get("server",{}).get("port",None)
+        self.topic = val.get("topic",None)
+
+    def get_value(self, **kw):
+        res = super().get_value(**kw)
+        try:
+            s = res["server"]
+        except KeyError:
+            res["server"] = s = {}
+        s['host'] = self.host
+        s['port'] = self.port
+        return res
+
+    async def set_server(self, server):
+        self._server = server
+        await self._update_server()
+
+    def set_paths(self, paths):
+        """set enabled paths. Empty: all are on"""
+        for v in self:
+            v._update_disable(bool(paths))
+        for p in paths:
+            v = self
+            for k in p:
+                try:
+                    v = v[k]
+                except KeyError:
+                    break
+            else:
+                v.disabled = False
+
+    async def flush(self):
+        await self.server.flush()
+
+
+class AkumuliRoot(_AkumuliBase, ClientRoot):
+    CFG = "akumuli"
+    err = None
+
+    async def run_starting(self, server=None):  # pylint: disable=arguments-differ
+        self._server = server
+        if self.err is None:
+            self.err = await ErrorRoot.as_handler(self.client)
+        await super().run_starting()
+
+    def child_type(self, name):
+        return AkumuliServer
+
+    async def update_server(self):
+        await self._update_server()

moat-kv-akumuli-0.8.3/moat/kv/akumuli/task.py

@@ -0,0 +1,71 @@
+"""
+Akumuli task for MoaT-KV
+"""
+
+import anyio
+import asyncakumuli as akumuli
+import socket
+from pprint import pformat
+
+try:
+    from collections.abc import Mapping
+except ImportError:
+    from collections import Mapping
+
+from moat.util import combine_dict
+from moat.kv.exceptions import ClientConnectionError
+from .model import AkumuliServer
+
+from asyncakumuli import Entry, DS
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+async def task(client, cfg, server: AkumuliServer, paths=(), evt=None):  # pylint: disable=unused-argument
+    cfg = combine_dict(
+        server.value_or({}, Mapping).get("server", {}),
+        server.parent.value_or({}, Mapping).get("server", {}),
+        cfg["server_default"],
+    )
+
+    async def process_raw(self):
+        async with client.msg_monitor(server.topic) as mon:
+            async for msg in mon:
+                try:
+                    msg = msg["data"]
+                except KeyError:
+                    continue
+                try:
+                    msg.setdefault("mode", DS.gauge)
+                    tags = msg.setdefault("tags", {})
+                    for k,v in tags.items():
+                        if isinstance(str,bytes):
+                            tags[k] = v.decode("utf-8")
+                        else:
+                            tags[k] = str(v)
+                            # no-op if it's already a string
+
+                    e = Entry(**msg)
+                    await srv.put(e)
+                except Exception:
+                    logger.exception("Bad message on %s: \n%s", server.topic, pformat(msg))
+
+    try:
+        async with anyio.create_task_group() as tg:
+            async with akumuli.connect(**cfg) as srv:
+                srv._distkv__tg = tg
+                server.set_paths(paths)
+                await server.set_server(srv)
+                if evt is not None:
+                    evt.set()
+
+                if server.topic is not None:
+                    await tg.start(process_raw)
+                while True:
+                    await anyio.sleep(99999)
+    except TimeoutError:
+        raise
+    except socket.error as e:  # this would eat TimeoutError
+        raise ClientConnectionError(cfg["host"], cfg["port"]) from e

moat-kv-akumuli-0.8.3/moat-kv-akumuli@.service

@@ -0,0 +1,22 @@
+[Unit]
+Description=MoaT-KV-Akumuli server
+After=moat-kv.service
+Requires=moat-kv.service
+
+ConditionFileNotEmpty=/etc/moat/moat.cfg
+
+[Install]
+WantedBy=multi-user.target
+
+[Service]
+Type=notify
+ExecStart=/usr/bin/moat kv akumuli %I monitor
+
+EnvironmentFile=/usr/lib/moat/kv/env
+EnvironmentFile=-/etc/moat/kv.env
+
+TimeoutSec=300
+WatchdogSec=10
+
+Restart=always
+RestartSec=30

moat-kv-akumuli-0.8.3/moat_kv_akumuli.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.1
+Name: moat-kv-akumuli
+Version: 0.8.3
+Summary: Akumuli storage connector for MoaT-KV
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat-kv-akumuli
+Keywords: MoaT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+
+===========
+DistAkumuli
+===========
+
+DistAkumuli is a simple link between Akumuli and DistKV.
+
+It will update an Akumuli series whenever a DistKV value changes.

moat-kv-akumuli-0.8.3/moat_kv_akumuli.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+.gitignore
+.pylintrc
+Makefile
+README.rst
+TODO.rst
+USAGE.rst
+moat-kv-akumuli@.service
+pyproject.toml
+moat/kv/akumuli/__init__.py
+moat/kv/akumuli/_config.yaml
+moat/kv/akumuli/_main.py
+moat/kv/akumuli/model.py
+moat/kv/akumuli/task.py
+moat_kv_akumuli.egg-info/PKG-INFO
+moat_kv_akumuli.egg-info/SOURCES.txt
+moat_kv_akumuli.egg-info/dependency_links.txt
+moat_kv_akumuli.egg-info/requires.txt
+moat_kv_akumuli.egg-info/top_level.txt
+tests/__init__.py
+tests/conftest.py
+tests/test_akumuli.py

moat-kv-akumuli-0.8.3/moat_kv_akumuli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moat-kv-akumuli-0.8.3/moat_kv_akumuli.egg-info/requires.txt

@@ -0,0 +1 @@
+moat-kv~=0.70.2

moat-kv-akumuli-0.8.3/moat_kv_akumuli.egg-info/top_level.txt

@@ -0,0 +1 @@
+moat

moat-kv-akumuli-0.8.3/pyproject.toml

@@ -0,0 +1,98 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [ "setuptools", "wheel", "setuptools-scm",]
+
+[project]
+classifiers = [
+	"Development Status :: 4 - Beta",
+	"Intended Audience :: Information Technology",
+	"License :: OSI Approved :: MIT License",
+	"License :: OSI Approved :: Apache Software License",
+	"Programming Language :: Python :: 3",
+	"Topic :: Database",                                                                            
+	"Topic :: Home Automation",
+]
+dependencies = [
+	"moat-kv ~= 0.70.2",
+]
+dynamic = [ "version",]
+keywords = [ "MoaT",]
+requires-python = ">=3.8"
+name = "moat-kv-akumuli"
+description = "Akumuli storage connector for MoaT-KV"
+readme = "README.rst"
+[[project.authors]]
+email = "matthias@urlichs.de"
+name = "Matthias Urlichs"
+
+[project.license]
+file = "LICENSE"
+
+[project.urls]
+homepage = "https://m-o-a-t.org"
+repository = "https://github.com/M-o-a-T/moat-kv-akumuli"
+
+[tool.flake8]
+max-line-length = 99
+ignore = [ "F841", "F401", "E731", "E502", "E402", "E127", "E123", "W503", "E231", "E203", "E501" ]
+
+[tool.isort]
+line_length = 99
+multi_line_output = 3
+profile = "black"
+
+[tool.setuptools]
+packages = [ "moat.kv.akumuli",]
+[tool.setuptools.package-data]
+"*" = ["*.yaml"]
+
+[tool.setuptools_scm]
+
+[tool.black]
+line-length = 99
+
+[tool.tox]
+legacy_tox_ini = """
+[tox]
+isolated_build = True
+envlist = py310,check
+
+[testenv]
+setenv = 
+    PYTHONPATH = {env:PYTHONPATH}{:}{toxinidir}
+deps = 
+    anyio
+    asyncwebsockets
+    asyncclick
+    asyncscope
+    trio
+    pytest
+commands = 
+    python3 -mpytest tests/
+
+[testenv:check]
+commands = 
+    pylint moat tests
+    flake8p moat tests
+    black --check moat tests
+deps = 
+    pytest
+    pylint
+    black
+    flake8-pyproject
+    flake8
+
+"""
+
+[tool.pytest]
+filterwarnings = [
+    "error",
+    "ignore:unclosed:ResourceWarning",
+]
+addopts = "--verbose"
+
+[tool.pylint]
+[tool.pylint.messages_control]
+disable = "wrong-import-order,ungrouped-imports,too-many-nested-blocks,use-dict-literal,unspecified-encoding,too-many-statements,too-many-return-statements,too-many-locals,too-many-instance-attributes,too-many-branches,too-many-arguments,too-few-public-methods,superfluous-parens,no-else-return,no-else-continue,invalid-name,fixme"
+
+[tool.moat]

moat-kv-akumuli-0.8.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moat-kv-akumuli-0.8.3/tests/conftest.py

@@ -0,0 +1,5 @@
+from pytest_trio.enable_trio_mode import *  # noqa: F403,F401,E501 pylint:disable=wildcard-import,unused-wildcard-import
+
+import logging
+
+logging.basicConfig(level=logging.DEBUG)

moat-kv-akumuli-0.8.3/tests/test_akumuli.py

@@ -0,0 +1,50 @@
+import anyio
+from time import time
+
+from moat.util import P, load_ext
+from moat.kv.mock.mqtt import stdtest
+
+from asyncakumuli.mock import Tester, TCP_PORT
+
+task = akumuli_task = load_ext("moat.kv.akumuli.task", "task", err=True)
+
+akumuli_model = load_ext("moat.kv.akumuli.model", err=True)
+AkumuliRoot = akumuli_model.AkumuliRoot
+
+
+def _hook(e):
+    e.ns_time = int(time() * 1000000000)
+
+
+akumuli_model._test_hook = _hook
+
+
+async def test_basic():  # no autojump
+    async with (
+            stdtest(test_0={"init": 125}, n=1, tocks=200) as st,
+            st.client(0) as client,
+            Tester().run() as t,
+            ):
+        await st.run(f"akumuli test add -h 127.0.0.1 -p {TCP_PORT}")
+        await client.set(P("test.one.two"), value=41)
+        await st.run("akumuli test at test.foo.bar add test.one.two whatever foo=bar")
+        aki = await AkumuliRoot.as_handler(client)
+        aki._cfg.server_default.port = TCP_PORT
+        st.tg.start_soon(task, client, aki._cfg, aki["test"])
+        await anyio.sleep(1)
+        await aki["test"].flush()
+        await client.set(P("test.one.two"), value=42)
+        await anyio.sleep(0.3)
+        await aki["test"].flush()
+        await anyio.sleep(0.8)
+        await client.set(P("test.one.two"), value=43)
+        await anyio.sleep(0.3)
+        await aki["test"].flush()
+
+        n = 0
+        async for x in t.get_data("whatever", tags={}, t_start=time() - 1000, t_end=time() + 1000):
+            n += 1
+            assert x.value in (41,42,43)
+            assert abs(time() - x.time) < 10
+        assert n > 1
+        pass