moat-db-rain 0.0.1__tar.gz

moat_db_rain-0.0.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_db_rain-0.0.1/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: moat-db-rain
+Version: 0.0.1
+Summary: MoaT irrigation scheduling and monitoring
+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 :: 3 - Alpha
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: moat-util~=0.63.0
+Requires-Dist: moat-db~=0.2.7
+Requires-Dist: moat-lib-run~=0.2.0
+Requires-Dist: moat-link~=0.9.1
+Requires-Dist: asyncclick>=8.3
+Requires-Dist: anyio>=4.10
+Provides-Extra: systemd
+Requires-Dist: systemd.daemon; extra == "systemd"
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: ty; extra == "dev"
+Dynamic: license-file
+
+# MoaT-DB-Rain
+
+% start synopsis
+% start main
+
+This module provides irrigation scheduling and monitoring for MoaT,
+migrated from the legacy Django `rainman` app to a `moat.db.rain`
+SQLAlchemy + Alembic submodule. It supersedes the old `rainman` Django
+app with command-line CRUD, a scheduler engine, and a per-site
+`moat db rain <SITE> monitor` daemon.
+
+% end synopsis
+% end main

moat_db_rain-0.0.1/README.md

@@ -0,0 +1,13 @@
+# MoaT-DB-Rain
+
+% start synopsis
+% start main
+
+This module provides irrigation scheduling and monitoring for MoaT,
+migrated from the legacy Django `rainman` app to a `moat.db.rain`
+SQLAlchemy + Alembic submodule. It supersedes the old `rainman` Django
+app with command-line CRUD, a scheduler engine, and a per-site
+`moat db rain <SITE> monitor` daemon.
+
+% end synopsis
+% end main

moat_db_rain-0.0.1/debian/.gitignore

@@ -0,0 +1,8 @@
+/files
+/*.log
+/*.debhelper
+/*.debhelper-build-stamp
+/*.substvars
+/debhelper-build-stamp
+/moat-db-rain
+/moat-db-rain@.service

moat_db_rain-0.0.1/debian/changelog

@@ -0,0 +1,5 @@
+moat-db-rain (0.0.1-1) unstable; urgency=medium
+
+  * Initial creation.
+
+ -- Matthias Urlichs <matthias@urlichs.de>  Fri, 27 Jun 2026 00:00:00 +0200

moat_db_rain-0.0.1/debian/control

@@ -0,0 +1,20 @@
+Source: moat-db-rain
+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://M-o-a-T.org
+
+Package: moat-db-rain
+Architecture: all
+Depends: ${misc:Depends}, ${python3:Depends},
+  moat-db (>= 0.2.7),
+  moat-link,
+  python3-anyio (>= 4.10),
+Description: MoaT irrigation scheduling and monitoring
+  Irrigation scheduling and monitoring for MoaT, migrated from the
+  legacy Django rainman app to a moat.db.rain SQLAlchemy submodule.
+  Ships a per-site systemd monitor daemon.

moat_db_rain-0.0.1/debian/py3dist-overrides

@@ -0,0 +1,4 @@
+moat_lib_run python3-moat-lib-run
+moat_lib_config python3-moat-lib-config
+moat_db python3-moat-db
+moat_link python3-moat-link

moat_db_rain-0.0.1/debian/rules

@@ -0,0 +1,11 @@
+#!/usr/bin/make -f
+
+export PYBUILD_NAME=moat-db-rain
+%:
+	dh $@ --with python3 --buildsystem=pybuild
+
+debian/moat-db-rain@.service: moat-db-rain@.service
+	cp $< $@
+
+override_dh_auto_install: debian/moat-db-rain@.service
+	dh_auto_install

moat_db_rain-0.0.1/debian/source/format

@@ -0,0 +1 @@
+3.0 (quilt)

moat_db_rain-0.0.1/moat-db-rain@.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=MoaT irrigation monitor for %i
+After=moat-link.service
+ConditionFileNotEmpty=/etc/moat/moat.yaml
+
+[Install]
+WantedBy=multi-user.target
+
+[Service]
+Type=notify
+ExecStart=/usr/bin/moat db rain %i monitor
+EnvironmentFile=/usr/lib/moat/link/env
+EnvironmentFile=-/etc/moat/rain.env
+TimeoutSec=300
+WatchdogSec=10
+Restart=always
+RestartSec=30

moat_db_rain-0.0.1/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools", "wheel"]
+
+[project]
+name = "moat-db-rain"
+version = "0.0.1"
+description = "MoaT irrigation scheduling and monitoring"
+readme = "README.md"
+requires-python = ">=3.11"
+keywords = ["MoaT"]
+classifiers = [
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Framework :: AsyncIO",
+  "Framework :: Trio",
+  "Framework :: AnyIO",
+  "Development Status :: 3 - Alpha",
+]
+dependencies = [
+  "moat-util ~= 0.63.0",
+  "moat-db ~= 0.2.7",
+  "moat-lib-run ~= 0.2.0",
+  "moat-link ~= 0.9.1",
+  "asyncclick >= 8.3",
+  "anyio >= 4.10",
+]
+
+[[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"
+
+[project.optional-dependencies]
+systemd = ["systemd.daemon"]
+dev = ["ruff", "ty"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.yaml"]

moat_db_rain-0.0.1/setup.cfg

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

moat_db_rain-0.0.1/src/moat/db/rain/__init__.py

@@ -0,0 +1,9 @@
+"""MoaT irrigation database module."""
+
+from __future__ import annotations
+
+from moat.lib.config import CfgStore
+
+__all__ = []
+
+CfgStore.with_(__name__)

moat_db_rain-0.0.1/src/moat/db/rain/_main.py

@@ -0,0 +1,69 @@
+"""Command-line interface for moat.db.rain."""
+
+from __future__ import annotations
+
+import sys
+
+import asyncclick as click
+from sqlalchemy import select
+
+from moat.util import yprint
+from moat.db import database
+from moat.lib.run import load_subgroup
+
+from .cmds._util import site_dump
+from .model import Site
+
+#: Subcommands whose entities are **global** (not per-site) and thus
+#: accept the dummy site ``-`` in place of a real site name.
+#: Currently the day-definition and day-range registries.
+_GLOBAL_SUBCOMMANDS: frozenset[str] = frozenset({"day", "dayrange"})
+
+
+@load_subgroup(
+    sub_pre="moat.db.rain.cmds",
+    sub_post="cli",
+    ext_pre="moat.db.rain",
+    ext_post="_main.cli",
+    invoke_without_command=True,
+)
+@click.argument("site", type=str, nargs=1)
+@click.pass_context
+async def cli(ctx, site):
+    """Irrigation management.
+
+    Manage irrigation sites, controllers, valves, feeds, sensors,
+    schedules, and the monitoring daemon.  The site is named before the
+    verb — ``moat db rain <SITE> <verb>`` — mirroring ``moat link wago``.
+
+    \b
+    Use ``moat db rain -`` to list all sites.
+    Use ``moat db rain <SITE>`` (no subcommand) to show one site.
+    Use ``moat db rain - <verb>`` for global subcommands (day, dayrange)
+    that don't need a site.
+    """
+    obj = ctx.obj
+    sess = ctx.with_resource(database(obj.cfg.db))
+    ctx.with_resource(sess.begin())
+    obj.session = sess
+    obj.site_name = site
+
+    if site == "-":
+        if ctx.invoked_subcommand is None:
+            seen = False
+            with sess.execute(select(Site).order_by(Site.name)) as sites:
+                for (s,) in sites:
+                    seen = True
+                    print(s.name, file=obj.stdout)
+            if not seen:
+                print("No sites defined yet. Use '--help'?", file=sys.stderr)
+            return
+        if ctx.invoked_subcommand not in _GLOBAL_SUBCOMMANDS:
+            raise click.BadParameter(
+                f"The site '-' is a dummy for global commands only; "
+                f"'{ctx.invoked_subcommand}' needs a real site.",
+            )
+        return
+
+    if ctx.invoked_subcommand is None:
+        yprint(site_dump(sess.one(Site, name=site)), stream=obj.stdout)

moat_db_rain-0.0.1/src/moat/db/rain/cmds/__init__.py

@@ -0,0 +1,3 @@
+"""
+Sub-command processing here.
+"""

moat_db_rain-0.0.1/src/moat/db/rain/cmds/_util.py

@@ -0,0 +1,238 @@
+"""Shared helpers for the ``moat db rain`` subcommands.
+
+This module's name starts with ``_`` so the subcommand loader (which
+skips underscore-prefixed modules) never exposes it as a command.
+"""
+
+from __future__ import annotations
+
+import sys
+from contextlib import contextmanager
+from datetime import datetime
+
+import asyncclick as click
+from sqlalchemy import select
+
+from moat.util import NotGiven
+from moat.db.rain.model import Controller, Site, Valve
+from moat.lib.run import option_ng
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from typing import Any
+
+
+#: Seconds per day — scales the site evaporation ``rate`` between its
+#: stored unit (mm/second) and the CLI unit (mm/day).
+SECS_PER_DAY: int = 24 * 3600
+
+
+def site_of(obj):
+    """Resolve the currently-selected site (``obj.site_name``) to a row.
+
+    Raises:
+        click.UsageError: if the named site does not exist.
+    """
+    try:
+        return obj.session.one(Site, name=obj.site_name)
+    except KeyError:
+        raise click.UsageError(f"Site {obj.site_name!r} doesn't exist.") from None
+
+
+def scale_site_rate(kw: dict[str, Any]) -> None:
+    """Convert a CLI ``rate`` (mm/day) in ``kw`` to the stored mm/second.
+
+    Mutates ``kw`` in place: if a ``rate`` was supplied (i.e. not
+    :data:`~moat.util.NotGiven`), it is divided by :data:`SECS_PER_DAY`.
+    The stored :attr:`Site.rate` column is in mm/second; the CLI accepts
+    mm/day, so the command layer scales before :meth:`~Base.apply`.
+    """
+    if is_given(kw.get("rate", NotGiven)):
+        kw["rate"] = kw["rate"] / SECS_PER_DAY
+
+
+def site_dump(site: Site) -> dict[str, Any]:
+    """Dump a site for the CLI, presenting ``rate`` in mm/day.
+
+    The stored :attr:`Site.rate` is mm/second; the CLI shows mm/day, so
+    the dumped value is multiplied by :data:`SECS_PER_DAY`.
+    """
+    res = site.dump()
+    if "rate" in res:
+        res["rate"] = res["rate"] * SECS_PER_DAY
+    return res
+
+
+def require_name(obj, what: str) -> str:
+    """Return ``obj.name`` or raise a usage error.
+
+    Args:
+        obj: The click object carrying the selected entity name.
+        what: Human-readable entity name for the error message.
+    """
+    name = obj.name
+    if name is None:
+        raise click.UsageError(f"The {what} needs a name. Use '--name'.")
+    return name
+
+
+def get_one(obj, model, what: str, **kw):
+    """Fetch a single ``model`` row matching ``kw`` or raise.
+
+    Args:
+        obj: The click object carrying the session.
+        model: The mapped class to query.
+        what: Human-readable entity name for the error message.
+        **kw: Filter keyword arguments forwarded to :meth:`Mgr.one`.
+
+    Raises:
+        click.UsageError: if no row matches.
+    """
+    try:
+        return obj.session.one(model, **kw)
+    except KeyError:
+        raise click.UsageError(f"This {what} doesn't exist.") from None
+
+
+def absent(obj, model, what: str, **kw) -> None:
+    """Raise if a ``model`` row matching ``kw`` already exists.
+
+    Args:
+        obj: The click object carrying the session.
+        model: The mapped class to query.
+        what: Human-readable entity name for the error message.
+        **kw: Filter keyword arguments forwarded to :meth:`Mgr.one`.
+
+    Raises:
+        click.UsageError: if a matching row exists.
+    """
+    try:
+        obj.session.one(model, **kw)
+    except KeyError:
+        return
+    raise click.UsageError(f"This {what} already exists.") from None
+
+
+def list_in_site(obj, model):
+    """Iterate the rows of ``model`` belonging to the selected site."""
+    site = site_of(obj)
+    with obj.session.execute(select(model).where(model.site == site).order_by(model.name)) as rs:
+        for (row,) in rs:
+            yield row
+
+
+def list_global(obj, model):
+    """Iterate every row of ``model`` (for globally-scoped entities).
+
+    Args:
+        obj: The click object carrying the session.
+        model: The mapped class to query; must have a ``name`` column.
+    """
+    with obj.session.execute(select(model).order_by(model.name)) as rs:
+        for (row,) in rs:
+            yield row
+
+
+def valve_spec(obj, spec: str):
+    """Resolve a ``controller:name`` valve spec to a :class:`Valve` row.
+
+    Args:
+        obj: The click object carrying the session and site name.
+        spec: A ``controller:name`` string identifying the valve.
+
+    Raises:
+        click.UsageError: if the spec is malformed or the valve is absent.
+    """
+    try:
+        ctrl_name, vname = spec.split(":", 1)
+    except ValueError:
+        raise click.UsageError(f"Bad valve spec {spec!r}; use 'controller:name'.") from None
+    ctrl = get_one(obj, Controller, "controller", site=site_of(obj), name=ctrl_name)
+    return get_one(obj, Valve, "valve", controller=ctrl, name=vname)
+
+
+def is_given(v) -> bool:
+    """True unless ``v`` is the ``NotGiven`` sentinel."""
+    return v is not NotGiven
+
+
+def parse_dt(s: str) -> datetime:
+    """Parse an ISO-8601 timestamp, forcing timezone awareness.
+
+    Naive timestamps are interpreted in the local timezone, matching the
+    repo-wide convention of tz-aware datetimes everywhere.
+
+    Raises:
+        click.UsageError: if ``s`` is not a parseable timestamp.
+    """
+    try:
+        dt = datetime.fromisoformat(s)
+    except ValueError:
+        raise click.UsageError(f"Bad timestamp {s!r}.") from None
+    if dt.tzinfo is None:
+        dt = dt.astimezone()
+    return dt
+
+
+@contextmanager
+def lookup_errors() -> Iterator[None]:
+    """Translate :class:`Mgr.one` lookup failures into a :class:`UsageError`.
+
+    ``apply()`` methods resolve parents and link targets by name via
+    ``sess.one(Model, ...)``; a miss raises a bare ``KeyError``. This wraps
+    such calls so the CLI surfaces a readable error instead of a traceback.
+    """
+    try:
+        yield
+    except KeyError as e:
+        model, kw = e.args[0], e.args[1]
+        name = kw.get("name")
+        if name is not None:
+            raise click.UsageError(f"{model.lower()} {name!r} doesn't exist.") from None
+        raise click.UsageError(f"This {model.lower()} doesn't exist.") from None
+
+
+def bool_pair(set_flag: bool, clr_flag: bool, key: str) -> dict:
+    """Translate two mutually-exclusive set/clear flags into an apply arg.
+
+    Args:
+        set_flag: True if the "set" flag was passed.
+        clr_flag: True if the "clear" flag was passed.
+        key: The column name to set.
+
+    Returns:
+        ``{key: True}``, ``{key: False}``, or ``{}`` if neither flag was given.
+
+    Raises:
+        click.UsageError: if both flags were passed at once.
+    """
+    if set_flag and clr_flag:
+        raise click.UsageError(f"--{key} and --no-{key} are mutually exclusive.")
+    if set_flag:
+        return {key: True}
+    if clr_flag:
+        return {key: False}
+    return {}
+
+
+def site_opts(c):
+    """Decorator: the scalar options of a :class:`Site`."""
+    c = option_ng("--name", "-n", type=str, help="Rename this site")(c)
+    c = option_ng("--comment", "-c", type=str, help="Free-form description")(c)
+    c = option_ng("--rate", "-r", "rate", type=float, help="Evaporation rate (mm/day)")(c)
+    c = option_ng("--rain-delay", "-d", "rain_delay", type=int, help="Pause after rain (seconds)")(
+        c
+    )
+    return c
+
+
+def emit_log(msg: str) -> None:
+    """Print a scheduler event line to stderr (the ``--verbose`` sink).
+
+    The engine's ``log`` callback is a plain ``Callable[[str], None]``;
+    the CLI wires ``--verbose`` to this printer so ``gen`` / ``recalc``
+    narrate their decisions without polluting the YAML result on stdout.
+    """
+    print(msg, file=sys.stderr)

moat_db_rain-0.0.1/src/moat/db/rain/cmds/add.py

@@ -0,0 +1,25 @@
+"""Create an irrigation site: ``moat db rain <SITE> add``."""
+
+from __future__ import annotations
+
+import asyncclick as click
+
+from moat.util import yprint
+from moat.db.rain.model import Site
+
+from ._util import absent, scale_site_rate, site_dump, site_opts
+
+
+@click.command()
+@site_opts
+@click.pass_obj
+async def cli(obj, **kw):
+    """Create an irrigation site."""
+    name = obj.site_name
+    absent(obj, Site, "site", name=name)
+    site = Site(name=name)
+    obj.session.add(site)
+    scale_site_rate(kw)
+    site.apply(**kw)
+    obj.session.flush()
+    yprint(site_dump(site), stream=obj.stdout)

moat_db_rain-0.0.1/src/moat/db/rain/cmds/controller.py

@@ -0,0 +1,86 @@
+"""Command-line interface for irrigation controllers.
+
+``moat db rain <SITE> controller {show,add,set,delete}``
+"""
+
+from __future__ import annotations
+
+import sys
+
+import asyncclick as click
+
+from moat.util import yprint
+from moat.db.rain.model import Controller
+from moat.lib.run import option_ng
+
+from ._util import absent, get_one, is_given, list_in_site, require_name, site_of
+
+
+@click.group(name="controller", short_help="Manage irrigation controllers")
+@click.option("--name", "-n", type=str, default=None, help="Controller name")
+@click.pass_obj
+async def cli(obj, name):
+    """Manage irrigation controllers."""
+    obj.name = name
+
+
+def opts(c):
+    """Scalar options of a :class:`Controller`."""
+    c = option_ng("--name", "-n", type=str, help="Rename this controller")(c)
+    c = option_ng("--comment", "-c", type=str, help="Free-form description")(c)
+    c = option_ng("--location", "-l", type=str, help="Where the controller lives")(c)
+    c = option_ng("--max-on", "-m", "max_on", type=int, help="Max simultaneously-open valves")(c)
+    return c
+
+
+@cli.command(name="show")
+@click.pass_obj
+async def show_(obj):
+    """Show one controller, or list all controllers in this site."""
+    if obj.name is None:
+        seen = False
+        for c in list_in_site(obj, Controller):
+            seen = True
+            print(c.name, file=obj.stdout)
+        if not seen:
+            print("No controllers defined yet. Use '--help'?", file=sys.stderr)
+        return
+    c = get_one(obj, Controller, "controller", site=site_of(obj), name=obj.name)
+    yprint(c.dump(), stream=obj.stdout)
+
+
+@cli.command()
+@opts
+@click.pass_obj
+async def add(obj, **kw):
+    """Add a controller to this site."""
+    name = require_name(obj, "controller")
+    if not is_given(kw.get("location", ...)):
+        raise click.UsageError("A controller needs --location.")
+    absent(obj, Controller, "controller", site=site_of(obj), name=name)
+    c = Controller(name=name)
+    obj.session.add(c)
+    c.apply(site=obj.site_name, **kw)
+    obj.session.flush()
+    yprint(c.dump(), stream=obj.stdout)
+
+
+@cli.command(name="set")
+@opts
+@click.pass_obj
+async def set_(obj, **kw):
+    """Modify a controller."""
+    name = require_name(obj, "controller")
+    c = get_one(obj, Controller, "controller", site=site_of(obj), name=name)
+    c.apply(site=obj.site_name, **kw)
+    obj.session.flush()
+    yprint(c.dump(), stream=obj.stdout)
+
+
+@cli.command(name="delete")
+@click.pass_obj
+async def delete_(obj):
+    """Remove a controller (and its valves)."""
+    name = require_name(obj, "controller")
+    c = get_one(obj, Controller, "controller", site=site_of(obj), name=name)
+    obj.session.delete(c)