nonebot-plugin-R6States 1.0.0__py3-none-any.whl

nonebot_plugin_R6States/__init__.py

@@ -0,0 +1,117 @@
+from nonebot import on_command, logger
+from nonebot.adapters import Message
+from nonebot.params import CommandArg
+from nonebot.plugin import PluginMetadata, get_plugin_config
+from nonebot.adapters.onebot.v11 import MessageEvent, MessageSegment, GroupMessageEvent
+
+from .config import Config
+from .service import VALID_PLATFORMS, ServiceError, get_full_stats
+from .formatter import format_full_stats
+from .renderer import render_full_stats
+from .config_mannger import (
+    KEY_TTL_DAYS,
+    set_apikey,
+    resolve_apikey,
+    get_apikey_age_days,
+)
+
+__plugin_meta__ = PluginMetadata(
+    name="彩六数据查询",
+    description="查询指定玩家的数据",
+    usage="/r6 <id> [平台]　/r6key <key>　/r6help",
+    homepage="https://github.com/Siornya/nonebot-plugin-R6States",
+    type="application",
+    config=Config,
+    supported_adapters={"~onebot.v11"},
+)
+
+plugin_config = get_plugin_config(Config)
+
+r6 = on_command("r6", aliases={"R6"}, priority=10, block=True)
+r6_key = on_command("r6key", aliases={"R6key", "R6DAPI", "r6dapi"}, priority=5, block=True)
+r6_help = on_command("r6help", aliases={"R6help"}, priority=5, block=True)
+
+HELP_TEXT = (
+    "彩六数据查询\n"
+    "/r6 <id> [平台]   查询玩家数据（平台默认 uplay，可选 psn/xbl）\n"
+    "/r6key <key>      设置本群/本人的 r6data API Key\n"
+    "/r6help           显示本帮助\n"
+    "Key 可在 https://r6data.com/ 免费获取；优先用你的个人 Key，没有则用群 Key"
+)
+
+
+def _scope_id(event: MessageEvent) -> str:
+    """设置 key 的归属：群聊按群、私聊按人。"""
+    if isinstance(event, GroupMessageEvent):
+        return str(event.group_id)
+    return str(event.user_id)
+
+
+def _lookup_scopes(event: MessageEvent) -> list[str]:
+    """查询时的 key 候选顺序：个人优先，个人没设则回退到群。"""
+    if isinstance(event, GroupMessageEvent):
+        return [str(event.user_id), str(event.group_id)]
+    return [str(event.user_id)]
+
+
+@r6_help.handle()
+async def _():
+    await r6_help.finish(HELP_TEXT)
+
+
+@r6_key.handle()
+async def _(event: MessageEvent, args: Message = CommandArg()):
+    key = args.extract_plain_text().strip()
+    if not key:
+        await r6_key.finish(
+            "请在命令后输入 API Key，例如：/r6key abcdef...\n"
+            "没有的话可在 https://r6data.com/ 免费获取"
+        )
+
+    scope = _scope_id(event)
+    set_apikey(scope, key)
+    where = "本群" if isinstance(event, GroupMessageEvent) else "个人"
+    await r6_key.finish(f"✅ 已设置{where} API Key（官方有效期约 {KEY_TTL_DAYS} 天）")
+
+
+@r6.handle()
+async def _(event: MessageEvent, args: Message = CommandArg()):
+    tokens = args.extract_plain_text().split()
+    if not tokens:
+        await r6.finish("用法：/r6 <id> [平台]，详见 /r6help")
+
+    # 末尾 token 若是平台名则作为平台，其余都当作玩家 id。
+    platform = "uplay"
+    if len(tokens) > 1 and tokens[-1].lower() in VALID_PLATFORMS:
+        platform = tokens[-1].lower()
+        tokens = tokens[:-1]
+
+    if len(tokens) > 5:
+        await r6.finish("一次最多查询 5 个 id")
+
+    scopes = _lookup_scopes(event)
+
+    # key 临近过期的轻提醒（针对实际命中的那个 key，不阻断查询）。
+    _, matched = resolve_apikey(scopes)
+    age = get_apikey_age_days(matched) if matched else None
+    if age is not None and age >= KEY_TTL_DAYS:
+        await r6.send(f"⚠️ 当前 API Key 已设置 {age:.0f} 天，可能已过期，如查询失败请 /r6key 重设")
+
+    for player_id in tokens:
+        try:
+            data = await get_full_stats(
+                player_id, scopes, platform, season_year=plugin_config.current_season
+            )
+            if plugin_config.r6_output_image:
+                try:
+                    png = render_full_stats(player_id, data)
+                    await r6.send(MessageSegment.image(png))
+                    continue
+                except Exception as e:  # noqa: BLE001 - 渲染失败回退文本
+                    logger.warning(f"图片渲染失败，回退文本: {type(e).__name__}: {e}")
+            await r6.send(format_full_stats(player_id, data))
+        except ServiceError as e:
+            await r6.send(f"❌ {player_id}：{e.message}")
+        except Exception as e:  # noqa: BLE001
+            logger.error(f"查询 {player_id} 出错: {type(e).__name__}: {e}")
+            await r6.send(f"❌ {player_id}：查询失败")

nonebot_plugin_R6States/cache.py

@@ -0,0 +1,63 @@
+"""轻量本地缓存：单 JSON 文件 + 每条目独立 TTL + 异步锁 + 原子写。
+
+设计动机（对比旧的 players.yaml）：
+- 旧实现按**整文件** mtime 判 TTL，一次写入会重置所有条目的有效期，过期还整包丢弃。
+- 这里每条目自带写入时间戳，**各自过期**；TTL 由调用方按 endpoint 指定。
+- 写入走 "临时文件 + os.replace" 原子替换，配异步锁，避免并发下半写/相互覆盖。
+"""
+from __future__ import annotations
+
+import os
+import json
+import time
+import asyncio
+import tempfile
+from typing import Any, Optional
+from pathlib import Path
+
+
+class JSONCache:
+    def __init__(self, path: Path) -> None:
+        self._path = path
+        self._lock = asyncio.Lock()
+
+    def _load(self) -> dict[str, dict[str, Any]]:
+        if not self._path.exists():
+            return {}
+        try:
+            with self._path.open("r", encoding="utf-8") as f:
+                data = json.load(f)
+            return data if isinstance(data, dict) else {}
+        except (json.JSONDecodeError, OSError):
+            # 缓存损坏不应影响主流程：当作空缓存重建。
+            return {}
+
+    def _atomic_write(self, data: dict[str, dict[str, Any]]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(dir=str(self._path.parent), suffix=".tmp")
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                json.dump(data, f, ensure_ascii=False, separators=(",", ":"))
+            os.replace(tmp, self._path)
+        except BaseException:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            raise
+
+    async def get(self, key: str, ttl: float) -> Optional[Any]:
+        """命中且未超过 ttl（秒）则返回缓存值，否则返回 None。"""
+        async with self._lock:
+            entry = self._load().get(key)
+        if not entry:
+            return None
+        if time.time() - entry.get("ts", 0) > ttl:
+            return None
+        return entry.get("value")
+
+    async def set(self, key: str, value: Any) -> None:
+        async with self._lock:
+            data = self._load()
+            data[key] = {"ts": time.time(), "value": value}
+            self._atomic_write(data)

nonebot_plugin_R6States/config.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class Config(BaseModel):
+    #: 当前赛季代码（如 "Y10S4"）。查询默认按此赛季过滤；填 "all" 则不过滤、查生涯。
+    #: 在 .env 里用 CURRENT_SEASON=Y10S4 覆盖；每赛季更新一次即可。
+    current_season: str = "Y11S2"
+
+    #: 查询结果是否渲染成图片（失败时自动回退文本）。.env 用 R6_OUTPUT_IMAGE=false 关闭。
+    r6_output_image: bool = True

nonebot_plugin_R6States/config_mannger.py

@@ -0,0 +1,72 @@
+"""按群/按人管理 r6data api-key。
+
+落盘格式（带设置时间戳，用于过期提醒；key 官方有效期约 1 个月）::
+
+    {"apikeys": {"<id>": {"key": "...", "set_at": 1712345678.0}}}
+"""
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Optional
+
+from .storage import API_KEY_FILE
+
+#: 官方 key 有效期约 30 天，超过这个天数就在查询时给个提醒。
+KEY_TTL_DAYS = 30
+
+
+def load_config() -> dict[str, Any]:
+    if not API_KEY_FILE.exists():
+        return {"apikeys": {}}
+    try:
+        with API_KEY_FILE.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return {"apikeys": {}}
+    data.setdefault("apikeys", {})
+    return data
+
+
+def save_config(data: dict[str, Any]) -> None:
+    API_KEY_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with API_KEY_FILE.open("w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+def set_apikey(target_id: str, key: str) -> None:
+    data = load_config()
+    data["apikeys"][target_id] = {"key": key, "set_at": time.time()}
+    save_config(data)
+
+
+def _entry(target_id: str) -> Optional[dict[str, Any]]:
+    raw = load_config()["apikeys"].get(target_id)
+    if raw is None:
+        return None
+    return raw
+
+
+def get_apikey(target_id: str) -> Optional[str]:
+    entry = _entry(target_id)
+    return entry["key"] if entry else None
+
+
+def resolve_apikey(scopes: list[str]) -> tuple[Optional[str], Optional[str]]:
+    """按候选顺序找第一个有 key 的归属，返回 (key, 命中的 scope)。
+
+    群聊传 [群号, 用户号]：群没设 key 时回退到个人 key。
+    """
+    for scope in scopes:
+        key = get_apikey(scope)
+        if key:
+            return key, scope
+    return None, None
+
+
+def get_apikey_age_days(target_id: str) -> Optional[float]:
+    """key 已设置的天数；旧格式/未设置返回 None。"""
+    entry = _entry(target_id)
+    if not entry:
+        return None
+    return (time.time() - entry["set_at"]) / 86400

nonebot_plugin_R6States/formatter.py

@@ -0,0 +1,91 @@
+"""把 fullStats 返回格式化成可发送文本。
+
+fullStats 顶层有三块：
+- ``operators``：干员明细（operator/side/roundsPlayed/winPercent/kd/headshotPercent...）
+- ``platform_families_full_profiles``：各 board(ranked/casual/...)的完整档案
+- ``data``：tracker 风格的 platformInfo / metadata(等级、通行证) / segments
+"""
+from __future__ import annotations
+
+from typing import Any
+
+#: 默认展示出场最多的前 N 个干员
+TOP_N = 8
+
+_SIDE_CN = {"Attacker": "攻", "Defender": "防"}
+_BOARD_CN = {
+    "ranked": "排位", "casual": "休闲", "standard": "标准",
+    "event": "活动", "warmup": "热身",
+}
+
+
+def _format_boards(profiles: list[dict[str, Any]]) -> list[str]:
+    """各 board 取最新赛季档案，输出概览行。"""
+    out: list[str] = []
+    for fam in profiles:
+        for board in fam.get("board_ids_full_profiles") or []:
+            fps = board.get("full_profiles") or []
+            if not fps:
+                continue
+            fp = max(fps, key=lambda f: f.get("season_id", 0))
+            p = fp.get("profile") or {}
+            wins, losses = p.get("wins", 0), p.get("losses", 0)
+            kills, deaths = p.get("kills", 0), p.get("deaths", 0)
+            wr = wins / (wins + losses) * 100 if (wins + losses) else 0
+            kd = kills / deaths if deaths else float(kills)
+            name = _BOARD_CN.get(board.get("board_id", ""), board.get("board_id", "?"))
+            out.append(
+                f"{name} RP{p.get('rank_points', 0)}(峰{p.get('max_rank_points', 0)}) "
+                f"胜负{wins}/{losses}({wr:.0f}%) KD{kd:.2f} 掉线{p.get('abandon', 0)}"
+            )
+    return out
+
+
+def _format_operators(operators: list[dict[str, Any]], top_n: int) -> list[str]:
+    ranked = sorted(operators, key=lambda o: o.get("roundsPlayed", 0), reverse=True)
+    out: list[str] = []
+    for op in ranked[:top_n]:
+        side = _SIDE_CN.get(op.get("side", ""), op.get("side", "?"))
+        out.append(
+            f"{op.get('operator', '?')}({side}) "
+            f"场{op.get('roundsPlayed', 0)} "
+            f"胜{op.get('winPercent', 0)}% "
+            f"KD{op.get('kd', 0)}"
+        )
+    # 聚合：用总量重算，避免对各干员百分比做无权平均
+    kills = sum(o.get("kills", 0) for o in operators)
+    deaths = sum(o.get("deaths", 0) for o in operators)
+    rounds = sum(o.get("roundsPlayed", 0) for o in operators)
+    kd = kills / deaths if deaths else float(kills)
+    out.append(f"— 合计 {len(operators)} 干员 场{rounds} KD{kd:.2f}")
+    return out
+
+
+def format_full_stats(player_id: str, data: dict[str, Any], top_n: int = TOP_N) -> str:
+    info = data.get("data") or {}
+    handle = (info.get("platformInfo") or {}).get("platformUserHandle") or player_id
+    meta = info.get("metadata") or {}
+
+    lines = [f"🎯 {handle} 数据快照"]
+
+    head_bits = []
+    if meta.get("clearanceLevel") is not None:
+        head_bits.append(f"等级{meta['clearanceLevel']}")
+    if meta.get("battlepassLevel") is not None:
+        head_bits.append(f"通行证{meta['battlepassLevel']}")
+    if head_bits:
+        lines.append("　".join(head_bits))
+
+    board_lines = _format_boards(data.get("platform_families_full_profiles") or [])
+    if board_lines:
+        lines.append("— 档案 —")
+        lines.extend(board_lines)
+
+    operators = data.get("operators") or []
+    if operators:
+        lines.append("— 干员 Top —")
+        lines.extend(_format_operators(operators, top_n))
+
+    if not board_lines and not operators:
+        return f"🎯 {handle}：没有查询到数据"
+    return "\n".join(lines)

nonebot_plugin_R6States/r6data.py

@@ -0,0 +1,491 @@
+"""
+r6data.py — Python 移植版 r6-data.js (Players + Game)
+
+对 https://api.r6data.com/api 的薄封装,异步 (httpx)。从官方 npm 包
+`r6-data.js` 移植而来;源码层逻辑长期稳定,只有下面 ``易变常量`` 区域会
+随赛季/平台调整,跟新版时基本只动那几行。
+
+依赖:  pip install httpx
+用法:
+    from .r6data import R6Client
+
+    r6 = R6Client(api_key="YOUR_KEY")
+    info = await r6.players.get_account_info("PlayerName", "uplay")
+    ops  = await r6.game.get_operators(side="attacker")
+    await r6.aclose()
+
+NoneBot 启动时检查版本(贴进插件 __init__.py):
+    from nonebot import get_driver, logger
+    from .r6data import check_latest_version, BASED_ON_VERSION
+
+    @get_driver().on_startup
+    async def _r6_version_check():
+        latest = await check_latest_version()
+        if latest and latest != BASED_ON_VERSION:
+            logger.warning(
+                f"r6data 移植基于 r6-data.js@{BASED_ON_VERSION}, "
+                f"上游最新为 {latest},建议核对是否有接口变化。"
+            )
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional, Sequence, Mapping
+
+import httpx
+
+# ──────────────────────────────────────────────────────────────────────────
+# 易变常量 —— 跟随上游版本时,基本只需要改这一段
+# ──────────────────────────────────────────────────────────────────────────
+
+#: 本移植对标的 r6-data.js 版本。启动时与 npm 最新版比对。
+BASED_ON_VERSION = "3.1.7"
+
+#: 上游历史上换过一次域名 (r6data.eu -> r6data.com)。如再变,改这里。
+BASE_URL = "https://api.r6data.com/api"
+
+#: getRanks 接受的 version 取值;新赛季可能新增 v7...
+VALID_RANK_VERSIONS = ("v1", "v2", "v3", "v4", "v5", "v6")
+
+#: getPlayerStats / 对比时 board_id 的合法取值
+VALID_BOARD_IDS = ("casual", "event", "warmup", "standard", "ranked")
+
+# 平台 / 平台族(供调用方参考,运行时不强校验)
+PLATFORM_TYPES = ("uplay", "psn", "xbl")
+PLATFORM_FAMILIES = ("pc", "console")
+
+__all__ = [
+    "R6Client",
+    "Players",
+    "Game",
+    "R6APIError",
+    "check_latest_version",
+    "BASED_ON_VERSION",
+    "BASE_URL",
+]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 错误类型
+# ──────────────────────────────────────────────────────────────────────────
+
+class R6APIError(Exception):
+    """非 2xx 响应抛出。``status`` / ``data`` 携带服务端返回内容。"""
+
+    def __init__(self, message: str, *, status: Optional[int] = None,
+                 data: Any = None) -> None:
+        super().__init__(message)
+        self.status = status
+        self.data = data
+
+
+def _clean_params(params: Mapping[str, Any]) -> dict[str, str]:
+    """丢弃 None/空串,其余转字符串 —— 对应原库 buildUrlAndParams。"""
+    out: dict[str, str] = {}
+    for key, value in params.items():
+        if value is None or value == "":
+            continue
+        if isinstance(value, bool):
+            out[key] = "true" if value else "false"
+        else:
+            out[key] = str(value)
+    return out
+
+
+def _validate_board_id(board_id: Optional[str]) -> None:
+    if board_id and board_id not in VALID_BOARD_IDS:
+        raise ValueError(
+            "Invalid board_id. Must be one of: " + ", ".join(VALID_BOARD_IDS)
+        )
+
+
+def _filter_board_profiles(data: Any, board_id: Optional[str]) -> None:
+    """原库 filterBoardProfiles:就地把每个 profile 的 board_ids_full_profiles
+    过滤成只剩指定 board_id。"""
+    if not board_id or not isinstance(data, dict):
+        return
+    profiles = data.get("platform_families_full_profiles")
+    if not isinstance(profiles, list):
+        return
+    for profile in profiles:
+        boards = profile.get("board_ids_full_profiles")
+        if isinstance(boards, list):
+            profile["board_ids_full_profiles"] = [
+                b for b in boards if b.get("board_id") == board_id
+            ]
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 资源:Players
+# ──────────────────────────────────────────────────────────────────────────
+
+class Players:
+    def __init__(self, client: "R6Client") -> None:
+        self._client = client
+
+    async def get_account_info(self, name_on_platform: str,
+                               platform_type: str) -> Any:
+        """玩家账号信息 (type=accountInfo)。"""
+        if not name_on_platform or not platform_type:
+            raise ValueError("Missing required parameters: name_on_platform, platform_type")
+        return await self._client._get("/stats", {
+            "type": "accountInfo",
+            "nameOnPlatform": name_on_platform,
+            "platformType": platform_type,
+        })
+
+    async def get_is_banned(self, name_on_platform: str,
+                            platform_type: str) -> Any:
+        """封禁状态 (type=isBanned)。"""
+        if not name_on_platform or not platform_type:
+            raise ValueError("Missing required parameters: name_on_platform, platform_type")
+        return await self._client._get("/stats", {
+            "type": "isBanned",
+            "nameOnPlatform": name_on_platform,
+            "platformType": platform_type,
+        })
+
+    async def get_player_stats(self, name_on_platform: str, platform_type: str,
+                               platform_families: str,
+                               board_id: Optional[str] = None) -> Any:
+        """玩家战绩 (type=stats)。给了 board_id 会就地过滤结果。"""
+        if not name_on_platform or not platform_type or not platform_families:
+            raise ValueError(
+                "Missing required parameters: name_on_platform, platform_type, platform_families")
+        _validate_board_id(board_id)
+        params = {
+            "type": "stats",
+            "nameOnPlatform": name_on_platform,
+            "platformType": platform_type,
+            "platform_families": platform_families,
+        }
+        if board_id:
+            params["board_id"] = board_id
+        data = await self._client._get("/stats", params)
+        _filter_board_profiles(data, board_id)
+        return data
+
+    async def get_player_comparisons(
+        self,
+        players: Sequence[Mapping[str, str]],
+        platform_families: str,
+        board_id: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """对比多名玩家。每个 player 形如
+        {"nameOnPlatform": ..., "platformType": ...}。逐个查询并汇总,
+        单个失败不影响其余(对应原库行为)。"""
+        if not players or len(players) < 2:
+            raise ValueError("At least 2 players are required for comparison")
+        if not platform_families:
+            raise ValueError("Missing required parameter: platform_families")
+        for i, p in enumerate(players):
+            if not p.get("nameOnPlatform") or not p.get("platformType"):
+                raise ValueError(
+                    f"Player {i + 1} is missing required fields: nameOnPlatform, platformType")
+        _validate_board_id(board_id)
+
+        comparisons: list[dict[str, Any]] = []
+        errors: list[dict[str, Any]] = []
+        for player in players:
+            params = {
+                "type": "stats",
+                "nameOnPlatform": player["nameOnPlatform"],
+                "platformType": player["platformType"],
+                "platform_families": platform_families,
+            }
+            if board_id:
+                params["board_id"] = board_id
+            try:
+                data = await self._client._get("/stats", params)
+                _filter_board_profiles(data, board_id)
+                profiles = (data or {}).get("platform_families_full_profiles") or []
+                if profiles:
+                    comparisons.append({"player": player, "stats": data, "success": True})
+                else:
+                    comparisons.append({"player": player, "stats": None,
+                                        "success": False, "error": "No stats found for player"})
+            except Exception as exc:  # noqa: BLE001 - 单玩家失败需被收集而非中断
+                errors.append({"player": player, "error": str(exc)})
+                comparisons.append({"player": player, "stats": None,
+                                    "success": False, "error": str(exc)})
+
+        result: dict[str, Any] = {"comparisons": comparisons}
+        if errors:
+            result["errors"] = errors
+        return result
+
+    async def get_operator_stats(self, name_on_platform: str, platform_type: str,
+                                 season_year: Optional[str] = None,
+                                 modes: Optional[str] = None) -> Any:
+        """干员维度战绩 (type=operatorStats)。modes: ranked|casual|unranked。"""
+        if not name_on_platform or not platform_type:
+            raise ValueError("Missing required parameters: name_on_platform, platform_type")
+        params = {
+            "type": "operatorStats",
+            "nameOnPlatform": name_on_platform,
+            "platformType": platform_type,
+            "modes": modes,
+        }
+        if season_year:
+            params["seasonYear"] = season_year
+        return await self._client._get("/stats", params)
+
+    async def get_full_stats(self, name_on_platform: str, platform_type: str,
+                             season_year: Optional[str] = None,
+                             modes: Optional[str] = None) -> Any:
+        """完整快照 (type=fullStats)。单请求合并三套数据：
+
+        - ``operators``：等同 operatorStats
+        - ``platform_families_full_profiles``：各 board(ranked/casual/...)完整档案
+        - ``data``：tracker 风格的 metadata/segments/platformInfo(等级、段位段等)
+
+        modes: ranked|casual|unranked|quick-match|standard|all（默认 all）。
+        season_year: 如 "Y10S4" 或 "all"（默认 all，不按赛季过滤）。
+        """
+        if not name_on_platform or not platform_type:
+            raise ValueError("Missing required parameters: name_on_platform, platform_type")
+        params = {
+            "type": "fullStats",
+            "nameOnPlatform": name_on_platform,
+            "platformType": platform_type,
+        }
+        if season_year:
+            params["seasonYear"] = season_year
+        if modes:
+            params["modes"] = modes
+        return await self._client._get("/stats", params)
+
+    async def get_seasonal_stats(self, name_on_platform: str,
+                                 platform_type: str) -> Any:
+        """当前赛季战绩 (type=seasonalStats)。"""
+        if not name_on_platform or not platform_type:
+            raise ValueError("Missing required parameters: name_on_platform, platform_type")
+        return await self._client._get("/stats", {
+            "type": "seasonalStats",
+            "nameOnPlatform": name_on_platform,
+            "platformType": platform_type,
+        })
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 资源:Game(静态数据)
+# ──────────────────────────────────────────────────────────────────────────
+
+class Game:
+    def __init__(self, client: "R6Client") -> None:
+        self._client = client
+
+    async def get_game_stats(self) -> Any:
+        return await self._client._get("/stats", {"type": "gameStats"})
+
+    async def get_maps(self, *, name: Optional[str] = None,
+                       location: Optional[str] = None,
+                       release_date: Optional[str] = None,
+                       playlists: Optional[str] = None,
+                       map_reworked: Optional[bool] = None) -> Any:
+        return await self._client._get("/maps", {
+            "name": name, "location": location, "releaseDate": release_date,
+            "playlists": playlists, "mapReworked": map_reworked,
+        })
+
+    async def get_operators(self, *, name: Optional[str] = None,
+                            safename: Optional[str] = None,
+                            realname: Optional[str] = None,
+                            birthplace: Optional[str] = None,
+                            age: Optional[int] = None,
+                            date_of_birth: Optional[str] = None,
+                            season_introduced: Optional[str] = None,
+                            health: Optional[int] = None,
+                            speed: Optional[int] = None,
+                            unit: Optional[str] = None,
+                            country_code: Optional[str] = None,
+                            roles: Optional[str] = None,
+                            side: Optional[str] = None) -> Any:
+        return await self._client._get("/operators", {
+            "name": name, "safename": safename, "realname": realname,
+            "birthplace": birthplace, "age": age, "date_of_birth": date_of_birth,
+            "season_introduced": season_introduced, "health": health,
+            "speed": speed, "unit": unit, "country_code": country_code,
+            "roles": roles, "side": side,
+        })
+
+    async def get_ranks(self, *, name: Optional[str] = None,
+                        min_mmr: Optional[int] = None,
+                        max_mmr: Optional[int] = None,
+                        version: Optional[str] = None) -> Any:
+        if version and version not in VALID_RANK_VERSIONS:
+            raise ValueError(
+                "Version not valid. Choose between " + ", ".join(VALID_RANK_VERSIONS) + ".")
+        return await self._client._get("/ranks", {
+            "name": name, "min_mmr": min_mmr, "max_mmr": max_mmr, "version": version,
+        })
+
+    async def get_seasons(self, *, name: Optional[str] = None,
+                          map: Optional[str] = None,
+                          operators: Optional[str] = None,
+                          weapons: Optional[str] = None,
+                          description: Optional[str] = None,
+                          code: Optional[str] = None,
+                          start_date: Optional[str] = None) -> Any:
+        return await self._client._get("/seasons", {
+            "name": name, "map": map, "operators": operators, "weapons": weapons,
+            "description": description, "code": code, "startDate": start_date,
+        })
+
+    async def get_weapons(self, *, name: Optional[str] = None) -> Any:
+        return await self._client._get("/weapons", {"name": name})
+
+    async def get_charms(self, *, name: Optional[str] = None,
+                         collection: Optional[str] = None,
+                         rarity: Optional[str] = None,
+                         availability: Optional[str] = None,
+                         bundle: Optional[str] = None,
+                         season: Optional[str] = None) -> Any:
+        return await self._client._get("/charms", {
+            "name": name, "collection": collection, "rarity": rarity,
+            "availability": availability, "bundle": bundle, "season": season,
+        })
+
+    async def get_universal_skins(self, *, name: Optional[str] = None) -> Any:
+        return await self._client._get("/universalSkins", {"name": name})
+
+    async def get_attachment(self, *, name: Optional[str] = None,
+                             style: Optional[str] = None,
+                             rarity: Optional[str] = None,
+                             availability: Optional[str] = None,
+                             bundle: Optional[str] = None,
+                             season: Optional[str] = None) -> Any:
+        return await self._client._get("/attachment", {
+            "name": name, "style": style, "rarity": rarity,
+            "availability": availability, "bundle": bundle, "season": season,
+        })
+
+    async def get_search_all(self, query: str) -> Any:
+        if not query or not isinstance(query, str):
+            raise ValueError("Search query is required and must be a string")
+        return await self._client._get("/searchAll", {"q": query})
+
+    async def get_service_status(self) -> Any:
+        return await self._client._get("/serviceStatus", {})
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 主客户端
+# ──────────────────────────────────────────────────────────────────────────
+
+class R6Client:
+    """
+    用法::
+
+        r6 = R6Client(api_key="...")
+        try:
+            data = await r6.players.get_player_stats("Name", "uplay", "pc")
+        finally:
+            await r6.aclose()
+
+    也可作为异步上下文管理器::
+
+        async with R6Client(api_key="...") as r6:
+            ...
+    """
+
+    def __init__(self, api_key: str, *, base_url: str = BASE_URL,
+                 timeout: float = 15.0,
+                 client: Optional[httpx.AsyncClient] = None) -> None:
+        if not api_key:
+            raise ValueError("Missing required config parameter: api_key")
+        self.api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        # 允许外部注入共享的 AsyncClient(例如复用 NoneBot 的);否则自建。
+        self._http = client or httpx.AsyncClient(timeout=timeout)
+        self._owns_http = client is None
+
+        self.players = Players(self)
+        self.game = Game(self)
+
+    async def __aenter__(self) -> "R6Client":
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        """关闭内部创建的 httpx client(注入的不会被关闭)。"""
+        if self._owns_http:
+            await self._http.aclose()
+
+    async def _get(self, path: str, params: Mapping[str, Any]) -> Any:
+        url = f"{self._base_url}/{path.lstrip('/')}"
+        headers = {
+            "Accept": "application/json",
+            "Cache-Control": "no-cache",
+            "User-Agent": f"r6data.py (port of r6-data.js@{BASED_ON_VERSION})",
+            "api-key": self.api_key,
+        }
+        resp = await self._http.get(url, params=_clean_params(params), headers=headers)
+        return self._handle(resp)
+
+    @staticmethod
+    def _handle(resp: httpx.Response) -> Any:
+        text = resp.text
+        data: Any = None
+        if text:
+            try:
+                data = resp.json()
+            except ValueError:
+                data = text
+        if resp.is_success:
+            return data
+        if resp.status_code == 401:
+            raise R6APIError("Authentication error", status=401, data=data)
+        raise R6APIError(
+            f"Request failed with status code {resp.status_code}",
+            status=resp.status_code, data=data,
+        )
+
+
+# ──────────────────────────────────────────────────────────────────────────
+# 启动时版本检查
+# ──────────────────────────────────────────────────────────────────────────
+
+_NPM_LATEST_URL = "https://registry.npmjs.org/r6-data.js/latest"
+
+
+def _parse_semver(v: str) -> tuple[int, ...]:
+    core = v.split("-", 1)[0].split("+", 1)[0]
+    parts: list[int] = []
+    for piece in core.split("."):
+        try:
+            parts.append(int(piece))
+        except ValueError:
+            parts.append(0)
+    return tuple(parts)
+
+
+async def check_latest_version(*, timeout: float = 5.0) -> Optional[str]:
+    """查 npm registry 上 r6-data.js 的最新版本号。
+
+    成功返回版本字符串(如 "3.1.8");网络/解析失败返回 None(只告警、
+    绝不阻塞启动)。比对建议::
+
+        latest = await check_latest_version()
+        if latest and _parse_semver(latest) > _parse_semver(BASED_ON_VERSION):
+            logger.warning(...)
+    """
+    try:
+        async with httpx.AsyncClient(timeout=timeout) as c:
+            resp = await c.get(_NPM_LATEST_URL,
+                               headers={"Accept": "application/json"})
+        if resp.is_success:
+            version = resp.json().get("version")
+            return version if isinstance(version, str) else None
+    except Exception:  # noqa: BLE001 - 检查失败不应影响主流程
+        return None
+    return None
+
+
+def is_outdated(latest: Optional[str]) -> bool:
+    """latest 比 BASED_ON_VERSION 新则 True;latest 为 None 时 False。"""
+    if not latest:
+        return False
+    return _parse_semver(latest) > _parse_semver(BASED_ON_VERSION)

nonebot_plugin_R6States/renderer.py

@@ -0,0 +1,201 @@
+"""把 fullStats 渲染成图片（PNG 字节）。
+
+- 双字体：拉丁/数字用 Mona Sans，汉字用 Noto Sans CJK，按字符分段、基线对齐。
+- 2x 超采样：按 SCALE 倍分辨率绘制，避免客户端放大时发虚。
+- 干员区为对齐表格，数字右对齐；攻/防用不同颜色。
+内容提取复用 formatter 的 _format_boards（档案行）；干员直接读结构化字段以便排版。
+"""
+from __future__ import annotations
+
+from io import BytesIO
+from typing import Any, Optional
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+from .formatter import _format_boards
+
+_ASSETS = Path(__file__).parent / "assets"
+_MONA = str(_ASSETS / "MonaSans.ttf")
+_NOTO = str(_ASSETS / "NotoSansSC.ttf")
+
+# 配色
+_BG = (24, 27, 33)
+_WHITE = (240, 242, 245)
+_GRAY = (140, 146, 156)
+_DIM = (96, 102, 112)
+_ACCENT = (240, 165, 0)
+_BODY = (210, 214, 220)
+_LINE = (44, 49, 58)
+_ATK = (236, 122, 80)   # 攻
+_DEF = (94, 160, 232)   # 防
+
+_SCALE = 2              # 超采样倍率
+_W = 760 * _SCALE
+_PAD = 36 * _SCALE
+
+_font_cache: dict[tuple[str, int, Optional[int]], ImageFont.FreeTypeFont] = {}
+
+
+def _font(path: str, size: int, weight: Optional[int] = None) -> ImageFont.FreeTypeFont:
+    """按字号取字体；weight 给定时尝试调可变字重（失败则忽略）。"""
+    key = (path, size * _SCALE, weight)
+    if key in _font_cache:
+        return _font_cache[key]
+    f = ImageFont.truetype(path, size * _SCALE)
+    if weight is not None:
+        try:
+            vals = []
+            for ax in f.get_variation_axes():
+                name = ax.get("name", b"")
+                name = name.decode() if isinstance(name, bytes) else name
+                vals.append(weight if name.lower() == "weight" else ax.get("default", 0))
+            f.set_variation_by_axes(vals)
+        except Exception:  # noqa: BLE001 - 非可变字体或轴缺失时退回默认实例
+            pass
+    _font_cache[key] = f
+    return f
+
+
+def _is_cjk(ch: str) -> bool:
+    return "一" <= ch <= "鿿" or "　" <= ch <= "〿" or "＀" <= ch <= "￯"
+
+
+def _runs(text: str) -> list[tuple[str, bool]]:
+    out: list[tuple[str, bool]] = []
+    cur, cur_cjk = "", None
+    for ch in text:
+        c = _is_cjk(ch)
+        if cur and c != cur_cjk:
+            out.append((cur, cur_cjk))  # type: ignore[arg-type]
+            cur = ""
+        cur, cur_cjk = cur + ch, c
+    if cur:
+        out.append((cur, cur_cjk))  # type: ignore[arg-type]
+    return out
+
+
+def _measure(text: str, size: int, weight: Optional[int] = None) -> int:
+    return sum(
+        int(_font(_NOTO if cjk else _MONA, size, weight).getlength(run))
+        for run, cjk in _runs(text)
+    )
+
+
+def _draw(draw: ImageDraw.ImageDraw, x: int, baseline: int, text: str,
+          size: int, fill: tuple[int, int, int], weight: Optional[int] = None) -> int:
+    for run, cjk in _runs(text):
+        f = _font(_NOTO if cjk else _MONA, size, weight)
+        draw.text((x, baseline), run, font=f, fill=fill, anchor="ls")
+        x += int(f.getlength(run))
+    return x
+
+
+def _draw_right(draw: ImageDraw.ImageDraw, right_x: int, baseline: int, text: str,
+                size: int, fill: tuple[int, int, int], weight: Optional[int] = None) -> None:
+    _draw(draw, right_x - _measure(text, size, weight), baseline, text, size, fill, weight)
+
+
+def _ascent(size: int) -> int:
+    return _font(_NOTO, size).getmetrics()[0]
+
+
+def render_full_stats(player_id: str, data: dict[str, Any], top_n: int = 8) -> bytes:
+    info = data.get("data") or {}
+    handle = (info.get("platformInfo") or {}).get("platformUserHandle") or player_id
+    meta = info.get("metadata") or {}
+
+    # 画在足够高的画布上，最后按实际内容裁剪
+    img = Image.new("RGB", (_W, 1600 * _SCALE), _BG)
+    draw = ImageDraw.Draw(img)
+    draw.rectangle([(0, 0), (_W, 6 * _SCALE)], fill=_ACCENT)
+
+    p = _PAD
+    rcol = _W - _PAD
+    y = _PAD + 8 * _SCALE
+
+    # ── 头部：玩家名 + 等级/通行证 ──
+    y += _ascent(38)
+    _draw(draw, p, y, handle, 38, _WHITE, weight=700)
+    bits = []
+    if meta.get("clearanceLevel") is not None:
+        bits.append(f"Lv {meta['clearanceLevel']}")
+    if meta.get("battlepassLevel") is not None:
+        bits.append(f"BP {meta['battlepassLevel']}")
+    if bits:
+        _draw_right(draw, rcol, y, "  ".join(bits), 20, _GRAY)
+    y += _font(_NOTO, 38).getmetrics()[1] + 14 * _SCALE
+
+    def section(title: str) -> None:
+        nonlocal y
+        y += 16 * _SCALE
+        draw.line([(p, y), (rcol, y)], fill=_LINE, width=1 * _SCALE)
+        y += 14 * _SCALE + _ascent(22)
+        _draw(draw, p, y, title, 22, _ACCENT, weight=700)
+        y += _font(_NOTO, 22).getmetrics()[1] + 10 * _SCALE
+
+    # ── 档案 ──
+    boards = _format_boards(data.get("platform_families_full_profiles") or [])
+    if boards:
+        section("档案")
+        for line in boards:
+            y += _ascent(21)
+            _draw(draw, p, y, line, 21, _BODY)
+            y += _font(_NOTO, 21).getmetrics()[1] + 8 * _SCALE
+
+    # ── 干员：攻/防双列，各取出场前 4 ──
+    operators = data.get("operators") or []
+    if operators:
+        section("干员 Top")
+        by_rounds = lambda o: o.get("roundsPlayed", 0)  # noqa: E731
+        atks = sorted((o for o in operators if o.get("side") == "Attacker"),
+                      key=by_rounds, reverse=True)[:4]
+        defs = sorted((o for o in operators if o.get("side") == "Defender"),
+                      key=by_rounds, reverse=True)[:4]
+
+        gap = 48 * _SCALE
+        col_w = (_W - 2 * _PAD - gap) // 2
+        lx, rx = p, p + col_w + gap
+
+        # 列头：攻 / 防
+        y += _ascent(19)
+        _draw(draw, lx, y, "攻", 19, _ATK, weight=700)
+        _draw(draw, rx, y, "防", 19, _DEF, weight=700)
+        y += _font(_NOTO, 19).getmetrics()[1] + 12 * _SCALE
+
+        def _cell(cx: int, base: int, op: dict[str, Any]) -> None:
+            r = cx + col_w
+            nx = _draw(draw, cx, base, op.get("operator", "?"), 21, _BODY, weight=600)
+            _draw(draw, nx + 6 * _SCALE, base, f"·{op.get('roundsPlayed', 0)}", 15, _DIM)
+            _draw_right(draw, r, base, f"{op.get('kd', 0)}", 21, _WHITE, weight=700)
+            _draw_right(draw, r - 78 * _SCALE, base, f"{op.get('winPercent', 0)}%", 17, _BODY)
+
+        for i in range(max(len(atks), len(defs))):
+            base = y + _ascent(21)
+            if i < len(atks):
+                _cell(lx, base, atks[i])
+            if i < len(defs):
+                _cell(rx, base, defs[i])
+            y = base + _font(_NOTO, 21).getmetrics()[1] + 11 * _SCALE
+
+        # 合计（全部干员）
+        kills = sum(o.get("kills", 0) for o in operators)
+        deaths = sum(o.get("deaths", 0) for o in operators)
+        rounds = sum(o.get("roundsPlayed", 0) for o in operators)
+        kd = kills / deaths if deaths else float(kills)
+        y += 6 * _SCALE
+        draw.line([(p, y), (rcol, y)], fill=_LINE, width=1 * _SCALE)
+        y += 12 * _SCALE + _ascent(19)
+        _draw(draw, p, y, f"合计 {len(operators)} 干员 · 场{rounds}", 19, _GRAY)
+        _draw_right(draw, rcol, y, f"KD {kd:.2f}", 19, _GRAY)
+        y += _font(_NOTO, 19).getmetrics()[1]
+
+    if not boards and not operators:
+        y += _ascent(22)
+        _draw(draw, p, y, "没有查询到数据", 22, _GRAY)
+        y += _font(_NOTO, 22).getmetrics()[1]
+
+    img = img.crop((0, 0, _W, y + _PAD))
+    buf = BytesIO()
+    img.save(buf, format="PNG")
+    return buf.getvalue()

nonebot_plugin_R6States/service.py

@@ -0,0 +1,68 @@
+"""数据源（API 为主）+ 缓存层。
+
+对外只暴露 ``get_operator_stats``：先查本地缓存，未命中再打 r6data API，
+成功后回写缓存。错误统一转成 ``ServiceError``，由指令层决定怎么回话。
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from .cache import JSONCache
+from .storage import PLAYER_CACHE_FILE
+from .r6data import R6Client, R6APIError
+from .config_mannger import resolve_apikey
+
+#: 玩家快照属于会变的数据，缓存 30 分钟即可显著降低 API 用量。
+FULL_STATS_TTL = 30 * 60
+
+VALID_PLATFORMS = ("uplay", "psn", "xbl")
+
+#: 免费申请 api-key 的入口，附在缺/失效提示里
+APIKEY_HELP = "可在 https://r6data.com/ 免费获取 Key，再用 /r6key <key> 绑定"
+
+_cache = JSONCache(PLAYER_CACHE_FILE)
+
+
+class ServiceError(Exception):
+    def __init__(self, message: str, *, expired: bool = False) -> None:
+        super().__init__(message)
+        self.message = message
+        self.expired = expired
+
+
+async def get_full_stats(
+    player_id: str,
+    scopes: list[str],
+    platform: str = "uplay",
+    season_year: str | None = None,
+    modes: str | None = None,
+) -> dict[str, Any]:
+    if platform not in VALID_PLATFORMS:
+        raise ServiceError(f"平台无效，可选：{', '.join(VALID_PLATFORMS)}")
+
+    api_key, _ = resolve_apikey(scopes)
+    if not api_key:
+        raise ServiceError(f"未设置 API Key。{APIKEY_HELP}")
+
+    cache_key = f"fullStats:{platform}:{season_year or 'all'}:{modes or 'all'}:{player_id.lower()}"
+    cached = await _cache.get(cache_key, ttl=FULL_STATS_TTL)
+    if cached is not None:
+        return cached
+
+    try:
+        async with R6Client(api_key=api_key) as r6:
+            data = await r6.players.get_full_stats(
+                player_id, platform, season_year=season_year, modes=modes
+            )
+    except R6APIError as e:
+        if e.status == 401:
+            raise ServiceError(
+                f"API Key 鉴权失败，可能已过期（官方有效期约 1 个月）。{APIKEY_HELP}",
+                expired=True,
+            ) from e
+        raise ServiceError(f"API 返回错误（{e.status}）：{e}") from e
+    except Exception as e:  # noqa: BLE001 - 网络等异常统一兜底
+        raise ServiceError(f"请求失败：{type(e).__name__}") from e
+
+    await _cache.set(cache_key, data)
+    return data

nonebot_plugin_R6States/storage.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+DATA_DIR = Path("data") / "r6states"
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+API_KEY_FILE = DATA_DIR / "api_keys.json"
+PLAYER_CACHE_FILE = DATA_DIR / "cache.json"

nonebot_plugin_r6states-1.0.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.1
+Name: nonebot-plugin-R6States
+Version: 1.0.0
+Summary: 查询指定玩家的各项数据
+Author-Email: Siornya <wxh200607@outlook.com>
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: nonebot2>=2.3.1
+Requires-Dist: nonebot-adapter-onebot>=2.4.6
+Requires-Dist: httpx>=0.27
+Requires-Dist: pillow>=10.0
+Description-Content-Type: text/markdown
+
+# nonebot-plugin-R6States
+
+一个基于 **NoneBot2** 的《彩虹六号：围攻》战绩查询插件
+
+---
+
+## 功能特性
+
+* ✅ 通过 QQ 指令查询 R6 玩家战绩
+* ✅ 支持 **单人查询 / 多人查询**
+* ✅ 数据源自 [R6Data API](https://r6data.com/)
+* ✅ 玩家数据缓存半小时，降低 API 用量
+* ✅ 数据分析功能
+* ⚙️ 地图筛选 `-m / --map`
+
+---
+
+## 参考运行环境
+
+* **Python 3.12**
+* **NoneBot2**
+* **OneBot v11**
+* **NapCat（反向 WebSocket）**
+
+---
+
+## Usage 使用说明
+
+### 安装
+
+可以直接将 `nonebot_plugin_R6States` 文件夹放入插件目录中。
+
+### 基础指令
+
+```text
+/R6 <player_id>
+```
+
+### 多人查询
+
+```text
+/R6 -g <id1> <id2> ... <idN>
+```
+
+### 帮助信息
+
+```text
+/R6help
+```
+
+### 额外获取地图信息
+
+```text
+-m / --map <map_name>
+```
+
+---
+
+## 特别提醒
+
+* 本插件为 **非育碧官方工具**
+* 所有数据来自R6Data API
+* 设计初衷仅对于个人与学习
+* 请勿用于“超出个人正常使用范围”的用途

nonebot_plugin_r6states-1.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+nonebot_plugin_R6States/__init__.py,sha256=Qf9gGA4MGqxaQELX2hJDMQHzDPBMP6rSZ4w2funIoms,4467
+nonebot_plugin_R6States/assets/MonaSans.ttf,sha256=hKrhDUQnoZR-lrH9mybDEJ_6D1Dy-q6M5GDKHjSIntU,347676
+nonebot_plugin_R6States/assets/NotoSansSC.ttf,sha256=owQYEaeMNhsd5Q-VPIBeAkSVHCHFvUEvcjLvDYma8No,17772300
+nonebot_plugin_R6States/cache.py,sha256=j6uDEJ378kge0igGY9MzyLq9ccjBgPCi80MPFSz-js4,2314
+nonebot_plugin_R6States/config.py,sha256=vqD21-_DqbPHvqLBmn-XXwSHThjmxNYLZoUnbPFqGIA,479
+nonebot_plugin_R6States/config_mannger.py,sha256=ObmYL0KRVFUKMwkcsNy70hc37igfkR6rlQDp2dkILLw,2073
+nonebot_plugin_R6States/formatter.py,sha256=lfi6F9dn1bjkaOyHKAsoIFJq2pQmY-T5TW9mojMxdoI,3627
+nonebot_plugin_R6States/r6data.py,sha256=E5zJVs5kUK7ufK9Y0_8ojsQ0up6UjQmYbOLudSCWb0s,21941
+nonebot_plugin_R6States/renderer.py,sha256=TsGSc0Ap-cch5HXnRS2gfeMn44nRzzsLhK0L8s7CwTA,7498
+nonebot_plugin_R6States/service.py,sha256=5YfX5Ie__IuZptVvWGp92m1TFozPU-9dM220mQgVvP8,2371
+nonebot_plugin_R6States/storage.py,sha256=SOVBSSPrhOiSpV7glJseyrxjBOpARpvLFg-NBZMekcU,230
+nonebot_plugin_r6states-1.0.0.dist-info/METADATA,sha256=22JZ6GwFTrCdUPn4YzzQuGMlf363CtDFx1OSctqblLw,1383
+nonebot_plugin_r6states-1.0.0.dist-info/WHEEL,sha256=VP-D4TPS230sME9Z3vb3INXvo1yt0924YRm5AOsk_dE,90
+nonebot_plugin_r6states-1.0.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+nonebot_plugin_r6states-1.0.0.dist-info/licenses/LICENSE,sha256=gPW3tSB4cMTX_vKXHjEqRkaOy2unmqs09opEBaky93M,1064
+nonebot_plugin_r6states-1.0.0.dist-info/RECORD,,

nonebot_plugin_r6states-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.9)
+Root-Is-Purelib: true
+Tag: py3-none-any

nonebot_plugin_r6states-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+

nonebot_plugin_r6states-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Siornya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.