moat-link-wago 0.9.0__tar.gz

moat_link_wago-0.9.0/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthias Urlichs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

moat_link_wago-0.9.0/Makefile

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

moat_link_wago-0.9.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: moat-link-wago
+Version: 0.9.0
+Summary: Wago controller connector for MoaT-Link
+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.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.2
+Requires-Dist: asyncclick~=8.3
+Requires-Dist: asyncwago~=0.31.6
+Requires-Dist: moat-util~=0.63.0
+Requires-Dist: moat-link~=0.9.0
+Requires-Dist: moat-lib-config~=0.2.0
+Dynamic: license-file
+
+# Wago controller connector
+
+% start synopsis
+Connects MoaT-Link to Wago bus controllers via the asyncwago library.
+% end synopsis
+
+% start main
+
+This module bridges MoaT-Link values and Wago controller ports, in both
+directions, via the ``asyncwago`` library.  It replaces the legacy
+``moat-kv-wago`` package.
+
+## Quick start
+
+1. Configure a Wago controller:
+
+   ```shell
+   moat link wago myctrl add -h 10.0.0.1
+   ```
+
+2. Map a port to a MoaT-Link path:
+
+   ```shell
+   moat link wago myctrl at input 1 3 add -m read -s dest .data.lamp.kitchen
+   ```
+
+3. Run the connector:
+
+   ```shell
+   moat link wago myctrl monitor
+   ```
+
+## Deprecation
+
+This package supersedes ``moat-kv-wago``.  The address tree now lives in
+MoaT-Link under the ``wago.<NAME>`` prefix; ports are stored as
+``input`` or ``output`` type, then card number, then port number.
+
+% end main

moat_link_wago-0.9.0/README.md

@@ -0,0 +1,39 @@
+# Wago controller connector
+
+% start synopsis
+Connects MoaT-Link to Wago bus controllers via the asyncwago library.
+% end synopsis
+
+% start main
+
+This module bridges MoaT-Link values and Wago controller ports, in both
+directions, via the ``asyncwago`` library.  It replaces the legacy
+``moat-kv-wago`` package.
+
+## Quick start
+
+1. Configure a Wago controller:
+
+   ```shell
+   moat link wago myctrl add -h 10.0.0.1
+   ```
+
+2. Map a port to a MoaT-Link path:
+
+   ```shell
+   moat link wago myctrl at input 1 3 add -m read -s dest .data.lamp.kitchen
+   ```
+
+3. Run the connector:
+
+   ```shell
+   moat link wago myctrl monitor
+   ```
+
+## Deprecation
+
+This package supersedes ``moat-kv-wago``.  The address tree now lives in
+MoaT-Link under the ``wago.<NAME>`` prefix; ports are stored as
+``input`` or ``output`` type, then card number, then port number.
+
+% end main

moat_link_wago-0.9.0/debian/changelog

@@ -0,0 +1,11 @@
+moat-link-wago (0.9.0-1) unstable; urgency=medium
+
+  * New release for 26.2.5
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Thu, 25 Jun 2026 16:10:54 +0200
+
+moat-link-wago (0.1.0-1) unstable; urgency=medium
+
+  * Initial release.
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 25 Jun 2026 12:00:00 +0200

moat_link_wago-0.9.0/debian/control

@@ -0,0 +1,22 @@
+Source: moat-link-wago
+Maintainer: Matthias Urlichs <matthias@urlichs.de>
+Section: python
+Priority: optional
+Build-Depends: dh-python, python3-all, debhelper (>= 13), debhelper-compat (= 13),
+  python3-setuptools,
+  python3-wheel,
+Standards-Version: 3.9.6
+Homepage: https://github.com/M-o-a-T/moat
+
+Package: moat-link-wago
+Architecture: all
+Depends: ${misc:Depends}, ${python3:Depends},
+  moat-util,
+  moat-link,
+Recommends:
+  python3-trio (>= 0.22),
+Description: Wago controller connector for MoaT-Link
+ Bridges MoaT-Link values to and from Wago bus controllers via the
+ asyncwago library.
+ .
+ Part of the MoaT ecosystem for distributed home automation.

moat_link_wago-0.9.0/debian/py3dist-overrides

@@ -0,0 +1 @@
+asyncwago python3-asyncwago

moat_link_wago-0.9.0/debian/rules

@@ -0,0 +1,10 @@
+#!/usr/bin/make -f
+
+export PYBUILD_NAME=moat-link-wago
+%:
+	dh $@ --with python3 --buildsystem=pybuild
+
+override_dh_auto_install:
+	dh_auto_install
+	install -D -m 644 systemd/moat-link-wago@.service \
+		debian/moat-link-wago/usr/lib/systemd/system/moat-link-wago@.service

moat_link_wago-0.9.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [ "setuptools", "wheel",]
+
+[project]
+classifiers = [
+	"Intended Audience :: Developers",
+	"Programming Language :: Python :: 3",
+	"Framework :: AsyncIO",
+	"Framework :: Trio",
+	"Framework :: AnyIO",
+	"Development Status :: 4 - Beta",
+	]
+dependencies = [
+	"anyio ~= 4.2",
+	"asyncclick ~= 8.3",
+	"asyncwago ~= 0.31.6",
+	"moat-util ~= 0.63.0",
+	"moat-link ~= 0.9.0",
+	"moat-lib-config ~= 0.2.0",
+	]
+version = "0.9.0"
+keywords = [ "MoaT",]
+requires-python = ">=3.13"
+name = "moat-link-wago"
+description = "Wago controller connector for MoaT-Link"
+readme = "README.md"
+
+[[project.authors]]
+name = "Matthias Urlichs"
+email = "matthias@urlichs.de"
+
+[project.urls]
+homepage = "https://m-o-a-t.org"
+repository = "https://github.com/M-o-a-T/moat"
+
+[tool.setuptools]
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.yaml"]

moat_link_wago-0.9.0/setup.cfg

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

moat_link_wago-0.9.0/src/moat/link/wago/__init__.py

@@ -0,0 +1,9 @@
+"""Wago controller connector for MoaT-Link."""
+
+from __future__ import annotations
+
+from moat.lib.config import register as _register
+
+__all__: list[str] = []
+
+_register(__name__)

moat_link_wago-0.9.0/src/moat/link/wago/_cfg.yaml

@@ -0,0 +1,17 @@
+prefix: !P wago
+
+# There is no "server" entry, that's stored in the MoaT-Link node
+server_default:
+  port: 29995
+
+# poll frequency: server
+poll: 0.1
+
+# ping frequency: server
+ping: 5
+
+# for counter reporting: port
+interval: 1
+
+# Pulses up=True/down=False/both=None, default Up: port
+count: true

moat_link_wago-0.9.0/src/moat/link/wago/_main.py

@@ -0,0 +1,338 @@
+"""
+Command-line interface for moat.link.wago.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+
+import asyncclick as click
+
+from moat.util import NotGiven, yprint
+from moat.lib.path import Path
+from moat.lib.run import AliasedGroup, attr_args
+from moat.link._data import data_get, node_attr
+from moat.link.announce import as_service
+from moat.link.client import Link
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _server_path(obj) -> Path:
+    """Return the link path of the currently-selected Wago server."""
+    return obj.wago_prefix + Path.build((obj.wago_name,))
+
+
+async def _require_server(obj) -> dict[str, Any]:
+    """Fetch the data stored at the server entry, or raise.
+
+    Raises:
+        click.UsageError: if the entry is missing or not a mapping.
+    """
+    try:
+        data = await obj.conn.d_get(_server_path(obj))
+    except KeyError:
+        raise click.UsageError(f"Server {obj.wago_name!r} does not exist.") from None
+    if not isinstance(data, dict):
+        raise click.UsageError(f"Server {obj.wago_name!r} has no configuration.")
+    return data
+
+
+@click.group(
+    cls=AliasedGroup,
+    name="wago",
+    short_help="Manage Wago controllers.",
+    invoke_without_command=True,
+    help="""\
+        Manager for Wago bus controllers.
+
+        \b
+        Use '… wago -' to list all entries.
+        Use '… wago NAME' to show details of a single entry.
+        """,
+)
+@click.argument("name", type=str, nargs=1)
+@click.pass_context
+async def cli(ctx, name: str) -> None:
+    """Dispatch to a server- or port-specific subcommand."""
+    obj = ctx.obj
+    cfg = obj.cfg["link"]
+    obj.conn = await ctx.with_async_resource(Link(cfg))
+    obj.wago_cfg = obj.cfg.link.wago
+    obj.wago_prefix = obj.wago_cfg.prefix
+    obj.wago_name = name
+
+    if name == "-":
+        if ctx.invoked_subcommand is not None:
+            raise click.BadParameter(
+                "The name '-' triggers a list and precludes subcommands.",
+            )
+        cnt = 0
+        async with obj.conn.d_walk(obj.wago_prefix, min_depth=1, max_depth=1) as mon:
+            async for p, _d in mon:
+                cnt += 1
+                print(p[-1], file=obj.stdout)
+        if not cnt and obj.debug:
+            print("no entries", file=sys.stderr)
+        return
+
+    if ctx.invoked_subcommand is None:
+        try:
+            data = await obj.conn.d_get(_server_path(obj))
+        except KeyError:
+            raise click.UsageError(
+                f"Server {obj.wago_name!r} does not exist.",
+            ) from None
+        srv = data.get("server", {}) if isinstance(data, dict) else {}
+        cnt = 0
+        if isinstance(srv, dict):
+            for k in ("host", "port"):
+                v = srv.get(k)
+                if v is not None:
+                    cnt += 1
+                    print(f"server {k} {v}", file=obj.stdout)
+        if not cnt and obj.debug:
+            print("exists, no data", file=sys.stderr)
+
+
+@cli.command("--help", hidden=True)
+@click.pass_context
+def _cli_help(ctx) -> None:
+    """Workaround so ``cli NAME --help`` produces help text."""
+    print(cli.get_help(ctx))
+
+
+def _server_options(proc):
+    """Decorate ``add``/``set`` with the server-config options."""
+    proc = click.option(
+        "-p",
+        "--port",
+        type=int,
+        default=None,
+        help="Port of the Wago controller (default 29995).",
+    )(proc)
+    proc = click.option(
+        "-h",
+        "--host",
+        type=str,
+        default=None,
+        help="Host name or IP of the Wago controller.",
+    )(proc)
+    return proc
+
+
+@cli.command(short_help="Add a Wago controller")
+@_server_options
+@click.option("-f", "--force", is_flag=True, help="Allow replacing an existing controller.")
+@click.pass_obj
+async def add(obj, host, port, force) -> None:
+    """Add a Wago controller."""
+    path = _server_path(obj)
+    if not force:
+        try:
+            await obj.conn.d_get(path)
+        except KeyError:
+            pass
+        else:
+            raise click.UsageError(
+                f"Controller {obj.wago_name!r} already exists. Use --force or 'set'.",
+            )
+
+    srv: dict[str, Any] = {}
+    if host is not None:
+        srv["host"] = host
+    if port is not None:
+        srv["port"] = port
+    await obj.conn.d_set(path, {"server": srv})
+
+
+@cli.command("set", short_help="Modify a Wago controller")
+@_server_options
+@click.pass_obj
+async def set_(obj, host, port) -> None:
+    """Modify a Wago controller.
+
+    Pass ``-`` as a value (where applicable) to clear an existing setting.
+    """
+    data = await _require_server(obj)
+    srv = data.get("server", {})
+    if not isinstance(srv, dict):
+        srv = {}
+
+    if host is not None:
+        if host == "-":
+            srv.pop("host", None)
+        else:
+            srv["host"] = host
+    if port is not None:
+        srv["port"] = port
+    data["server"] = srv
+
+    await obj.conn.d_set(_server_path(obj), data)
+
+
+@cli.command("delete", short_help="Delete a Wago controller")
+@click.option("-r", "--recursive", is_flag=True, help="Also remove all entries below.")
+@click.pass_obj
+async def delete_(obj, recursive: bool) -> None:
+    """Delete a Wago controller.
+
+    Without ``--recursive`` the controller entry itself is removed but its
+    child port entries are kept (they become orphans).
+    """
+    path = _server_path(obj)
+    args: dict[str, Any] = {}
+    if recursive:
+        args["rec"] = True
+    res = await obj.conn.d.delete(path, **args)
+    if getattr(obj, "meta", False):
+        yprint(res[0], stream=obj.stdout)
+
+
+@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: bool) -> None:
+    """Emit a controller's (sub)state as a list / YAML file."""
+    path = _server_path(obj)
+    if not one_line:
+        await data_get(obj.conn, path, recursive=True, out=obj.stdout)
+        return
+    async with obj.conn.d_walk(path) as mon:
+        async for p, d in mon:
+            print(f"{path + p} {d}", file=obj.stdout)
+
+
+@cli.group(
+    "at",
+    invoke_without_command=True,
+    short_help="Create/show/delete a port entry.",
+)
+@click.argument("type_", type=str, nargs=1)
+@click.argument("card", type=int, nargs=1)
+@click.argument("port", type=int, nargs=1)
+@click.pass_context
+async def at_cli(ctx, type_: str, card: int, port: int) -> None:
+    """Manage a single port entry under a controller.
+
+    TYPE is ``input`` or ``output``.  CARD and PORT are integers.
+    """
+    obj = ctx.obj
+    if type_ not in ("input", "output"):
+        raise click.UsageError("TYPE must be 'input' or 'output'.")
+    try:
+        await obj.conn.d_get(_server_path(obj))
+    except KeyError:
+        raise click.UsageError(
+            "Create the controller before assigning ports to it!",
+        ) from None
+    obj.wago_subpath = Path.build((type_, card, port))
+    if ctx.invoked_subcommand is None:
+        await data_get(
+            obj.conn,
+            _server_path(obj) + obj.wago_subpath,
+            recursive=False,
+            out=obj.stdout,
+        )
+
+
+@at_cli.command("--help", hidden=True)
+@click.pass_context
+def _at_help(ctx) -> None:
+    """Workaround so ``at TYPE CARD PORT --help`` produces help text."""
+    print(at_cli.get_help(ctx))
+
+
+@at_cli.command("dump")
+@click.option("-l", "--one-line", is_flag=True, help="Single line per entry")
+@click.pass_obj
+async def dump_at(obj, one_line: bool) -> None:
+    """Emit a subtree as a list / YAML file."""
+    path = _server_path(obj) + obj.wago_subpath
+    if not one_line:
+        await data_get(obj.conn, path, recursive=True, out=obj.stdout)
+        return
+    async with obj.conn.d_walk(path) as mon:
+        async for p, d in mon:
+            print(f"{path + p} {d}", file=obj.stdout)
+
+
+@at_cli.command("add", short_help="Add a port entry")
+@attr_args
+@click.option("-f", "--force", is_flag=True, help="Allow replacing an existing entry.")
+@click.option(
+    "-m",
+    "--mode",
+    required=True,
+    help='Port mode: "read", "count", "write", "oneshot", or "pulse".',
+)
+@click.pass_obj
+async def add_at(obj, mode, force, **kw) -> None:
+    """Add a port mapping.
+
+    \b
+    TYPE CARD PORT: identify the physical port. Required.
+
+    Use the ``-s`` option to set attributes like ``dest`` or ``src``,
+    e.g. ``-s dest .my.path``.
+    """
+    sub: Path = obj.wago_subpath
+    path = _server_path(obj) + sub
+
+    if not force:
+        try:
+            await obj.conn.d_get(path)
+        except KeyError:
+            pass
+        else:
+            raise click.UsageError("This entry already exists. Use '--force' or 'set'.")
+
+    val: dict[str | None, Any] = {"mode": mode}
+    res, _meta = await node_attr(obj, path, val=val, **kw)
+
+    if getattr(obj, "meta", False):
+        yprint(res, stream=obj.stdout)
+
+
+@at_cli.command("delete")
+@click.pass_obj
+async def delete_at(obj) -> None:
+    """Remove a port mapping from the controller."""
+    path = _server_path(obj) + obj.wago_subpath
+    try:
+        await obj.conn.d_get(path)
+    except KeyError:
+        raise click.UsageError("This entry doesn't exist.") from None
+    await obj.conn.d_set(path, NotGiven)
+
+
+@at_cli.command("set")
+@attr_args
+@click.pass_obj
+async def set_at(obj, **kw) -> None:
+    """Modify a port entry."""
+    path = _server_path(obj) + obj.wago_subpath
+    res, _meta = await node_attr(obj, path, **kw)
+    if getattr(obj, "meta", False):
+        yprint(res, stream=obj.stdout)
+
+
+@cli.command()
+@click.pass_obj
+async def monitor(obj) -> None:
+    """Stand-alone task to talk to a single Wago controller."""
+    from .task import task  # noqa: PLC0415
+
+    async with as_service(obj) as srv:
+        await task(
+            obj.conn,
+            obj.wago_cfg,
+            obj.wago_name,
+            task_status=srv,
+        )

moat_link_wago-0.9.0/src/moat/link/wago/model.py

@@ -0,0 +1,189 @@
+"""
+Node model for the Wago controller connector.
+
+The tree mirrors the MoaT-Link subtree under the configured prefix.
+Each server entry is keyed by its name; below it the tree branches
+into ``input`` and ``output`` types, then card numbers, then port
+numbers.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from attrs import define
+
+from moat.util import NotGiven
+from moat.lib.path import Path
+from moat.link.node import Node
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.lib.rpc import Key
+
+    from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+@define
+class WagoPort(Node):
+    """A single Wago input or output port.
+
+    The stored configuration is a dict with these keys:
+
+    * ``mode``: ``"read"``, ``"count"``, ``"write"``, ``"oneshot"``,
+      or ``"pulse"``.
+    * ``dest``: destination path (for ``mode=read|count``).
+    * ``src``: source path (for ``mode=write|oneshot|pulse``).
+    * ``state``: optional state path (for output modes).
+    * ``rest``: rest-state flag (default ``False``).
+    * ``interval``: polling interval in seconds (for ``mode=count``).
+    * ``count``: pulse direction (``True``/``False``/``None``).
+    * ``t_on``: on-time in seconds (for ``mode=oneshot|pulse``).
+    * ``t_off``: off-time in seconds (for ``mode=pulse``).
+    """
+
+    @property
+    def mode(self) -> str | None:
+        """Port mode, or ``None`` if unset."""
+        d = self.data_
+        return d.get("mode") if isinstance(d, dict) else None
+
+    @property
+    def dest(self) -> Path | None:
+        """Destination path (input modes), or ``None``."""
+        d = self.data_
+        s = d.get("dest") if isinstance(d, dict) else None
+        return s if s is None else Path.build(s)
+
+    @property
+    def src(self) -> Path | None:
+        """Source path (output modes), or ``None``."""
+        d = self.data_
+        s = d.get("src") if isinstance(d, dict) else None
+        return s if s is None else Path.build(s)
+
+    @property
+    def state(self) -> Path | None:
+        """Optional state path (output modes), or ``None``."""
+        d = self.data_
+        s = d.get("state") if isinstance(d, dict) else None
+        return s if s is None else Path.build(s)
+
+    @property
+    def rest(self) -> bool:
+        """Rest-state flag (default ``False``)."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        return bool(d.get("rest", False)) if isinstance(d, dict) else False
+
+    @property
+    def interval(self) -> float | None:
+        """Polling interval (for ``mode=count``), or ``None``."""
+        d = self.data_
+        return d.get("interval") if isinstance(d, dict) else None
+
+    @property
+    def count(self) -> bool | None:
+        """Pulse direction (``True``/``False``/``None``)."""
+        d = self.data_
+        v = d.get("count") if isinstance(d, dict) else None
+        return v if v is None else bool(v)
+
+    @property
+    def t_on(self) -> float | None:
+        """On-time in seconds (for ``mode=oneshot|pulse``), or ``None``."""
+        d = self.data_
+        return d.get("t_on") if isinstance(d, dict) else None
+
+    @property
+    def t_off(self) -> float | None:
+        """Off-time in seconds (for ``mode=pulse``), or ``None``."""
+        d = self.data_
+        return d.get("t_off") if isinstance(d, dict) else None
+
+    @property
+    def card(self) -> int:
+        """Card number (parent key)."""
+        # The parent of a port is a card; we walk up the tree.
+        # This is typically known from the path context.
+        return 0
+
+    @property
+    def port(self) -> int:
+        """Port number (this node's key)."""
+        return 0
+
+    def is_complete(self) -> bool:
+        """Whether this entry has a complete configuration."""
+        m = self.mode
+        if m in ("read", "count"):
+            return self.dest is not None
+        if m in ("write", "oneshot", "pulse"):
+            return self.src is not None
+        return False
+
+
+@define
+class WagoCard(Node):
+    """Intermediate card-number node; children are :class:`WagoPort`."""
+
+    def add_child(self, item: Key) -> WagoPort:
+        """Create child entries as :class:`WagoPort`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = WagoPort()
+        return s
+
+
+@define
+class WagoType(Node):
+    """Intermediate ``input`` or ``output`` node; children are :class:`WagoCard`."""
+
+    def add_child(self, item: Key) -> WagoCard:
+        """Create child entries as :class:`WagoCard`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = WagoCard()
+        return s
+
+
+@define
+class WagoServer(Node):
+    """One Wago server (controller) in the configuration tree.
+
+    Children at the ``input`` / ``output`` levels branch out into
+    card/port levels and finally into :class:`WagoPort` leaves.
+    """
+
+    def add_child(self, item: Key) -> WagoType:
+        """Create child entries as :class:`WagoType`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = WagoType()
+        return s
+
+    @property
+    def cfg(self) -> dict[str, Any]:
+        """Server-level config dict (``host``/``port``)."""
+        d = self.data_
+        if d is NotGiven or not isinstance(d, dict):
+            return {}
+        s = d.get("server", {})
+        return s if isinstance(s, dict) else {}
+
+
+@define
+class WagoRoot(Node):
+    """Root of the Wago configuration tree.
+
+    Children are :class:`WagoServer` nodes.
+    """
+
+    def add_child(self, item: Key) -> WagoServer:
+        """Create child servers as :class:`WagoServer`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = WagoServer()
+        return s

moat_link_wago-0.9.0/src/moat/link/wago/task.py

@@ -0,0 +1,153 @@
+"""
+Main supervisor task for the Wago connector.
+
+Connects to a single Wago controller and monitors the MoaT-Link
+configuration subtree for one server.  Spawns / cancels per-port
+workers as entries appear or change.
+"""
+
+from __future__ import annotations
+
+import anyio
+import logging
+
+import asyncwago as wago
+
+from moat.util import combine_dict
+from moat.lib.path import Path
+from moat.link.meta import MsgMeta
+
+from .model import WagoPort, WagoRoot, WagoServer
+from .worker import run_in, run_out
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from anyio.abc import TaskStatus
+
+    from moat.link.client import LinkSender
+
+    from collections.abc import Mapping
+
+logger = logging.getLogger(__name__)
+
+
+async def task(
+    link: LinkSender,
+    cfg: Mapping,
+    server_name: str,
+    *,
+    task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED,
+) -> None:
+    """Run the Wago connector for one controller.
+
+    Args:
+        link: an active MoaT-Link sender.
+        cfg: the ``link.wago`` configuration section.
+        server_name: the server entry name inside the config subtree.
+        task_status: task-status for ``tg.start``.
+    """
+    prefix = Path.build(cfg["prefix"])
+    server_path = prefix / server_name
+
+    server_data = await link.d_get(server_path)
+    if not isinstance(server_data, dict):
+        server_data = {}
+    srv_cfg = combine_dict(
+        server_data.get("server", {}),
+        cfg.get("server_default", {}),
+    )
+
+    try:
+        async with wago.open_server(**srv_cfg) as srv:
+            r = await srv.describe()
+
+            # Build a local node tree and mark discovered ports present.
+            root = WagoRoot()
+            for type_name, cards in r.items():
+                srv_node = root.add_child(server_name)
+                type_node = srv_node.add_child(type_name)
+                for card_num, port_count in cards.items():
+                    card_node = type_node.add_child(card_num)
+                    for port_num in range(1, port_count + 1):
+                        port_node = card_node.add_child(port_num)
+                        meta = MsgMeta(origin="discover", t=anyio.current_time())
+                        port_node.set_(Path(), {"present": True}, meta)
+
+            # Update server-level settings.
+            poll = cfg.get("poll")
+            if poll is not None:
+                await srv.set_freq(poll)
+            ping = cfg.get("ping")
+            if ping is not None:
+                await srv.set_ping_freq(ping)
+
+            async with anyio.create_task_group() as tg:
+                workers: dict[Path, anyio.CancelScope] = {}
+
+                def _cancel(p: Path) -> None:
+                    sc = workers.pop(p, None)
+                    if sc is not None:
+                        sc.cancel()
+
+                async def _start(p: Path, entry: WagoPort) -> None:
+                    _cancel(p)
+                    if not entry.is_complete():
+                        logger.warning("Incomplete entry at %s, skipping", p)
+                        return
+                    if len(p) != 3:
+                        logger.warning("Entry %s is not at a 3-element port path", p)
+                        return
+                    card, port_num = int(p[1]), int(p[2])
+                    type_name = str(p[0])
+
+                    runner = run_in if type_name == "input" else run_out
+
+                    async def _run(
+                        *,
+                        task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED,
+                    ) -> None:
+                        with anyio.CancelScope() as sc:
+                            workers[p] = sc
+                            task_status.started()
+                            try:
+                                await runner(link, srv, entry, card, port_num, p)
+                            except Exception:
+                                logger.exception("Worker for %s failed", p)
+                            finally:
+                                if workers.get(p) is sc:
+                                    del workers[p]
+
+                    await tg.start(_run)
+
+                async with link.d_watch(
+                    server_path,
+                    subtree=True,
+                    mark=True,
+                    cls=WagoServer,
+                ) as mon:
+                    task_status.started()
+
+                    async for msg in mon:
+                        if msg is None:
+                            continue
+                        p, _data = msg
+                        if not p:
+                            continue
+
+                        node = mon.nodes.get(p)
+                        if isinstance(node, WagoPort):
+                            if node.is_complete():
+                                await _start(p, node)
+                            else:
+                                _cancel(p)
+                        else:
+                            _cancel(p)
+
+            tg.cancel_scope.cancel()
+    except TimeoutError:
+        raise
+    except OSError as exc:
+        raise RuntimeError(
+            f"Cannot connect to {srv_cfg.get('host')}:{srv_cfg.get('port')}"
+        ) from exc

moat_link_wago-0.9.0/src/moat/link/wago/worker.py

@@ -0,0 +1,220 @@
+"""
+Per-port workers for the Wago controller connector.
+
+Each worker drives a single :class:`~moat.link.wago.model.WagoPort`.
+Input workers monitor the Wago controller and publish to MoaT-Link;
+output workers watch a MoaT-Link value and write to the controller.
+"""
+
+from __future__ import annotations
+
+import anyio
+import logging
+
+from moat.util import NotGiven
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.lib.path import Path
+    from moat.link.client import LinkSender
+
+    from .model import WagoPort
+
+    from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+async def run_in(
+    link: LinkSender,
+    srv: Any,
+    entry: WagoPort,
+    card: int,
+    port: int,
+    subpath: Path,
+) -> None:
+    """Forward Wago input changes to a MoaT-Link destination.
+
+    Args:
+        link: Active MoaT-Link sender.
+        srv: Connected Wago server.
+        entry: Configuration entry for this port.
+        card: Card number.
+        port: Port number.
+        subpath: Path of this entry relative to the server (for naming).
+    """
+    mode = entry.mode
+    dest = entry.dest
+    if mode is None or dest is None:
+        return
+
+    rest = entry.rest
+
+    if mode == "read":
+        async with srv.monitor_input(card, port) as mon:
+            async for val in mon:
+                await link.d_set(dest, val != rest)
+    elif mode == "count":
+        intv = entry.interval
+        direc = entry.count
+        delta = 0
+        try:
+            old = await link.d_get(dest)
+            if isinstance(old, (int, float)):
+                delta = old
+        except KeyError:
+            pass
+        async with srv.count_input(card, port, direction=direc, interval=intv) as mon:
+            async for val in mon:
+                await link.d_set(dest, val + delta)
+    else:
+        logger.warning("Unknown input mode %r at %s", mode, subpath)
+
+
+async def run_out(
+    link: LinkSender,
+    srv: Any,
+    entry: WagoPort,
+    card: int,
+    port: int,
+    subpath: Path,
+) -> None:
+    """Forward MoaT-Link source updates to a Wago output.
+
+    Args:
+        link: Active MoaT-Link sender.
+        srv: Connected Wago server.
+        entry: Configuration entry for this port.
+        card: Card number.
+        port: Port number.
+        subpath: Path of this entry relative to the server (for naming).
+    """
+    mode = entry.mode
+    src = entry.src
+    if mode is None or src is None:
+        return
+
+    rest = entry.rest
+    state = entry.state
+
+    if mode == "write":
+        async with link.d_watch(src, mark=False, state=False) as wp:
+            async for raw in wp:
+                if raw is NotGiven:
+                    continue
+                val = bool(raw)
+                await srv.write_output(card, port, val != rest)
+                if state is not None:
+                    await link.d_set(state, val)
+    elif mode == "oneshot":
+        t_on = entry.t_on
+        _work: anyio.CancelScope | None = None
+        _work_done: anyio.Event | None = None
+
+        async def _cancel_work() -> None:
+            nonlocal _work, _work_done
+            if _work is not None:
+                _work.cancel()
+                if _work_done is not None:
+                    await _work_done.wait()
+                _work = None
+                _work_done = None
+
+        async def _do_oneshot(val: bool) -> None:
+            nonlocal _work, _work_done
+            if val:
+                await _cancel_work()
+                done_evt = anyio.Event()
+                _work_done = done_evt
+                with anyio.CancelScope() as sc:
+                    _work = sc
+                    async with srv.write_timed_output(card, port, not rest, t_on) as work:
+                        if state is not None:
+                            await link.d_set(state, True)
+                        await work.wait()
+                if _work is sc:
+                    _work = None
+                    if _work_done is done_evt:
+                        _work_done = None
+                    done_evt.set()
+                with anyio.fail_after(2, shield=True):
+                    if state is not None:
+                        try:
+                            v = await srv.read_output(card, port)
+                        except anyio.ClosedResourceError:
+                            pass
+                        else:
+                            await link.d_set(state, v != rest)
+            else:
+                await _cancel_work()
+                await srv.write_output(card, port, rest)
+                if state is not None:
+                    await link.d_set(state, False)
+
+        async with link.d_watch(src, mark=False, state=False) as wp:
+            async for raw in wp:
+                if raw is NotGiven:
+                    continue
+                await _do_oneshot(bool(raw))
+
+    elif mode == "pulse":
+        t_on = entry.t_on
+        t_off = entry.t_off
+        _work: anyio.CancelScope | None = None
+        _work_done: anyio.Event | None = None
+
+        async def _cancel_pulse() -> None:
+            nonlocal _work, _work_done
+            if _work is not None:
+                _work.cancel()
+                if _work_done is not None:
+                    await _work_done.wait()
+                _work = None
+                _work_done = None
+
+        async def _do_pulse(val: bool) -> None:
+            nonlocal _work, _work_done
+            if val:
+                await _cancel_pulse()
+                done_evt = anyio.Event()
+                _work_done = done_evt
+                try:
+                    with anyio.CancelScope() as sc:
+                        _work = sc
+                        if t_on is None or t_off is None:
+                            raise RuntimeError("t_on or t_off is None")
+                        async with srv.write_pulsed_output(
+                            card, port, not rest, t_on, t_off
+                        ) as work:
+                            if state is not None:
+                                await link.d_set(state, t_on / (t_on + t_off))
+                            await work.wait()
+                finally:
+                    if _work is sc:
+                        _work = None
+                        if _work_done is done_evt:
+                            _work_done = None
+                        done_evt.set()
+                    with anyio.fail_after(2, shield=True):
+                        if state is not None:
+                            try:
+                                v = await srv.read_output(card, port)
+                            except anyio.ClosedResourceError:
+                                pass
+                            else:
+                                await link.d_set(state, v != rest)
+            else:
+                await _cancel_pulse()
+                await srv.write_output(card, port, rest)
+                if state is not None:
+                    await link.d_set(state, False)
+
+        async with link.d_watch(src, mark=False, state=False) as wp:
+            async for raw in wp:
+                if raw is NotGiven:
+                    continue
+                await _do_pulse(bool(raw))
+
+    else:
+        logger.warning("Unknown output mode %r at %s", mode, subpath)

moat_link_wago-0.9.0/src/moat_link_wago.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: moat-link-wago
+Version: 0.9.0
+Summary: Wago controller connector for MoaT-Link
+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.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.2
+Requires-Dist: asyncclick~=8.3
+Requires-Dist: asyncwago~=0.31.6
+Requires-Dist: moat-util~=0.63.0
+Requires-Dist: moat-link~=0.9.0
+Requires-Dist: moat-lib-config~=0.2.0
+Dynamic: license-file
+
+# Wago controller connector
+
+% start synopsis
+Connects MoaT-Link to Wago bus controllers via the asyncwago library.
+% end synopsis
+
+% start main
+
+This module bridges MoaT-Link values and Wago controller ports, in both
+directions, via the ``asyncwago`` library.  It replaces the legacy
+``moat-kv-wago`` package.
+
+## Quick start
+
+1. Configure a Wago controller:
+
+   ```shell
+   moat link wago myctrl add -h 10.0.0.1
+   ```
+
+2. Map a port to a MoaT-Link path:
+
+   ```shell
+   moat link wago myctrl at input 1 3 add -m read -s dest .data.lamp.kitchen
+   ```
+
+3. Run the connector:
+
+   ```shell
+   moat link wago myctrl monitor
+   ```
+
+## Deprecation
+
+This package supersedes ``moat-kv-wago``.  The address tree now lives in
+MoaT-Link under the ``wago.<NAME>`` prefix; ports are stored as
+``input`` or ``output`` type, then card number, then port number.
+
+% end main

moat_link_wago-0.9.0/src/moat_link_wago.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE.txt
+Makefile
+README.md
+pyproject.toml
+debian/changelog
+debian/control
+debian/py3dist-overrides
+debian/rules
+src/moat/link/wago/__init__.py
+src/moat/link/wago/_cfg.yaml
+src/moat/link/wago/_main.py
+src/moat/link/wago/model.py
+src/moat/link/wago/task.py
+src/moat/link/wago/worker.py
+src/moat_link_wago.egg-info/PKG-INFO
+src/moat_link_wago.egg-info/SOURCES.txt
+src/moat_link_wago.egg-info/dependency_links.txt
+src/moat_link_wago.egg-info/requires.txt
+src/moat_link_wago.egg-info/top_level.txt
+systemd/moat-link-wago@.service

moat_link_wago-0.9.0/src/moat_link_wago.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moat_link_wago-0.9.0/src/moat_link_wago.egg-info/requires.txt

@@ -0,0 +1,6 @@
+anyio~=4.2
+asyncclick~=8.3
+asyncwago~=0.31.6
+moat-lib-config~=0.2.0
+moat-link~=0.9.0
+moat-util~=0.63.0

moat_link_wago-0.9.0/src/moat_link_wago.egg-info/top_level.txt

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

moat_link_wago-0.9.0/systemd/moat-link-wago@.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=MoaT-Link Wago connector (%I)
+After=moat-link-server.service
+Requires=moat-link-server.service
+
+ConditionFileNotEmpty=/etc/moat/moat.yaml
+
+[Install]
+WantedBy=multi-user.target
+
+[Service]
+Type=notify
+ExecStart=/usr/bin/moat link wago %I monitor
+
+EnvironmentFile=-/etc/moat/link.env
+
+TimeoutSec=300
+WatchdogSec=10
+
+Restart=always
+RestartSec=30