Initial release of AstrBot reminder plugin

This commit is contained in:
itxiaohui committed 2026-10-05 19:22:07 +08:00
commit cf10c43e61
20 files changed
+1692

No files matched your search

+1
View File
@@ -0,0 +1 @@
"""Time parsing, storage and platform delivery services."""
+87
View File
@@ -0,0 +1,87 @@
"""Deliver through the current adapter; never persist a live event or old msg_id."""
from html import escape
OFFICIAL = {"qq_official", "qq_official_webhook"}
def field(value, name, default=None):
return value.get(name, default) if isinstance(value, dict) else getattr(value, name, default)
def route(event):
group = str(event.get_group_id() or "")
raw = event.message_obj.raw_message
data = field(raw, "raw_data", raw)
if event.get_platform_name() in OFFICIAL:
if field(raw, "group_openid") or field(data, "group_openid"):
return "group", str(field(raw, "group_openid") or field(data, "group_openid"))
if field(raw, "channel_id") or field(data, "channel_id"):
# Guild DMs need a separate guild ID, not the user's OpenID.
if not group:
return "guild_dm", str(field(raw, "guild_id") or field(data, "guild_id") or "")
return "channel", str(field(raw, "channel_id") or field(data, "channel_id"))
if not group:
return "c2c", str(event.get_sender_id())
raise ValueError("无法识别官方 QQ 群消息来源,请检查 AstrBot 适配器版本。")
return ("group", group) if group else ("private", str(event.get_sender_id()))
def find_platform(context, platform_id):
manager = context.platform_manager
return next((p for p in manager.platform_insts if str(p.meta().id) == platform_id), None)
def available(platform):
if platform is None:
return False
status = field(field(platform, "status"), "value", "running")
# An absent/starting/disconnected platform does not count as a failed delivery.
return str(status).lower() == "running"
def reminder_text(rem):
creator = rem["creator_name"] or rem["creator_id"]
prefix = f"来自 {creator} 的提醒:\n" if rem["target_id"] != rem["creator_id"] else ""
return f"{prefix}⏰ {rem['content']}\n(提醒 #{rem['id']})"
async def deliver(platform, rem):
"""Official SDK return value must contain a message ID to count as sent."""
client = platform.get_client()
text = reminder_text(rem)
if rem["platform_name"] in OFFICIAL:
api = client.api
scene = rem["scene"]
if scene == "group":
mention = f'<qqbot-at-user id="{escape(rem["target_id"], quote=True)}" />'
result = await api.post_group_message(
group_openid=rem["destination"], msg_type=0, content=f"{mention}\n{text}"
)
elif scene == "c2c":
result = await api.post_c2c_message(openid=rem["destination"], msg_type=0, content=text)
elif scene == "channel":
result = await api.post_message(
channel_id=rem["destination"], content=f"<@{rem['target_id']}>\n{text}"
)
elif scene == "guild_dm":
result = await api.post_dms(guild_id=rem["destination"], content=text)
else:
raise ValueError(f"未知官方 QQ 投递场景:{scene}")
if not field(result, "id"):
raise RuntimeError(
"QQ 官方发送接口未返回消息 ID,请检查主动消息权限、额度和适配器版本。"
)
return
# Preserve old OneBot behavior, including a real @ and member validation.
if rem["platform_name"] == "aiocqhttp":
message = [{"type": "text", "data": {"text": text}}]
if rem["scene"] == "group":
message.insert(0, {"type": "at", "data": {"qq": rem["target_id"]}})
result = await client.send_group_msg(group_id=int(rem["destination"]), message=message)
else:
result = await client.send_private_msg(user_id=int(rem["destination"]), message=message)
if not field(result, "message_id"):
raise RuntimeError("OneBot 发送接口未返回消息 ID。")
return
raise ValueError(f"不支持的提醒平台:{rem['platform_name']}")
+223
View File
@@ -0,0 +1,223 @@
"""Transactional SQLite persistence outside the installed plugin directory."""
import asyncio
import json
import sqlite3
import time
from contextlib import closing
from pathlib import Path
def scope_key(platform_id, group_id, user_id):
# Group UMO may include the sender when unique-session is enabled.
return json.dumps([platform_id, "group" if group_id else "private", group_id or user_id])
class ReminderStore:
def __init__(self, path):
self.path = Path(path)
self._lock = asyncio.Lock()
async def _run(self, operation):
def run():
with closing(sqlite3.connect(self.path, timeout=10)) as db, db:
db.row_factory = sqlite3.Row
return operation(db)
async with self._lock:
# Wait for the worker before releasing the lock even during unload.
worker = asyncio.create_task(asyncio.to_thread(run))
try:
return await asyncio.shield(worker)
except asyncio.CancelledError:
await worker
raise
async def initialize(self):
self.path.parent.mkdir(parents=True, exist_ok=True)
def create(db):
db.executescript("""
PRAGMA journal_mode=WAL;
CREATE TABLE IF NOT EXISTS reminders (
id INTEGER PRIMARY KEY AUTOINCREMENT,
scope TEXT NOT NULL, platform_id TEXT NOT NULL,
platform_name TEXT NOT NULL, destination TEXT NOT NULL,
scene TEXT NOT NULL, umo TEXT NOT NULL,
creator_id TEXT NOT NULL, creator_name TEXT NOT NULL DEFAULT '',
target_id TEXT NOT NULL, target_name TEXT NOT NULL DEFAULT '',
content TEXT NOT NULL, remind_at REAL NOT NULL,
timezone TEXT NOT NULL, repeat_type TEXT NOT NULL
CHECK(repeat_type IN ('none','daily','weekly')),
status TEXT NOT NULL DEFAULT 'active'
CHECK(status IN ('active','done','cancelled')),
failure_count INTEGER NOT NULL DEFAULT 0,
last_error TEXT NOT NULL DEFAULT '',
retry_at REAL NOT NULL DEFAULT 0,
lease_owner TEXT NOT NULL DEFAULT '', lease_until REAL NOT NULL DEFAULT 0,
created_at REAL NOT NULL
);
CREATE INDEX IF NOT EXISTS reminders_due ON reminders(status, remind_at);
CREATE INDEX IF NOT EXISTS reminders_scope ON reminders(scope, creator_id);
CREATE TABLE IF NOT EXISTS members (
scope TEXT NOT NULL, user_id TEXT NOT NULL,
nickname TEXT NOT NULL DEFAULT '', seen_at REAL NOT NULL,
PRIMARY KEY(scope, user_id)
);
""")
await self._run(create)
async def observe(self, scope, user_id, nickname=""):
await self._run(
lambda db: (
db.execute(
"INSERT INTO members VALUES (?,?,?,?) ON CONFLICT(scope,user_id) DO UPDATE SET "
"nickname=CASE WHEN excluded.nickname!='' THEN excluded.nickname ELSE members.nickname END, "
"seen_at=excluded.seen_at",
(scope, user_id, nickname or "", time.time()),
).rowcount
)
)
async def member(self, scope, value):
def read(db):
rows = db.execute(
"SELECT * FROM members WHERE scope=? AND (user_id=? OR nickname=?)",
(scope, value, value),
).fetchall()
exact = [r for r in rows if r["user_id"] == value]
if exact:
return dict(exact[0])
if len(rows) > 1:
raise ValueError("本群有重名用户,请使用真实 @ 或 /tx identity 获取的用户标识。")
return dict(rows[0]) if rows else None
return await self._run(read)
async def add(self, record, limit):
def insert(db):
db.execute("BEGIN IMMEDIATE")
count = db.execute(
"SELECT COUNT(*) FROM reminders WHERE scope=? AND creator_id=? AND status='active'",
(record["scope"], record["creator_id"]),
).fetchone()[0]
if count >= limit:
raise ValueError(f"你在当前会话最多只能设置 {limit} 个提醒,请先取消一些。")
columns = (
"scope",
"platform_id",
"platform_name",
"destination",
"scene",
"umo",
"creator_id",
"creator_name",
"target_id",
"target_name",
"content",
"remind_at",
"timezone",
"repeat_type",
)
cursor = db.execute(
f"INSERT INTO reminders ({','.join(columns)},created_at) "
f"VALUES ({','.join('?' for _ in range(len(columns) + 1))})",
tuple(record[c] for c in columns) + (time.time(),),
)
return cursor.lastrowid
return await self._run(insert)
async def list(self, scope, creator_id=None, history=False):
def read(db):
sql, params = "SELECT * FROM reminders WHERE scope=?", [scope]
if creator_id is not None:
sql += " AND creator_id=?"
params.append(creator_id)
if not history:
sql += " AND status='active'"
sql += " ORDER BY remind_at,id"
return [dict(r) for r in db.execute(sql, params).fetchall()]
return await self._run(read)
async def get(self, reminder_id, scope):
def read(db):
row = db.execute(
"SELECT * FROM reminders WHERE id=? AND scope=?", (reminder_id, scope)
).fetchone()
return dict(row) if row else None
return await self._run(read)
async def cancel(self, scope, creator_id, reminder_id=None):
def write(db):
sql = "UPDATE reminders SET status='cancelled', lease_owner='', lease_until=0 WHERE scope=? AND status='active'"
params = [scope]
if creator_id is not None:
sql += " AND creator_id=?"
params.append(creator_id)
if reminder_id is not None:
sql += " AND id=?"
params.append(reminder_id)
return db.execute(sql, params).rowcount
return await self._run(write)
async def due(self, now):
return await self._run(
lambda db: [
dict(r)
for r in db.execute(
"SELECT * FROM reminders WHERE status='active' AND remind_at<=? "
"AND retry_at<=? AND lease_until<=? ORDER BY remind_at,id LIMIT 100",
(now, now, now),
)
]
)
async def claim(self, reminder_id, owner, now):
# One lease per send prevents overlapping hot reloads from sending twice.
return await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET lease_owner=?,lease_until=? WHERE id=? AND status='active' "
"AND lease_until<=? AND remind_at<=? AND retry_at<=?",
(owner, now + 120, reminder_id, now, now, now),
).rowcount
== 1
)
)
async def success(self, reminder_id, owner, next_time=None):
return await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET status=?,remind_at=COALESCE(?,remind_at),failure_count=0,"
"last_error='',retry_at=0,lease_owner='',lease_until=0 WHERE id=? AND lease_owner=? AND status='active'",
("active" if next_time is not None else "done", next_time, reminder_id, owner),
).rowcount
)
)
async def failure(self, reminder_id, owner, error, maximum, retry_at):
def write(db):
db.execute(
"UPDATE reminders SET failure_count=failure_count+1,last_error=?,retry_at=?,"
"status=CASE WHEN failure_count+1>=? THEN 'cancelled' ELSE 'active' END,"
"lease_owner='',lease_until=0 WHERE id=? AND lease_owner=? AND status='active'",
(str(error)[:500], retry_at, maximum, reminder_id, owner),
)
await self._run(write)
async def release(self, reminder_id, owner):
await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET lease_owner='',lease_until=0 WHERE id=? AND lease_owner=?",
(reminder_id, owner),
).rowcount
)
)
+76
View File
@@ -0,0 +1,76 @@
"""Resolve real mention components, QQ official markup and observed member names."""
import re
from .delivery import OFFICIAL, field
MARKUP = re.compile(
r"<qqbot-at-user\s+id=[\"\']([^\"\']+)[\"\']\s*/>|<@!?([^>]+)>|\[CQ:at,qq=([^,\]]+)[^\]]*\]"
)
TEXT_AT = re.compile(r"(?<![\w@])@([^\s@]+)")
VALID_ID = re.compile(r"[A-Za-z0-9_-]{1,128}\Z")
async def resolve_target(event, args, store, scope):
sender = str(event.get_sender_id())
bot_ids = {str(event.message_obj.self_id)}
raw = event.message_obj.raw_message
raw_data = field(raw, "raw_data", raw)
mentions = field(raw, "mentions", None) or field(raw_data, "mentions", []) or []
trusted = {}
for mention in mentions:
user = str(field(mention, "id", None) or field(mention, "member_openid", ""))
if field(mention, "is_you", False) or field(mention, "bot", False):
bot_ids.add(user)
elif user:
trusted[user] = str(field(mention, "username", "") or "")
for component in event.get_messages():
if field(component, "type") in {"At", "at"} or type(component).__name__ == "At":
user = str(field(component, "qq", ""))
if user and user not in bot_ids:
trusted[user] = str(field(component, "name", "") or "")
candidates = list(trusted)
for match in MARKUP.finditer(args):
user = next(g for g in match.groups() if g is not None)
if user not in bot_ids:
candidates.append(user)
args = MARKUP.sub(" ", args)
textual = list(TEXT_AT.finditer(args))
for match in textual:
value = match.group(1)
# @all must not be allowed as a recipient.
if value in {"all", "everyone", "全体成员"}:
raise ValueError("一次提醒只能指定一个成员,不能 @ 全体成员。")
names = [user for user, name in trusted.items() if name and name == value]
if len(names) > 1:
raise ValueError("被 @ 成员重名,请使用用户标识。")
member = await store.member(scope, value)
candidates.append(names[0] if names else member["user_id"] if member else value)
args = TEXT_AT.sub(" ", args).strip()
candidates = list(dict.fromkeys(candidates))
if len(candidates) > 1:
raise ValueError("一次提醒只能指定一个成员。")
target = candidates[0] if candidates else sender
if not VALID_ID.fullmatch(target) or target == "all":
raise ValueError("提醒对象标识无效,请使用真实 @。")
if not event.get_group_id() and target != sender:
raise ValueError("私聊只能提醒自己;提醒他人请在群内使用。")
member = await store.member(scope, target)
if target != sender:
if event.get_platform_name() in OFFICIAL:
if target not in trusted and not member:
raise ValueError(
"无法确认该用户的本群 OpenID。请真实 @ 对方;若官方未提供成员标识,"
"让对方先在本群 @ 机器人发送 /tx identity,再用 @用户标识。普通 QQ 号不能转换成 OpenID。"
)
elif event.get_platform_name() == "aiocqhttp":
try:
await event.bot.get_group_member_info(
group_id=int(event.get_group_id()), user_id=int(target), no_cache=True
)
except Exception as exc:
raise ValueError("无法在本群找到该成员,请重新 @ 群成员。") from exc
name = trusted.get(target) or (member["nickname"] if member else "")
if target == sender:
name = event.get_sender_name() or ""
return args, target, name
+107
View File
@@ -0,0 +1,107 @@
"""Parse the old reminder syntax and the formats advertised by its help."""
import re
from dataclasses import dataclass
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo
WEEKDAYS = {s: i for i, s in enumerate("一二三四五六日")}
WEEKDAYS.update({str(i + 1): i for i in range(7)})
WEEKDAYS["天"] = 6
@dataclass(frozen=True)
class ParsedReminder:
when: datetime
content: str
repeat: str = "none"
def parse_time(text: str, now: datetime) -> ParsedReminder:
"""Always use an explicit timezone; reject past/invalid/zero times."""
text = text.strip()
flags = re.I | re.S
try:
match = re.fullmatch(r"每天\s*(\d{1,2})[::](\d{2})\s+(.+)", text, flags)
if match:
hour, minute, content = match.groups()
when = now.replace(hour=int(hour), minute=int(minute), second=0, microsecond=0)
if when <= now:
when += timedelta(days=1)
return _result(when, content, "daily")
match = re.fullmatch(
r"每周([一二三四五六日天1-7])\s*(\d{1,2})[::](\d{2})\s+(.+)", text, flags
)
if match:
weekday, hour, minute, content = match.groups()
when = now.replace(hour=int(hour), minute=int(minute), second=0, microsecond=0)
when += timedelta(days=(WEEKDAYS[weekday] - now.weekday()) % 7)
# The old code incorrectly skipped later times on the same weekday.
if when <= now:
when += timedelta(weeks=1)
return _result(when, content, "weekly")
match = re.fullmatch(
r"(\d+)\s*(分钟|小时|天|minutes?|hours?|days?|min|h|d)(?:后)?\s+(.+)", text, flags
)
if match:
amount, unit, content = match.groups()
amount = int(amount)
if amount <= 0:
raise ValueError("提醒间隔必须大于 0。")
unit = unit.lower()
seconds = (
60
if unit in {"分钟", "minute", "minutes", "min"}
else (3600 if unit in {"小时", "hour", "hours", "h"} else 86400)
)
return _result(now + timedelta(seconds=amount * seconds), content)
match = re.fullmatch(r"(\d{4}-\d{2}-\d{2})\s+(\d{1,2})[::](\d{2})\s+(.+)", text, flags)
if match:
date, hour, minute, content = match.groups()
when = datetime.strptime(f"{date} {hour}:{minute}", "%Y-%m-%d %H:%M").replace(
tzinfo=now.tzinfo
)
else:
match = re.fullmatch(r"(今天|明天|后天)?\s*(\d{1,2})[::](\d{2})\s+(.+)", text, flags)
if not match:
raise ValueError("时间格式错误,发送 /tx help 查看全部格式。")
day, hour, minute, content = match.groups()
when = now.replace(hour=int(hour), minute=int(minute), second=0, microsecond=0)
when += timedelta(days={None: 0, "今天": 0, "明天": 1, "后天": 2}[day])
if when <= now:
raise ValueError("单次提醒时间已经过去,请指定未来时间。")
return _result(when, content)
except (OverflowError, ValueError) as exc:
if isinstance(exc, OverflowError) or str(exc).startswith(
("hour must", "minute must", "day is", "time data")
):
raise ValueError("日期或时间无效,请检查日期、小时和分钟。") from exc
raise
def _result(when, content, repeat="none"):
content = content.strip()
if not content:
raise ValueError("提醒内容不能为空。")
return ParsedReminder(when, content, repeat)
def next_occurrence(timestamp: float, repeat: str, timezone: str, now: float) -> float:
"""Skip missed cycles after downtime instead of flooding a group."""
previous = datetime.fromtimestamp(timestamp, ZoneInfo(timezone))
current = datetime.fromtimestamp(now, previous.tzinfo)
step = 1 if repeat == "daily" else 7
days = max(step, ((current.date() - previous.date()).days // step) * step)
target = previous + timedelta(days=days)
if target.timestamp() <= now:
target += timedelta(days=step)
return target.timestamp()
def describe(timestamp: float, repeat: str, timezone: str) -> str:
when = datetime.fromtimestamp(timestamp, ZoneInfo(timezone))
if repeat == "daily":
return f"每天 {when:%H:%M}(下次 {when:%Y-%m-%d %H:%M})"
if repeat == "weekly":
return f"每周{'一二三四五六日'[when.weekday()]} {when:%H:%M}(下次 {when:%Y-%m-%d %H:%M})"
return when.strftime("%Y-%m-%d %H:%M")