f888faf2bd
Calendar reminders use bot.state (SQLite KV) for persistence across restarts. Supports one-shot at specific date/time and yearly recurring reminders with leap day handling. Restored automatically on connect via 001 event handler. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
508 lines
18 KiB
Python
508 lines
18 KiB
Python
"""Plugin: one-shot, repeating, and calendar-based reminders."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import calendar
|
|
import hashlib
|
|
import json
|
|
import re
|
|
import time
|
|
from datetime import date, datetime, timezone
|
|
from zoneinfo import ZoneInfo
|
|
|
|
from derp.plugin import command, event
|
|
|
|
_DURATION_RE = re.compile(r"(?:(\d+)d)?(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$")
|
|
_DATE_RE = re.compile(r"^(\d{4})-(\d{2})-(\d{2})$")
|
|
_TIME_RE = re.compile(r"^(\d{2}):(\d{2})$")
|
|
|
|
|
|
def _make_id(nick: str, label: str) -> str:
|
|
"""Generate a short hex ID from nick + label + timestamp."""
|
|
raw = f"{nick}:{label}:{time.monotonic()}".encode()
|
|
return hashlib.sha256(raw).hexdigest()[:6]
|
|
|
|
|
|
def _parse_duration(spec: str) -> int | None:
|
|
"""Parse a duration like '5m', '1h30m', '2d', '90s', or raw seconds."""
|
|
try:
|
|
secs = int(spec)
|
|
return secs if secs > 0 else None
|
|
except ValueError:
|
|
pass
|
|
m = _DURATION_RE.match(spec.lower())
|
|
if not m or not any(m.groups()):
|
|
return None
|
|
days = int(m.group(1) or 0)
|
|
hours = int(m.group(2) or 0)
|
|
mins = int(m.group(3) or 0)
|
|
secs = int(m.group(4) or 0)
|
|
total = days * 86400 + hours * 3600 + mins * 60 + secs
|
|
return total if total > 0 else None
|
|
|
|
|
|
def _format_duration(secs: int) -> str:
|
|
"""Format seconds into compact duration."""
|
|
parts = []
|
|
if secs >= 86400:
|
|
parts.append(f"{secs // 86400}d")
|
|
secs %= 86400
|
|
if secs >= 3600:
|
|
parts.append(f"{secs // 3600}h")
|
|
secs %= 3600
|
|
if secs >= 60:
|
|
parts.append(f"{secs // 60}m")
|
|
secs %= 60
|
|
if secs or not parts:
|
|
parts.append(f"{secs}s")
|
|
return "".join(parts)
|
|
|
|
|
|
# ---- Calendar helpers -------------------------------------------------------
|
|
|
|
def _get_tz(bot) -> ZoneInfo:
|
|
"""Get configured timezone, default UTC."""
|
|
name = bot.config.get("bot", {}).get("timezone", "UTC")
|
|
try:
|
|
return ZoneInfo(name)
|
|
except (KeyError, Exception):
|
|
return ZoneInfo("UTC")
|
|
|
|
|
|
def _parse_date(spec: str) -> date | None:
|
|
"""Parse YYYY-MM-DD into a date, or None."""
|
|
m = _DATE_RE.match(spec)
|
|
if not m:
|
|
return None
|
|
try:
|
|
return date(int(m.group(1)), int(m.group(2)), int(m.group(3)))
|
|
except ValueError:
|
|
return None
|
|
|
|
|
|
def _parse_time(spec: str) -> tuple[int, int] | None:
|
|
"""Parse HH:MM into (hour, minute), or None."""
|
|
m = _TIME_RE.match(spec)
|
|
if not m:
|
|
return None
|
|
h, mi = int(m.group(1)), int(m.group(2))
|
|
if h > 23 or mi > 59:
|
|
return None
|
|
return (h, mi)
|
|
|
|
|
|
def _next_yearly(month: int, day: int, hour: int, minute: int,
|
|
tz: ZoneInfo) -> datetime:
|
|
"""Calculate the next occurrence of a yearly date as aware datetime."""
|
|
now = datetime.now(tz)
|
|
year = now.year
|
|
clamped_day = min(day, calendar.monthrange(year, month)[1])
|
|
candidate = datetime(year, month, clamped_day, hour, minute, tzinfo=tz)
|
|
if candidate <= now:
|
|
year += 1
|
|
clamped_day = min(day, calendar.monthrange(year, month)[1])
|
|
candidate = datetime(year, month, clamped_day, hour, minute, tzinfo=tz)
|
|
return candidate
|
|
|
|
|
|
# ---- Persistence helpers ----------------------------------------------------
|
|
|
|
def _save(bot, rid: str, data: dict) -> None:
|
|
"""Persist a calendar reminder to bot.state."""
|
|
bot.state.set("remind", rid, json.dumps(data))
|
|
|
|
|
|
def _delete_saved(bot, rid: str) -> None:
|
|
"""Remove a calendar reminder from bot.state."""
|
|
bot.state.delete("remind", rid)
|
|
|
|
|
|
# ---- In-memory tracking -----------------------------------------------------
|
|
|
|
# {rid: (task, target, nick, label, created, repeating)}
|
|
_reminders: dict[str, tuple[asyncio.Task, str, str, str, str, bool]] = {}
|
|
# Reverse lookup: (target, nick) -> [rid, ...]
|
|
_by_user: dict[tuple[str, str], list[str]] = {}
|
|
# Calendar-based rids (persisted)
|
|
_calendar: set[str] = set()
|
|
|
|
|
|
def _cleanup(rid: str, target: str, nick: str) -> None:
|
|
"""Remove a reminder from tracking structures."""
|
|
_reminders.pop(rid, None)
|
|
_calendar.discard(rid)
|
|
ukey = (target, nick)
|
|
if ukey in _by_user:
|
|
_by_user[ukey] = [r for r in _by_user[ukey] if r != rid]
|
|
if not _by_user[ukey]:
|
|
del _by_user[ukey]
|
|
|
|
|
|
def _track(rid: str, task: asyncio.Task, target: str, nick: str,
|
|
label: str, created: str, repeating: bool) -> None:
|
|
"""Add a reminder to in-memory tracking."""
|
|
_reminders[rid] = (task, target, nick, label, created, repeating)
|
|
_by_user.setdefault((target, nick), []).append(rid)
|
|
|
|
|
|
# ---- Coroutines -------------------------------------------------------------
|
|
|
|
async def _remind_once(bot, rid: str, target: str, nick: str, label: str,
|
|
duration: int, created: str) -> None:
|
|
"""One-shot reminder: sleep, fire, clean up."""
|
|
try:
|
|
await asyncio.sleep(duration)
|
|
await bot.send(target, f"{nick}: reminder #{rid} (set {created})")
|
|
if label:
|
|
await bot.send(target, label)
|
|
except asyncio.CancelledError:
|
|
pass
|
|
finally:
|
|
_cleanup(rid, target, nick)
|
|
|
|
|
|
async def _remind_repeat(bot, rid: str, target: str, nick: str, label: str,
|
|
interval: int, created: str) -> None:
|
|
"""Repeating reminder: fire every interval until cancelled."""
|
|
try:
|
|
while True:
|
|
await asyncio.sleep(interval)
|
|
await bot.send(target, f"{nick}: reminder #{rid} (every {_format_duration(interval)})")
|
|
if label:
|
|
await bot.send(target, label)
|
|
except asyncio.CancelledError:
|
|
pass
|
|
finally:
|
|
_cleanup(rid, target, nick)
|
|
|
|
|
|
async def _schedule_at(bot, rid: str, target: str, nick: str, label: str,
|
|
fire_dt: datetime, created: str) -> None:
|
|
"""One-shot calendar reminder: sleep until fire_dt, send, delete."""
|
|
try:
|
|
now = datetime.now(timezone.utc)
|
|
delta = max(0, (fire_dt - now).total_seconds())
|
|
await asyncio.sleep(delta)
|
|
await bot.send(target, f"{nick}: reminder #{rid} (set {created})")
|
|
if label:
|
|
await bot.send(target, label)
|
|
_delete_saved(bot, rid)
|
|
except asyncio.CancelledError:
|
|
pass
|
|
finally:
|
|
_cleanup(rid, target, nick)
|
|
|
|
|
|
async def _schedule_yearly(bot, rid: str, target: str, nick: str,
|
|
label: str, fire_dt: datetime, month: int,
|
|
day: int, hour: int, minute: int,
|
|
tz: ZoneInfo, created: str) -> None:
|
|
"""Yearly recurring reminder: fire, compute next year, loop."""
|
|
try:
|
|
dt = fire_dt
|
|
while True:
|
|
now = datetime.now(timezone.utc)
|
|
delta = max(0, (dt - now).total_seconds())
|
|
await asyncio.sleep(delta)
|
|
await bot.send(target, f"{nick}: reminder #{rid} (yearly)")
|
|
if label:
|
|
await bot.send(target, label)
|
|
# Compute next year's date
|
|
dt = _next_yearly(month, day, hour, minute, tz)
|
|
# Update persisted fire_iso
|
|
stored = bot.state.get("remind", rid)
|
|
if stored:
|
|
data = json.loads(stored)
|
|
data["fire_iso"] = dt.isoformat()
|
|
_save(bot, rid, data)
|
|
except asyncio.CancelledError:
|
|
pass
|
|
finally:
|
|
_cleanup(rid, target, nick)
|
|
|
|
|
|
# ---- Restore on connect -----------------------------------------------------
|
|
|
|
def _restore(bot) -> None:
|
|
"""Restore persisted calendar reminders from bot.state."""
|
|
for rid in bot.state.keys("remind"):
|
|
# Skip if already active
|
|
entry = _reminders.get(rid)
|
|
if entry and not entry[0].done():
|
|
continue
|
|
raw = bot.state.get("remind", rid)
|
|
if not raw:
|
|
continue
|
|
try:
|
|
data = json.loads(raw)
|
|
except json.JSONDecodeError:
|
|
continue
|
|
|
|
target = data["target"]
|
|
nick = data["nick"]
|
|
label = data["label"]
|
|
created = data["created"]
|
|
fire_dt = datetime.fromisoformat(data["fire_iso"])
|
|
rtype = data["type"]
|
|
|
|
if rtype == "at":
|
|
if fire_dt <= datetime.now(timezone.utc):
|
|
_delete_saved(bot, rid)
|
|
continue
|
|
task = asyncio.create_task(
|
|
_schedule_at(bot, rid, target, nick, label, fire_dt, created),
|
|
)
|
|
elif rtype == "yearly":
|
|
tz = _get_tz(bot)
|
|
month_day = data["month_day"]
|
|
month = int(month_day.split("-")[0])
|
|
day_raw = int(month_day.split("-")[1])
|
|
hm = _parse_time(data["time_str"]) or (12, 0)
|
|
hour, minute = hm
|
|
# Recalculate if past
|
|
if fire_dt <= datetime.now(timezone.utc):
|
|
fire_dt = _next_yearly(month, day_raw, hour, minute, tz)
|
|
data["fire_iso"] = fire_dt.isoformat()
|
|
_save(bot, rid, data)
|
|
task = asyncio.create_task(
|
|
_schedule_yearly(bot, rid, target, nick, label, fire_dt,
|
|
month, day_raw, hour, minute, tz, created),
|
|
)
|
|
else:
|
|
continue
|
|
|
|
_calendar.add(rid)
|
|
_track(rid, task, target, nick, label, created, rtype == "yearly")
|
|
|
|
|
|
@event("001")
|
|
async def on_connect(bot, message):
|
|
"""Restore persisted calendar reminders on connect."""
|
|
_restore(bot)
|
|
|
|
|
|
# ---- Command handler ---------------------------------------------------------
|
|
|
|
@command("remind", help="Reminder: !remind [every|at|yearly] <spec> <text> | list | cancel <id>")
|
|
async def cmd_remind(bot, message):
|
|
"""Set a one-shot, repeating, or calendar-based reminder.
|
|
|
|
Usage:
|
|
!remind 5m check the oven
|
|
!remind every 1h drink water
|
|
!remind at 2027-02-15 14:00 deploy release
|
|
!remind yearly 02-15 happy anniversary
|
|
!remind list
|
|
!remind cancel <id>
|
|
"""
|
|
parts = message.text.split(None, 2)
|
|
if len(parts) < 2:
|
|
await bot.reply(
|
|
message,
|
|
"Usage: !remind [every|at|yearly] <spec> <text> | list | cancel <id>",
|
|
)
|
|
return
|
|
|
|
target = message.target if message.is_channel else message.nick
|
|
nick = message.nick
|
|
sub = parts[1].lower()
|
|
ukey = (target, nick)
|
|
|
|
# ---- List ----------------------------------------------------------------
|
|
if sub == "list":
|
|
rids = _by_user.get(ukey, [])
|
|
active = []
|
|
for rid in rids:
|
|
entry = _reminders.get(rid)
|
|
if entry and not entry[0].done():
|
|
if rid in _calendar:
|
|
# Show next fire time
|
|
raw = bot.state.get("remind", rid)
|
|
if raw:
|
|
data = json.loads(raw)
|
|
fire_iso = data["fire_iso"]
|
|
fire_dt = datetime.fromisoformat(fire_iso)
|
|
tz = _get_tz(bot)
|
|
local = fire_dt.astimezone(tz)
|
|
tag_type = data["type"]
|
|
time_str = local.strftime("%Y-%m-%d %H:%M")
|
|
tag = f"#{rid} ({tag_type} {time_str})"
|
|
else:
|
|
tag = f"#{rid} (calendar)"
|
|
elif entry[5]:
|
|
tag = f"#{rid} (repeat)"
|
|
else:
|
|
tag = f"#{rid}"
|
|
active.append(tag)
|
|
if not active:
|
|
await bot.reply(message, "No active reminders")
|
|
return
|
|
await bot.reply(message, f"Reminders: {', '.join(active)}")
|
|
return
|
|
|
|
# ---- Cancel --------------------------------------------------------------
|
|
if sub == "cancel":
|
|
rid = parts[2].lstrip("#") if len(parts) > 2 else ""
|
|
if not rid:
|
|
await bot.reply(message, "Usage: !remind cancel <id>")
|
|
return
|
|
entry = _reminders.get(rid)
|
|
if entry and not entry[0].done() and entry[2] == nick:
|
|
entry[0].cancel()
|
|
_delete_saved(bot, rid)
|
|
await bot.reply(message, f"Cancelled #{rid}")
|
|
else:
|
|
await bot.reply(message, f"No active reminder #{rid}")
|
|
return
|
|
|
|
# ---- At (calendar one-shot) ----------------------------------------------
|
|
if sub == "at":
|
|
rest = parts[2] if len(parts) > 2 else ""
|
|
tokens = rest.split(None, 2) if rest else []
|
|
if not tokens:
|
|
await bot.reply(message, "Usage: !remind at <YYYY-MM-DD> [HH:MM] <text>")
|
|
return
|
|
d = _parse_date(tokens[0])
|
|
if d is None:
|
|
await bot.reply(message, "Invalid date (use: YYYY-MM-DD)")
|
|
return
|
|
# Try to parse optional time
|
|
hour, minute = 12, 0
|
|
time_str = "12:00"
|
|
label_start = 1
|
|
if len(tokens) > 1:
|
|
parsed = _parse_time(tokens[1])
|
|
if parsed:
|
|
hour, minute = parsed
|
|
time_str = tokens[1]
|
|
label_start = 2
|
|
label = " ".join(tokens[label_start:]) if len(tokens) > label_start else ""
|
|
tz = _get_tz(bot)
|
|
fire_dt = datetime(d.year, d.month, d.day, hour, minute, tzinfo=tz)
|
|
fire_utc = fire_dt.astimezone(timezone.utc)
|
|
if fire_utc <= datetime.now(timezone.utc):
|
|
await bot.reply(message, "That date/time is in the past")
|
|
return
|
|
rid = _make_id(nick, label)
|
|
created = datetime.now(timezone.utc).strftime("%H:%M:%S UTC")
|
|
data = {
|
|
"type": "at",
|
|
"target": target,
|
|
"nick": nick,
|
|
"label": label,
|
|
"fire_iso": fire_utc.isoformat(),
|
|
"month_day": None,
|
|
"time_str": time_str,
|
|
"created": created,
|
|
}
|
|
_save(bot, rid, data)
|
|
_calendar.add(rid)
|
|
task = asyncio.create_task(
|
|
_schedule_at(bot, rid, target, nick, label, fire_utc, created),
|
|
)
|
|
_track(rid, task, target, nick, label, created, False)
|
|
local_str = fire_dt.strftime("%Y-%m-%d %H:%M")
|
|
await bot.reply(message, f"Reminder #{rid} set (at {local_str})")
|
|
return
|
|
|
|
# ---- Yearly (recurring) --------------------------------------------------
|
|
if sub == "yearly":
|
|
rest = parts[2] if len(parts) > 2 else ""
|
|
tokens = rest.split(None, 2) if rest else []
|
|
if not tokens:
|
|
await bot.reply(message, "Usage: !remind yearly <MM-DD> [HH:MM] <text>")
|
|
return
|
|
# Parse MM-DD
|
|
md_parts = tokens[0].split("-")
|
|
if len(md_parts) != 2:
|
|
await bot.reply(message, "Invalid date (use: MM-DD)")
|
|
return
|
|
try:
|
|
month = int(md_parts[0])
|
|
day_raw = int(md_parts[1])
|
|
except ValueError:
|
|
await bot.reply(message, "Invalid date (use: MM-DD)")
|
|
return
|
|
if month < 1 or month > 12 or day_raw < 1 or day_raw > 31:
|
|
await bot.reply(message, "Invalid date (use: MM-DD)")
|
|
return
|
|
# Validate day for the given month (allow 29 for Feb -- leap day)
|
|
max_day = 29 if month == 2 else calendar.monthrange(2000, month)[1]
|
|
if day_raw > max_day:
|
|
await bot.reply(message, "Invalid date (use: MM-DD)")
|
|
return
|
|
hour, minute = 12, 0
|
|
time_str = "12:00"
|
|
label_start = 1
|
|
if len(tokens) > 1:
|
|
parsed = _parse_time(tokens[1])
|
|
if parsed:
|
|
hour, minute = parsed
|
|
time_str = tokens[1]
|
|
label_start = 2
|
|
label = " ".join(tokens[label_start:]) if len(tokens) > label_start else ""
|
|
tz = _get_tz(bot)
|
|
fire_dt = _next_yearly(month, day_raw, hour, minute, tz)
|
|
fire_utc = fire_dt.astimezone(timezone.utc)
|
|
rid = _make_id(nick, label)
|
|
created = datetime.now(timezone.utc).strftime("%H:%M:%S UTC")
|
|
month_day = f"{month:02d}-{day_raw:02d}"
|
|
data = {
|
|
"type": "yearly",
|
|
"target": target,
|
|
"nick": nick,
|
|
"label": label,
|
|
"fire_iso": fire_utc.isoformat(),
|
|
"month_day": month_day,
|
|
"time_str": time_str,
|
|
"created": created,
|
|
}
|
|
_save(bot, rid, data)
|
|
_calendar.add(rid)
|
|
task = asyncio.create_task(
|
|
_schedule_yearly(bot, rid, target, nick, label, fire_utc,
|
|
month, day_raw, hour, minute, tz, created),
|
|
)
|
|
_track(rid, task, target, nick, label, created, True)
|
|
local_str = fire_dt.strftime("%Y-%m-%d %H:%M")
|
|
await bot.reply(message, f"Reminder #{rid} set (yearly {month_day}, next {local_str})")
|
|
return
|
|
|
|
# ---- Repeating (every) ---------------------------------------------------
|
|
repeating = False
|
|
if sub == "every":
|
|
repeating = True
|
|
rest = parts[2] if len(parts) > 2 else ""
|
|
parts = ["", "", *rest.split(None, 1)] # re-split: [_, _, duration, text]
|
|
|
|
dur_idx = 2 if repeating else 1
|
|
dur_spec = parts[dur_idx] if dur_idx < len(parts) else ""
|
|
duration = _parse_duration(dur_spec)
|
|
if duration is None:
|
|
await bot.reply(message, "Invalid duration (use: 5m, 1h30m, 2d, 90s)")
|
|
return
|
|
|
|
label = ""
|
|
if repeating:
|
|
label = parts[3] if len(parts) > 3 else ""
|
|
else:
|
|
label = parts[2] if len(parts) > 2 else ""
|
|
|
|
rid = _make_id(nick, label)
|
|
created = datetime.now(timezone.utc).strftime("%H:%M:%S UTC")
|
|
|
|
if repeating:
|
|
task = asyncio.create_task(
|
|
_remind_repeat(bot, rid, target, nick, label, duration, created),
|
|
)
|
|
else:
|
|
task = asyncio.create_task(
|
|
_remind_once(bot, rid, target, nick, label, duration, created),
|
|
)
|
|
|
|
_track(rid, task, target, nick, label, created, repeating)
|
|
|
|
kind = f"every {_format_duration(duration)}" if repeating else _format_duration(duration)
|
|
await bot.reply(message, f"Reminder #{rid} set ({kind})")
|