nonebot-plugin-volt-toy 0.1.0__py3-none-any.whl

nonebot_plugin_volt_toy/__init__.py

@@ -0,0 +1,41 @@
+"""Volt-Toy —— 电击群友。
+
+v0.1 只做手动电：施电、记账、榜单、管理。
+图片检测留了挂点，暂不实现。
+"""
+
+__version__ = "0.1.0"
+
+from nonebot import require
+
+# require 必须先于任何 import：否则这两个库会以「被普通 import」的方式装载，
+# require 会判定它们不是插件并抛错。
+require("nonebot_plugin_localstore")
+require("nonebot_plugin_alconna")
+require("nonebot_plugin_uninfo")
+
+from nonebot.plugin import PluginMetadata, inherit_supported_adapters  # noqa: E402
+
+from .config import PluginConfig  # noqa: E402
+
+__plugin_meta__ = PluginMetadata(
+    name="Volt-Toy 电击群友",
+    description="用指令电群友：电压 / 电量 / 度数记账，失败计数，供电局文案。",
+    usage=(
+        "zap [@目标] —— 施电，不 @ 则电自己\n"
+        "zapkwh / zaptop / zapmax / zapking —— 度数 / 次数 / 峰值 / 电王榜\n"
+        "zapinfo [@目标] —— 个人用电档案\n"
+        "zapclear / zapnodo / zapon / zapoff —— 管理"
+    ),
+    type="application",
+    config=PluginConfig,
+    # 收发走 alconna 的 uniseg、会话信息走 uninfo，因此声明两者共同支持的适配器
+    supported_adapters=inherit_supported_adapters(
+        "nonebot_plugin_alconna",
+        "nonebot_plugin_uninfo",
+    ),
+    homepage="https://github.com/Funny1Potato/Volt-Toy",
+    extra={"License": "MIT", "Author": "Funny1Potato"},
+)
+
+from . import commands as _commands  # noqa: E402,F401

nonebot_plugin_volt_toy/commands.py

@@ -0,0 +1,270 @@
+"""指令层：Alconna 解析参数，平台层解析会话，业务在内核 ZapService。
+
+写法依据：
+- nonebot 官方最佳实践 `on_alconna` 页面：`Match[<type>]` 注入、`use_cmd_start`
+  默认是 False（必须显式打开才会响应 `/` 前缀）、`on_alconna(..., priority=, block=)`
+  通过 **kwargs 转发给 matcher。
+- alconna `uniseg` 页面：用 `UniMessage([Text(...), Image(...)])` 组装并 `.send()`；
+  `At` 的字段是 `flag/target/display`，`flag` 可能是 role/channel，需要过滤。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from arclet.alconna import Alconna, Args
+from nonebot import logger
+from nonebot.adapters import Bot, Event
+from nonebot_plugin_alconna import At, Image, Match, on_alconna
+from nonebot_plugin_alconna.uniseg import Text, UniMessage
+
+from volt_toy_core import texts
+from volt_toy_core.render import info_text, rank_king, rank_kwh, rank_max, rank_top
+from volt_toy_core.service import ZapRequest
+
+from . import platform
+from . import runtime
+from .runtime import config, save_whitelist, settings, state
+
+
+_ALCONNA_REFS: list[Alconna] = []
+
+
+def _cmd(*args: Any, **kwargs: Any) -> Alconna:
+    """持有强引用，避免 Alconna 被 GC 后 matcher 静默失效。"""
+    alc = Alconna(*args, **kwargs)
+    _ALCONNA_REFS.append(alc)
+    return alc
+
+
+zap_cmd = on_alconna(
+    _cmd("zap", Args["target?", At]),
+    aliases={"电", "电击", "雷"},
+    use_cmd_start=True,
+    priority=10,
+    block=True,
+)
+zapkwh_cmd = on_alconna(
+    _cmd("zapkwh"), aliases={"度数榜", "电费榜"}, use_cmd_start=True, priority=11, block=True
+)
+zaptop_cmd = on_alconna(
+    _cmd("zaptop"), aliases={"被电榜"}, use_cmd_start=True, priority=11, block=True
+)
+zapmax_cmd = on_alconna(
+    _cmd("zapmax"), aliases={"峰值榜"}, use_cmd_start=True, priority=11, block=True
+)
+zapking_cmd = on_alconna(
+    _cmd("zapking"), aliases={"电王榜"}, use_cmd_start=True, priority=11, block=True
+)
+zapinfo_cmd = on_alconna(
+    _cmd("zapinfo", Args["target?", At]), aliases={"电档"}, use_cmd_start=True, priority=11, block=True
+)
+zapclear_cmd = on_alconna(
+    _cmd("zapclear", Args["target?", At]), use_cmd_start=True, priority=11, block=True
+)
+zapnodo_cmd = on_alconna(
+    _cmd("zapnodo", Args["target?", At]), aliases={"绝缘"}, use_cmd_start=True, priority=11, block=True
+)
+zapon_cmd = on_alconna(_cmd("zapon"), use_cmd_start=True, priority=11, block=True)
+zapoff_cmd = on_alconna(_cmd("zapoff"), use_cmd_start=True, priority=11, block=True)
+
+_NO_SESSION = "这个适配器没有提供会话信息，暂时电不了。"
+
+
+def _at_value(segment: Any) -> str:
+    # At 也能表示 @角色 / @频道，这里只接受具体用户
+    if str(getattr(segment, "flag", "user")) != "user":
+        return ""
+    for attr in ("target", "qq", "user_id", "id"):
+        value = getattr(segment, attr, None)
+        if value:
+            return str(value)
+    return ""
+
+
+def _at_name(segment: Any) -> str:
+    for attr in ("display", "name"):
+        value = getattr(segment, attr, None)
+        if value:
+            return str(value).lstrip("@")
+    return ""
+
+
+async def _reply(text: str) -> None:
+    await UniMessage.text(text).send()
+
+
+async def _resolve_target(
+    bot: Bot, session: platform.SceneInfo, target: Match[At]
+) -> tuple[str, str]:
+    if target.available:
+        uid = _at_value(target.result)
+        if uid:
+            name = _at_name(target.result)
+            if not name:
+                name = await platform.member_name(bot, session, uid)
+            return uid, name
+    return session.user_id, session.display_user
+
+
+@zap_cmd.handle()
+async def _handle_zap(bot: Bot, event: Event, target: Match[At]) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+
+    target_id, target_name = await _resolve_target(bot, session, target)
+    if target_id == session.bot_id and target_id:
+        await _reply(
+            texts.render(
+                texts.pick("bot", scope=session.key),
+                actor=session.display_user,
+                target=target_name,
+            )
+        )
+        return
+
+    request = ZapRequest(
+        gid=session.key,
+        actor=session.user_id,
+        target=target_id,
+        actor_name=session.display_user,
+        target_name=target_name or target_id,
+        self_zap=target_id == session.user_id,
+        privileged=platform.is_admin(bot, session, session.user_id),
+    )
+    outcome = await runtime.service.zap(request)
+
+    if outcome.ok and config.volt_show_avatar:
+        avatar = await platform.fetch_avatar(
+            bot, session, target_id, config.volt_avatar_timeout
+        )
+        if avatar:
+            message = UniMessage([Text(outcome.text), Image(raw=avatar)])
+        else:
+            message = UniMessage.text(outcome.text)
+    else:
+        message = UniMessage.text(outcome.text)
+    await message.send()
+
+
+@zapkwh_cmd.handle()
+async def _handle_kwh(bot: Bot, event: Event) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+    records = runtime.get_store().records(session.key)
+    await _reply(rank_kwh(records, settings, scope=session.key))
+
+
+@zaptop_cmd.handle()
+async def _handle_top(bot: Bot, event: Event) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+    records = runtime.get_store().records(session.key)
+    await _reply(rank_top(records, scope=session.key))
+
+
+@zapmax_cmd.handle()
+async def _handle_max(bot: Bot, event: Event) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+    records = runtime.get_store().records(session.key)
+    await _reply(rank_max(records, scope=session.key))
+
+
+@zapking_cmd.handle()
+async def _handle_king(bot: Bot, event: Event) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+    await _reply(rank_king(runtime.get_store().records(session.key), scope=session.key))
+
+
+@zapinfo_cmd.handle()
+async def _handle_info(bot: Bot, event: Event, target: Match[At]) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+    uid, name = await _resolve_target(bot, session, target)
+    record = runtime.get_store().records(session.key).get(uid)
+    if not record:
+        await _reply(texts.render(texts.MISSING_TEXT, name=name or uid))
+        return
+    await _reply(info_text(record, settings, name=name))
+
+
+@zapclear_cmd.handle()
+async def _handle_clear(bot: Bot, event: Event, target: Match[At]) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+    if not platform.is_admin(bot, session, session.user_id):
+        await _reply("无权限使用此命令。")
+        return
+    uid, name = await _resolve_target(bot, session, target)
+    if not await runtime.get_store().clear(session.key, uid):
+        await _reply(f"没有查到 {name or uid} 的用电记录。")
+        return
+    await _reply(
+        texts.render(
+            texts.pick("clear", scope=session.key),
+            name=name or uid,
+            actor=session.display_user,
+        )
+    )
+
+
+@zapnodo_cmd.handle()
+async def _handle_nodo(bot: Bot, event: Event, target: Match[At]) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+    if not platform.is_admin(bot, session, session.user_id):
+        await _reply("无权限使用此命令。")
+        return
+    uid, name = await _resolve_target(bot, session, target)
+    if uid in state.whitelist:
+        state.whitelist.discard(uid)
+        save_whitelist(state.whitelist)
+        await _reply(f"已解除 {name or uid} 的免电保护。")
+    else:
+        state.whitelist.add(uid)
+        save_whitelist(state.whitelist)
+        await _reply(f"已将 {name or uid} 加入免电名单。")
+
+
+@zapon_cmd.handle()
+async def _handle_on(bot: Bot, event: Event) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+    if not platform.is_admin(bot, session, session.user_id):
+        await _reply("无权限使用此命令。")
+        return
+    state.set_group_enabled(session.key, True)
+    await _reply("本群用电业务已恢复。")
+
+
+@zapoff_cmd.handle()
+async def _handle_off(bot: Bot, event: Event) -> None:
+    session = await platform.resolve(bot, event)
+    if session is None:
+        await _reply(_NO_SESSION)
+        return
+    if not platform.is_admin(bot, session, session.user_id):
+        await _reply("无权限使用此命令。")
+        return
+    state.set_group_enabled(session.key, False)
+    await _reply("本群用电业务已停止。")

nonebot_plugin_volt_toy/config.py

@@ -0,0 +1,35 @@
+"""插件配置定义。
+
+字段名即环境变量名（大写），例如 `volt_receive_cap` → `VOLT_RECEIVE_CAP`。
+"""
+
+from nonebot import get_plugin_config
+from pydantic import BaseModel, Field
+
+
+class PluginConfig(BaseModel):
+    volt_receive_cap: int = Field(
+        25, description="单目标每日受电上限；超出只记次数与失败，不加电量（0 = 不限）"
+    )
+    volt_overload_window: int = Field(60, description="过载统计窗口（秒）")
+    volt_overload_threshold: int = Field(10, description="窗口内最多施电次数，达到即跳闸")
+    volt_overload_ban: int = Field(300, description="跳闸时长（秒）")
+
+    volt_daily_quota: int = Field(0, description="每日施电额度（0 = 不限）")
+    volt_cooldown: int = Field(0, description="同一目标冷却秒数（0 = 关闭）")
+
+    volt_crit_prob: float = Field(0.15, description="暴击概率（0~1）")
+    volt_self_efficiency: float = Field(0.8, description="电自己的效率倍率（0~1）")
+    volt_price_per_kwh: float = Field(0.55, description="电价（元/度），只影响展示")
+
+    volt_is_log: bool = Field(False, description="是否写逐条审计日志 zap_log.jsonl")
+    volt_group_default: bool = Field(True, description="新群默认是否启用")
+    volt_whitelist: list[str] = Field(default_factory=list, description="免电名单初始值（用户 id）")
+
+    volt_show_avatar: bool = Field(True, description="成功施电后是否附带被电者头像（仅 QQ 系协议）")
+    volt_avatar_timeout: float = Field(5.0, description="头像下载超时（秒），失败时只发文本")
+
+
+__all__ = ["PluginConfig", "plugin_config"]
+
+plugin_config: PluginConfig = get_plugin_config(PluginConfig)

nonebot_plugin_volt_toy/platform.py

@@ -0,0 +1,225 @@
+"""跨协议会话解析（依据 nonebot-plugin-uninfo 与 alconna 官方文档）。
+
+- `get_session(bot, event)`：uninfo 的公开接口，适配器不支持时返回 None
+- `get_target(event, bot)`：alconna 的回落，只保证有会话 id
+- 会话键：`适配器slug:scene_path`，scene_path 由 uninfo 统一（群=群号，频道=父id_子id）
+- 昵称/头像：uninfo 的 `User.name` / `User.avatar`，取不到再退回 id
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+from nonebot import get_driver, logger
+from nonebot.adapters import Bot, Event
+from nonebot_plugin_alconna.uniseg import get_target
+from nonebot_plugin_uninfo import get_interface, get_session
+
+MAX_AVATAR_BYTES = 5 * 1024 * 1024
+
+_ADAPTER_ALIASES = {
+    "OneBot V11": "onebot11",
+    "OneBot V12": "onebot12",
+}
+
+# uninfo 在各适配器里统一了角色 id（见 uninfo permission.py 的 ADMIN/OWNER）
+_ADMIN_ROLE_IDS = {"OWNER", "ADMINISTRATOR"}
+_ADMIN_ROLE_NAMES = {"owner", "admin"}
+
+
+def adapter_name_of(value: Any) -> str:
+    """SupportAdapter 是枚举，必须取 .value 才是 'onebot11'。"""
+    return str(getattr(value, "value", value) or "")
+
+
+def adapter_slug(name: Any) -> str:
+    text = adapter_name_of(name).strip()
+    if text in _ADAPTER_ALIASES:
+        return _ADAPTER_ALIASES[text]
+    return re.sub(r"[^0-9a-z]+", "", text.lower()) or "unknown"
+
+
+def _user_name(user: Any) -> str:
+    if user is None:
+        return ""
+    return str(getattr(user, "name", None) or getattr(user, "nick", None) or "")
+
+
+@dataclass(slots=True)
+class SceneInfo:
+    key: str
+    slug: str
+    scene_path: str
+    chat_id: str
+    user_id: str
+    user_name: str
+    card: str = ""
+    avatar: str = ""
+    is_private: bool = False
+    is_channel: bool = False
+    adapter: str = ""
+    role_id: str = ""
+    role_name: str = ""
+    bot_id: str = ""
+    scene_type: Any = None
+    member_scene_type: Any = None
+    member_scene_id: str = ""
+
+    @property
+    def display_user(self) -> str:
+        return self.card or self.user_name or self.user_id
+
+
+def _role_fields(member: Any) -> tuple[str, str]:
+    role = getattr(member, "role", None) if member is not None else None
+    if role is None:
+        return "", ""
+    return str(getattr(role, "id", "") or ""), str(getattr(role, "name", "") or "")
+
+
+async def _from_uninfo(bot: Bot, event: Event, session: Any) -> SceneInfo:
+    scene = session.scene
+    member = getattr(session, "member", None)
+    user = getattr(session, "user", None)
+    parent = getattr(scene, "parent", None) or scene
+    slug = adapter_slug(session.adapter)
+    role_id, role_name = _role_fields(member)
+    return SceneInfo(
+        key=f"{slug}:{session.scene_path}",
+        slug=slug,
+        scene_path=str(session.scene_path),
+        chat_id=str(scene.id),
+        user_id=str(getattr(user, "id", "") or _event_user_id(event)),
+        user_name=_user_name(user),
+        card=str(getattr(member, "nick", "") or "").strip(),
+        avatar=str(getattr(user, "avatar", "") or ""),
+        is_private=bool(getattr(scene, "is_private", False)),
+        is_channel=bool(getattr(scene, "is_channel", False)),
+        adapter=bot.adapter.get_name(),
+        role_id=role_id,
+        role_name=role_name.lower(),
+        bot_id=str(getattr(session, "self_id", "") or getattr(bot, "self_id", "")),
+        scene_type=getattr(scene, "type", None),
+        member_scene_type=getattr(parent, "type", None),
+        member_scene_id=str(getattr(parent, "id", "") or ""),
+    )
+
+
+def _event_user_id(event: Event) -> str:
+    try:
+        return str(event.get_user_id() or "")
+    except Exception:
+        return ""
+
+
+async def resolve(bot: Bot, event: Event) -> SceneInfo | None:
+    """解析当前事件所属会话；适配器不支持时返回 None。"""
+    try:
+        session = await get_session(bot, event)
+    except Exception as error:
+        logger.debug(f"volt-toy: uninfo 解析会话失败: {error}")
+        session = None
+
+    if session is not None:
+        try:
+            return await _from_uninfo(bot, event, session)
+        except Exception as error:
+            logger.debug(f"volt-toy: uninfo 会话结构异常: {error}")
+
+    try:
+        target = get_target(event, bot)
+    except Exception as error:
+        logger.debug(f"volt-toy: 无法解析会话: {error}")
+        return None
+    path = f"{target.parent_id}_{target.id}" if (target.channel and target.parent_id) else target.id
+    slug = adapter_slug(bot.adapter.get_name())
+    uid = _event_user_id(event)
+    return SceneInfo(
+        key=f"{slug}:{path}",
+        slug=slug,
+        scene_path=str(path),
+        chat_id=str(target.id),
+        user_id=uid,
+        user_name=uid,
+        is_private=bool(getattr(target, "private", False)),
+        is_channel=bool(getattr(target, "channel", False)),
+        adapter=bot.adapter.get_name(),
+        bot_id=str(getattr(bot, "self_id", "") or ""),
+    )
+
+
+async def member_name(bot: Bot, session: SceneInfo | None, uid: str) -> str:
+    """按 id 取显示名：群名片 > 昵称 > id。"""
+    uid = str(uid or "").strip()
+    if not uid or session is None:
+        return uid
+    interface = get_interface(bot)
+    if interface is None:
+        return uid
+    if session.member_scene_type is not None and session.member_scene_id:
+        try:
+            member = await interface.get_member(
+                session.member_scene_type, session.member_scene_id, uid
+            )
+            if member is not None:
+                return str(getattr(member, "nick", "") or _user_name(getattr(member, "user", None)) or uid)
+        except Exception as error:
+            logger.debug(f"volt-toy: 取成员 {uid} 失败: {error}")
+    try:
+        user = await interface.get_user(uid)
+        if user is not None:
+            return _user_name(user) or uid
+    except Exception as error:
+        logger.debug(f"volt-toy: 取用户 {uid} 失败: {error}")
+    return uid
+
+
+def is_admin(bot: Bot, session: SceneInfo | None, uid: str) -> bool:
+    if not uid:
+        return False
+    superusers = set(getattr(get_driver().config, "superusers", set()) or set())
+    if uid in superusers:
+        return True
+    if session is None or session.is_private:
+        return False
+    return session.role_id in _ADMIN_ROLE_IDS or session.role_name in _ADMIN_ROLE_NAMES
+
+
+def _qq_like(session: SceneInfo) -> bool:
+    return session.slug in {"onebot11", "onebot12", "qq"} or "qq" in session.adapter.lower()
+
+
+async def _avatar_url(bot: Bot, session: SceneInfo, uid: str) -> str:
+    """优先用 uninfo 给出的头像地址；QQ 系协议再用 qlogo 兜底。"""
+    if uid == session.user_id and session.avatar:
+        return session.avatar
+    interface = get_interface(bot)
+    if interface is not None:
+        try:
+            user = await interface.get_user(uid)
+            if user is not None and user.avatar:
+                return str(user.avatar)
+        except Exception as error:
+            logger.debug(f"volt-toy: 取头像地址失败: {error}")
+    if _qq_like(session) and uid.isdigit():
+        return f"https://q4.qlogo.cn/headimg_dl?dst_uin={uid}&spec=640"
+    return ""
+
+
+async def fetch_avatar(bot: Bot, session: SceneInfo, uid: str, timeout: float) -> bytes | None:
+    """尽力取头像；拿不到就返回 None，不影响文本消息。"""
+    url = await _avatar_url(bot, session, uid)
+    if not url.startswith(("http://", "https://")):
+        return None
+    try:
+        async with httpx.AsyncClient(timeout=timeout, follow_redirects=True) as client:
+            response = await client.get(url)
+            if response.status_code != 200 or len(response.content) > MAX_AVATAR_BYTES:
+                return None
+            return response.content
+    except Exception as error:
+        logger.debug(f"volt-toy: 头像下载失败: {error}")
+        return None

nonebot_plugin_volt_toy/runtime.py

@@ -0,0 +1,61 @@
+"""插件级单例：配置、状态、存储与服务。"""
+
+from __future__ import annotations
+
+from nonebot import get_driver, logger
+from volt_toy_core.service import ZapService
+from volt_toy_core.settings import Settings
+from volt_toy_core.state import RuntimeState
+from volt_toy_core.storage import JsonStore, read_json_list, write_json_list
+
+from . import store as store_module
+from .config import plugin_config as config
+
+settings = Settings(
+    receive_cap=config.volt_receive_cap,
+    overload_window=config.volt_overload_window,
+    overload_threshold=config.volt_overload_threshold,
+    overload_ban=config.volt_overload_ban,
+    daily_quota=config.volt_daily_quota,
+    cooldown=config.volt_cooldown,
+    crit_prob=config.volt_crit_prob,
+    self_efficiency=config.volt_self_efficiency,
+    price_per_kwh=config.volt_price_per_kwh,
+    is_log=config.volt_is_log,
+    group_default_enabled=config.volt_group_default,
+)
+
+state = RuntimeState()
+
+# store / service 在 startup 时才就绪（localstore 需要插件已加载才能推断调用方）。
+service: ZapService
+
+
+def get_store() -> JsonStore:
+    return store_module.store
+
+
+def load_whitelist() -> set[str]:
+    stored = read_json_list(store_module.WHITELIST_FILE)
+    if stored:
+        return set(stored)
+    return {str(item) for item in config.volt_whitelist}
+
+
+def save_whitelist(items: set[str]) -> None:
+    write_json_list(store_module.WHITELIST_FILE, sorted(items))
+
+
+@get_driver().on_startup
+async def _prepare() -> None:
+    global service
+    store_module.resolve()
+    await store_module.store.load()
+    state.whitelist = load_whitelist()
+    service = ZapService(
+        store=store_module.store,
+        state=state,
+        settings=settings,
+        log=store_module.log,
+    )
+    logger.debug(f"Volt-Toy 账本: {store_module.ACCOUNT_FILE}")

nonebot_plugin_volt_toy/store.py

@@ -0,0 +1,32 @@
+"""数据文件位置：由 nonebot-plugin-localstore 统一管理。
+
+localstore 通过调用栈推断「是哪个插件在要文件」。导入期调用要求模块
+已经被 nonebot 登记为插件；一旦插件是以普通模块方式被 import（例如
+editable 安装时被其他 finder 抢先解析），这里就会抛
+``Cannot detect caller plugin``。把解析推迟到 startup，两种加载方式都安全。
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from nonebot import logger
+from nonebot_plugin_localstore import get_plugin_data_file
+from volt_toy_core.storage import JsonStore, JsonlLog
+
+ACCOUNT_FILE: Path
+LOG_FILE: Path
+WHITELIST_FILE: Path
+
+store: JsonStore
+log: JsonlLog
+
+
+def resolve() -> None:
+    """在插件加载完成后调用一次，构造存储对象。"""
+    global ACCOUNT_FILE, LOG_FILE, WHITELIST_FILE, store, log
+    ACCOUNT_FILE = get_plugin_data_file("zap.json")
+    LOG_FILE = get_plugin_data_file("zap_log.jsonl")
+    WHITELIST_FILE = get_plugin_data_file("zap_whitelist.json")
+    store = JsonStore(ACCOUNT_FILE, logger=logger.warning)
+    log = JsonlLog(LOG_FILE)