moat-kv-cal 0.1.2__py3-none-any.whl

moat/kv/cal/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

moat/kv/cal/_cfg.yaml

@@ -0,0 +1,2 @@
+prefix: !P calendar
+poll: 1200

moat/kv/cal/_main.py

@@ -0,0 +1,266 @@
+# command line interface
+from __future__ import annotations
+
+import asyncclick as click
+from functools import partial
+from moat.util import P, Path
+from moat.kv.data import data_get
+from .model import CalRoot
+from .util import find_next_alarm
+from datetime import datetime, timezone, timedelta
+import pytz
+
+import anyio
+import aiocaldav as caldav
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+utc = timezone.utc
+now = partial(datetime.now, utc)
+
+
+@click.group(short_help="Manage calendar polling.")
+@click.pass_obj
+async def cli(obj):
+    """
+    List known calendars and poll them.
+    """
+    obj.data = await CalRoot.as_handler(obj.client)
+
+
+@cli.command("run")
+@click.pass_obj
+async def run_(obj):
+    """Process calendar alarms"""
+    from moat.kv.client import client_scope
+
+    kv = await client_scope(**obj.cfg.kv)
+    cal_cfg = (await kv.get(P("calendar.test"))).value
+    try:
+        tz = pytz.timezone(cal_cfg["zone"])
+    except KeyError:
+        tz = utc
+    else:
+        now = partial(datetime.now, tz)
+
+    try:
+        t_scan = datetime.fromtimestamp(cal_cfg["scan"], utc)
+    except KeyError:
+        t_scan = now()
+    interval = timedelta(0, cal_cfg.get("interval", 1800))
+
+    try:
+        t_al = await kv.get(cal_cfg["dst"])
+    except KeyError:
+        t_al = now()
+    else:
+        t_al = datetime.fromtimestamp(t_al.value["time"], tz)
+
+    async with caldav.DAVClient(
+        url=cal_cfg["url"],
+        username=cal_cfg["user"],
+        password=cal_cfg["pass"],
+    ) as client:
+        principal = await client.principal()
+        calendar = await principal.calendar(name="privat neu")
+        while True:
+            t_now = now()
+            if t_now < t_scan:
+                await anyio.sleep((t_scan - t_now).total_seconds())
+                cal_cfg = (await kv.get(P("calendar.test"))).value
+                cal_cfg["scan"] = t_scan.timestamp()
+                await kv.set(P("calendar.test"), value=cal_cfg)
+                t_now = t_scan
+
+            logger.info("Scan %s", t_scan)
+            ev, v, ev_t = await find_next_alarm(calendar, zone=tz, now=t_scan)
+            t_scan += interval
+            t_scan = max(t_now, t_scan).astimezone(tz)
+
+            if ev is None:
+                logger.warning("NO EVT")
+                continue
+            if evt <= t_now:
+                if t_al != ev_t:
+                    # set alarm message
+                    logger.warning("ALARM %s %s", v.summary.value, ev_t)
+                    await kv.set(
+                        cal_cfg["dst"],
+                        value=dict(time=int(ev_t.timestamp()), info=v.summary.value),
+                    )
+                    t_al = ev_t
+                    t_scan = t_now + timedelta(0, cal_cfg.get("interval", 1800) / 3)
+            elif ev_t < t_scan:
+                t_scan = ev_t
+                logger.warning("ScanEarly %s", t_scan)
+            else:
+                logger.warning("ScanLate %s", t_scan)
+
+
+@cli.command("list")
+@click.pass_obj
+async def list_(obj):
+    """Emit the current state as a YAML file."""
+    prefix = obj.cfg.kv.cal.prefix
+    path = Path()
+
+    def pm(p):
+        if len(p) == 0:
+            return p
+        elif not isinstance(p[0], int):
+            return None
+        elif len(p) == 1:
+            return Path("%02x" % p[0])
+        else:
+            return Path("%02x.%12x" % (p[0], p[1])) + p[2:]
+
+    if obj.meta:
+
+        def pm(p):
+            return Path(str(prefix + path)) + p
+
+    await data_get(obj, prefix + path, as_dict="_", path_mangle=pm)
+
+
+# @cli.command("attr", help="Mirror a device attribute to/from MoaT-KV")
+# @click.option("-d", "--device", help="Device to access.")
+# @click.option("-f", "--family", help="Device family to modify.")
+# @click.option("-i", "--interval", type=float, help="read value every N seconds")
+# @click.option("-w", "--write", is_flag=True, help="Write to the device")
+# @click.option("-a", "--attr", "attr_", help="The node's attribute to use", default=":")
+# @click.argument("attr", nargs=1)
+# @click.argument("path", nargs=1)
+# @click.pass_obj
+# async def attr__(obj, device, family, write, attr, interval, path, attr_):
+#    """Show/add/modify an entry to repeatedly read an 1wire device's attribute.
+#
+#    You can only set an interval, not a path, on family codes.
+#    A path of '-' deletes the entry.
+#    If you set neither interval nor path, reports the current
+#    values.
+#    """
+#    path = P(path)
+#    prefix = obj.cfg.kv.cal.prefix
+#    if (device is not None) + (family is not None) != 1:
+#        raise click.UsageError("Either family or device code must be given")
+#    if interval and write:
+#        raise click.UsageError("Writing isn't polled")
+#
+#    remove = False
+#    if len(path) == 1 and path[0] == "-":
+#        path = ()
+#        remove = True
+#
+#    if family:
+#        if path:
+#            raise click.UsageError("You cannot set a per-family path")
+#        fd = (int(family, 16),)
+#    else:
+#        f, d = device.split(".", 2)[0:2]
+#        fd = (int(f, 16), int(d, 16))
+#
+#    attr = P(attr)
+#    attr_ = P(attr_)
+#    if remove:
+#        res = await obj.client.delete(prefix + fd + attr)
+#    else:
+#        val = dict()
+#        if path:
+#            val["src" if write else "dest"] = path
+#        if interval:
+#            val["interval"] = interval
+#        if len(attr_):
+#            val["src_attr" if write else "dest_attr"] = attr_
+#
+#        res = await obj.client.set(prefix + fd + attr, value=val)
+#
+#    if res is not None and obj.meta:
+#        yprint(res, stream=obj.stdout)
+#
+#
+# @cli.command("set")
+# @click.option("-d", "--device", help="Device to modify.")
+# @click.option("-f", "--family", help="Device family to modify.")
+# @attr_args
+# @click.argument("subpath", nargs=1, type=P, default=P(":"))
+# @click.pass_obj
+# async def set_(obj, device, family, subpath, **kw):
+#    """Set or delete some random attribute.
+#
+#    For deletion, use '-e ATTR -'.
+#    """
+#    if (device is not None) + (family is not None) != 1:
+#        raise click.UsageError("Either family or device code must be given")
+#
+#    if family:
+#        fd = (int(family, 16),)
+#        if len(subpath):
+#            raise click.UsageError("You can't use a subpath here.")
+#    else:
+#        f, d = device.split(".", 2)[0:2]
+#        fd = (int(f, 16), int(d, 16))
+#
+#    res = await node_attr(obj, obj.cfg.kv.cal.prefix + fd + subpath, **kw)
+#    if res and obj.meta:
+#        yprint(res, stream=obj.stdout)
+#
+#
+# @cli.command("server")
+# @click.option("-h", "--host", help="Host name of this server.")
+# @click.option("-p", "--port", help="Port of this server.")
+# @click.option("-d", "--delete", is_flag=True, help="Delete this server.")
+# @click.argument("name", nargs=-1)
+# @click.pass_obj
+# async def server_(obj, name, host, port, delete):
+#    """
+#    Configure a server.
+#
+#    No arguments: list them.
+#    """
+#    prefix = obj.cfg.kv.cal.prefix
+#    if not name:
+#        if host or port or delete:
+#            raise click.UsageError("Use a server name to set parameters")
+#        async for r in obj.client.get_tree(
+#            prefix | "server", min_depth=1, max_depth=1
+#        ):
+#            print(r.path[-1], file=obj.stdout)
+#        return
+#    elif len(name) > 1:
+#        raise click.UsageError("Only one server allowed")
+#    name = name[0]
+#    if host or port:
+#        if delete:
+#            raise click.UsageError("You can't delete and set at the same time.")
+#        value = attrdict()
+#        if host:
+#            value.host = host
+#        if port:
+#            if port == "-":
+#                value.port = NotGiven
+#            else:
+#                value.port = int(port)
+#    elif delete:
+#        res = await obj.client.delete_tree(prefix | "server" | name, nchain=obj.meta)
+#        if obj.meta:
+#            yprint(res, stream=obj.stdout)
+#        return
+#    else:
+#        value = None
+#    res = await node_attr(
+#        obj, prefix | "server" | name, ((P("server"), value),),(),())
+#    if res and obj.meta:
+#        yprint(res, stream=obj.stdout)
+#
+#
+# @cli.command()
+# @click.pass_obj
+# @click.argument("server", nargs=-1)
+# async def monitor(obj, server):
+#    """Stand-alone task to monitor one or more OWFS servers."""
+#    from .task import task
+#
+#    async with as_service(obj) as srv:
+#        await task(obj.client, obj.cfg, server, srv)

moat/kv/cal/model.py

@@ -0,0 +1,94 @@
+"""
+Moat-KV client data model for calendars
+"""
+
+from __future__ import annotations
+
+
+from moat.kv.obj import ClientEntry, ClientRoot, AttrClientEntry
+from moat.kv.errors import ErrorRoot
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class CalAlarm(AttrClientEntry):
+    """
+    An alarm handler. ``True`` is sent to @cmd. If @state doesn't follow
+    within @timeout (default ten) seconds, raise an alarm and skip the
+    delay. Otherwise go to the next entry.
+
+    @src if set overrides the acknowledge source of the calendar.
+    """
+
+    ATTRS = ("cmd", "state", "delay", "src", "timeout")
+
+    cls = ClientEntry
+
+
+class CalEntry(AttrClientEntry):
+    """
+    A calendar entry to be monitored specifically (usually recurring).
+
+    The entry's name is the UUID in the parent calendar.
+
+    Summary+start+duration are updated from the calendar when it changes.
+    @alarms, if set, modify when the entry's alarm sequence should trigger.
+    @src if set overrides the acknowledge source of the calendar.
+    """
+
+    ATTRS = ("summary", "start", "duration", "alarms", "src")
+
+    @classmethod
+    def child_type(cls, name):
+        if isinstance(name, int):
+            return CalAlarm
+        return ClientEntry
+
+
+class CalBase(AttrClientEntry):
+    """
+    A monitored calendar. Every @freq seconds the CalDAV server at @url
+    is queried for events during the next @days. They are published
+    to @dst/UUID as records with summary/start/duration/alarmtime(s)/UID.
+
+    @dst gets the same data, but for the next-most alarm time.
+    @src is the signal that the alarm has been acknowledged.
+    """
+
+    ATTRS = ("url", "username", "password", "freq", "days", "dst", "src")
+
+    @classmethod
+    def child_type(cls, name):
+        if isinstance(name, int):
+            return CalAlarm
+        return CalEntry
+
+
+class CalRoot(ClientRoot):
+    cls = {}
+    reg = {}
+    CFG = "cal"
+    err = None
+
+    async def run_starting(self):
+        if self.err is None:
+            self.err = await ErrorRoot.as_handler(self.client)
+        await super().run_starting()
+
+    @property
+    def server(self):
+        return self["server"]
+
+    @classmethod
+    def register(cls, typ):
+        def acc(kls):
+            cls.reg[typ] = kls
+            return kls
+
+        return acc
+
+    @classmethod
+    def child_type(kls, name):
+        return CalBase

moat/kv/cal/util.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone, date, time
+from dateutil.rrule import rrulestr
+from vobject.icalendar import VAlarm, VEvent
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+async def find_next_alarm(calendar, future=10, now=None, zone=timezone.utc) -> Tuple(
+    VAlarm,
+    datetime,
+):
+    """
+    fetch the next alarm in the current calendar
+
+    returns an (event, alarm_time) tuple
+    """
+    ## It should theoretically be possible to find both the events and
+    ## tasks in one calendar query, but not all server implementations
+    ## supports it, hence either event, todo or journal should be set
+    ## to True when searching.  Here is a date search for events, with
+    ## expand:
+    events_fetched = await calendar.search(
+        start=datetime.now(),
+        end=datetime.now() + timedelta(days=future),
+        event=True,
+        expand=False,
+    )
+
+    if now is None:
+        now = datetime.now(timezone.utc)
+    ev = None
+    ev_v = None
+    ev_t = None
+
+    for e in events_fetched:
+        vx = None
+        vx_t = None
+        rids = set()
+        # create a list of superseded events
+        for v in e.vobject_instance.components():
+            if v.behavior is not VEvent:
+                continue
+            try:
+                rid = v.recurrence_id
+            except AttributeError:
+                continue
+            else:
+                rids.add(rid.value)
+
+        # find earliest event, skipping superseded ones
+        for v in e.vobject_instance.components():
+            if v.behavior is not VEvent:
+                continue
+            try:
+                rid = v.recurrence_id
+            except AttributeError:
+                rid = None
+
+            t_start = next_start(v, now)
+            if t_start is None:
+                raise ValueError("Start time: ??")
+                # t_start = next_start(v, now)
+            if not t_start.tzinfo:
+                t_start = t_start.astimezone(zone)
+            if rid is None and t_start in rids:
+                continue
+
+            if vx is None or t_start < vx_t:
+                vx, vx_t = v, t_start
+
+        for al in vx.components():
+            if al.behavior is not VAlarm:
+                continue
+            if not al.useBegin:
+                continue
+            if isinstance(t_start, date) and not isinstance(t_start, datetime):
+                t_start = datetime.combine(t_start, time(0), tzinfo=zone)
+                # XXX TODO count back from the current timezone's midnight
+
+            t_al = t_start + al.trigger.value
+            if t_al < now:
+                continue
+            if ev is None or ev_t > t_al:
+                ev, ev_v, ev_t = e, vx, t_al
+    if ev:
+        logger.warning("Next alarm: %s at %s", ev.vobject_instance.vevent.summary.value, ev_t)
+    return ev, ev_v, ev_t
+
+
+def next_start(v, now):
+    st = v.dtstart.value
+    try:
+        rule = rrulestr(v.rrule.value, dtstart=st)
+    except AttributeError:
+        pass
+    else:
+        excl = set()
+        for edt in v.contents.get("exdate", ()):
+            for ed in edt.value:
+                excl.add(ed)
+
+        st = rule.after(now, inc=True)
+        while st in excl:
+            st = rule.after(edt, inc=False)
+
+        for edt in v.contents.get("rdate", ()):
+            for ed in edt.value:
+                if now <= ed.value < st:
+                    st = ed.value
+
+    return st

moat_kv_cal-0.1.2.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: moat-kv-cal
+Version: 0.1.2
+Summary: Calendar management for MoaT-KV
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Information Technology
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: moat-kv~=0.70.23
+Requires-Dist: moat-util~=0.56.4
+Requires-Dist: aiocaldav
+Dynamic: license-file
+
+===========
+MoaT-KV-Cal
+===========
+
+MoaT-KV-Cal is a calendar extension to MoaT-KV.
+
+It can monitor a calendar (or specific entries thereof), publish pending
+entries, set alerts, control that they are acknowledged, and escalate
+if/when they are not.
+

moat_kv_cal-0.1.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+moat/kv/cal/__init__.py,sha256=ZBoFcXbv35djD599Vo_PKTqDjvQXYYXTcPUs5RcQZrs,101
+moat/kv/cal/_cfg.yaml,sha256=UrczyUBlF7NIPt26pUu0CFdM67xC5TcPmSoVrg79tyQ,31
+moat/kv/cal/_main.py,sha256=VN_Dn3Oz25HZIWYBZQvXb_P3Yh2rtHSADUBCLoudL0k,8356
+moat/kv/cal/model.py,sha256=-n0yMEYImoHVDuNWibFJ4-LIpYsx3SmCo6hmAc8rsZU,2355
+moat/kv/cal/util.py,sha256=zPuj6zlAug2Q6GS8K0_Zd1k6A_Ci3hK4SkRg8yQ4QFg,3445
+moat_kv_cal-0.1.2.dist-info/licenses/LICENSE.txt,sha256=L5vKJLVOg5t0CEEPpW9-O_0vzbP0PEjEF06tLvnIDuk,541
+moat_kv_cal-0.1.2.dist-info/METADATA,sha256=6w2eC98kQbfUEut6cBSWtxy0I2zTLckpX6RZc1N767Q,929
+moat_kv_cal-0.1.2.dist-info/WHEEL,sha256=xcaH6rP_nCxh1LBIPM7Q0uOnzSGjsIye-Q44j_zbzw8,104
+moat_kv_cal-0.1.2.dist-info/top_level.txt,sha256=pcs9fl5w5AB5GVi4SvBqIVmFrkRwQkVw_dEvW0Q0cSA,5
+moat_kv_cal-0.1.2.dist-info/RECORD,,

moat_kv_cal-0.1.2.dist-info/WHEEL

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

moat_kv_cal-0.1.2.dist-info/licenses/LICENSE.txt

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

moat_kv_cal-0.1.2.dist-info/top_level.txt

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