moat-link-ow 0.1.1__tar.gz

moat_link_ow-0.1.1/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_ow-0.1.1/Makefile

@@ -0,0 +1,14 @@
+#!/usr/bin/make -f
+
+PACKAGE = moat-link-ow
+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_ow-0.1.1/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: moat-link-ow
+Version: 0.1.1
+Summary: 1-Wire (OWFS) 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: asyncowfs~=0.15
+Requires-Dist: attrs
+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
+
+# 1-Wire (OWFS) connector
+
+% start synopsis
+Connects MoaT-Link to 1-Wire buses via the asyncowfs library.
+% end synopsis
+
+% start main
+
+This module bridges MoaT-Link values and 1-Wire device attributes, in
+both directions, via the ``asyncowfs`` library.  It replaces the legacy
+``moat-kv-ow`` package.
+
+## Quick start
+
+1. Configure an OWFS server (owserver):
+
+   ```shell
+   moat link ow mybus add -h 10.0.0.1
+   ```
+
+2. Map a device attribute to a MoaT-Link path:
+
+   ```shell
+   moat link ow mybus at 10.345678.90 temperature add -s dest .data.temp.room -s interval =5
+   ```
+
+3. Run the connector:
+
+   ```shell
+   moat link ow mybus monitor
+   ```
+
+## Deprecation
+
+This package supersedes ``moat-kv-ow``.  The address tree now lives in
+MoaT-Link under the ``ow.<NAME>`` prefix; device attributes are stored
+below the server entry, keyed by family code, hardware code, and the
+attribute path.
+
+% end main

moat_link_ow-0.1.1/README.md

@@ -0,0 +1,40 @@
+# 1-Wire (OWFS) connector
+
+% start synopsis
+Connects MoaT-Link to 1-Wire buses via the asyncowfs library.
+% end synopsis
+
+% start main
+
+This module bridges MoaT-Link values and 1-Wire device attributes, in
+both directions, via the ``asyncowfs`` library.  It replaces the legacy
+``moat-kv-ow`` package.
+
+## Quick start
+
+1. Configure an OWFS server (owserver):
+
+   ```shell
+   moat link ow mybus add -h 10.0.0.1
+   ```
+
+2. Map a device attribute to a MoaT-Link path:
+
+   ```shell
+   moat link ow mybus at 10.345678.90 temperature add -s dest .data.temp.room -s interval =5
+   ```
+
+3. Run the connector:
+
+   ```shell
+   moat link ow mybus monitor
+   ```
+
+## Deprecation
+
+This package supersedes ``moat-kv-ow``.  The address tree now lives in
+MoaT-Link under the ``ow.<NAME>`` prefix; device attributes are stored
+below the server entry, keyed by family code, hardware code, and the
+attribute path.
+
+% end main

moat_link_ow-0.1.1/debian/.gitignore

@@ -0,0 +1,7 @@
+/files
+/*.log
+/*.debhelper
+/*.debhelper-build-stamp
+/*.substvars
+/debhelper-build-stamp
+/moat-link-ow

moat_link_ow-0.1.1/debian/changelog

@@ -0,0 +1,11 @@
+moat-link-ow (0.1.1-1) unstable; urgency=medium
+
+  * New release for 26.2.8
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Sat, 11 Jul 2026 03:26:42 +0200
+
+moat-link-ow (0.1.0-1) unstable; urgency=medium
+
+  * Initial release.
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Wed, 09 Jul 2026 12:00:00 +0200

moat_link_ow-0.1.1/debian/control

@@ -0,0 +1,22 @@
+Source: moat-link-ow
+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-ow
+Architecture: all
+Depends: ${misc:Depends}, ${python3:Depends},
+  moat-util,
+  moat-link,
+Recommends:
+  python3-trio (>= 0.22),
+Description: 1-Wire (OWFS) connector for MoaT-Link
+ Bridges MoaT-Link values to and from 1-Wire device attributes via the
+ asyncowfs library and an owserver connection.
+ .
+ Part of the MoaT ecosystem for distributed home automation.

moat_link_ow-0.1.1/debian/py3dist-overrides

@@ -0,0 +1 @@
+asyncowfs python3-asyncowfs

moat_link_ow-0.1.1/debian/rules

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

moat_link_ow-0.1.1/pyproject.toml

@@ -0,0 +1,43 @@
+[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",
+	"asyncowfs ~= 0.15",
+	"attrs",
+	"moat-util ~= 0.63.0",
+	"moat-link ~= 0.9.0",
+	"moat-lib-config ~= 0.2.0",
+	]
+version = "0.1.1"
+keywords = [ "MoaT",]
+requires-python = ">=3.13"
+name = "moat-link-ow"
+description = "1-Wire (OWFS) 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_ow-0.1.1/setup.cfg

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

moat_link_ow-0.1.1/src/moat/link/ow/__init__.py

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

moat_link_ow-0.1.1/src/moat/link/ow/_cfg.yaml

@@ -0,0 +1,5 @@
+prefix: !P "1wire"
+
+# There is no "server" entry, that's stored in the MoaT-Link node
+server_default:
+  port: 4304

moat_link_ow-0.1.1/src/moat/link/ow/_main.py

@@ -0,0 +1,367 @@
+"""
+Command-line interface for moat.link.ow.
+
+Manages 1-Wire (OWFS) servers and their per-attribute mirror entries.
+The ``at`` sub-group targets a single device attribute identified by a
+1-Wire device id (``FF.CODE.CHK``) and an attribute path.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+
+import asyncclick as click
+
+from moat.util import NotGiven, yprint
+from moat.lib.path import P, 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 .model import device_subpath
+
+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 OWFS server."""
+    return obj.ow_prefix + Path.build((obj.ow_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.ow_name!r} does not exist.") from None
+    if not isinstance(data, dict):
+        raise click.UsageError(f"Server {obj.ow_name!r} has no configuration.")
+    return data
+
+
+@click.group(
+    cls=AliasedGroup,
+    name="ow",
+    short_help="Manage 1-Wire (OWFS) servers.",
+    invoke_without_command=True,
+    help="""\
+        Manager for 1-Wire (OWFS) bus servers.
+
+        \b
+        Use '… ow -' to list all servers.
+        Use '… ow NAME' to show details of a single server.
+        """,
+)
+@click.argument("name", type=str, nargs=1)
+@click.pass_context
+async def cli(ctx, name: str) -> None:
+    """Dispatch to a server- or attribute-specific subcommand."""
+    obj = ctx.obj
+    cfg = obj.cfg["link"]
+    obj.conn = await ctx.with_async_resource(Link(cfg))
+    obj.ow_cfg = obj.cfg.link.ow
+    obj.ow_prefix = obj.ow_cfg.prefix
+    obj.ow_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.ow_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.ow_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)
+
+
+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 owserver (default 4304).",
+    )(proc)
+    proc = click.option(
+        "-h",
+        "--host",
+        type=str,
+        default=None,
+        help="Host name or IP of the owserver.",
+    )(proc)
+    return proc
+
+
+@cli.command(short_help="Add an OWFS server")
+@_server_options
+@click.option("-f", "--force", is_flag=True, help="Allow replacing an existing server.")
+@click.pass_obj
+async def add(obj, host, port, force) -> None:
+    """Add an OWFS server (owserver)."""
+    path = _server_path(obj)
+    if not force:
+        try:
+            await obj.conn.d_get(path)
+        except KeyError:
+            pass
+        else:
+            raise click.UsageError(
+                f"Server {obj.ow_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 an OWFS server")
+@_server_options
+@click.pass_obj
+async def set_(obj, host, port) -> None:
+    """Modify an OWFS server.
+
+    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 an OWFS server")
+@click.option("-r", "--recursive", is_flag=True, help="Also remove all entries below.")
+@click.pass_obj
+async def delete_(obj, recursive: bool) -> None:
+    """Delete an OWFS server.
+
+    Without ``--recursive`` the server entry itself is removed but its
+    child attribute 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 server'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 an attribute mapping",
+)
+@click.argument("device", type=str, nargs=1)
+@click.argument("attr", type=str, nargs=1)
+@click.pass_context
+async def at_cli(ctx, device: str, attr: str) -> None:
+    """Manage a single 1-Wire attribute mapping under a server.
+
+    DEVICE is a 1-Wire device id in ``FF.CODE.CHK`` form (the checksum is
+    ignored); ATTR is the device attribute path, e.g. ``temperature`` or
+    ``foo.bar``.
+    """
+    obj = ctx.obj
+    try:
+        dev_sub = device_subpath(device)
+    except ValueError as exc:
+        raise click.UsageError(str(exc)) from None
+    try:
+        sub = dev_sub + P(attr)
+    except Exception as exc:
+        raise click.UsageError(f"Bad attribute {attr!r}: {exc}") from None
+    try:
+        await obj.conn.d_get(_server_path(obj))
+    except KeyError:
+        raise click.UsageError(
+            "Create the server before mapping attributes to it!",
+        ) from None
+    obj.ow_subpath = sub
+    if ctx.invoked_subcommand is None:
+        await data_get(
+            obj.conn,
+            _server_path(obj) + sub,
+            recursive=False,
+            out=obj.stdout,
+        )
+
+
+@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.ow_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 an attribute mapping")
+@attr_args
+@click.option("-f", "--force", is_flag=True, help="Allow replacing an existing entry.")
+@click.option(
+    "-w",
+    "--write",
+    is_flag=True,
+    help="Write direction (Link→device); needs 'src'. Default: read (device→Link).",
+)
+@click.option(
+    "-i",
+    "--interval",
+    type=float,
+    default=None,
+    help="Polling interval in seconds (read direction).",
+)
+@click.option(
+    "-a",
+    "--attr",
+    "attr_",
+    default=None,
+    help="Sub-attribute path: 'src_attr' for write, 'dest_attr' for read.",
+)
+@click.pass_obj
+async def add_at(obj, write, interval, attr_, force, **kw) -> None:
+    """Add a 1-Wire attribute mapping.
+
+    \b
+    DEVICE ATTR: identify the device attribute. Required.
+
+    For read direction (default) set ``dest`` to the MoaT-Link path that
+    receives the polled value; for write direction (``-w``) set ``src``
+    to the MoaT-Link path whose changes are forwarded to the device.
+
+    Use the ``-s`` option to set attributes, e.g. ``-s dest .my.path``
+    or ``-s src .my.path``.
+    """
+    sub: Path = obj.ow_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] = {}
+    if attr_ is not None:
+        val["src_attr" if write else "dest_attr"] = P(attr_)
+    if not write and interval is not None:
+        val["interval"] = interval
+
+    res, _meta = await node_attr(obj, path, val=val, **kw)
+
+    required = "src" if write else "dest"
+    if not isinstance(res, dict) or res.get(required) is None:
+        raise click.UsageError(
+            f"For {'write' if write else 'read'} direction you must set the "
+            f"{required!r} attribute, e.g. `-s {required} .some.path`.",
+        )
+
+    if getattr(obj, "meta", False):
+        yprint(res, stream=obj.stdout)
+
+
+@at_cli.command("set")
+@attr_args
+@click.pass_obj
+async def set_at(obj, **kw) -> None:
+    """Modify a 1-Wire attribute mapping."""
+    path = _server_path(obj) + obj.ow_subpath
+    res, _meta = await node_attr(obj, path, **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 an attribute mapping from the server."""
+    path = _server_path(obj) + obj.ow_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)
+
+
+@cli.command()
+@click.pass_obj
+async def monitor(obj) -> None:
+    """Stand-alone task to talk to a single OWFS server."""
+    from .task import task  # noqa: PLC0415
+
+    async with as_service(obj, host=False) as srv:
+        await task(
+            obj.conn,
+            obj.ow_cfg,
+            obj.ow_name,
+            task_status=srv,
+        )

moat_link_ow-0.1.1/src/moat/link/ow/model.py

@@ -0,0 +1,207 @@
+"""
+Node model for the 1-Wire (OWFS) bus 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 the device's family code (a byte), then the device's 48-bit
+hardware code, and finally the attribute path that selects the
+1-Wire value to mirror.
+
+A single attribute entry can mirror in either direction:
+
+* **read** (``dest`` set): the device attribute is polled and its value
+  is published to the MoaT-Link path ``dest``.
+* **write** (``src`` set): a MoaT-Link path ``src`` is watched and its
+  value is written to the device attribute.
+
+Both directions accept an optional sub-attribute path (``dest_attr`` /
+``src_attr``) that selects, or merges into, a nested field of the
+transferred value.
+"""
+
+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__)
+
+
+def parse_device(addr: str) -> tuple[int, int]:
+    """Split a 1-Wire device id ``FF.CODE.CHECK`` into ``(family, code)``.
+
+    Args:
+        addr: A device id such as ``"10.345678.90"``.  The family and code
+            components are interpreted as hexadecimal; the trailing
+            checksum is discarded.
+
+    Returns:
+        ``(family, code)`` as a pair of ``int``.
+
+    Raises:
+        ValueError: if *addr* is not a 3-part dotted device id.
+    """
+    parts = addr.split(".")
+    if len(parts) != 3:
+        raise ValueError(f"Not a 3-part 1-Wire device id: {addr!r}")
+    return int(parts[0], 16), int(parts[1], 16)
+
+
+def device_subpath(addr: str) -> Path:
+    """Return the ``(family, code)`` subpath for a 1-Wire device id."""
+    f, c = parse_device(addr)
+    return Path.build((f, c))
+
+
+@define
+class OwAttr(Node):
+    """A single 1-Wire attribute mapping.
+
+    The stored configuration is a dict with these keys:
+
+    * ``dest``: destination MoaT-Link path (read direction).
+    * ``src``: source MoaT-Link path (write direction).
+    * ``interval``: polling interval in seconds (read direction).
+    * ``dest_attr``: sub-attribute path merged into ``dest``'s value.
+    * ``src_attr``: sub-attribute path extracted from ``src``'s value.
+    * ``idem``: idempotency flag (default ``True``).
+    """
+
+    def add_child(self, item: Key) -> OwAttr:
+        """Nested attribute segments are :class:`OwAttr` nodes too."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = OwAttr()
+        return s
+
+    @property
+    def dest(self) -> Path | None:
+        """Destination path (read direction), 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 (write direction), 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 interval(self) -> float | None:
+        """Polling interval in seconds (read direction), or ``None``."""
+        d = self.data_
+        return d.get("interval") if isinstance(d, dict) else None
+
+    @property
+    def dest_attr(self) -> Path | None:
+        """Sub-attribute merged into ``dest``'s value, or ``None``."""
+        d = self.data_
+        s = d.get("dest_attr") if isinstance(d, dict) else None
+        return s if s is None else Path.build(s)
+
+    @property
+    def src_attr(self) -> Path | None:
+        """Sub-attribute extracted from ``src``'s value, or ``None``."""
+        d = self.data_
+        s = d.get("src_attr") if isinstance(d, dict) else None
+        return s if s is None else Path.build(s)
+
+    @property
+    def idem(self) -> bool:
+        """Idempotency flag (default ``True``)."""
+        d = self.data_ if self.data_ is not NotGiven else {}
+        if not isinstance(d, dict):
+            return True
+        return bool(d.get("idem", True))
+
+    @property
+    def is_read(self) -> bool:
+        """Whether this entry mirrors device→Link (``dest`` is set)."""
+        return self.dest is not None
+
+    @property
+    def is_write(self) -> bool:
+        """Whether this entry mirrors Link→device (``src`` is set)."""
+        return self.src is not None
+
+    def is_complete(self) -> bool:
+        """Whether this entry has a usable direction."""
+        return self.is_read or self.is_write
+
+
+@define
+class OwDevice(Node):
+    """One 1-Wire device; children are :class:`OwAttr`."""
+
+    def add_child(self, item: Key) -> OwAttr:
+        """Create child entries as :class:`OwAttr`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = OwAttr()
+        return s
+
+
+@define
+class OwFamily(Node):
+    """Intermediate family-code node; children are :class:`OwDevice`."""
+
+    def add_child(self, item: Key) -> OwDevice:
+        """Create child entries as :class:`OwDevice`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = OwDevice()
+        return s
+
+
+@define
+class OwServer(Node):
+    """One OWFS server (owserver) in the configuration tree.
+
+    Children at the integer ``family`` level branch out into
+    code/attribute levels and finally into :class:`OwAttr` leaves.
+    """
+
+    def add_child(self, item: Key) -> OwFamily:
+        """Create child entries as :class:`OwFamily`."""
+        if item in self._sub:
+            raise ValueError("exists")
+        self._sub[item] = s = OwFamily()
+        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 OwRoot(Node):
+    """Root of the 1-Wire configuration tree.
+
+    Children are :class:`OwServer` nodes.
+    """
+
+    def add_child(self, item: Key) -> OwServer:
+        """Create child servers as :class:`OwServer`."""
+        if item in self._sub:
+            raise ValueError(f"exists: {item!r}")
+        self._sub[item] = s = OwServer()
+        return s

moat_link_ow-0.1.1/src/moat/link/ow/task.py

@@ -0,0 +1,246 @@
+"""
+Main supervisor task for the 1-Wire (OWFS) connector.
+
+Connects to a single owserver and monitors the MoaT-Link configuration
+subtree for one server.  Attribute entries are mirrored in both
+directions:
+
+* **read** entries are polled by asyncowfs; the resulting values arrive
+  on the single :attr:`~asyncowfs.service.Service.events` stream and are
+  dispatched to their MoaT-Link destination here.
+* **write** entries get a dedicated worker that watches a MoaT-Link
+  source and forwards changes onto the bus.
+
+Per-entry write workers are spawned / cancelled as entries appear,
+change, or disappear; read polling is (re)configured whenever a device
+is located or its entry changes.
+"""
+
+from __future__ import annotations
+
+import anyio
+import logging
+
+from asyncowfs import OWFS
+from asyncowfs.event import (
+    DeviceException,
+    DeviceLocated,
+    DeviceNotFound,
+    DeviceValue,
+)
+
+from moat.util import combine_dict
+from moat.lib.path import Path
+
+from .model import OwAttr, OwServer
+from .worker import forward_read, 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
+    from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def _canon_attr(attr: Any) -> tuple[str, ...]:
+    """Canonicalise a polled attribute into a string tuple for matching.
+
+    asyncowfs reports single attributes as strings (``"temperature"``)
+    and nested ones either as slash-joined strings or as the tuple that
+    was originally passed to :meth:`~asyncowfs.device.Device.set_polling_interval`.
+    """
+    if isinstance(attr, str):
+        attr = attr.split("/")
+    return tuple(str(x) for x in attr)
+
+
+async def task(
+    link: LinkSender,
+    cfg: Mapping,
+    server_name: str,
+    *,
+    task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED,
+) -> None:
+    """Run the 1-Wire connector for one owserver.
+
+    Args:
+        link: an active MoaT-Link sender.
+        cfg: the ``link.ow`` 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", {}),
+    )
+
+    async with OWFS() as ow, anyio.create_task_group() as tg:
+        devs: dict[tuple[int, int], Any] = {}
+        entries: dict[Path, OwAttr] = {}
+        by_key: dict[tuple[int, int, tuple[str, ...]], Path] = {}
+        writers: dict[Path, anyio.CancelScope] = {}
+
+        def _fc(p: Path) -> tuple[int, int]:
+            return int(p[0]), int(p[1])
+
+        def _attr_path(p: Path) -> Path:
+            return Path.build(tuple(p)[2:])
+
+        def _key(p: Path) -> tuple[int, int, tuple[str, ...]]:
+            f, c = _fc(p)
+            return f, c, _canon_attr(tuple(p)[2:])
+
+        def _cancel_writer(p: Path) -> None:
+            sc = writers.pop(p, None)
+            if sc is not None:
+                sc.cancel()
+
+        async def _activate(p: Path, n: OwAttr) -> None:
+            """(Re)configure one entry: writer and/or polling."""
+            _cancel_writer(p)
+            entries[p] = n
+            by_key[_key(p)] = p
+
+            dev = devs.get(_fc(p))
+            if dev is None:
+                return  # device not located yet; activated on arrival
+
+            ap = _attr_path(p)
+            # Clear any stale polling from a previous incarnation.
+            try:
+                await dev.set_polling_interval(ap, 0)
+            except Exception:
+                logger.debug("Clear-poll for %s failed", p, exc_info=True)
+
+            if n.is_read:
+                intv = n.interval
+                if intv and intv > 0:
+                    try:
+                        await dev.set_polling_interval(ap, intv)
+                    except Exception as exc:
+                        logger.warning("Polling setup for %s failed: %r", p, exc)
+            elif n.is_write:
+                apw = ap
+
+                async def _run(
+                    *,
+                    task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED,
+                ) -> None:
+                    with anyio.CancelScope() as sc:
+                        writers[p] = sc
+                        task_status.started()
+                        try:
+                            await run_out(link, dev, n, apw, p)
+                        except Exception:
+                            logger.exception("Writer for %s failed", p)
+                        finally:
+                            if writers.get(p) is sc:
+                                del writers[p]
+
+                await tg.start(_run)
+
+        def _deactivate(p: Path) -> None:
+            """Tear down one entry."""
+            _cancel_writer(p)
+            n = entries.pop(p, None)
+            if n is None:
+                return
+            if by_key.get(_key(p)) is p:
+                del by_key[_key(p)]
+            if n.is_read:
+                dev = devs.get(_fc(p))
+                if dev is not None:
+                    tg.start_soon(_safe_clear_poll, dev, _attr_path(p), p)
+
+        async def _safe_clear_poll(dev: Any, ap: Path, p: Path) -> None:
+            try:
+                await dev.set_polling_interval(ap, 0)
+            except Exception:
+                logger.debug("Clear-poll for %s failed", p, exc_info=True)
+
+        async def _on_located(dev: Any) -> None:
+            key = int(dev.family), int(dev.code)
+            devs[key] = dev
+            for p, n in list(entries.items()):
+                if _fc(p) == key:
+                    await _activate(p, n)
+
+        def _on_not_found(dev: Any) -> None:
+            key = int(dev.family), int(dev.code)
+            devs.pop(key, None)
+            for p in list(writers):
+                if _fc(p) == key:
+                    _cancel_writer(p)
+
+        async def _on_value(dev: Any, attr: Any, val: Any) -> None:
+            key = int(dev.family), int(dev.code), _canon_attr(attr)
+            p = by_key.get(key)
+            if p is None:
+                return
+            n = entries.get(p)
+            if n is not None and n.is_read:
+                try:
+                    await forward_read(link, n, val)
+                except Exception as exc:
+                    logger.warning("Forward read for %s failed: %r", p, exc)
+
+        async def mon_events(*, task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED) -> None:
+            async with ow.events as events:
+                task_status.started()
+                async for msg in events:
+                    try:
+                        if isinstance(msg, DeviceValue):
+                            await _on_value(msg.device, msg.attribute, msg.value)
+                        elif isinstance(msg, DeviceLocated):
+                            await _on_located(msg.device)
+                        elif isinstance(msg, DeviceNotFound):
+                            _on_not_found(msg.device)
+                        elif isinstance(msg, DeviceException):
+                            logger.warning(
+                                "OWFS error at %s.%s: %r",
+                                msg.device,
+                                msg.attribute,
+                                msg.exception,
+                            )
+                    except Exception:
+                        logger.exception("Event processing failed for %r", msg)
+
+        # Start the event reader before adding the server so that the
+        # initial scan's device-location events are not lost.
+        await tg.start(mon_events)
+        await ow.add_server(name=server_name, **srv_cfg)
+
+        async with link.d_watch(
+            server_path,
+            subtree=True,
+            mark=True,
+            cls=OwServer,
+        ) as mon:
+            task_status.started()
+
+            async for msg in mon:
+                if msg is None:
+                    continue
+                p, _d = msg
+                if not p:
+                    continue
+
+                node = mon.nodes.get(p)
+                if isinstance(node, OwAttr) and node.is_complete():
+                    await _activate(p, node)
+                else:
+                    _deactivate(p)
+
+        tg.cancel_scope.cancel()

moat_link_ow-0.1.1/src/moat/link/ow/worker.py

@@ -0,0 +1,106 @@
+"""
+Per-attribute workers for the 1-Wire (OWFS) bus connector.
+
+The read direction (device→MoaT-Link) is driven by asyncowfs' central
+event stream and dispatched from :mod:`moat.link.ow.task`; this module
+provides :func:`forward_read`, which publishes a polled value to a
+MoaT-Link destination.
+
+The write direction (MoaT-Link→device) is implemented by :func:`run_out`,
+which watches a MoaT-Link source path and forwards changes onto the
+1-Wire bus.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from moat.util import NotGiven, attrdict
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from moat.lib.path import Path
+    from moat.link.client import LinkSender
+
+    from .model import OwAttr
+
+    from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+async def forward_read(link: LinkSender, entry: OwAttr, val: Any) -> None:
+    """Publish a polled device value to the entry's MoaT-Link destination.
+
+    If :attr:`~moat.link.ow.model.OwAttr.dest_attr` is set, the value is
+    merged into the (possibly pre-existing) dict stored at ``dest``;
+    otherwise ``dest`` is replaced wholesale.
+
+    Args:
+        link: Active MoaT-Link sender.
+        entry: Configuration entry for this attribute.
+        val: The value read from the 1-Wire device.
+    """
+    dest = entry.dest
+    if dest is None:
+        return
+    dest_attr = entry.dest_attr
+
+    if dest_attr is not None:
+        try:
+            cur = await link.d_get(dest)
+        except KeyError:
+            cur = attrdict()
+        else:
+            if not isinstance(cur, dict):
+                cur = attrdict()
+            else:
+                cur = attrdict(cur)
+        new = cur._update(dest_attr, val)  # noqa: SLF001
+        await link.d_set(dest, new)
+    else:
+        await link.d_set(dest, val)
+
+
+async def run_out(
+    link: LinkSender,
+    dev: Any,
+    entry: OwAttr,
+    attr_path: Path,
+    subpath: Path,
+) -> None:
+    """Forward MoaT-Link source updates onto a 1-Wire device attribute.
+
+    Args:
+        link: Active MoaT-Link sender.
+        dev: Located asyncowfs :class:`~asyncowfs.device.Device`.
+        entry: Configuration entry for this attribute.
+        attr_path: The device-side attribute path to write to.
+        subpath: Path of this entry relative to the server (for logging).
+    """
+    src = entry.src
+    if src is None:
+        return
+    src_attr = entry.src_attr
+
+    async with link.d_watch(src, mark=False, state=False) as wp:
+        async for val in wp:
+            if val is NotGiven:
+                continue
+            out = val
+            if src_attr is not None:
+                try:
+                    for k in src_attr:
+                        out = out[k]
+                except (KeyError, TypeError, IndexError):
+                    logger.warning(
+                        "Attribute %r missing in source value at %s",
+                        tuple(src_attr),
+                        subpath,
+                    )
+                    continue
+            try:
+                await dev.set(*attr_path, value=out)
+            except Exception as exc:
+                logger.warning("Write to %s failed: %r", subpath, exc)

moat_link_ow-0.1.1/src/moat_link_ow.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: moat-link-ow
+Version: 0.1.1
+Summary: 1-Wire (OWFS) 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: asyncowfs~=0.15
+Requires-Dist: attrs
+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
+
+# 1-Wire (OWFS) connector
+
+% start synopsis
+Connects MoaT-Link to 1-Wire buses via the asyncowfs library.
+% end synopsis
+
+% start main
+
+This module bridges MoaT-Link values and 1-Wire device attributes, in
+both directions, via the ``asyncowfs`` library.  It replaces the legacy
+``moat-kv-ow`` package.
+
+## Quick start
+
+1. Configure an OWFS server (owserver):
+
+   ```shell
+   moat link ow mybus add -h 10.0.0.1
+   ```
+
+2. Map a device attribute to a MoaT-Link path:
+
+   ```shell
+   moat link ow mybus at 10.345678.90 temperature add -s dest .data.temp.room -s interval =5
+   ```
+
+3. Run the connector:
+
+   ```shell
+   moat link ow mybus monitor
+   ```
+
+## Deprecation
+
+This package supersedes ``moat-kv-ow``.  The address tree now lives in
+MoaT-Link under the ``ow.<NAME>`` prefix; device attributes are stored
+below the server entry, keyed by family code, hardware code, and the
+attribute path.
+
+% end main

moat_link_ow-0.1.1/src/moat_link_ow.egg-info/SOURCES.txt

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

moat_link_ow-0.1.1/src/moat_link_ow.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moat_link_ow-0.1.1/src/moat_link_ow.egg-info/requires.txt

@@ -0,0 +1,7 @@
+anyio~=4.2
+asyncclick~=8.3
+asyncowfs~=0.15
+attrs
+moat-lib-config~=0.2.0
+moat-link~=0.9.0
+moat-util~=0.63.0

moat_link_ow-0.1.1/src/moat_link_ow.egg-info/top_level.txt

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

moat_link_ow-0.1.1/systemd/moat-link-ow@.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=MoaT-Link 1-Wire 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 ow %I monitor
+
+EnvironmentFile=-/etc/moat/link.env
+
+TimeoutSec=300
+WatchdogSec=10
+
+Restart=always
+RestartSec=30