moat-link-gate 0.0.1__py3-none-any.whl

moat/link/gate/__init__.py

@@ -0,0 +1,366 @@
+"""
+Gateway to wherever
+"""
+
+from __future__ import annotations
+
+import anyio
+import logging
+
+from attrs import define, field
+
+from moat.util import NotGiven, P, Path, to_attrdict
+from moat.lib.codec import get_codec
+from moat.link.meta import MsgMeta
+from moat.link.node import Node
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.util import attrdict
+    from moat.lib.codec import Codec
+
+    from .client import Link, Watcher
+
+    from typing import Any
+
+__all__ = ["Gate"]
+
+
+class GateVanished(RuntimeError):
+    "internal error: gate got dropped, or driver changed"
+
+    pass
+
+
+@define
+class GateNode(Node):
+    """
+    A gatewayed node. It stores the external value and metadata.
+
+    Data and meta
+    """
+
+    ext_meta: dict[str, Any] | None = field(init=False, default=None)
+    ext_data: Any = field(init=False, default=NotGiven)
+    lock: anyio.abc.Lock = field(init=False, factory=anyio.Lock)
+
+    todo: bool = field(init=False, default=False)
+
+    @property
+    def has_src(self):
+        "Check whether source data is present"
+        return self.data_ is not NotGiven or self.meta not in (None, NotGiven)
+
+    @property
+    def has_dst(self):
+        "Check whether destination data is present"
+        return self.ext_data is not NotGiven or self.ext_meta not in (None, NotGiven)
+
+    @property
+    def has_both(self):
+        "Check whether both source and destination data are present"
+        if self.data_ is NotGiven and self.meta is None:
+            return False
+        if self.ext_data is NotGiven and self.ext_meta is None:
+            return False
+        return True
+
+
+class Gate:
+    """
+    This is the base class for data gateways.
+
+    Gateways are described by a dict in ``:r.gate.NAME`` with the following
+    entries:
+
+    * src: source path, covered by ``moat.link``
+    * dst: destination, *must not* be at or under the ``moat.link`` root (if MQTT)
+    * driver:
+      * mqtt: the destination is a raw MQTT thing
+    * codec: Encoding of the destination (source is always ``std-cbor``).
+    * retain: ``True/False/None``; the latter is the default and copies
+      the data's retain flag
+
+    The gateway works thus:
+    * if a data item is not in the source or arrives from dest, copy to source
+    * if a data item is not in the destination or arrives from source, copy to dest
+    * if the values are equal, do nothing
+    * if the source metadata say the data is from the destination, copy dest to source
+    * otherwise copy source to dest.
+
+    Subclasses override
+    * get_dst
+    * set_dst
+    * newer_dst
+    """
+
+    state: Node
+    src: Node
+    tg: anyio.abc.TaskGroup
+    codec: Codec
+
+    _src_done: anyio.Event
+    _dst_done: anyio.Event
+
+    cfg: attrdict
+    cf: attrdict
+
+    def __init__(self, cfg: dict[str, Any], cf: dict[str, Any], path: Path, link: Link):
+        """
+        Setup.
+        @cfg: initial data for this gateway.
+        """
+        self.cfg = cfg
+        self.cf = to_attrdict(cf)
+        self.codec = cf.get("codec", "cbor")
+        if isinstance(self.codec, str):
+            self.codec = get_codec(self.codec)
+
+        self.link = link
+        self.path = path
+        self.origin = str(Path("GATE") + (P(cf["name"]) if "name" in cf else self.path[1:]))
+
+        self.logger = logging.getLogger(f"moat.link.{path}")
+
+    async def get_src(self, *, task_status=anyio.TASK_STATUS_IGNORED):
+        """
+        Fetch the internal data.
+        """
+        async with self.link.d_watch(
+            self.cf.src, subtree=True, state=None, meta=True, mark=True
+        ) as mon:
+            task_status.started()
+            async for pdm in mon:
+                if pdm is None:
+                    self._src_done.set()
+                    continue
+                p, d, m = pdm
+                if m is not None and m.origin == self.origin and self._src_done.is_set():
+                    # mine, so skip
+                    continue
+
+                node = self.data.get(p)
+                if self.running or node.has_src:
+                    # self.logger.debug("S NOW %r %r %r",p,d,m)
+                    await self._set_dst(p, node, d, m)
+                else:
+                    # self.logger.debug("S DLY %r %r %r",p,d,m)
+                    node.set_(p, d, m)
+                    node.todo = True
+
+    async def _set_dst(self, path: Path, node: GateNode, data: Any, meta: MsgMeta):
+        node.ext_data = NotGiven
+        node.ext_meta = NotGiven
+        node.set_(path, data, meta)
+        node.todo = False
+
+        async with node.lock:
+            await self.set_dst(path, data, meta, node)
+
+    def dst_is_current(self):  # noqa: D102
+        self._dst_done.set()
+
+    async def get_dst(self, *, task_status=anyio.TASK_STATUS_IGNORED):
+        """
+        Fetch the external data.
+
+        Override this; call `set_src` with each item.
+
+        You must call `dst_is_current` when the current state has been read
+        and you're now waiting for updates. If your backend doesn't support
+        this, use a timeout *and* an update counter; `set_src` returns True
+
+        """
+        raise NotImplementedError
+
+    async def set_src(self, path: Path, data: Any, aux: MsgMeta):
+        """
+        Update source state (possibly). @aux is additional metadata that
+        the destination resolver can use to disambiguate.
+        """
+        node = self.data.get(path)
+
+        if self.running or node.has_dst:
+            await self._set_src(self.cf.src + path, node, data, aux)
+        else:
+            node.ext_data = data
+            node.ext_meta = aux or NotGiven
+            node.todo = True
+
+    async def _set_src(self, path: Path, node: GateNode, data: Any, aux: MsgMeta):
+        async with node.lock:
+            if not self.is_update(node, data, aux):
+                return
+            meta = MsgMeta(origin=self.origin)
+            if aux not in (None, NotGiven):
+                meta["gw"] = aux
+
+            await self.link.d_set(path, data, meta)
+
+            node.set_((), NotGiven, NotGiven)
+            node.ext_data = data
+            node.ext_meta = aux or NotGiven
+            node.todo = False
+
+    async def set_dst(self, path: Path, data: Any, meta: MsgMeta, node: GateNode):
+        """
+        Update destination state. @meta is the source metadata, in case
+        it is useful in some way.
+        """
+        raise NotImplementedError
+
+    def is_update(self, node: GateNode, data: Any, aux: MsgMeta):  # noqa: ARG002
+        """
+        Check whether this new destination data is an update.
+        """
+        return True
+
+    def newer_dst(self, node) -> bool | None:
+        """
+        Test whether the destination data is newer, based on the node's
+        metadata. Return `True` if the data should be copied to the source,
+        `False` if the source should be copied to the destination, or
+        `None` if inconclusive.
+
+        This method is only called when starting up.
+        """
+        raise NotImplementedError
+
+    async def run(self, *, task_status=anyio.TASK_STATUS_IGNORED):
+        """
+        Run a bidirectional copy.
+
+        This method auto-restarts the gateway if its data changes.
+        It ends if the gateway node is removed or the driver changes.
+
+        The task status is set when the initial sync has completed.
+
+        Called by the system.
+        """
+        run = True
+        while run:
+            self.state = Node()
+            self.data = GateNode()
+            self._src_done = anyio.Event()
+            self._dst_done = anyio.Event()
+            self.running = False
+
+            try:
+                async with anyio.create_task_group() as self.tg:
+                    await self.tg.start(self._restart)
+                    await self.run_(task_status=task_status)
+            except* GateVanished:
+                run = False
+            else:
+                task_status = anyio.TASK_STATUS_IGNORED
+                await anyio.sleep(1)
+
+    async def _restart(self, *, task_status=anyio.TASK_STATUS_IGNORED):
+        "Restart the thing when the root changes."
+        async with self.link.d_watch(self.path) as mon:
+            task_status.started()
+            async for d in mon:
+                if self.cf == d:
+                    continue
+                if d is NotGiven or d.get("driver") != self.cf.driver:
+                    raise GateVanished(str(self.path))
+                self.cf = d
+                self.tg.cancel_scope.cancel()
+                return
+
+    async def run_(self, *, task_status=anyio.TASK_STATUS_IGNORED):
+        """
+        The core runner for the gateway.
+
+        If your implementation needs a context or a support task,
+        override this and call the original. `tg` can be used.
+        """
+        # start initial loops
+        await self.tg.start(self.get_src)
+        await self.tg.start(self.get_dst)
+
+        # wait for initial scans to be done
+        await self._src_done.wait()
+        await self._dst_done.wait()
+        self.running = True
+
+        # resolve any conflicts in the initial data
+        async def visit(path, node):
+            if not node.todo:
+                return
+
+            if not node.has_src:
+                # no source data
+                if not node.has_dst:
+                    # no destination data
+                    return
+
+                # copy dest to source
+                d = True
+
+            elif not node.has_dst:
+                # copy source to dest
+                d = False
+
+            else:
+                # both are set. Ugh.
+                d = self.newer_dst(node)
+
+            if d is False:
+                self.logger.debug("SRC %s %s %r/%r", self.path, path, node.data_, node.meta)
+                await self._set_dst(path, node, node.data_, node.meta)
+
+            elif d is True:
+                self.logger.debug("DST %s %s %r/%r", self.path, path, node.ext_data, node.ext_meta)
+
+                meta = MsgMeta(origin=self.origin)
+                if node.ext_meta:
+                    meta["gw"] = node.ext_meta
+                await self.link.d_set(self.cf.src + path, node.ext_data, meta)
+
+            elif node.data_ != node.ext_data:
+                self.logger.warning(
+                    "Conflict %s %s %r/%r vs %r/%r",
+                    self.path,
+                    path,
+                    node.data_,
+                    node.meta,
+                    node.ext_data,
+                    node.ext_meta,
+                )
+
+        await self.data.walk(visit, force=True)
+        task_status.started()
+
+    async def state_updater(self, mon: Watcher, *, task_status=anyio.TASK_STATUS_IGNORED):
+        """
+        Status update handler.
+
+        By default this just gets the monitor node and updates the raw
+        node data in the background.
+        """
+        node = await mon.get_node()
+        task_status.started(node)
+
+        # nothing further to do
+
+
+async def run_gate(
+    cfg: dict, link: Link, cf: Path | str, *, task_status=anyio.TASK_STATUS_IGNORED
+):
+    """
+    Run a gate in @link, described by @name.
+    """
+    from importlib import import_module  # noqa: PLC0415
+
+    if isinstance(cf, str):
+        cf = P("gate") / cf
+    path = cf
+    cf = await link.d_get(path)
+
+    drv = cf["driver"]
+    if "." not in drv:
+        drv = "moat.link.gate." + drv
+    gate = import_module(drv).Gate(cfg, cf, path, link)
+    await gate.run(task_status=task_status)

moat/link/gate/_main.py

@@ -0,0 +1,140 @@
+"""
+Command line for gatewaying
+"""
+
+from __future__ import annotations
+
+import sys
+
+import asyncclick as click
+
+from moat.util import NotGiven, P, yprint
+from moat.lib.run import attr_args
+from moat.link._data import data_get, node_attr
+from moat.link.client import Link
+from moat.link.meta import MsgMeta
+
+
+@click.group(short_help="Manage gateways.", invoke_without_command=True)
+@click.argument("path", type=P, nargs=1)
+@click.pass_context
+async def cli(ctx, path):
+    """
+    This subcommand gates MoaT-Link data to/from other channels.
+    """
+    obj = ctx.obj
+    cfg = obj.cfg["link"]
+    if obj.get("port", None) is not None:
+        cfg.client.port = obj.port
+    obj.conn = await ctx.with_async_resource(Link(cfg, common=True))
+    obj.path = path
+    if ctx.invoked_subcommand is None:
+        await _list(obj)
+
+
+@cli.command()
+@click.pass_obj
+async def run(obj):
+    """
+    Run a gateway setup.
+    """
+    from moat.link.announce import announcing  # noqa: PLC0415
+    from moat.link.gate import run_gate  # noqa: PLC0415
+    from moat.util.systemd import as_service  # noqa: PLC0415
+
+    gate = P("gate") + obj.path
+    async with (
+        as_service(obj) as srv,
+        announcing(obj.conn, host=False, name=gate, force=True, via=srv.evt),
+    ):
+        await run_gate(obj.cfg, obj.conn, gate, task_status=srv)
+
+
+@cli.command("list")
+@click.pass_obj
+async def list_(obj):
+    """
+    List gates / a gate's data.
+    """
+    await _list(obj)
+
+
+async def _list(obj):
+    if not obj.path:
+        seen = False
+        async with obj.conn.d_walk(P("gate"), min_depth=1, max_depth=1) as mon:
+            async for p, _d in mon:
+                seen = True
+                print(p[-1])
+        if not seen and obj.debug:
+            print("- no data.", file=sys.stderr)
+        return
+
+    k = {}
+    k["recursive"] = True
+    k["raw"] = True
+    k["empty"] = True
+    await data_get(obj.conn, P("gate") + obj.path, **k)
+
+
+@cli.command("set", short_help="Add or update a gate entry")
+@attr_args
+@click.option("-S", "--src", type=P, help="Source (in Moat-Link)")
+@click.option("-D", "--dst", type=P, help="Destination (driver specific)")
+@click.option("-d", "--driver", type=str, help="Driver")
+@click.pass_obj
+async def set_(obj, src, dst, driver, **kw):
+    """
+    Add/change a gateway entry.
+    """
+
+    if not len(obj.path):
+        raise SyntaxError("Can't set the top level")
+    if driver:
+        kw["vars_"] += ((P("driver"), driver),)
+    if src:
+        kw["path_"] += ((P("src"), src),)
+    if dst:
+        kw["path_"] += ((P("dst"), dst),)
+    await node_attr(obj, P("gate") + obj.path, **kw)
+
+
+class nstr:
+    def __new__(cls, val):
+        if val is NotGiven:
+            return val
+        return str(val)
+
+
+@cli.command(short_help="Delete an entry / subtree")
+@click.option(
+    "-b",
+    "--before",
+    type=float,
+    help="Don't delete entries created after this timestamp",
+)
+@click.option("-r", "--recursive", is_flag=True, help="Delete a complete subtree")
+@click.pass_obj
+async def delete(obj, before, recursive):
+    """
+    Delete an entry, or a subtree.
+
+    You really should use "--before" flag to ensure that no other change
+    arrived after you viewed the data in question.
+
+    Non-recursively deleting an entry with children works and does *not*
+    affect the child entries.
+
+    The root entry cannot be deleted.
+    """
+    args = {}
+    if recursive:
+        args["rec"] = recursive
+    if before:
+        args["ts"] = before
+    res = await obj.conn.d.delete(obj.path, **args)
+    if obj.meta:
+        res = dict(data=res[0], meta=MsgMeta.restore(res[1:]).repr())
+    else:
+        res = res[0]
+    yprint(res, stream=obj.stdout)

moat/link/gate/kv.py

@@ -0,0 +1,97 @@
+"""
+MoaT gateway
+"""
+
+from __future__ import annotations
+
+import anyio
+
+from moat.util import NotGiven, Path, PathLongener
+from moat.kv.client import Client, open_client
+from moat.link.meta import MsgMeta
+
+from . import Gate as _Gate
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.link.gate import GateNode
+
+    from typing import Any
+
+
+class Gate(_Gate):  # noqa: D101
+    kv: Client
+
+    async def run_(self, *, task_status=anyio.TASK_STATUS_IGNORED):
+        "Main loop. Overridden to start a Moat-KV client"
+        async with open_client("moat.link.gate.kv", **self.cfg["kv"]) as self.kv:
+            await super().run_(task_status=task_status)
+
+    async def get_dst(self, task_status=anyio.TASK_STATUS_IGNORED):  # noqa: D102
+        pl = PathLongener()
+        # This chops the `self.cf.dst` prefix off the resulting path
+        async with self.kv.watch(self.cf.dst, fetch=True, long_path=False, nchain=2) as mon:
+            task_status.started()
+            async for msg in mon:
+                if "path" not in msg:
+                    if msg.get("state", "") == "uptodate":
+                        self.dst_is_current()
+                    continue
+                path = pl.long(msg.depth, msg.path)
+                await self.set_src(
+                    path,
+                    msg.get("value", NotGiven),
+                    MsgMeta(origin=msg.chain.node, t=msg.chain.tick),
+                )
+
+    async def set_dst(self, path: Path, data: Any, meta: MsgMeta, node: GateNode):
+        "Set KV data."
+
+        meta  # noqa:B018
+
+        # XXX ideally we should have the previous value's external chain
+        # available here, just to be able to complain when there's a conflict
+        if data is NotGiven:
+            res = await self.kv.delete(self.cf.dst + path, nchain=1)
+        else:
+            res = await self.kv.set(self.cf.dst + path, value=data, nchain=1)
+
+        node.ext_meta = res.chain
+
+    def is_update(self, node: GateNode, data: Any, meta: MsgMeta):
+        "Check for update"
+        data  # noqa:B018
+        # If the message is an echo of what we sent earlier, ignore it.
+        try:
+            if meta.origin == node.ext_meta.node and meta["t"] == node.ext_meta.tick:
+                return False
+        except (AttributeError, KeyError):
+            pass
+        return True
+
+    def newer_dst(self, node):  # noqa: D102
+        # If the internal message has a copy of the outside metadata, it
+        # should be either unmodified or older. Test the data to be sure.
+        # Otherwise compare the chains.
+        if node.meta.origin == self.origin:
+            return None
+
+        if "gw" in node.meta:
+            last_node = node.meta["gw"]
+            if last_node.origin != node.ext_meta.origin:
+                return True
+            if last_node["t"] < node.ext_meta["t"]:
+                return True
+            if last_node["t"] > node.ext_meta["t"]:
+                return False
+            return None
+
+        # same data = nothing to do
+        # XXX may require inexact comparison for floats
+        if node.data == node.ext_data:
+            return None
+
+        # Otherwise assume that the local data is newer because there's no
+        # gateway data in it.
+        return False

moat/link/gate/mqtt.py

@@ -0,0 +1,167 @@
+"""
+MoaT gateway
+"""
+
+from __future__ import annotations
+
+import anyio
+from contextlib import AsyncExitStack
+
+from moat.util import NotGiven, P, Path
+from moat.link.meta import MsgMeta
+
+from . import Gate as _Gate
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.link.node.codec import CodecNode
+
+    from . import GateNode
+
+    from typing import Any
+
+
+class Gate(_Gate):  # noqa: D101
+    codecs: CodecNode | None = None
+
+    async def run_(self, *, task_status=anyio.TASK_STATUS_IGNORED):
+        "Main loop. Overridden to fetch the codecs"
+        async with AsyncExitStack() as ex:
+            if isinstance(self.cf.codec, Path):
+                cdv = await ex.enter_async_context(
+                    self.link.d_watch(
+                        P("conv") + self.cf.codec, subtree=True, state=None, meta=False
+                    )
+                )
+                self.codec_vecs = await cdv.get_node()
+
+                self.codecs = await self.link.get_codec_tree()
+
+            await super().run_(task_status=task_status)
+
+    async def get_dst(self, *, task_status=anyio.TASK_STATUS_IGNORED):  # noqa: D102
+        async with AsyncExitStack() as ex:
+            if self.codecs is not None:
+                codec = "noop"
+
+                def conv(p, d):
+                    # two step
+                    # (a) look up the codec type in the vector
+                    try:
+                        vd = self.codec_vecs.search(p)
+                        cd = self.codecs.get(Path.build(vd.data["codec"]))
+                    except (KeyError, ValueError):
+                        return NotGiven
+                    try:
+                        return cd.dec_value(d)
+                    except Exception as exc:
+                        self.logger.error("Decode: %s %r: %r", p, d, exc)
+                        return NotGiven
+
+            else:
+                codec = self.codec
+
+                def conv(p, d):
+                    p  # noqa:B018
+                    return d
+
+            mon = await ex.enter_async_context(
+                self.link.monitor(self.cf.dst, subtree=True, codec=codec)
+            )
+            task_status.started()
+            ld = len(self.cf.dst)
+            while True:
+                try:
+                    with anyio.fail_after(self.cf.get("timeout", 0.5)):
+                        msg = await anext(mon)
+                except TimeoutError:
+                    break
+                p = Path.build(msg.topic[ld:])
+                res = conv(p, msg.data)
+                if res is NotGiven:
+                    continue
+                await self.set_src(p, res, msg.meta)
+            self.dst_is_current()
+
+            async for msg in mon:
+                if msg.meta is not None and msg.meta.origin == self.origin:
+                    # mine, so skip
+                    continue
+                p = Path.build(msg.topic[ld:])
+                if msg.data == b"":
+                    res = NotGiven
+                else:
+                    res = conv(p, msg.data)
+                    if res is NotGiven:
+                        continue
+                await self.set_src(p, res, msg.meta)
+
+    async def set_dst(self, path: Path, data: Any, meta: MsgMeta, node: GateNode):  # noqa: D102
+        meta = MsgMeta(origin=self.origin, timestamp=meta.timestamp)
+        if data is NotGiven:
+            await self.link.send(self.cf.dst + path, b"", retain=True, codec="noop", meta=meta)
+        elif self.codecs is not None:
+            try:
+                vd = self.codec_vecs.search(path)
+                cd = self.codecs.get(Path.build(vd.data["codec"]))
+            except (ValueError, KeyError):
+                self.logger.error("No codec: %s %r", path, data)
+                return
+            res = cd.enc_value(data)
+            if isinstance(res, (str, bytes, bytearray)):
+                await self.link.send(self.cf.dst + path, res, retain=True, codec="noop", meta=meta)
+            else:
+                self.logger.error("Bad codec: %s %r > %r", path, data, res)
+
+        else:
+            await self.link.send(
+                self.cf.dst + path, data, retain=True, codec=self.codec, meta=meta
+            )
+
+        node.ext_meta = meta
+
+    def is_update(self, node: GateNode, data: Any, meta: MsgMeta):
+        """
+        Test whether this is an update.
+
+        @data is currently ignored.
+        """
+        data  # noqa:B018
+        # if the old metadata match the new, it's not an update.
+        try:
+            if node.ext_meta.origin == meta.origin and node.ext_meta.timestamp == meta.timestamp:
+                return False
+        except (AttributeError, KeyError):
+            pass
+        return True
+
+    def newer_dst(self, node):  # noqa: D102
+        # If the external message has no metadata, it can't be from us,
+        # thus assume it's newer.
+        if not node.ext_meta:
+            return True
+
+        # If the internal and external metadata match, the message is from
+        # us, so nothing to do.
+        if self.origin == node.ext_meta.origin:
+            return None
+
+        # If the internal message has a copy of the outside metadata, it's
+        # either unmodified or older. Test the data to be sure.
+        if "gw" in node.meta:
+            if node.meta["gw"] == node.ext_meta:
+                return None if node.data_ == node.ext_data else True
+            else:
+                return True
+
+        # Otherwise, if the external message is ours, it's old.
+        if node.ext_meta.origin == self.origin:
+            return False
+
+        # if the timestamps are too close, there might be a problem.
+        if abs(node.ext_meta.timestamp - node.meta.timestamp) < 0.1:
+            return None
+
+        # Otherwise use the message with the newer timestamp.
+        return node.ext_meta.timestamp > node.meta.timestamp

moat_link_gate-0.0.1.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: moat-link-gate
+Version: 0.0.1
+Summary: Gateway modules for MoaT-Link (KV and MQTT)
+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
+Keywords: MoaT
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AnyIO
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.2
+Requires-Dist: asyncclick
+Requires-Dist: attrs
+Requires-Dist: moat-util~=0.62.2
+Requires-Dist: moat-link~=0.2.46
+Requires-Dist: moat-lib-mqtt~=0.0.1
+Dynamic: license-file
+
+# moat-link-gate
+
+Gateway modules for MoaT-Link providing KV and MQTT integrations.
+
+This package provides gateway functionality for MoaT-Link, including:
+- KV (key-value) gateway for data storage integration
+- MQTT gateway for MQTT broker integration
+
+## Installation
+
+```bash
+pip install moat-link-gate
+```
+
+## Usage
+
+The gateways can be configured through MoaT-Link's configuration system.
+
+## Dependencies
+
+- moat-link: Core MoaT-Link functionality
+- moat-lib-mqtt: MQTT client library
+
+## License
+
+This project is licensed under the same terms as MoaT.

moat_link_gate-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+moat/link/gate/__init__.py,sha256=vOKlZRcowuUSe8eCtlwpT98MUCXjsWYFkFHKtpZSb0o,11395
+moat/link/gate/_main.py,sha256=u0ydGxvG85UU7fQ3kPLL8ymsH0P-z3056d9MRL5kCoI,3686
+moat/link/gate/kv.py,sha256=JYrMQEMggyByJXOD4WNZXQ9GddIprSRYHknW_V_xFJ4,3270
+moat/link/gate/mqtt.py,sha256=IcziqygqwC0kU9Zswwa25ysYbw8MpNJnhTY-5xfFS9A,5844
+moat_link_gate-0.0.1.dist-info/licenses/LICENSE.txt,sha256=L5vKJLVOg5t0CEEPpW9-O_0vzbP0PEjEF06tLvnIDuk,541
+moat_link_gate-0.0.1.dist-info/METADATA,sha256=9laWCjLJRDyvCHzN_nO8QBBtp114gYZnJxbMSo8KOSU,1353
+moat_link_gate-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+moat_link_gate-0.0.1.dist-info/top_level.txt,sha256=pcs9fl5w5AB5GVi4SvBqIVmFrkRwQkVw_dEvW0Q0cSA,5
+moat_link_gate-0.0.1.dist-info/RECORD,,

moat_link_gate-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

moat_link_gate-0.0.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,14 @@
+The code in this repository, and all MoaT submodules it refers to,
+is part of the MoaT project.
+
+Unless a submodule's LICENSE.txt states otherwise, all included files are
+licensed under the LGPL V3, as published by the FSF at
+https://www.gnu.org/licenses/lgpl-3.0.html .
+
+In addition to the LGPL's terms, the author(s) respectfully ask all users of
+this code to contribute any bug fixes or enhancements. Also, please link back to
+https://M-o-a-T.org.
+
+Thank you.
+
+Copyright © 2021 ff.: the MoaT contributor(s), as per the git changelog(s).

moat_link_gate-0.0.1.dist-info/top_level.txt

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