nonebot-plugin-taozi 0.2.0__py3-none-any.whl

nonebot_plugin_taozi/__init__.py

@@ -0,0 +1,30 @@
+from nonebot import require
+from nonebot.plugin import PluginMetadata
+
+from .config import Config, plugin_config
+from .render import init_font_config
+
+require("nonebot_plugin_localstore")
+init_font_config(plugin_config.taozi_font)
+
+__plugin_meta__ = PluginMetadata(
+    name="桃纸助手",
+    description="图片化的有出处桃系词典与可选轻互动",
+    usage=(
+        "桃系词典 [词条]｜随机桃词｜今日桃签｜我的桃色 [桃色/取消]｜"
+        "桃趣状态｜桃趣 开启/关闭"
+    ),
+    type="application",
+    homepage="https://github.com/TonyLiangP2010405/nonebot-plugin-taozi",
+    config=Config,
+    supported_adapters={"~onebot.v11"},
+    extra={
+        "authoritative": False,
+        "disclaimer": "非官方粉丝插件；词条含义以公开来源和具体语境为准。",
+    },
+)
+
+from .commands import fun as fun
+from .commands import help as help
+from .commands import lexicon as lexicon
+from .commands import settings as settings

nonebot_plugin_taozi/commands/__init__.py

@@ -0,0 +1,2 @@
+"""NoneBot command matchers for 桃纸助手."""
+

nonebot_plugin_taozi/commands/common.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from datetime import datetime
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+import nonebot_plugin_localstore as store
+from nonebot.adapters.onebot.v11 import GroupMessageEvent, MessageEvent
+from nonebot.matcher import Matcher
+
+from ..config import plugin_config
+from ..fortune import Cooldown
+from ..output import finish_message_card
+from ..state import TaoziStateStore
+
+state_store = TaoziStateStore(store.get_plugin_data_file("state.json"))
+fun_cooldown = Cooldown(plugin_config.taozi_fun_cooldown_seconds)
+
+
+def get_group_id(event: MessageEvent) -> str | None:
+    if isinstance(event, GroupMessageEvent):
+        return str(event.group_id)
+    return None
+
+
+def get_scope_id(event: MessageEvent) -> str:
+    group_id = get_group_id(event)
+    if group_id is not None:
+        return f"group:{group_id}"
+    return f"private:{event.get_user_id()}"
+
+
+def get_today():
+    try:
+        timezone = ZoneInfo(plugin_config.taozi_timezone)
+    except ZoneInfoNotFoundError:
+        timezone = ZoneInfo("Asia/Shanghai")
+    return datetime.now(timezone).date()
+
+
+async def is_fun_enabled(event: MessageEvent) -> bool:
+    if not plugin_config.taozi_fun_enabled:
+        return False
+    group_id = get_group_id(event)
+    if group_id is None:
+        return True
+    return await state_store.is_group_enabled(group_id, default=True)
+
+
+async def require_fun(
+    matcher: type[Matcher],
+    event: MessageEvent,
+    *,
+    command_key: str,
+) -> None:
+    if not await is_fun_enabled(event):
+        await finish_message_card(
+            matcher,
+            "桃趣互动已关闭",
+            "本会话的桃趣互动已关闭；桃系词典仍可正常使用。",
+            chips=("词典仍可用",),
+        )
+
+    cooldown_key = f"{command_key}:{get_scope_id(event)}:{event.get_user_id()}"
+    remaining = fun_cooldown.acquire(cooldown_key)
+    if remaining > 0:
+        await finish_message_card(
+            matcher,
+            "稍等一下",
+            f"桃趣冷却中，请等待约 {remaining:.0f} 秒再试。",
+            chips=("冷却中",),
+        )

nonebot_plugin_taozi/commands/fun.py

@@ -0,0 +1,144 @@
+import secrets
+
+from nonebot import on_command
+from nonebot.adapters.onebot.v11 import Message, MessageEvent
+from nonebot.params import CommandArg
+
+from ..config import plugin_config
+from ..fortune import pick_daily_fortune, render_fortune
+from ..interactions import (
+    ALLOWED_SELF_COLORS,
+    is_cancel_request,
+    parse_self_color,
+    render_color_selected,
+)
+from ..lexicon import BUILTIN_LEXICON, render_entry
+from ..output import finish_fortune_card, finish_lexicon_card, finish_message_card
+from .common import get_scope_id, get_today, require_fun, state_store
+
+daily_fortune = on_command(
+    "今日桃签",
+    aliases={"桃签"},
+    priority=10,
+    block=True,
+)
+random_term = on_command(
+    "随机桃词",
+    aliases={"随机桃梗"},
+    priority=10,
+    block=True,
+)
+self_color = on_command(
+    "我的桃色",
+    aliases={"我是桃"},
+    priority=10,
+    block=True,
+)
+cancel_color = on_command("取消桃色", priority=10, block=True)
+
+
+@daily_fortune.handle()
+async def handle_daily_fortune(event: MessageEvent) -> None:
+    await require_fun(daily_fortune, event, command_key="daily_fortune")
+    day = get_today()
+    fortune = pick_daily_fortune(event.get_user_id(), day)
+    await finish_fortune_card(
+        daily_fortune,
+        fortune,
+        day.isoformat(),
+        render_fortune(fortune),
+    )
+
+
+@random_term.handle()
+async def handle_random_term(event: MessageEvent) -> None:
+    await require_fun(random_term, event, command_key="random_term")
+    entry = secrets.choice(BUILTIN_LEXICON.entries)
+    await finish_lexicon_card(
+        random_term,
+        entry,
+        render_entry(
+            entry,
+            show_sources=plugin_config.taozi_lexicon_show_sources,
+            compact=True,
+        ),
+        compact=True,
+    )
+
+
+@self_color.handle()
+async def handle_self_color(event: MessageEvent, args: Message = CommandArg()) -> None:
+    await require_fun(self_color, event, command_key="self_color")
+    value = args.extract_plain_text().strip()
+    scope_id = get_scope_id(event)
+    user_id = event.get_user_id()
+
+    if not value:
+        selected = await state_store.get_self_color(scope_id, user_id)
+        if selected is None:
+            body = (
+                "你还没有自选桃色。\n"
+                f"可选：{'、'.join(ALLOWED_SELF_COLORS)}\n"
+                "用法：/我的桃色 黑桃"
+            )
+            await finish_message_card(
+                self_color,
+                "我的桃色",
+                body,
+                chips=("自愿选择", "随时取消"),
+            )
+        body = (
+            f"你当前自选的桃色是：{selected}。\n"
+            "这是插件内的自愿玩笑身份，不代表机器人评价。"
+        )
+        await finish_message_card(
+            self_color,
+            "我的桃色",
+            body,
+            chips=(selected or "未选择", "自愿选择"),
+        )
+
+    if is_cancel_request(value):
+        removed = await state_store.remove_self_color(scope_id, user_id)
+        message = "已取消你的自选桃色。" if removed else "你目前没有自选桃色。"
+        await finish_message_card(
+            self_color,
+            "桃色设置",
+            message,
+            chips=("已更新",),
+        )
+
+    color = parse_self_color(value)
+    if color is None:
+        body = (
+            f"不支持“{value}”。可选桃色：{'、'.join(ALLOWED_SELF_COLORS)}；"
+            "也可以发送“/我的桃色 取消”。"
+        )
+        await finish_message_card(
+            self_color,
+            "无法识别桃色",
+            body,
+            chips=("请重新选择",),
+        )
+
+    await state_store.set_self_color(scope_id, user_id, color)
+    await finish_message_card(
+        self_color,
+        "桃色设置成功",
+        render_color_selected(color),
+        chips=(color, "自愿选择"),
+        footer="这只是插件内的玩笑身份；发送“/我的桃色 取消”即可移除。",
+    )
+
+
+@cancel_color.handle()
+async def handle_cancel_color(event: MessageEvent) -> None:
+    await require_fun(cancel_color, event, command_key="cancel_color")
+    removed = await state_store.remove_self_color(get_scope_id(event), event.get_user_id())
+    message = "已取消你的自选桃色。" if removed else "你目前没有自选桃色。"
+    await finish_message_card(
+        cancel_color,
+        "桃色设置",
+        message,
+        chips=("已更新",),
+    )

nonebot_plugin_taozi/commands/help.py

@@ -0,0 +1,30 @@
+from nonebot import on_command
+
+from ..output import finish_message_card
+
+help_command = on_command(
+    "桃纸帮助",
+    aliases={"桃纸助手"},
+    priority=10,
+    block=True,
+)
+
+
+@help_command.handle()
+async def handle_help() -> None:
+    body = (
+        "词典：/桃系词典 [词条]\n"
+        "随机词条：/随机桃词\n"
+        "每日互动：/今日桃签\n"
+        "自选身份：/我的桃色 [白桃/黑桃/红桃/黄桃/取消]\n"
+        "互动状态：/桃趣状态\n"
+        "群管理：/桃趣 开启｜关闭｜状态\n\n"
+        "词典保留出处、可信度和语境边界；互动文案不是主播原话。"
+    )
+    await finish_message_card(
+        help_command,
+        "桃纸助手",
+        body,
+        chips=("非官方", "图片模式"),
+        footer="有出处的桃系词典 · 可选的轻互动",
+    )

nonebot_plugin_taozi/commands/lexicon.py

@@ -0,0 +1,54 @@
+from nonebot import on_command
+from nonebot.adapters.onebot.v11 import Message
+from nonebot.params import CommandArg
+
+from ..config import plugin_config
+from ..lexicon import BUILTIN_LEXICON, render_entry
+from ..output import finish_lexicon_card, finish_message_card
+
+lexicon_command = on_command(
+    "桃系词典",
+    aliases={"桃词典"},
+    priority=10,
+    block=True,
+)
+
+
+@lexicon_command.handle()
+async def handle_lexicon(args: Message = CommandArg()) -> None:
+    query = args.extract_plain_text().strip()
+    if not query:
+        body = (
+            "已收录桃系词条：\n"
+            f"{BUILTIN_LEXICON.list_terms()}\n\n"
+            "用法：/桃系词典 黑桃"
+        )
+        await finish_message_card(
+            lexicon_command,
+            "桃系词典",
+            body,
+            chips=("有出处", "可修订"),
+            footer="输入“/桃系词典 词条名”查看解释、边界和来源。",
+        )
+
+    entry = BUILTIN_LEXICON.find(query)
+    if entry is None:
+        suggestions = BUILTIN_LEXICON.suggest(query)
+        suffix = f"\n你可能想查：{'、'.join(suggestions)}" if suggestions else ""
+        body = (
+            f"暂未收录“{query}”。{suffix}\n"
+            "词典只收录有公开出处、能说明边界的用法。"
+        )
+        await finish_message_card(
+            lexicon_command,
+            "暂未收录",
+            body,
+            chips=("等待考证",),
+            footer="有可靠公开来源后，可以通过更新词典数据补充。",
+        )
+
+    await finish_lexicon_card(
+        lexicon_command,
+        entry,
+        render_entry(entry, show_sources=plugin_config.taozi_lexicon_show_sources),
+    )

nonebot_plugin_taozi/commands/settings.py

@@ -0,0 +1,98 @@
+from nonebot import on_command
+from nonebot.adapters.onebot.v11 import GroupMessageEvent, Message, MessageEvent
+from nonebot.adapters.onebot.v11.permission import GROUP_ADMIN, GROUP_OWNER
+from nonebot.params import CommandArg
+from nonebot.permission import SUPERUSER
+
+from ..config import plugin_config
+from ..output import finish_message_card
+from .common import get_group_id, is_fun_enabled, state_store
+
+fun_status = on_command("桃趣状态", priority=10, block=True)
+fun_settings = on_command(
+    "桃趣",
+    permission=SUPERUSER | GROUP_ADMIN | GROUP_OWNER,
+    priority=10,
+    block=True,
+)
+
+
+@fun_status.handle()
+async def handle_fun_status(event: MessageEvent) -> None:
+    enabled = await is_fun_enabled(event)
+    state = "开启" if enabled else "关闭"
+    detail = ""
+    if not plugin_config.taozi_fun_enabled:
+        detail = "\n全局配置 TAOZI_FUN_ENABLED=false。"
+    body = f"当前会话的桃趣互动：{state}。{detail}\n桃系词典不受此开关影响。"
+    await finish_message_card(
+        fun_status,
+        "桃趣状态",
+        body,
+        chips=(state, "词典始终可用"),
+    )
+
+
+@fun_settings.handle()
+async def handle_fun_settings(event: MessageEvent, args: Message = CommandArg()) -> None:
+    if not isinstance(event, GroupMessageEvent):
+        await finish_message_card(
+            fun_settings,
+            "无法设置",
+            "桃趣开关只能在群聊中设置。",
+        )
+
+    action = args.extract_plain_text().strip()
+    group_id = get_group_id(event)
+    if group_id is None:
+        await finish_message_card(
+            fun_settings,
+            "无法设置",
+            "无法识别当前群聊。",
+        )
+
+    if action in {"开启", "打开", "启用"}:
+        await state_store.set_group_enabled(group_id, True)
+        if plugin_config.taozi_fun_enabled:
+            await finish_message_card(
+                fun_settings,
+                "桃趣设置",
+                "已开启本群的桃趣互动。",
+                chips=("已开启",),
+            )
+        body = (
+            "已保存本群的开启设置，但全局配置 TAOZI_FUN_ENABLED=false，"
+            "修改配置并重启后才会生效。"
+        )
+        await finish_message_card(
+            fun_settings,
+            "设置已保存",
+            body,
+            chips=("等待全局开启",),
+        )
+
+    if action in {"关闭", "禁用"}:
+        await state_store.set_group_enabled(group_id, False)
+        await finish_message_card(
+            fun_settings,
+            "桃趣设置",
+            "已关闭本群的桃趣互动；桃系词典仍可使用。",
+            chips=("已关闭", "词典仍可用"),
+        )
+
+    if action == "状态":
+        enabled = await is_fun_enabled(event)
+        state = "开启" if enabled else "关闭"
+        await finish_message_card(
+            fun_settings,
+            "桃趣状态",
+            f"本群桃趣互动当前为：{state}。",
+            chips=(state,),
+        )
+
+    await finish_message_card(
+        fun_settings,
+        "桃趣设置",
+        "用法：/桃趣 开启｜/桃趣 关闭｜/桃趣 状态",
+        chips=("仅群管理可用",),
+    )

nonebot_plugin_taozi/config.py

@@ -0,0 +1,17 @@
+from nonebot import get_plugin_config
+from pydantic import BaseModel, Field
+
+
+class Config(BaseModel):
+    """桃纸助手配置。所有配置均有默认值，插件可零配置加载。"""
+
+    taozi_fun_enabled: bool = True
+    taozi_fun_cooldown_seconds: int = Field(default=8, ge=0, le=300)
+    taozi_lexicon_show_sources: bool = True
+    taozi_timezone: str = "Asia/Shanghai"
+    taozi_image_enabled: bool = True
+    taozi_image_fallback_text: bool = True
+    taozi_font: str = ""
+
+
+plugin_config = get_plugin_config(Config)

nonebot_plugin_taozi/fortune.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import hashlib
+import time
+from dataclasses import dataclass
+from datetime import date
+
+
+@dataclass(frozen=True, slots=True)
+class Fortune:
+    name: str
+    message: str
+    keyword: str
+
+
+FORTUNES = (
+    Fortune("出货签", "今天适合随缘探索。看见问号，就去看看。", "探索"),
+    Fortune("老演员签", "可能会碰见熟面孔。别急，换个地方再试试。", "耐心"),
+    Fortune("无情机器签", "挑一件小事认真做完：收菜、钓鱼或解图鉴都可以。", "专注"),
+    Fortune("头部主播签", "自信一点，有想法就先做起来。", "行动"),
+    Fortune("好穷签", "资源少一点也没事，先享受手头能玩的部分。", "知足"),
+    Fortune("帽险家签", "今天适合去没走过的地方，给自己留一点惊喜。", "发现"),
+    Fortune("师父签", "遇到不确定的事，可以听听大家的建议再决定。", "交流"),
+    Fortune("六冠王签", "目标可以有，但过程也要好玩。慢慢来。", "平衡"),
+)
+
+
+def pick_daily_fortune(user_id: str, day: date, *, salt: str = "taozi") -> Fortune:
+    payload = f"{salt}:{day.isoformat()}:{user_id}".encode()
+    digest = hashlib.sha256(payload).digest()
+    index = int.from_bytes(digest[:8], byteorder="big") % len(FORTUNES)
+    return FORTUNES[index]
+
+
+def render_fortune(fortune: Fortune) -> str:
+    return "\n".join(
+        [
+            f"【今日桃签·{fortune.name}】",
+            fortune.message,
+            f"今日关键词：{fortune.keyword}",
+            "——互动文案，仅供娱乐，不是主播原话。",
+        ]
+    )
+
+
+class Cooldown:
+    def __init__(self, seconds: int) -> None:
+        self._seconds = seconds
+        self._last_seen: dict[str, float] = {}
+
+    def acquire(self, key: str, *, now: float | None = None) -> float:
+        if self._seconds <= 0:
+            return 0.0
+
+        current = time.monotonic() if now is None else now
+        previous = self._last_seen.get(key)
+        if previous is not None:
+            remaining = self._seconds - (current - previous)
+            if remaining > 0:
+                return remaining
+
+        self._last_seen[key] = current
+        return 0.0
+

nonebot_plugin_taozi/interactions.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from .lexicon import normalize_term
+
+ALLOWED_SELF_COLORS = ("白桃", "黑桃", "红桃", "黄桃")
+_COLOR_INDEX = {normalize_term(color): color for color in ALLOWED_SELF_COLORS}
+_CANCEL_WORDS = {"取消", "移除", "清除", "无"}
+
+
+def parse_self_color(value: str) -> str | None:
+    return _COLOR_INDEX.get(normalize_term(value))
+
+
+def is_cancel_request(value: str) -> bool:
+    return normalize_term(value) in _CANCEL_WORDS
+
+
+def render_color_selected(color: str) -> str:
+    lines = [
+        f"已将你自选的桃色记录为：{color}。",
+        "这是你主动选择的插件内玩笑身份，不代表机器人对你的评价。",
+        "发送“/我的桃色 取消”可随时移除。",
+    ]
+    if color == "红桃":
+        lines.append("提示：红桃的稳定社区含义目前仍未核实，这里只记录名称。")
+    return "\n".join(lines)
+

nonebot_plugin_taozi/lexicon.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import difflib
+import json
+import re
+from importlib import resources
+from pathlib import Path
+from typing import Any
+
+from pydantic import TypeAdapter
+
+from .models import LexiconEntry
+
+_ENTRY_LIST_ADAPTER = TypeAdapter(list[LexiconEntry])
+_SPACE_RE = re.compile(r"\s+")
+
+
+def normalize_term(value: str) -> str:
+    """Normalize user input without changing the displayed canonical term."""
+
+    return _SPACE_RE.sub("", value).casefold()
+
+
+class TaoziLexicon:
+    def __init__(self, entries: list[LexiconEntry]) -> None:
+        if not entries:
+            raise ValueError("桃系词典不能为空")
+
+        self._entries = tuple(entries)
+        self._index: dict[str, LexiconEntry] = {}
+        for entry in self._entries:
+            for name in (entry.term, *entry.aliases):
+                normalized = normalize_term(name)
+                previous = self._index.get(normalized)
+                if previous is not None and previous.term != entry.term:
+                    raise ValueError(f"词条别名冲突：{name}")
+                self._index[normalized] = entry
+
+    @classmethod
+    def from_json_text(cls, payload: str) -> TaoziLexicon:
+        raw: Any = json.loads(payload)
+        return cls(_ENTRY_LIST_ADAPTER.validate_python(raw))
+
+    @classmethod
+    def from_path(cls, path: Path) -> TaoziLexicon:
+        return cls.from_json_text(path.read_text(encoding="utf-8"))
+
+    @property
+    def entries(self) -> tuple[LexiconEntry, ...]:
+        return self._entries
+
+    def find(self, query: str) -> LexiconEntry | None:
+        return self._index.get(normalize_term(query))
+
+    def suggest(self, query: str, *, limit: int = 3) -> list[str]:
+        normalized = normalize_term(query)
+        if not normalized:
+            return []
+
+        contained = [
+            entry.term
+            for entry in self._entries
+            if normalized in normalize_term(entry.term)
+            or any(normalized in normalize_term(alias) for alias in entry.aliases)
+        ]
+        if contained:
+            return contained[:limit]
+
+        matches = difflib.get_close_matches(normalized, self._index.keys(), n=limit, cutoff=0.45)
+        suggestions: list[str] = []
+        for match in matches:
+            term = self._index[match].term
+            if term not in suggestions:
+                suggestions.append(term)
+        return suggestions
+
+    def list_terms(self) -> str:
+        return "、".join(entry.term for entry in self._entries)
+
+
+def load_builtin_lexicon() -> TaoziLexicon:
+    resource = resources.files("nonebot_plugin_taozi").joinpath("resources/lexicon.json")
+    return TaoziLexicon.from_json_text(resource.read_text(encoding="utf-8"))
+
+
+def render_entry(
+    entry: LexiconEntry,
+    *,
+    show_sources: bool = True,
+    compact: bool = False,
+) -> str:
+    lines = [
+        f"【{entry.term}】",
+        f"所指对象：{entry.subject}",
+        f"解释：{entry.meaning}",
+        f"可信度：{entry.confidence}",
+        f"边界：{entry.boundary}",
+    ]
+    if entry.aliases and not compact:
+        lines.insert(1, f"别名：{'、'.join(entry.aliases)}")
+
+    if show_sources:
+        lines.append("代表出处：")
+        sources = entry.sources[:1] if compact else entry.sources
+        for index, source in enumerate(sources, start=1):
+            lines.append(f"{index}. {source.title}")
+            lines.append(source.url)
+
+    if not compact:
+        lines.append(f"最后核验：{entry.verified_at}")
+        lines.append("注：非官方粉丝整理，含义会随社区语境变化。")
+    return "\n".join(lines)
+
+
+BUILTIN_LEXICON = load_builtin_lexicon()
+

nonebot_plugin_taozi/models.py

@@ -0,0 +1,30 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+Confidence = Literal["高", "中", "低"]
+SubjectType = Literal["水友立场", "主播状态", "社区造词", "含义待核实"]
+
+
+class EvidenceSource(BaseModel):
+    title: str = Field(min_length=1)
+    url: str = Field(pattern=r"^https://")
+    note: str | None = None
+
+
+class LexiconEntry(BaseModel):
+    term: str = Field(min_length=1)
+    aliases: list[str] = Field(default_factory=list)
+    meaning: str = Field(min_length=1)
+    subject: SubjectType
+    confidence: Confidence
+    boundary: str = Field(min_length=1)
+    verified_at: str = Field(pattern=r"^\d{4}-\d{2}-\d{2}$")
+    sources: list[EvidenceSource] = Field(min_length=1)
+
+
+class PersistedState(BaseModel):
+    version: Literal[1] = 1
+    disabled_groups: set[str] = Field(default_factory=set)
+    self_colors: dict[str, dict[str, str]] = Field(default_factory=dict)
+