Update chat_message_handle.py

fix: 更新问题，戳一戳图片路径问题

.gitignore

@@ -142,7 +142,6 @@ test.py
 server_ip.py
 member_activity_handle.py
 Yu-Gi-Oh/
-search_image/
 black_word/
 csgo/
 fantasy_card/

README.md

@@ -32,6 +32,12 @@
 ## 普通帮助图片
 ![x](https://github.com/HibiKier/zhenxun_bot/blob/0.0.8.2/docs_image/3238573864-836268675-E2FFBB2AC143EAF4DDDF150438508721.png)
 
+## Web UI
+[zhenxun_bot_webui](https://github.com/HibiKier/zhenxun_bot_webui)
+
+## 一键安装脚本
+[zhenxun_bot-deploy](https://github.com/AkashiCoin/zhenxun_bot-deploy)
+
 ## 提供符合真寻标准的插件仓库
 
 [AkashiCoin/nonebot_plugins_zhenxun_bot](https://github.com/AkashiCoin/nonebot_plugins_zhenxun_bot)
@@ -236,10 +242,84 @@ __Docker 最新版本由 [Sakuracio](https://github.com/Sakuracio) 提供__
 
 ## 更新
 
+### 2022/4/26
+
+* 修复了群白名单无法正确添加
+* 优化了管理员帮助图片，背景图层将位于最下层
+* 修复了树脂140时不断提醒（未测试
+* 新增了消息记录的消息排行
+* WebUI新增CPU，内存，磁盘监控
+* WebUI新增资源文件夹统计可视化
+
+### 2022/4/12
+
+* 修复b了命令私聊出错
+
+### 2022/4/10 \[v0.1.4.7]
+
+* 新增消息记录模块
+* 丰富处理请求操作提示
+* web ui新增配置项修改
+
+### 2022/4/9
+
+* fix: 更新问题，戳一戳图片路径问题 [@pull/144](https://github.com/HibiKier/zhenxun_bot/pull/144)
+
+### 2022/4/8
+
+* 修复原神玩家查询
+
+### 2022/4/6
+
+* update search_type [@pull/143](https://github.com/HibiKier/zhenxun_bot/pull/143)
+
+### 2022/4/5 \[v0.1.4.6]
+
+* 修复web修改插件后帮助图片生成错误
+
+### 2022/4/4 \[v0.1.4.5]
+
+* 替换了bt搜索URL
+* 优化使用playwright的相关代码
+* 原神玩家查询新增层岩巨渊探索
+* 修复原神便笺角色头像黑框
+* 修复同意群聊请求错误
+* 提供webui方面的api
+* 新增web-ui（前端简易管理页面插件）插件
+
+### 2022/3/21
+
+* 修复statistics_handle.py乱码
+
+### 2022/3/18 \[v0.1.4.4]
+
+* 修复戳一戳无法功能关闭与ban禁用
+* 新增图片搜索 search_image
+
+### 2022/3/7
+
+* 优化增删权限插件
+
+### 2022/3/6
+
+* 修复树脂提醒无法开启
+* 修复p搜图片路径错误
+
+### 2022/3/3 \[v0.1.4.3]
+
+* 修复手动同意群聊请求依旧退出
+
+### 2022/3/1 \[v0.1.4.2]
+
+* 0.1.4内容
+
+### 2022/2/27 \[v0.1.4.1]
+
+* 优化抽卡
+
 ### 2022/2/25 \[v0.1.4]
 
 * PIX提供配置MAX_ONCE_NUM2FORWARD：当单次发送图片超过指定张数且在群聊时，将转为合并消息
-* 优化抽卡
 * 修复点歌无法正确发送
 * 修复我有一个朋友有时文本会包含CQ码
 * 修复群欢消息被动控制文本未删除 [@pull/124](https://github.com/HibiKier/zhenxun_bot/pull/124)
@@ -281,7 +361,6 @@ __Docker 最新版本由 [Sakuracio](https://github.com/Sakuracio) 提供__
 
 * 适配nonebot.beta2
 * 删除图片搜索 nonebot_plugin_picsearcher
-* 新增图片搜索 search_image
 * 替换cos api
 * 原神签到树脂提醒新增绑定群里，在某群绑定uid就会在某群发送提醒信息（有好友则私聊，需要重新绑定uid
 * 修改update_info.json
@@ -290,15 +369,15 @@ __Docker 最新版本由 [Sakuracio](https://github.com/Sakuracio) 提供__
 * epic restful 替换 [@pull/119](https://github.com/HibiKier/zhenxun_bot/pull/119)
 * fix: 修复远古时期残留的epic推送问题 [@pull/122](https://github.com/HibiKier/zhenxun_bot/pull/122)
 
-### 2021/2/11
+### 2022/2/11
 
 * 修复pix不使用反代无法下载图片
 
-### 2021/2/10 \[v0.1.1]
+### 2022/2/10 \[v0.1.1]
 
 * 修复购买道具出错
 
-### 2021/2/9 \[v0.1]
+### 2022/2/9 \[v0.1]
 
 * 新增原神自动签到和手动签到
 * 新增原神树脂提醒
@@ -308,7 +387,7 @@ __Docker 最新版本由 [Sakuracio](https://github.com/Sakuracio) 提供__
 * 修复修改商品时限制时间出错
 * 修复超时商品依旧可以被购买
 
-### 2021/1/16 \[v0.0.9.0]
+### 2022/1/16 \[v0.0.9.0]
 
 * Ai提供文本敏感词过滤器
 * 疫情插件适配新版腾讯API
@@ -327,7 +406,7 @@ __Docker 最新版本由 [Sakuracio](https://github.com/Sakuracio) 提供__
       * “send_success_msg”(发送成功的交互信息->即：使用道具 {name} {num} 次成功)
       * “_max_num_limit”(该道具单次使用的最多个数，默认1)
 
-### 2021/1/5 \[v0.0.8.2]
+### 2022/1/5 \[v0.0.8.2]
 
 * 提供金币消费hook，可在plugins2settings.yaml中配置该功能需要消费的金币
 * 商店插件将作为内置插件移动至basic_plugins

__version__

@@ -1 +1 @@
-__version__: v0.1.4
+__version__: v0.1.5.0

basic_plugins/admin_bot_manage/rule.py

@@ -24,11 +24,17 @@ def switch_rule(event: Event) -> bool:
             _data = plugins2settings_manager.get_data()
             for key in _data:
                 try:
-                    for x in _data[key]["cmd"]:
-                        cmd.append(f"开启{x}")
-                        cmd.append(f"关闭{x}")
-                        cmd.append(f"开启 {x}")
-                        cmd.append(f"关闭 {x}")
+                    if isinstance(_data[key]["cmd"], list):
+                        for x in _data[key]["cmd"]:
+                            cmd.append(f"开启{x}")
+                            cmd.append(f"关闭{x}")
+                            cmd.append(f"开启 {x}")
+                            cmd.append(f"关闭 {x}")
+                    else:
+                        cmd.append(f"开启{key}")
+                        cmd.append(f"关闭{key}")
+                        cmd.append(f"开启 {key}")
+                        cmd.append(f"关闭 {key}")
                 except KeyError:
                     pass
         msg = get_message_text(event.json()).split()

basic_plugins/admin_help/data_source.py

@@ -5,7 +5,6 @@ from utils.utils import get_matchers
 from utils.manager import group_manager
 from nonebot.adapters.onebot.v11 import Bot
 from nonebot import Driver
-import asyncio
 import nonebot
 
 
@@ -27,12 +26,10 @@ async def create_help_image():
     """
     创建管理员帮助图片
     """
-    await asyncio.get_event_loop().run_in_executor(
-        None, _create_help_image
-    )
+    await _create_help_image()
 
 
-def _create_help_image():
+async def _create_help_image():
     """
     创建管理员帮助图片
     """
@@ -85,9 +82,9 @@ def _create_help_image():
     height = len(help_str.split("\n")) * 33
     A = BuildImage(width, height, font_size=24)
     _background = BuildImage(width, height, background=background)
-    A.text((150, 110), help_str)
-    A.paste(_background, alpha=True)
-    A.save(admin_help_image)
+    await A.apaste(_background, alpha=True)
+    await A.atext((150, 110), help_str)
+    await A.asave(admin_help_image)
     logger.info(f'已成功加载 {len(_plugin_name_list)} 条管理员命令')
 
 

basic_plugins/ban/__init__.py

@@ -1,15 +1,17 @@
-from nonebot.adapters.onebot.v11 import GroupMessageEvent, PrivateMessageEvent, MessageEvent, Message, Bot
-from nonebot.params import CommandArg, Command
-from nonebot import on_command
+from typing import Tuple
+
+from configs.config import NICKNAME, Config
 from models.ban_user import BanUser
 from models.level_user import LevelUser
-from typing import Tuple
-from utils.utils import get_message_at, is_number
-from configs.config import NICKNAME, Config
+from nonebot import on_command
+from nonebot.adapters.onebot.v11 import (Bot, GroupMessageEvent, Message,
+                                         MessageEvent, PrivateMessageEvent)
+from nonebot.params import Command, CommandArg
 from nonebot.permission import SUPERUSER
-from .data_source import parse_ban_time, a_ban
 from services.log import logger
+from utils.utils import get_message_at, is_number
 
+from .data_source import a_ban, parse_ban_time
 
 __zx_plugin_name__ = "封禁Ban用户 [Admin]"
 __plugin_usage__ = """
@@ -34,19 +36,19 @@ usage：
         示例：b了 1234567
         示例：.ban 12345567
 """.strip()
-__plugin_des__ = '你被逮捕了！丢进小黑屋！'
-__plugin_cmd__ = ['.ban [at] ?[小时] ?[分钟]', '.unban [at]', 'b了 [at] [_superuser]']
+__plugin_des__ = "你被逮捕了！丢进小黑屋！"
+__plugin_cmd__ = [".ban [at] ?[小时] ?[分钟]", ".unban [at]", "b了 [at] [_superuser]"]
 __plugin_version__ = 0.1
-__plugin_author__ = 'HibiKier'
+__plugin_author__ = "HibiKier"
 __plugin_settings__ = {
     "admin_level": Config.get_config("ban", "BAN_LEVEL"),
-    "cmd": ['.ban', '.unban', 'ban', 'unban']
+    "cmd": [".ban", ".unban", "ban", "unban"],
 }
 __plugin_configs__ = {
     "BAN_LEVEL [LEVEL]": {
         "value": 5,
         "help": "ban/unban所需要的管理员权限等级",
-        "default_value": 5
+        "default_value": 5,
     }
 }
 
@@ -58,18 +60,23 @@ ban = on_command(
     block=True,
 )
 
-super_ban = on_command('b了', permission=SUPERUSER, priority=5, block=True)
+super_ban = on_command("b了", permission=SUPERUSER, priority=5, block=True)
 
 
 @ban.handle()
-async def _(bot: Bot, event: GroupMessageEvent, cmd: Tuple[str, ...] = Command(),  arg: Message = CommandArg()):
+async def _(
+    bot: Bot,
+    event: GroupMessageEvent,
+    cmd: Tuple[str, ...] = Command(),
+    arg: Message = CommandArg(),
+):
     cmd = cmd[0]
     result = ""
     qq = get_message_at(event.json())
     if qq:
         qq = qq[0]
         user_name = await bot.get_group_member_info(group_id=event.group_id, user_id=qq)
-        user_name = user_name['card'] or user_name['nickname']
+        user_name = user_name["card"] or user_name["nickname"]
         msg = arg.extract_plain_text().strip()
         time = parse_ban_time(msg)
         if isinstance(time, str):
@@ -108,7 +115,12 @@ async def _(bot: Bot, event: GroupMessageEvent, cmd: Tuple[str, ...] = Command()
 
 
 @ban.handle()
-async def _(bot: Bot, event: PrivateMessageEvent, cmd: Tuple[str, ...] = Command(),  arg: Message = CommandArg()):
+async def _(
+    bot: Bot,
+    event: PrivateMessageEvent,
+    cmd: Tuple[str, ...] = Command(),
+    arg: Message = CommandArg(),
+):
     cmd = cmd[0]
     msg = arg.extract_plain_text().strip()
     if msg:
@@ -123,34 +135,36 @@ async def _(bot: Bot, event: PrivateMessageEvent, cmd: Tuple[str, ...] = Command
                     result = await a_ban(qq, time, str(qq), event, 9)
                 else:
                     if await BanUser.unban(qq):
-                        logger.info(
-                            f"USER {event.user_id} 将 USER {qq} 解禁"
-                        )
+                        logger.info(f"USER {event.user_id} 将 USER {qq} 解禁")
                         result = f"已经把 {qq} 从黑名单中删除了！"
                     else:
                         result = f"{qq} 不在黑名单！"
                 await ban.send(result)
             else:
-                await ban.finish('qq号必须是数字！\n格式：.ban [qq] [hour]? [minute]?', at_sender=True)
+                await ban.finish(
+                    "qq号必须是数字！\n格式：.ban [qq] [hour]? [minute]?", at_sender=True
+                )
 
 
 @super_ban.handle()
 async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
+    user_name = ""
     if isinstance(event, GroupMessageEvent):
         qq = get_message_at(event.json())
+        if qq:
+            qq = qq[0]
+            user = await bot.get_group_member_info(group_id=event.group_id, user_id=qq)
+            user_name = user["card"] or user["nickname"]
     else:
         qq = arg.extract_plain_text().strip()
         if not is_number(qq):
             await super_ban.finish("对象qq必须为纯数字...")
-        qq = [qq]
+        qq = int(qq)
+        user_name = qq
     if qq:
-        qq = qq[0]
-        user = await bot.get_group_member_info(group_id=event.group_id, user_id=qq)
-        user_name = user['card'] or user['nickname']
         if not await BanUser.ban(qq, 10, 99999999):
             await BanUser.unban(qq)
             await BanUser.ban(qq, 10, 99999999)
         await ban.send(f"已将 {user_name} 拉入黑名单！")
     else:
-        await super_ban.send('需要添加被super ban的对象，可以使用at或者指定qq..')
-
+        await super_ban.send("需要添加被super ban的对象，可以使用at或者指定qq..")

basic_plugins/chat_history/__init__.py

@@ -0,0 +1,3 @@
+import nonebot
+
+nonebot.load_plugins("basic_plugins/chat_history")

basic_plugins/chat_history/_rule.py

@@ -0,0 +1,6 @@
+from nonebot.adapters.onebot.v11 import Event, MessageEvent
+from configs.config import Config
+
+
+def rule(event: Event) -> bool:
+    return Config.get_config("chat_history", "FLAG") and isinstance(event, MessageEvent)

basic_plugins/chat_history/chat_message.py

@@ -0,0 +1,38 @@
+from configs.config import Config
+from models.chat_history import ChatHistory
+from nonebot import on_message
+from nonebot.adapters.onebot.v11 import GroupMessageEvent, MessageEvent
+
+from ._rule import rule
+
+__zx_plugin_name__ = "消息存储 [Hidden]"
+__plugin_version__ = 0.1
+__plugin_author__ = "HibiKier"
+
+
+Config.add_plugin_config(
+    "chat_history", "FLAG", True, help_="是否开启消息自从存储", name="消息存储", default_value=True
+)
+
+
+chat_history = on_message(rule=rule, priority=1, block=False)
+
+
+@chat_history.handle()
+async def _(event: MessageEvent):
+    if isinstance(event, GroupMessageEvent):
+        await ChatHistory.add_chat_msg(
+            event.user_id, event.group_id, str(event.get_message())
+        )
+    else:
+        await ChatHistory.add_chat_msg(event.user_id, None, str(event.get_message()))
+
+
+# @test.handle()
+# async def _(event: MessageEvent):
+#     print(await ChatHistory.get_user_msg(event.user_id, "private"))
+#     print(await ChatHistory.get_user_msg_count(event.user_id, "private"))
+#     print(await ChatHistory.get_user_msg(event.user_id, "group"))
+#     print(await ChatHistory.get_user_msg_count(event.user_id, "group"))
+#     print(await ChatHistory.get_group_msg(event.group_id))
+#     print(await ChatHistory.get_group_msg_count(event.group_id))

basic_plugins/chat_history/chat_message_handle.py

@@ -0,0 +1,108 @@
+from datetime import datetime, timedelta
+
+import pytz
+from models.chat_history import ChatHistory
+from models.group_member_info import GroupInfoUser
+from nonebot import on_regex
+from nonebot.adapters.onebot.v11 import GroupMessageEvent
+from nonebot.params import RegexGroup
+from utils.image_utils import BuildImage, text2image
+from utils.utils import is_number
+from utils.message_builder import image
+from typing import Tuple, Any
+
+
+__zx_plugin_name__ = "消息统计"
+__plugin_usage__ = """
+usage：
+    发言记录统计
+    regex：(周|月)?消息排行(des|DES)?(n=[0-9]{1,2})?
+    指令：
+        消息统计?(des)?(n=?)
+        周消息统计?(des)?(n=?)
+        月消息统计?(des)?(n=?)
+    示例：
+        消息统计
+        消息统计des
+        消息统计DESn=15
+        消息统计n=15
+""".strip()
+__plugin_des__ = "发言消息排行"
+__plugin_cmd__ = [
+    "消息统计",
+    "周消息统计",
+    "月消息统计"
+]
+__plugin_type__ = ("数据统计", 1)
+__plugin_version__ = 0.1
+__plugin_author__ = "HibiKier"
+__plugin_settings__ = {
+    "level": 5,
+    "cmd": ["消息统计"],
+}
+
+
+msg_handler = on_regex(r"(周|月)?消息统计(des|DES)?(n=[0-9]{1,2})?", priority=5, block=True)
+
+
+@msg_handler.handle()
+async def _(event: GroupMessageEvent, reg_group: Tuple[Any, ...] = RegexGroup()):
+    gid = event.group_id
+    date_scope = None
+    date, order, num = reg_group
+    num = num.split("=")[-1] if num else 10
+    if num and is_number(num) and 10 < int(num) < 50:
+        num = int(num)
+    if date in ["周"]:
+        date_scope = (datetime.now() - timedelta(days=7), datetime.now())
+    elif date in ["月"]:
+        date_scope = (datetime.now() - timedelta(days=30), datetime.now())
+    if rank_data := await ChatHistory.get_group_msg_rank(
+        gid, num, order or "DESC", date_scope
+    ):
+        name = "昵称：\n\n"
+        num_str = "发言次数：\n\n"
+        idx = 1
+        for uid, num in rank_data:
+            try:
+                user_name = (await GroupInfoUser.get_member_info(uid, gid)).user_name
+            except AttributeError:
+                user_name = uid
+            name += f"\t{idx}.{user_name} \n\n"
+            num_str += f"\t{num}\n\n"
+            idx += 1
+        name_img = await text2image(name.strip(), padding=10, color="#f9f6f2")
+        num_img = await text2image(num_str.strip(), padding=10, color="#f9f6f2")
+        if not date_scope:
+            if date_scope := await ChatHistory.get_group_first_msg_datetime(gid):
+                date_scope = date_scope.astimezone(
+                    pytz.timezone("Asia/Shanghai")
+                ).replace(microsecond=0)
+            else:
+                date_scope = datetime.now().replace(microsecond=0)
+            date_str = f"日期：{date_scope} - 至今"
+        else:
+            date_str = f"日期：{date_scope[0].replace(microsecond=0)} - {date_scope[1].replace(microsecond=0)}"
+        date_w = BuildImage(0, 0, font_size=15).getsize(date_str)[0]
+        img_w = date_w if date_w > name_img.w + num_img.w else name_img.w + num_img.w
+        A = BuildImage(
+            img_w + 15,
+            num_img.h + 30,
+            color="#f9f6f2",
+            font="CJGaoDeGuo.otf",
+            font_size=15,
+        )
+        await A.atext((10, 10), date_str)
+        await A.apaste(name_img, (0, 30))
+        await A.apaste(num_img, (name_img.w, 30))
+        await msg_handler.send(image(b64=A.pic2bs4()))
+
+
+# @test.handle()
+# async def _(event: MessageEvent):
+#     print(await ChatHistory.get_user_msg(event.user_id, "private"))
+#     print(await ChatHistory.get_user_msg_count(event.user_id, "private"))
+#     print(await ChatHistory.get_user_msg(event.user_id, "group"))
+#     print(await ChatHistory.get_user_msg_count(event.user_id, "group"))
+#     print(await ChatHistory.get_group_msg(event.group_id))
+#     print(await ChatHistory.get_group_msg_count(event.group_id))

basic_plugins/hooks/_utils.py

@@ -2,6 +2,10 @@ from nonebot.adapters.onebot.v11 import GroupMessageEvent, PrivateMessageEvent
 from utils.manager import plugins2block_manager, StaticData
 import time
 
+ignore_rst_module = ["ai", "poke", "dialogue"]
+
+other_limit_plugins = ["poke"]
+
 
 class StatusMessageManager(StaticData):
 

basic_plugins/hooks/auth_hook.py

@@ -13,7 +13,12 @@ from utils.manager import (
     plugins2block_manager,
     plugins2count_manager,
 )
-from ._utils import set_block_limit_false, status_message_manager
+from ._utils import (
+    set_block_limit_false,
+    status_message_manager,
+    ignore_rst_module,
+    other_limit_plugins,
+)
 from nonebot.typing import T_State
 from typing import Optional
 from nonebot.adapters.onebot.v11 import (
@@ -37,12 +42,10 @@ _flmt_g = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
 _flmt_s = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
 _flmt_c = FreqLimiter(Config.get_config("hook", "CHECK_NOTICE_INFO_CD"))
 
-ignore_rst_module = ["ai", "poke", "dialogue"]
-
 
 # 权限检测
 @run_preprocessor
-async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
+async def _(matcher: Matcher, bot: Bot, event: Event, state: T_State):
     module = matcher.plugin_name
     plugins2info_dict = plugins2settings_manager.get_data()
     # 功能的金币检测 #######################################
@@ -64,7 +67,7 @@ async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
             await BagUser.spend_gold(event.user_id, event.group_id, cost_gold)
     try:
         if (
-            (not isinstance(event, MessageEvent) and module != "poke")
+            (not isinstance(event, MessageEvent) and module not in other_limit_plugins)
             or await BanUser.is_ban(event.user_id)
             and str(event.user_id) not in bot.config.superusers
         ) or (
@@ -88,7 +91,7 @@ async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
     except AttributeError:
         pass
     # 群黑名单检测 群总开关检测
-    if isinstance(event, GroupMessageEvent) or matcher.plugin_name == "poke":
+    if isinstance(event, GroupMessageEvent) or matcher.plugin_name == other_limit_plugins:
         try:
             if (
                 group_manager.get_group_level(event.group_id) < 0
@@ -145,9 +148,7 @@ async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
                 raise IgnoredException("权限不足")
     if module in plugins2info_dict.keys() and matcher.priority not in [1, 9]:
         # 戳一戳单独判断
-        if isinstance(event, GroupMessageEvent) or (
-            isinstance(event, PokeNotifyEvent) and event.group_id
-        ):
+        if isinstance(event, GroupMessageEvent) or isinstance(event, PokeNotifyEvent) or matcher.plugin_name in other_limit_plugins:
             if status_message_manager.get(event.group_id) is None:
                 status_message_manager.delete(event.group_id)
             if plugins2info_dict[module]["level"] > group_manager.get_group_level(

basic_plugins/hooks/ban_hook.py

@@ -4,13 +4,16 @@ from nonebot.adapters.onebot.v11.exception import ActionFailed
 from nonebot.typing import T_State
 from nonebot.adapters.onebot.v11 import (
     Bot,
+    Event,
     MessageEvent,
+    PokeNotifyEvent,
     GroupMessageEvent,
 )
 from configs.config import Config
 from models.ban_user import BanUser
 from utils.utils import is_number, static_flmt, FreqLimiter
 from utils.message_builder import at
+from ._utils import ignore_rst_module, other_limit_plugins
 
 
 Config.add_plugin_config(
@@ -25,18 +28,19 @@ _flmt = FreqLimiter(300)
 
 # 检查是否被ban
 @run_preprocessor
-async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
-    try:
-        if (
-            await BanUser.is_super_ban(event.user_id)
-            and str(event.user_id) not in bot.config.superusers
-        ):
-            raise IgnoredException("用户处于超级黑名单中")
-    except AttributeError:
-        pass
-    if not isinstance(event, MessageEvent):
-        return
-    if matcher.type == "message" and matcher.priority not in [1, 9]:
+async def _(matcher: Matcher, bot: Bot, event: Event, state: T_State):
+    if (
+        (isinstance(event, MessageEvent) or isinstance(event, PokeNotifyEvent))
+        and matcher.priority not in [1, 9]
+    ) or matcher.plugin_name in other_limit_plugins:
+        try:
+            if (
+                await BanUser.is_super_ban(event.user_id)
+                and str(event.user_id) not in bot.config.superusers
+            ):
+                raise IgnoredException("用户处于超级黑名单中")
+        except AttributeError:
+            pass
         if (
             await BanUser.is_ban(event.user_id)
             and str(event.user_id) not in bot.config.superusers
@@ -57,7 +61,11 @@ async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
                 if matcher.priority != 9:
                     try:
                         ban_result = Config.get_config("hook", "BAN_RESULT")
-                        if ban_result and _flmt.check(event.user_id):
+                        if (
+                            ban_result
+                            and _flmt.check(event.user_id)
+                            and matcher.plugin_name not in ignore_rst_module
+                        ):
                             _flmt.start_cd(event.user_id)
                             await bot.send_group_msg(
                                 group_id=event.group_id,
@@ -74,7 +82,7 @@ async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
                 if matcher.priority != 9:
                     try:
                         ban_result = Config.get_config("hook", "BAN_RESULT")
-                        if ban_result:
+                        if ban_result and matcher.plugin_name not in ignore_rst_module:
                             await bot.send_private_msg(
                                 user_id=event.user_id,
                                 message=at(event.user_id)

basic_plugins/hooks/other_hook.py

@@ -2,12 +2,15 @@ from nonebot.matcher import Matcher
 from nonebot.message import run_preprocessor, IgnoredException
 from nonebot.typing import T_State
 from ._utils import status_message_manager
+from utils.image_utils import text2image
+from typing import Dict, Any
 from nonebot.adapters.onebot.v11 import (
     Bot,
     MessageEvent,
     PrivateMessageEvent,
     GroupMessageEvent,
 )
+import re
 
 
 # 为什么AI会自己和自己聊天
@@ -38,3 +41,11 @@ async def _(matcher: Matcher, bot: Bot, event: MessageEvent, state: T_State):
             status_message_manager.delete(event.user_id)
             raise IgnoredException("有命令就别说话了")
 
+# @Bot.on_calling_api
+# async def handle_api_call(bot: Bot, api: str, data: Dict[str, Any]):
+#     if api in ["send_msg", "send_group_msg", "send_private_msg"]:
+#         msg = str(data["message"])
+#         if (r := re.search("\[\[To_Img\|?(.*?)]]", msg)) or (r := re.search("[[To_Img\|?(.*?)[[")):
+
+
+

basic_plugins/hooks/task_hook.py

@@ -10,7 +10,7 @@ async def handle_api_call(bot: Bot, api: str, data: Dict[str, Any]):
     r = None
     if (
         (
-            (api == "send_msg" and data["message_type"] == "group")
+            (api == "send_msg" and data.get("message_type") == "group")
             or api == "send_group_msg"
         )
         and (

basic_plugins/init_plugin_config/init_plugins_settings.py

@@ -74,7 +74,7 @@ def init_plugins_settings(data_path: str):
                         if plugin_settings.get('cost_gold') is None:
                             plugin_settings['cost_gold'] = 0
                         if (
-                            plugin_settings["cmd"] is not None
+                            plugin_settings.get("cmd") is not None
                             and plugin_name not in plugin_settings["cmd"]
                         ):
                             plugin_settings["cmd"].append(plugin_name)

basic_plugins/super_cmd/bot_friend_group.py

@@ -82,15 +82,16 @@ async def _(bot: Bot, cmd: Tuple[str, ...] = Command(), arg: Message = CommandAr
     if is_number(id_):
         id_ = int(id_)
         if cmd[:2] == "同意":
-            if await requests_manager.approve(bot, id_, "private"):
-                await friend_handle.send("同意好友请求成功..")
-            else:
-                await friend_handle.send("同意好友请求失败，可能是未找到此id的请求..")
+            flag = await requests_manager.approve(bot, id_, "private")
         else:
-            if await requests_manager.refused(bot, id_, "private"):
-                await friend_handle.send("拒绝好友请求成功..")
-            else:
-                await friend_handle.send("拒绝好友请求失败，可能是未找到此id的请求..")
+            flag = await requests_manager.refused(bot, id_, "private")
+        if flag == 1:
+            await friend_handle.send(f"{cmd[:2]}好友请求失败，该请求已失效..")
+            requests_manager.delete_request(id_, "private")
+        elif flag == 2:
+            await friend_handle.send(f"{cmd[:2]}好友请求失败，未找到此id的请求..")
+        else:
+            await friend_handle.send(f"{cmd[:2]}好友请求成功！")
     else:
         await friend_handle.send("id必须为纯数字！")
 
@@ -99,12 +100,12 @@ async def _(bot: Bot, cmd: Tuple[str, ...] = Command(), arg: Message = CommandAr
 async def _(bot: Bot, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
     cmd = cmd[0]
     id_ = arg.extract_plain_text().strip()
+    flag = None
     if is_number(id_):
         id_ = int(id_)
         if cmd[:2] == "同意":
-            rid = await requests_manager.approve(bot, id_, "group")
+            rid = requests_manager.get_group_id(id_)
             if rid:
-                await friend_handle.send("同意群聊请求成功..")
                 if await GroupInfo.get_group_info(rid):
                     await GroupInfo.set_group_flag(rid, 1)
                 else:
@@ -116,13 +117,18 @@ async def _(bot: Bot, cmd: Tuple[str, ...] = Command(), arg: Message = CommandAr
                         group_info["member_count"],
                         1
                     )
+                flag = await requests_manager.approve(bot, id_, "group")
             else:
-                await friend_handle.send("同意群聊请求失败，可能是未找到此id的请求..")
+                await friend_handle.send("同意群聊请求失败，未找到此id的请求..")
         else:
-            if await requests_manager.refused(bot, id_, "group"):
-                await friend_handle.send("拒绝群聊请求成功..")
-            else:
-                await friend_handle.send("拒绝群聊请求失败，可能是未找到此id的请求..")
+            flag = await requests_manager.refused(bot, id_, "group")
+        if flag == 1:
+            await friend_handle.send(f"{cmd[:2]}群聊请求失败，该请求已失效..")
+            requests_manager.delete_request(id_, "group")
+        elif flag == 2:
+            await friend_handle.send(f"{cmd[:2]}群聊请求失败，未找到此id的请求..")
+        else:
+            await friend_handle.send(f"{cmd[:2]}群聊请求成功！")
     else:
         await friend_handle.send("id必须为纯数字！")
 

basic_plugins/super_cmd/manager_group.py

@@ -136,7 +136,7 @@ async def _():
 @manager_group_whitelist.handle()
 async def _(bot: Bot, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
     cmd = cmd[0]
-    msg = arg.extract_plain_text().strip()
+    msg = arg.extract_plain_text().strip().split()
     all_group = [
         g["group_id"] for g in await bot.get_group_list()
     ]

basic_plugins/super_cmd/set_admin_permissions.py

@@ -1,7 +1,7 @@
 from nonebot import on_command
 from nonebot.permission import SUPERUSER
 from models.level_user import LevelUser
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message
+from nonebot.adapters.onebot.v11 import Bot, MessageEvent, Message, GroupMessageEvent
 from utils.utils import get_message_at, is_number
 from services.log import logger
 from utils.message_builder import at
@@ -37,41 +37,49 @@ super_cmd = on_command(
 
 
 @super_cmd.handle()
-async def _(bot: Bot, event: GroupMessageEvent, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
-    cmd = cmd[0]
-    group_id = -1
-    level = 0
+async def _(
+    bot: Bot,
+    event: MessageEvent,
+    cmd: Tuple[str, ...] = Command(),
+    arg: Message = CommandArg(),
+):
+    group_id = event.group_id if isinstance(event, GroupMessageEvent) else -1
+    level = None
+    args = arg.extract_plain_text().strip().split()
+    qq = get_message_at(event.json())
+    flag = 2
     try:
-        args = arg.extract_plain_text().strip().split()
-        qq = get_message_at(event.json())
-        flag = -1
-        if not qq:
-            if len(args) > 2:
-                if is_number(args[0]) and is_number(args[1]) and is_number(args[2]):
+        if qq:
+            qq = qq[0]
+            if cmd[0][:2] == "添加" and args and is_number(args[0]):
+                level = int(args[0])
+        else:
+            if cmd[0][:2] == "添加":
+                if (
+                    len(args) > 2
+                    and is_number(args[0])
+                    and is_number(args[1])
+                    and is_number(args[2])
+                ):
                     qq = int(args[0])
                     group_id = int(args[1])
                     level = int(args[2])
-                    flag = 1
-                else:
-                    await super_cmd.finish("所有参数必须是数字！", at_sender=True)
             else:
-                await super_cmd.finish(
-                    "权限参数不完全\n\t格式：添加/删除权限 [at] [level]"
-                    "\n\t格式：添加/删除权限 [qq] [group_id] [level]",
-                    at_sender=True,
-                )
-        else:
-            if not is_number(args[0]):
-                await super_cmd.finish("所有参数必须是数字！", at_sender=True)
-            level = int(args[0])
-            qq = qq[0]
-            group_id = event.group_id
-            flag = 2
-        if cmd[:2] == "添加":
+                if len(args) > 1 and is_number(args[0]) and is_number(args[1]):
+                    qq = int(args[0])
+                    group_id = int(args[1])
+            flag = 1
+        level = -1 if cmd[0][:2] == "删除" else level
+        if group_id == -1 or not level or not qq:
+            raise IndexError()
+    except IndexError:
+        await super_cmd.finish(__plugin_usage__)
+    try:
+        if cmd[0][:2] == "添加":
             if await LevelUser.set_level(qq, group_id, level, 1):
-                result = "添加管理成功, 权限: " + str(level)
+                result = f"添加管理成功, 权限: {level}"
             else:
-                result = "管理已存在, 更新权限: " + str(level)
+                result = f"管理已存在, 更新权限: {level}"
         else:
             if await LevelUser.delete_level(qq, event.group_id):
                 result = "删除管理成功!"
@@ -82,7 +90,10 @@ async def _(bot: Bot, event: GroupMessageEvent, cmd: Tuple[str, ...] = Command()
         elif flag == 1:
             await bot.send_group_msg(
                 group_id=group_id,
-                message=Message(f"{at(qq)}管理员修改了你的权限" f"\n--------\n你当前的权限等级：{level}"),
+                message=Message(
+                    f"{at(qq)}管理员修改了你的权限"
+                    f"\n--------\n你当前的权限等级：{level if level != -1 else 0}"
+                ),
             )
             await super_cmd.send("修改成功")
     except Exception as e:

configs/utils/__init__.py

@@ -11,14 +11,19 @@ class ConfigsManager:
 
     def __init__(self, file: Path):
         self._data: dict = {}
+        self._simple_data: dict = {}
         self._admin_level_data = []
+        self._simple_file = Path() / "configs" / "config.yaml"
         if file:
             file.parent.mkdir(exist_ok=True, parents=True)
             self.file = file
+            _yaml = YAML()
             if file.exists():
-                _yaml = YAML()
                 with open(file, "r", encoding="utf8") as f:
                     self._data = _yaml.load(f)
+            if self._simple_file.exists():
+                with open(self._simple_file, "r", encoding="utf8") as f:
+                    self._simple_data = _yaml.load(f)
 
     def add_plugin_config(
         self,
@@ -71,6 +76,7 @@ class ConfigsManager:
         """
         if module in self._data.keys():
             del self._data[module]
+        self.save()
 
     def set_config(self, module: str, key: str, value: str):
         """
@@ -80,8 +86,10 @@ class ConfigsManager:
         :param value: 值
         """
         if module in self._data.keys():
-            if self._data[module].get(key) is not None:
+            if self._data[module].get(key) is not None and self._data[module][key] != value:
                 self._data[module][key]["value"] = value
+                self._simple_data[module][key] = value
+                self.save()
 
     def set_help(self, module: str, key: str, help_: str):
         """
@@ -93,6 +101,7 @@ class ConfigsManager:
         if module in self._data.keys():
             if self._data[module].get(key) is not None:
                 self._data[module][key]["help"] = help_
+                self.save()
 
     def set_default_value(self, module: str, key: str, value: str):
         """
@@ -104,6 +113,7 @@ class ConfigsManager:
         if module in self._data.keys():
             if self._data[module].get(key) is not None:
                 self._data[module][key]["default_value"] = value
+                self.save()
 
     def get_config(self, module: str, key: str, default: Optional[Any] = None) -> Optional[Any]:
         """
@@ -142,11 +152,17 @@ class ConfigsManager:
         if key in self._data.keys():
             return self._data[key]
 
-    def save(self, path: Union[str, Path] = None):
+    def save(self, path: Union[str, Path] = None, save_simple_data: bool = False):
         """
         保存数据
         :param path: 路径
+        :param save_simple_data: 同时保存至config.yaml
         """
+        if save_simple_data:
+            with open(self._simple_file, "w", encoding="utf8") as f:
+                yaml.dump(
+                    self._simple_data, f, indent=2, Dumper=yaml.RoundTripDumper, allow_unicode=True
+                )
         path = path if path else self.file
         with open(path, "w", encoding="utf8") as f:
             yaml.dump(

models/chat_history.py

@@ -0,0 +1,214 @@
+from datetime import datetime, timedelta
+from typing import List, Literal, Optional, Tuple, Union
+
+from services.db_context import db
+
+
+class ChatHistory(db.Model):
+    __tablename__ = "chat_history"
+
+    id = db.Column(db.Integer(), primary_key=True)
+    user_qq = db.Column(db.BigInteger(), nullable=False)
+    group_id = db.Column(db.BigInteger())
+    text = db.Column(db.Text())
+    create_time = db.Column(db.DateTime(timezone=True), nullable=False)
+
+    @classmethod
+    async def add_chat_msg(cls, user_qq: int, group_id: Optional[int], text: str):
+        await cls.create(
+            user_qq=user_qq, group_id=group_id, text=text, create_time=datetime.now()
+        )
+
+    @classmethod
+    async def get_user_msg(
+        cls,
+        uid: int,
+        msg_type: Optional[Literal["private", "group"]],
+        days: Optional[int] = None,
+    ) -> List["ChatHistory"]:
+        """
+        说明：
+            获取用户消息
+        参数：
+            :param uid: 用户qq
+            :param msg_type: 消息类型，私聊或群聊
+            :param days: 限制日期
+        """
+        return await cls._get_msg(uid, None, "user", msg_type, days).gino.all()
+
+    @classmethod
+    async def get_group_user_msg(
+        cls,
+        uid: int,
+        gid: int,
+        limit: int = 10,
+        date_scope: Tuple[datetime, datetime] = None,
+    ) -> List["ChatHistory"]:
+        """
+        说明：
+            获取群聊指定用户聊天记录
+        参数：
+            :param uid: qq
+            :param gid: 群号
+            :param limit: 获取数量
+            :param date_scope: 日期范围，默认None为全搜索
+        """
+        return (
+            await cls._get_msg(uid, gid, "group", days=date_scope)
+            .limit(limit)
+            .gino.all()
+        )
+
+    @classmethod
+    async def get_group_user_msg_count(cls, uid: int, gid: int) -> Optional[int]:
+        """
+        说明：
+             查询群聊指定用户的聊天记录数量
+        参数：
+            :param uid: qq
+            :param gid: 群号
+        """
+        if x := await db.first(
+            db.text(
+                f"SELECT COUNT(id) as sum FROM public.chat_history WHERE user_qq = {uid} AND group_id = {gid}"
+            )
+        ):
+            return x[0]
+        return None
+
+    @classmethod
+    async def get_group_msg_rank(
+        cls,
+        gid: int,
+        limit: int = 10,
+        order: str = "DESC",
+        date_scope: Optional[Tuple[datetime, datetime]] = None,
+    ) -> Optional[Tuple[int, int]]:
+        """
+        说明：
+            获取排行数据
+        参数：
+            :param gid: 群号
+            :param limit: 获取数量
+            :param order: 排序类型，desc，des
+            :param date_scope: 日期范围
+        """
+        sql = f"SELECT user_qq, COUNT(id) as sum FROM public.chat_history WHERE group_id = {gid} "
+        if date_scope:
+            sql += f"AND create_time BETWEEN '{date_scope[0]}' AND '{date_scope[1]}' "
+        sql += f"GROUP BY user_qq ORDER BY sum {order if order and order.upper() != 'DES' else ''} LIMIT {limit}"
+        print(sql)
+        return await db.all(db.text(sql))
+
+    @classmethod
+    async def get_group_first_msg_datetime(cls, gid: int) -> Optional[datetime]:
+        """
+        说明：
+            获取群第一条记录消息时间
+        参数：
+            :param gid:
+        """
+        if (
+            msg := await cls.query.where(cls.group_id == gid)
+            .order_by(cls.create_time)
+            .gino.first()
+        ):
+            return msg.create_time
+        return None
+
+    @classmethod
+    async def get_user_msg_count(
+        cls,
+        uid: int,
+        msg_type: Optional[Literal["private", "group"]],
+        days: Optional[int] = None,
+    ) -> int:
+        """
+        说明：
+            获取用户消息数量
+        参数：
+            :param uid: 用户qq
+            :param msg_type: 消息类型，私聊或群聊
+            :param days: 限制日期
+        """
+        return (
+            await cls._get_msg(uid, None, "user", msg_type, days, True).gino.first()
+        )[0]
+
+    @classmethod
+    async def get_group_msg(
+        cls,
+        gid: int,
+        days: Optional[int] = None,
+    ) -> List["ChatHistory"]:
+        """
+        说明：
+            获取群聊消息
+        参数：
+            :param gid: 用户qq
+            :param days: 限制日期
+        """
+        return await cls._get_msg(None, gid, "group", None, days).gino.all()
+
+    @classmethod
+    async def get_group_msg_count(
+        cls,
+        gid: int,
+        days: Optional[int] = None,
+    ) -> List["ChatHistory"]:
+        """
+        说明：
+            获取群聊消息数量
+        参数：
+            :param gid: 用户qq
+            :param days: 限制日期
+        """
+        return (await cls._get_msg(None, gid, "group", None, days, True).gino.first())[
+            0
+        ]
+
+    @classmethod
+    def _get_msg(
+        cls,
+        uid: Optional[int],
+        gid: Optional[int],
+        type_: Literal["user", "group"],
+        msg_type: Optional[Literal["private", "group"]] = None,
+        days: Optional[Union[int, Tuple[datetime, datetime]]] = None,
+        is_select_count: bool = False,
+    ):
+        """
+        说明：
+            获取消息查询query
+        参数：
+            :param uid: 用户qq
+            :param gid: 群号
+            :param type_: 类型，私聊或群聊
+            :param msg_type: 消息类型，用户或群聊
+            :param days: 限制日期
+        """
+        if is_select_count:
+            setattr(ChatHistory, "count", db.func.count(cls.id).label("count"))
+            query = cls.select("count")
+        else:
+            query = cls.query
+        if type_ == "user":
+            query = query.where(cls.user_qq == uid)
+            if msg_type == "private":
+                query = query.where(cls.group_id == None)
+            elif msg_type == "group":
+                query = query.where(cls.group_id != None)
+        else:
+            query = query.where(cls.group_id == gid)
+            if uid:
+                query = query.where(cls.user_qq == uid)
+        if days:
+            if isinstance(days, int):
+                query = query.where(
+                    cls.create_time >= datetime.now() - timedelta(days=days)
+                )
+            elif isinstance(days, tuple):
+                query = query.where(cls.create_time >= days[0]).where(
+                    cls.create_time <= days[1]
+                )
+        return query

plugins/ai/__init__.py

@@ -76,6 +76,7 @@ async def _(bot: Bot, event: MessageEvent):
         f"问题：{msg} ---- 回答：{result}"
     )
     if result:
+        result = str(result)
         for t in Config.get_config("ai", "TEXT_FILTER"):
             result = result.replace(t, "*")
         await ai.finish(Message(result))

plugins/ai/data_source.py

@@ -57,7 +57,7 @@ async def get_chat_result(text: str, img_url: str, user_id: int, nickname: str)
                 if random.random() < 0.2:
                     if nickname.find("大人") == -1:
                         nickname += "大~人~"
-        rst = rst.replace("小主人", nickname).replace("小朋友", nickname)
+        rst = str(rst).replace("小主人", nickname).replace("小朋友", nickname)
     ai_message_manager.add_result(user_id, rst)
     return rst
 

plugins/alapi/wbtop.py

@@ -56,15 +56,15 @@ async def _(event: MessageEvent, arg: Message = CommandArg()):
             )
     if is_number(msg) and 0 < int(msg) <= 50:
         url = wbtop_data[int(msg) - 1]["url"]
-        try:
-            await wbtop.send("开始截取数据...")
-            img = await AsyncPlaywright.screenshot(
-                url,
-                f"{IMAGE_PATH}/temp/wbtop_{event.user_id}.png",
-                "#pl_feedlist_index",
-                sleep=5
-            )
+        await wbtop.send("开始截取数据...")
+        img = await AsyncPlaywright.screenshot(
+            url,
+            f"{IMAGE_PATH}/temp/wbtop_{event.user_id}.png",
+            "#pl_feedlist_index",
+            wait_time=5
+        )
+        if img:
             await wbtop.send(img)
-        except Exception as e:
-            logger.error(f"微博热搜截图出错... {type(e)}: {e}")
+        else:
             await wbtop.send("发生了一些错误.....")
+

plugins/bilibili_sub/__init__.py

@@ -211,7 +211,7 @@ async def _():
             await sub_manager.reload_sub_data()
             sub = await sub_manager.random_sub_data()
             if sub:
-                logger.info(f"Bilibili订阅开始检测：{sub.sub_id}")
+                logger.debug(f"Bilibili订阅开始检测：{sub.sub_id}")
                 rst = await get_sub_status(sub.sub_id, sub.sub_type)
                 await send_sub_msg(rst, sub, bot)
                 if sub.sub_type == "live":

plugins/bilibili_sub/data_source.py

@@ -311,28 +311,32 @@ async def get_user_dynamic(
         dynamic_upload_time = dynamic_info["cards"][0]["desc"]["timestamp"]
         if local_user.dynamic_upload_time < dynamic_upload_time:
             page = await browser.new_page()
-            await page.goto(
-                f"https://space.bilibili.com/{local_user.uid}/dynamic",
-                wait_until="networkidle",
-                timeout=10000,
-            )
-            await page.set_viewport_size({"width": 2560, "height": 1080})
-            # 删除置顶
-            await page.evaluate(
+            try:
+                await page.goto(
+                    f"https://space.bilibili.com/{local_user.uid}/dynamic",
+                    wait_until="networkidle",
+                    timeout=10000,
+                )
+                await page.set_viewport_size({"width": 2560, "height": 1080})
+                # 删除置顶
+                await page.evaluate(
+                    """
+                    xs = document.getElementsByClassName('first-card-with-title');
+                    for (x of xs) {
+                      x.remove();
+                    }
                 """
-                xs = document.getElementsByClassName('first-card-with-title');
-                for (x of xs) {
-                  x.remove();
-                }
-            """
-            )
-            card = await page.query_selector(".card")
-            # 截图并保存
-            await card.screenshot(
-                path=dynamic_path / f"{local_user.sub_id}_{dynamic_upload_time}.jpg",
-                timeout=100000,
-            )
-            await page.close()
+                )
+                card = await page.query_selector(".card")
+                # 截图并保存
+                await card.screenshot(
+                    path=dynamic_path / f"{local_user.sub_id}_{dynamic_upload_time}.jpg",
+                    timeout=100000,
+                )
+            except Exception as e:
+                logger.error(f"B站订阅：获取用户动态 发送错误 {type(e)}：{e}")
+            finally:
+                await page.close()
             return (
                 image(
                     f"{local_user.sub_id}_{dynamic_upload_time}.jpg",

plugins/bt/data_source.py

@@ -9,7 +9,7 @@ if platform.system() == "Windows":
     asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 
-url = "http://www.eclzz.world"
+url = "http://www.eclzz.mobi"
 
 
 async def get_bt_info(keyword: str, page: int):

plugins/c_song/__init__.py

@@ -1,58 +0,0 @@
-from .music_163 import get_song_id, get_song_info
-from nonebot.adapters.onebot.v11 import Bot, Event, GroupMessageEvent, Message
-from nonebot.params import CommandArg
-from nonebot.typing import T_State
-from services.log import logger
-from nonebot import on_command
-
-
-__zx_plugin_name__ = "点歌"
-__plugin_usage__ = """
-usage：
-    在线点歌
-    指令：
-        点歌 [歌名]
-""".strip()
-__plugin_des__ = "为你点播了一首曾经的歌"
-__plugin_cmd__ = ["点歌 [歌名]"]
-__plugin_type__ = ("一些工具",)
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "level": 5,
-    "default_status": True,
-    "limit_superuser": False,
-    "cmd": ["点歌"],
-}
-
-
-music = on_command("点歌", priority=5, block=True)
-
-
-@music.handle()
-async def handle_first_receive(state: T_State, arg: Message = CommandArg()):
-    args = arg.extract_plain_text().strip()
-    if args:
-        state["song_name"] = args
-
-
-@music.got("song_name", prompt="歌名是？")
-async def _(bot: Bot, event: Event, state: T_State):
-    song = state["song_name"]
-    song_id = await get_song_id(song)
-    if not song_id:
-        await music.finish("没有找到这首歌！", at_sender=True)
-    for _ in range(3):
-        song_content = [{"type": "music", "data": {"type": 163, "id": song_id}}]
-        logger.info(
-            f"(USER {event.user_id}, GROUP "
-            f"{event.group_id if isinstance(event, GroupMessageEvent) else 'private'})"
-            f" 点歌 :{song}"
-        )
-        await music.finish(song_content)
-    else:
-        await music.finish("网易云繁忙...")
-
-
-
-

plugins/check_zhenxun_update/data_source.py

@@ -73,6 +73,7 @@ async def check_update(bot: Bot) -> 'int, str':
                 message=f"检测真寻已更新，当前版本：{_version}，最新版本：{latest_version}\n" f"开始更新.....",
             )
             logger.info(f"开始下载真寻最新版文件....")
+            tar_gz_url = (await AsyncHttpx.get(tar_gz_url)).headers.get('Location')
             if await AsyncHttpx.download_file(tar_gz_url, zhenxun_latest_tar_gz):
                 logger.info("下载真寻最新版文件完成....")
                 error = await asyncio.get_event_loop().run_in_executor(

plugins/draw_card/__init__.py

@@ -1,25 +1,30 @@
-from nonebot import on_regex, on_keyword
-from nonebot.adapters.onebot.v11 import Bot, MessageEvent, Message
-from nonebot.permission import SUPERUSER
-from nonebot.typing import T_State
-from nonebot.params import RegexGroup
-from utils.utils import scheduler
-from .genshin_handle import genshin_draw, update_genshin_info, reset_count, reload_genshin_pool
-from .prts_handle import update_prts_info, prts_draw, reload_prts_pool
-from .pretty_handle import update_pretty_info, pretty_draw, reload_pretty_pool
-from .guardian_handle import update_guardian_info, guardian_draw, reload_guardian_pool
-from .pcr_handle import update_pcr_info, pcr_draw
-from .azur_handle import update_azur_info, azur_draw
-from .fgo_handle import update_fgo_info, fgo_draw
-from .onmyoji_handle import update_onmyoji_info, onmyoji_draw
-from .update_game_info import update_info
-from .util import is_number, check_num
-from .rule import is_switch
-from .config import draw_config
-from .async_update_game_info import async_update_game
-from typing import Tuple, Any
-import re
 import asyncio
+import traceback
+from cn2an import cn2an
+from dataclasses import dataclass
+from typing import Optional, Set, Tuple
+
+import nonebot
+from nonebot import on_regex, on_keyword
+from nonebot.adapters.onebot.v11 import MessageEvent
+from nonebot.log import logger
+from nonebot.matcher import Matcher
+from nonebot.params import RegexGroup
+from nonebot.permission import SUPERUSER
+from nonebot.typing import T_Handler
+from nonebot_plugin_apscheduler import scheduler
+
+from .handles.base_handle import BaseHandle
+from .handles.azur_handle import AzurHandle
+from .handles.fgo_handle import FgoHandle
+from .handles.genshin_handle import GenshinHandle
+from .handles.guardian_handle import GuardianHandle
+from .handles.onmyoji_handle import OnmyojiHandle
+from .handles.pcr_handle import PcrHandle
+from .handles.pretty_handle import PrettyHandle
+from .handles.prts_handle import PrtsHandle
+
+from .config import draw_config
 
 
 __zx_plugin_name__ = "游戏抽卡"
@@ -27,15 +32,15 @@ __plugin_usage__ = """
 usage：
     模拟赛马娘，原神，明日方舟，坎公骑冠剑，公主连结(国/台)，碧蓝航线，FGO，阴阳师进行抽卡
     指令：
-        原神[1-300]抽: 原神常驻池
-        原神角色[1-300]抽: 原神角色UP池子
-        原神武器[1-300]抽: 原神武器UP池子
+        原神[1-180]抽: 原神常驻池
+        原神角色[1-180]抽: 原神角色UP池子
+        原神武器[1-180]抽: 原神武器UP池子
         重置原神抽卡: 清空当前卡池的抽卡次数[即从0开始计算UP概率]
         方舟[1-300]抽: 方舟卡池，当有当期UP时指向UP池
         赛马娘[1-200]抽: 赛马娘卡池，当有当期UP时指向UP池
         坎公骑冠剑[1-300]抽: 坎公骑冠剑卡池，当有当期UP时指向UP池
         pcr/公主连接[1-300]抽: 公主连接卡池
-        碧蓝航线/碧蓝[重型/轻型/特型][1-300]抽: 碧蓝航线重型/轻型/特型卡池
+        碧蓝航线/碧蓝[重型/轻型/特型/活动][1-300]抽: 碧蓝航线重型/轻型/特型/活动卡池
         fgo[1-300]抽: fgo卡池
         阴阳师[1-300]抽: 阴阳师卡池
     * 以上指令可以通过 XX一井 来指定最大抽取数量 *
@@ -58,9 +63,9 @@ usage：
 """.strip()
 __plugin_des__ = "就算是模拟抽卡也不能改变自己是个非酋"
 __plugin_cmd__ = [
-    "原神[1-300]抽",
-    "原神角色[1-300]抽",
-    "原神武器[1-300]抽",
+    "原神[1-180]抽",
+    "原神角色[1-180]抽",
+    "原神武器[1-180]抽",
     "重置原神抽卡",
     "方舟[1-300]抽",
     "赛马娘[1-200]抽",
@@ -89,325 +94,163 @@ __plugin_settings__ = {
     "cmd": ["游戏抽卡", "抽卡"],
 }
 
-prts = on_regex(r'.*?方舟([1-9|一][0-9]{0,2}[抽|井|连])', rule=is_switch('prts'), priority=5, block=True)
-prts_update = on_keyword({'更新方舟信息', '更新明日方舟信息'}, permission=SUPERUSER, priority=1, block=True)
-prts_up_reload = on_keyword({'重载方舟卡池'}, priority=1, block=True)
 
-genshin = on_regex(r'.*?原神(武器|角色)?池?[1-9|一][0-9]{0,2}[抽|井|连]', rule=is_switch('genshin'), priority=5, block=True)
-genshin_update = on_keyword({'更新原神信息'}, permission=SUPERUSER, priority=1, block=True)
-genshin_reset = on_keyword({'重置原神抽卡'}, priority=1, block=True)
-genshin_up_reload = on_keyword({'重载原神卡池'}, priority=1, block=True)
-
-pretty = on_regex(r'.*?马娘卡?[1-9|一][0-9]{0,2}[抽|井|连]', rule=is_switch('pretty'), priority=5, block=True)
-pretty_update = on_keyword({'更新马娘信息', '更新赛马娘信息'}, permission=SUPERUSER, priority=1, block=True)
-pretty_up_reload = on_keyword({'重载赛马娘卡池'}, priority=1, block=True)
-
-guardian = on_regex(r'.*?坎公骑冠剑武?器?[1-9|一][0-9]{0,2}[抽|井|连]', rule=is_switch('guardian'), priority=5, block=True)
-guardian_update = on_keyword({'更新坎公骑冠剑信息'}, permission=SUPERUSER, priority=1, block=True)
-guardian_up_reload = on_keyword({'重载坎公骑冠剑卡池'}, priority=1, block=True)
-
-pcr = on_regex(r'.*?(pcr|公主连结|公主连接|公主链接|公主焊接)[1-9|一][0-9]{0,2}[抽|井|连]', rule=is_switch('pcr'), priority=5, block=True)
-pcr_update = on_keyword({'更新pcr信息', '更新公主连结信息'}, permission=SUPERUSER, priority=1, block=True)
-
-azur = on_regex(r'.*?碧蓝航?线?(轻型|重型|特型)池?[1-9|一][0-9]{0,2}[抽|连]', rule=is_switch('azur'), priority=5, block=True)
-azur_update = on_keyword({'更新碧蓝信息', '更新碧蓝航线信息'}, permission=SUPERUSER, priority=1, block=True)
-
-fgo = on_regex(r'.*?fgo[1-9|一][0-9]{0,2}[抽|连]', rule=is_switch('fgo'), priority=5, block=True)
-fgo_update = on_keyword({'更新fgo信息'}, permission=SUPERUSER, priority=1, block=True)
-
-onmyoji = on_regex(r'.*?阴阳师[1-9|一][0-9]{0,2}[抽|连]', rule=is_switch('onmyoji'), priority=5, block=True)
-onmyoji_update = on_keyword({'更新阴阳师信息'}, permission=SUPERUSER, priority=1, block=True)
+@dataclass
+class Game:
+    keywords: Set[str]
+    handle: BaseHandle
+    flag: bool
+    max_count: int = 300  # 一次最大抽卡数
+    reload_time: Optional[int] = None  # 重载UP池时间（小时）
 
 
-@prts.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State, reg: Tuple[Any, ...] = RegexGroup()):
-    msg = str(event.get_message()).strip()
-    if msg in ['方舟一井', '方舟1井']:
-        num = 300
-    else:
-        rmsg = re.search(r'.*?方舟(.*)[抽|连]', msg)
-        if rmsg:
-            num, flag = check_num(rmsg.group(1), 300)
-            if not flag:
-                await prts.finish(num, at_sender=True)
-        else:
-            return
-    await prts.send(await prts_draw(int(num)), at_sender=True)
+games = (
+    Game({"azur", "碧蓝", "碧蓝航线"}, AzurHandle(), draw_config.AZUR_FLAG),
+    Game({"fgo", "命运冠位指定"}, FgoHandle(), draw_config.FGO_FLAG),
+    Game(
+        {"genshin", "原神"},
+        GenshinHandle(),
+        draw_config.GENSHIN_FLAG,
+        max_count=180,
+        reload_time=18,
+    ),
+    Game(
+        {"guardian", "坎公骑冠剑"},
+        GuardianHandle(),
+        draw_config.GUARDIAN_FLAG,
+        reload_time=4,
+    ),
+    Game({"onmyoji", "阴阳师"}, OnmyojiHandle(), draw_config.ONMYOJI_FLAG),
+    Game({"pcr", "公主连结", "公主连接", "公主链接", "公主焊接"}, PcrHandle(), draw_config.PCR_FLAG),
+    Game(
+        {"pretty", "马娘", "赛马娘"},
+        PrettyHandle(),
+        draw_config.PRETTY_FLAG,
+        max_count=200,
+        reload_time=4,
+    ),
+    Game({"prts", "方舟", "明日方舟"}, PrtsHandle(), draw_config.PRTS_FLAG, reload_time=4),
+)
 
 
-@prts_up_reload.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    text = await reload_prts_pool()
-    await prts_up_reload.finish(Message(f'重载完成！\n{text}'))
-
-
-@genshin.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    msg = str(event.get_message()).strip()
-    rmsg = re.search(r'.*?原神(武器|角色)?池?(.*)[抽|井|连]', msg)
-    if rmsg:
-        pool_name = rmsg.group(1)
-        if pool_name == '武器':
-            pool_name = 'arms'
-        elif pool_name == '角色':
-            pool_name = 'char'
-        else:
-            pool_name = ''
-        num = rmsg.group(2)
-        if msg.find('一井') != -1 or msg.find('1井') != -1:
-            num = 180
-        else:
-            num, flag = check_num(num, 180)
-            if not flag:
-                await genshin.finish(num, at_sender=True)
-    else:
-        return
-    await genshin.send(await genshin_draw(event.user_id, int(num), pool_name), at_sender=True)
-
-
-@genshin_up_reload.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    text = await reload_genshin_pool()
-    await genshin_reset.finish(Message(f'重载成功！\n{text}'))
-
-
-@genshin_reset.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    reset_count(event.user_id)
-    await genshin_reset.send('重置了原神抽卡次数', at_sender=True)
-
-
-@pretty.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    msg = str(event.get_message()).strip()
-    if msg.find('1井') != -1 or msg.find('一井') != -1:
-        num = 200
-        if msg.find("卡") == -1:
-            pool_name = 'char'
-        else:
-            pool_name = 'card'
-    else:
-        rmsg = re.search(r'.*?马娘(.*)[抽|连]', msg)
-        if rmsg:
-            num = rmsg.group(1)
-            if num[0] == '卡':
-                num = num[1:]
-                pool_name = 'card'
+def create_matchers():
+    def draw_handler(game: Game) -> T_Handler:
+        async def handler(
+            matcher: Matcher, event: MessageEvent, args: Tuple[str, ...] = RegexGroup()
+        ):
+            pool_name, num, unit = args
+            if num == "单":
+                num = 1
             else:
-                pool_name = 'char'
-            num, flag = check_num(num, 200)
-            if not flag:
-                await pretty.finish(num, at_sender=True)
-        else:
-            return
-    await pretty.send(await pretty_draw(int(num), pool_name), at_sender=True)
+                try:
+                    num = int(cn2an(num, mode="smart"))
+                except ValueError:
+                    await matcher.finish("必！须！是！数！字！")
+            if unit == "井":
+                num *= game.max_count
+            if num < 1:
+                await matcher.finish("虚空抽卡？？？")
+            elif num > game.max_count:
+                await matcher.finish("一井都满不足不了你嘛！快爬开！")
+            pool_name = (
+                pool_name.replace("池", "")
+                .replace("武器", "arms")
+                .replace("角色", "char")
+                .replace("卡牌", "card")
+                .replace("卡", "card")
+            )
+            try:
+                res = await game.handle.draw(num, pool_name=pool_name, user_id=event.user_id)
+            except:
+                logger.warning(traceback.format_exc())
+                await matcher.finish("出错了...")
+            await matcher.finish(res, at_sender=True)
+
+        return handler
+
+    def update_handler(game: Game) -> T_Handler:
+        async def handler(matcher: Matcher):
+            await game.handle.update_info()
+            await matcher.finish("更新完成！")
+
+        return handler
+
+    def reload_handler(game: Game) -> T_Handler:
+        async def handler(matcher: Matcher):
+            res = await game.handle.reload_pool()
+            if res:
+                await matcher.finish(res)
+
+        return handler
+
+    def reset_handler(game: Game) -> T_Handler:
+        async def handler(matcher: Matcher, event: MessageEvent):
+            if game.handle.reset_count(event.user_id):
+                await matcher.finish("重置成功！")
+
+        return handler
+
+    def scheduled_job(game: Game) -> T_Handler:
+        async def handler():
+            await game.handle.reload_pool()
+
+        return handler
+
+    for game in games:
+        pool_pattern = r"([^\s单0-9零一二三四五六七八九百十]{0,3})"
+        num_pattern = r"(单|[0-9零一二三四五六七八九百十]{1,3})"
+        unit_pattern = r"([抽|井|连])"
+        draw_regex = r".*?(?:{})\s*{}\s*{}\s*{}".format(
+            "|".join(game.keywords), pool_pattern, num_pattern, unit_pattern
+        )
+        update_keywords = {f"更新{keyword}信息" for keyword in game.keywords}
+        reload_keywords = {f"重载{keyword}卡池" for keyword in game.keywords}
+        reset_keywords = {f"重置{keyword}抽卡" for keyword in game.keywords}
+        if game.flag:
+            on_regex(draw_regex, priority=5, block=True).append_handler(
+                draw_handler(game)
+            )
+            on_keyword(
+                update_keywords, permission=SUPERUSER, priority=1, block=True
+            ).append_handler(update_handler(game))
+            on_keyword(reload_keywords, priority=1, block=True).append_handler(
+                reload_handler(game)
+            )
+            on_keyword(reset_keywords, priority=1, block=True).append_handler(
+                reset_handler(game)
+            )
+            if game.reload_time:
+                scheduler.add_job(
+                    scheduled_job(game), trigger="cron", hour=game.reload_time, minute=1
+                )
 
 
-@pretty_up_reload.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    text = await reload_pretty_pool()
-    await genshin_reset.finish(Message(f'重载成功！\n{text}'))
-
-
-@guardian.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    msg = str(event.get_message()).strip()
-    pool_name = 'char'
-    if msg.find('1井') != -1 or msg.find('一井') != -1:
-        num = 300
-        if msg.find('武器') != -1:
-            pool_name = 'arms'
-    else:
-        rmsg = re.search(r'.*?坎公骑冠剑(.*)[抽|连]', msg)
-        if rmsg:
-            num = rmsg.group(1)
-            if num.find('武器') != -1:
-                pool_name = 'arms'
-                num = num.replace('武器', '')
-            num, flag = check_num(num, 300)
-            if not flag:
-                await guardian.finish(num, at_sender=True)
-        else:
-            return
-    await guardian.send(await guardian_draw(int(num), pool_name), at_sender=True)
-
-
-@guardian_up_reload.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    text = await reload_guardian_pool()
-    await genshin_reset.finish(Message(f'重载成功！\n{text}'))
-
-
-@pcr.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    msg = str(event.get_message()).strip()
-    if msg.find('1井') != -1 or msg.find('一井') != -1:
-        num = 300
-    else:
-        rmsg = re.search(r'.*?(pcr|公主连结)(.*)[抽|井|连]', msg)
-        if rmsg:
-            num, flag = check_num(rmsg.group(2), 300)
-            if not flag:
-                await pcr.finish(num, at_sender=True)
-        else:
-            return
-    await pcr.send(await pcr_draw(int(num)), at_sender=True)
-
-
-@azur.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    msg = str(event.get_message()).strip()
-    rmsg = re.search(r'.*?碧蓝航?线?(轻型|重型|特型)池?(.*)[抽|连]', msg)
-    if rmsg:
-        pool_name = rmsg.group(1)
-        num, flag = check_num(rmsg.group(2), 300)
-        if not flag:
-            await azur.finish(num, at_sender=True)
-    else:
-        return
-    await azur.send(await azur_draw(int(num), pool_name), at_sender=True)
-
-
-@fgo.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    msg = str(event.get_message()).strip()
-    rmsg = re.search(r'.*?fgo(.*)[抽|连]', msg)
-    if rmsg:
-        num, flag = check_num(rmsg.group(1), 300)
-        if not flag:
-            await fgo.finish(num, at_sender=True)
-    else:
-        return
-    await fgo.send(await fgo_draw(int(num)), at_sender=True)
-
-
-@onmyoji.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    msg = str(event.get_message()).strip()
-    rmsg = re.search(r'.*?阴阳师(.*)[抽|连]', msg)
-    if rmsg:
-        num, flag = check_num(rmsg.group(1), 300)
-        if not flag:
-            await onmyoji.finish(num, at_sender=True)
-    else:
-        return
-    await onmyoji.send(await onmyoji_draw(int(num)), at_sender=True)
-
-
-@prts_update.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    await update_prts_info()
-    await prts_update.finish('更新完成！')
-
-
-@genshin_update.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    await update_genshin_info()
-    await genshin_update.finish('更新完成！')
-
-
-@pretty_update.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    await update_pretty_info()
-    await genshin_update.finish('更新完成！')
-
-
-@guardian_update.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    await update_guardian_info()
-    await genshin_update.finish('更新完成！')
-
-
-@pcr_update.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    await update_pcr_info()
-    await genshin_update.finish('更新完成！')
-
-
-@azur_update.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    await update_azur_info()
-    await genshin_update.finish('更新完成！')
-
-
-@fgo_update.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    await update_fgo_info()
-    await genshin_update.finish('更新完成！')
-
-
-@onmyoji_update.handle()
-async def _(bot: Bot, event: MessageEvent, state: T_State):
-    await update_onmyoji_info()
-    await genshin_update.finish('更新完成！')
+create_matchers()
 
 
 # 更新资源
 @scheduler.scheduled_job(
-    'cron',
+    "cron",
     hour=4,
     minute=1,
 )
 async def _():
     tasks = []
-    if draw_config.PRTS_FLAG:
-        tasks.append(asyncio.ensure_future(update_prts_info()))
-    if draw_config.GENSHIN_FLAG:
-        tasks.append(asyncio.ensure_future(update_genshin_info()))
-    if draw_config.PRETTY_FLAG:
-        tasks.append(asyncio.ensure_future(update_pretty_info()))
-    if draw_config.GUARDIAN_FLAG:
-        tasks.append(asyncio.ensure_future(update_guardian_info()))
-    if draw_config.PCR_FLAG:
-        tasks.append(asyncio.ensure_future(update_pcr_info()))
-    if draw_config.AZUR_FLAG:
-        tasks.append(asyncio.ensure_future(update_azur_info()))
-    if draw_config.FGO_FLAG:
-        tasks.append(asyncio.ensure_future(update_fgo_info()))
-    if draw_config.ONMYOJI_FLAG:
-        tasks.append(asyncio.ensure_future(update_onmyoji_info()))
+    for game in games:
+        if game.flag:
+            tasks.append(asyncio.ensure_future(game.handle.update_info()))
     await asyncio.gather(*tasks)
 
 
-# 每天四点重载方舟up卡池
-@scheduler.scheduled_job(
-    'cron',
-    hour=4,
-    minute=1,
-)
+driver = nonebot.get_driver()
+
+
+@driver.on_startup
 async def _():
-    if draw_config.PRTS_FLAG:
-        await reload_prts_pool()
-
-
-# 每天四点重载赛马娘up卡池
-@scheduler.scheduled_job(
-    'cron',
-    hour=4,
-    minute=1,
-)
-async def _():
-    if draw_config.PRETTY_FLAG:
-        await reload_pretty_pool()
-
-
-# 每天下午六点点重载原神up卡池
-@scheduler.scheduled_job(
-    'cron',
-    hour=18,
-    minute=1,
-)
-async def _():
-    if draw_config.PRTS_FLAG:
-        await reload_genshin_pool()
-
-
-# 重载坎公骑冠剑卡池
-@scheduler.scheduled_job(
-    'cron',
-    hour=4,
-    minute=1,
-)
-async def _():
-    if draw_config.GUARDIAN_FLAG:
-        await reload_guardian_pool()
+    tasks = []
+    for game in games:
+        if game.flag:
+            game.handle.init_data()
+            if not game.handle.data_exists():
+                tasks.append(asyncio.ensure_future(game.handle.update_info()))
+    await asyncio.gather(*tasks)

plugins/draw_card/announcement.py

@@ -1,395 +0,0 @@
-from bs4 import BeautifulSoup
-import re
-from datetime import datetime, timedelta
-from .config import DRAW_DATA_PATH
-from asyncio.exceptions import TimeoutError
-from nonebot.log import logger
-from utils.http_utils import AsyncHttpx
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-headers = {'User-Agent': '"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; TencentTraveler 4.0)"'}
-
-prts_up_char = DRAW_DATA_PATH / "draw_card_up" / "prts_up_char.json"
-genshin_up_char = DRAW_DATA_PATH / "draw_card_up" / "genshin_up_char.json"
-pretty_up_char = DRAW_DATA_PATH / "draw_card_up" / "pretty_up_char.json"
-guardian_up_char = DRAW_DATA_PATH / "draw_card_up" / "guardian_up_char.json"
-
-prts_url = "https://ak.hypergryph.com/news.html"
-genshin_url = "https://wiki.biligame.com/ys/%E7%A5%88%E6%84%BF"
-pretty_url = "https://wiki.biligame.com/umamusume/%E5%85%AC%E5%91%8A"
-guardian_url = "https://wiki.biligame.com/gt/%E9%A6%96%E9%A1%B5"
-
-
-# 是否过时
-def is_expired(data: dict):
-    times = data['time'].split('-')
-    for i in range(len(times)):
-        times[i] = str(datetime.now().year) + '-' + times[i].split('日')[0].strip().replace('月', '-')
-    start_date = datetime.strptime(times[0], '%Y-%m-%d').date()
-    end_date = datetime.strptime(times[1], '%Y-%m-%d').date()
-    now = datetime.now().date()
-    return not start_date <= now <= end_date
-
-
-# 检查写入
-def check_write(data: dict, up_char_file):
-    try:
-        if is_expired(data['char']):
-            for x in list(data.keys()):
-                data[x]['title'] = ''
-        else:
-            with open(up_char_file, 'w', encoding='utf8') as f:
-                json.dump(data, f, indent=4, ensure_ascii=False)
-        if not up_char_file.exists():
-            with open(up_char_file, 'w', encoding='utf8') as f:
-                json.dump(data, f, indent=4, ensure_ascii=False)
-        else:
-            with open(up_char_file, 'r', encoding='utf8') as f:
-                old_data = json.load(f)
-            if is_expired(old_data['char']):
-                return old_data
-            else:
-                with open(up_char_file, 'w', encoding='utf8') as f:
-                    json.dump(data, f, indent=4, ensure_ascii=False)
-    except ValueError:
-        pass
-    return data
-
-
-class PrtsAnnouncement:
-
-    def __init__(self):
-        self.game_name = '明日方舟'
-
-    async def _get_announcement_text(self):
-        res = await AsyncHttpx.get(prts_url, timeout=7)
-        soup = BeautifulSoup(res.text, 'lxml')
-        ol = soup.find('ol', {'class': 'articleList active', 'data-category-key': 'LATEST'})
-        for li in ol:
-            type_ = li.find('span', {'class': 'articleItemCate'}).text
-            if type_ == '活动':
-                a = li.find('a')['href']
-                return (await AsyncHttpx.get(f'https://ak.hypergryph.com{a}', timeout=7)).text
-            
-    async def update_up_char(self):
-        prts_up_char.parent.mkdir(parents=True, exist_ok=True)
-        if prts_up_char.exists():
-            with open(prts_up_char, 'r', encoding='utf8') as f:
-                data = json.load(f)
-            if not data.get('char'):
-                prts_up_char.unlink()
-        try:
-            data = {'char': {'up_char': {'6': {}, '5': {}, '4': {}}, 'title': '', 'time': '', 'pool_img': ''}}
-            text = await self._get_announcement_text()
-            soup = BeautifulSoup(text, 'lxml')
-            content = soup.find('div', {'class': 'article-content'})
-            contents = [x for x in content.contents if x.text or str(x).find('img') != -1]
-            start_index = -1
-            end_index = -1
-            for i in range(len(contents)):
-                if str(contents[i]).startswith('<p>'):
-                    r = re.search('(.*)(寻访|复刻).*?开启', contents[i].text)
-                    if r:
-                        if str(contents[i+3].text).find('★') != -1:
-                            img = contents[i-1].find('img')
-                            if img:
-                                data['char']['pool_img'] = img['src']
-                            start_index = i
-                            for j in range(i, len(contents)):
-                                if str(contents[j]).find('注意') != -1:
-                                    end_index = j
-                                    break
-                            break
-            contents = contents[start_index: end_index]
-            title = contents[0].text
-            data['char']['title'] = title[title.find('【'): title.find('】') + 1]
-            data['char']['time'] = str(contents[1].text).split('：', maxsplit=1)[1]
-            for p in contents[2:]:
-                p = str(p.text)
-                r = None
-                if p.find('★') != -1:
-                    if p.find('权值') == -1:
-                        r = re.search(r'.*?：(.*)（占(.*)★.*?的(.*)%）', p)
-                    else:
-                        r = re.search(r'.*?：(.*)（在(.*)★.*?以(.*)倍权值.*?）', p)
-                    star = r.group(2)
-                if r:
-                    chars = r.group(1)
-                    if chars.find('/') != -1:
-                        chars = chars.strip().split('/')
-                    elif chars.find('\\') != -1:
-                        chars = chars.strip().split('\\')
-                    else:
-                        chars = chars.split('\n')
-                    chars = [x.replace('[限定]', '').strip() for x in chars]
-                    probability = r.group(3)
-                    probability = probability if int(probability) > 10 else f'权{probability}'
-                    for char in chars:
-                        if char.strip():
-                            data['char']['up_char'][star][char.strip()] = probability
-        except TimeoutError:
-            logger.warning(f'更新明日方舟UP池信息超时...')
-            if prts_up_char.exists():
-                with open(prts_up_char, 'r', encoding='utf8') as f:
-                    data = json.load(f)
-        except Exception as e:
-            logger.error(f'更新明日方舟未知错误 e：{e}')
-            if prts_up_char.exists():
-                with open(prts_up_char, 'r', encoding='utf8') as f:
-                    data = json.load(f)
-        return check_write(data, prts_up_char)
-
-
-class GenshinAnnouncement:
-
-    def __init__(self):
-        self.game_name = '原神'
-
-    async def _get_announcement_text(self):
-        return (await AsyncHttpx.get(genshin_url, timeout=7)).text
-
-    async def update_up_char(self):
-        genshin_up_char.parent.mkdir(exist_ok=True, parents=True)
-        data = {
-            'char': {'up_char': {'5': {}, '4': {}}, 'title': '', 'time': '', 'pool_img': ''},
-            'arms': {'up_char': {'5': {}, '4': {}}, 'title': '', 'time': '', 'pool_img': ''}
-        }
-        text = await self._get_announcement_text()
-        soup = BeautifulSoup(text, 'lxml')
-        try:
-            div = soup.find_all('div', {'class': 'row'})[1]
-            tables = div.find_all('table', {'class': 'wikitable'})
-            for table in tables:
-                trs = table.find('tbody').find_all('tr')
-                pool_img = trs[0].find('th').find('img')
-                if pool_img['title'].find('角色活动') == -1:
-                    type_ = 'arms'
-                else:
-                    type_ = 'char'
-                try:
-                    data[type_]['pool_img'] = str(pool_img['srcset']).split(' ')[0]
-                except KeyError:
-                    data[type_]['pool_img'] = pool_img['src']
-                data[type_]['title'] = str(pool_img['title']).split(f'期{"角色" if type_ == "char" else "武器"}')[0][:-3]
-                data[type_]['time'] = trs[1].find('td').text
-                if data[type_]['time'][-1] == '\n':
-                    data[type_]['time'] = data[type_]['time'][:-1]
-                if '版本更新后' in data[type_]['time']:
-                    sp = data[type_]['time'].split('~')
-                    end_time = datetime.strptime(sp[1].strip(), "%Y/%m/%d %H:%M")
-                    start_time = end_time - timedelta(days=20)
-                    data[type_]['time'] = start_time.strftime('%Y/%m/%d') + ' ~ ' + end_time.strftime('%Y/%m/%d')
-                tmp = ''
-                for tm in data[type_]['time'].split('~'):
-                    date_time_sp = tm.split('/')
-                    date_time_sp[2] = date_time_sp[2].strip().replace(' ', '日 ')
-                    tmp += date_time_sp[1] + '月' + date_time_sp[2] + ' - '
-                data[type_]['time'] = tmp[:-2].strip()
-                for a in trs[2].find('td').find_all('a'):
-                    char_name = a['title']
-                    data[type_]['up_char']['5'][char_name] = "50"
-                for a in trs[3].find('td').find_all('a'):
-                    char_name = a['title']
-                    data[type_]['up_char']['4'][char_name] = "50"
-        except TimeoutError:
-            logger.warning(f'更新原神UP池信息超时...')
-            if genshin_up_char.exists():
-                with open(genshin_up_char, 'r', encoding='utf8') as f:
-                    data = json.load(f)
-        except Exception as e:
-            logger.error(f'更新原神UP失败，疑似UP池已结束， e：{e}')
-            if genshin_up_char.exists():
-                with open(genshin_up_char, 'r', encoding='utf8') as f:
-                    data = json.load(f)
-                    data['char']['title'] = ''
-                    data['arms']['title'] = ''
-                with open(genshin_up_char, 'w', encoding='utf8') as wf:
-                    json.dump(data, wf, ensure_ascii=False, indent=4)
-                return data
-        return check_write(data, genshin_up_char)
-
-
-class PrettyAnnouncement:
-
-    def __init__(self):
-        self.game_name = '赛马娘'
-
-    async def _get_announcement_text(self):
-        res = await AsyncHttpx.get(pretty_url, timeout=7)
-        soup = BeautifulSoup(res.text, 'lxml')
-        divs = soup.find('div', {'id': 'mw-content-text'}).find('div').find_all('div')
-        for div in divs:
-            a = div.find('a')
-            try:
-                title = a['title']
-            except (KeyError, TypeError):
-                continue
-            if title.find('新角色追加') != -1:
-                url = a['href']
-                break
-        return (await AsyncHttpx.get(f'https://wiki.biligame.com/{url}', timeout=7)).text, title[:-2]
-
-    async def update_up_char(self):
-        data = {
-            'char': {'up_char': {'3': {}, '2': {}, '1': {}}, 'title': '', 'time': '', 'pool_img': ''},
-            'card': {'up_char': {'3': {}, '2': {}, '1': {}}, 'title': '', 'time': '', 'pool_img': ''}
-        }
-        try:
-            text, title = await self._get_announcement_text()
-            soup = BeautifulSoup(text, 'lxml')
-            context = soup.find('div', {'class': 'toc-sticky'})
-            if not context:
-                context = soup.find('div', {'class': 'mw-parser-output'})
-            data['char']['title'] = title
-            data['card']['title'] = title
-            for big in context.find_all('big'):
-                r = re.search(r'\d{1,2}/\d{1,2} \d{1,2}:\d{1,2}', str(big.text))
-                if r:
-                    time = str(big.text)
-                    break
-            else:
-                logger.warning('赛马娘UP无法找到活动日期....取消更新UP池子...')
-                return
-            time = time.replace('～', '-').replace('/', '月').split(' ')
-            time = time[0] + '日 ' + time[1] + ' - ' + time[3] + '日 ' + time[4]
-            data['char']['time'] = time
-            data['card']['time'] = time
-            for p in context.find_all('p'):
-                if str(p).find('当期UP赛马娘') != -1 and str(p).find('■') != -1:
-                    if not data['char']['pool_img']:
-                        try:
-                            data['char']['pool_img'] = p.find('img')['src']
-                        except TypeError:
-                            for center in context.find_all('center'):
-                                try:
-                                    img = center.find('img')
-                                    if img and str(img['alt']).find('新马娘') != -1 and str(img['alt']).find('总览') == 1:
-                                        data['char']['pool_img'] = img['src']
-                                except (TypeError, KeyError):
-                                    pass
-                    r = re.findall(r'.*?当期UP赛马娘([\s\S]*)＜奖励内容＞.*?', str(p))
-                    if r:
-                        for x in r:
-                            x = str(x).split('\n')
-                            for msg in x:
-                                if msg.find('★') != -1:
-                                    msg = msg.replace('<br/>', '')
-                                    char_name = msg[msg.find('['):].strip()
-                                    if (star := len(msg[:msg.find('[')].strip())) == 3:
-                                        data['char']['up_char']['3'][char_name] = '70'
-                                    elif star == 2:
-                                        data['char']['up_char']['2'][char_name] = '70'
-                                    elif star == 1:
-                                        data['char']['up_char']['1'][char_name] = '70'
-                if str(p).find('（当期UP对象）') != -1 and str(p).find('赛马娘') == -1 and str(p).find('■') != -1:
-                    # data['card']['pool_img'] = p.find('img')['src']
-                    if not data['char']['pool_img']:
-                        try:
-                            data['char']['pool_img'] = p.find('img')['src']
-                        except TypeError:
-                            for center in context.find_all('center'):
-                                try:
-                                    img = center.find('img')
-                                    if img and str(img['alt']).find('新卡') != -1 and str(img['alt']).find('总览') == 1:
-                                        data['card']['pool_img'] = img['src']
-                                except (TypeError, KeyError):
-                                    pass
-                    r = re.search(r'■全?新?支援卡（当期UP对象）([\s\S]*)</p>', str(p))
-                    if r:
-                        rmsg = r.group(1).strip()
-                        rmsg = rmsg.split('<br/>')
-                        rmsg = [x for x in rmsg if x]
-                        for x in rmsg:
-                            x = x.replace('\n', '').replace('・', '')
-                            star = x[:x.find('[')].strip()
-                            char_name = x[x.find('['):].strip()
-                            if star == 'SSR':
-                                data['card']['up_char']['3'][char_name] = '70'
-                            if star == 'SR':
-                                data['card']['up_char']['2'][char_name] = '70'
-                            if star == 'R':
-                                data['card']['up_char']['1'][char_name] = '70'
-            # 日文->中文
-            with open(DRAW_DATA_PATH / 'pretty_card.json', 'r', encoding='utf8') as f:
-                all_data = json.load(f)
-            for star in data['card']['up_char'].keys():
-                for name in list(data['card']['up_char'][star].keys()):
-                    char_name = name.split(']')[1].strip()
-                    tp_name = name[name.find('['): name.find(']') + 1].strip().replace('[', '【').replace(']', '】')
-                    for x in all_data.keys():
-                        if all_data[x]['名称'].find(tp_name) != -1 and all_data[x]['关联角色'] == char_name:
-                            data['card']['up_char'][star].pop(name)
-                            data['card']['up_char'][star][all_data[x]['中文名']] = '70'
-        except TimeoutError:
-            logger.warning(f'更新赛马娘UP池信息超时...')
-            if pretty_up_char.exists():
-                with open(pretty_up_char, 'r', encoding='utf8') as f:
-                    data = json.load(f)
-        except Exception as e:
-            logger.error(f'赛马娘up更新未知错误 {type(e)}：{e}')
-            if pretty_up_char.exists():
-                with open(pretty_up_char, 'r', encoding='utf8') as f:
-                    data = json.load(f)
-        return check_write(data, pretty_up_char)
-
-
-class GuardianAnnouncement:
-
-    def __init__(self):
-        self.game_name = '坎公骑冠剑'
-
-    async def _get_announcement_text(self):
-        return (await AsyncHttpx.get(guardian_url, timeout=7)).text
-
-    async def update_up_char(self):
-        data = {
-            'char': {'up_char': {'3': {}}, 'title': '', 'time': '', 'pool_img': ''},
-            'arms': {'up_char': {'5': {}}, 'title': '', 'time': '', 'pool_img': ''}
-        }
-        try:
-            text = await self._get_announcement_text()
-            soup = BeautifulSoup(text, 'lxml')
-            context = soup.select('div.col-sm-3:nth-child(3) > div:nth-child(2) > div:nth-child(1) '
-                                  '> div:nth-child(2) > div:nth-child(3) > font:nth-child(1)')[0]
-            title = context.find('p').find('b').text
-            tmp = title.split('，')
-            time = ''
-            for msg in tmp:
-                r = re.search(r'[从|至](.*)(开始|结束)', msg)
-                if r:
-                    time += r.group(1).strip() + ' - '
-            time = time[:-3]
-            title = time.split(' - ')[0] + 'UP卡池'
-            data['char']['title'] = title
-            data['arms']['title'] = title
-            data['char']['time'] = time
-            data['arms']['time'] = time
-            start_idx = -1
-            end_idx = -1
-            index = 0
-            divs = context.find_all('div')
-            for x in divs:
-                if x.text == '角色':
-                    start_idx = index
-                if x.text == '武器':
-                    end_idx = index
-                    break
-                index += 1
-            for x in divs[start_idx + 1: end_idx]:
-                name = x.find('p').find_all('a')[-1].text
-                data['char']['up_char']['3'][name] = '0'
-            for x in divs[end_idx + 1:]:
-                name = x.find('p').find_all('a')[-1].text
-                data['arms']['up_char']['5'][name] = '0'
-        except TimeoutError:
-            logger.warning(f'更新坎公骑冠剑UP池信息超时...')
-            if guardian_up_char.exists():
-                with open(guardian_up_char, 'r', encoding='utf8') as f:
-                    data = json.load(f)
-        except Exception as e:
-            logger.error(f'坎公骑冠剑up更新未知错误 {type(e)}：{e}')
-        return check_write(data, guardian_up_char)

plugins/draw_card/async_update_game_info.py

@@ -1,63 +0,0 @@
-import asyncio
-import nonebot
-from nonebot.log import logger
-from .pcr_handle import update_pcr_info, init_pcr_data
-from .azur_handle import update_azur_info, init_azur_data
-from .prts_handle import update_prts_info, init_prts_data
-from .pretty_handle import update_pretty_info, init_pretty_data
-from .guardian_handle import update_guardian_info, init_guardian_data
-from .genshin_handle import update_genshin_info, init_genshin_data
-from .fgo_handle import update_fgo_info, init_fgo_data
-from .onmyoji_handle import update_onmyoji_info, init_onmyoji_data
-from .config import draw_config, DRAW_DATA_PATH
-
-
-driver = nonebot.get_driver()
-
-
-@driver.on_startup
-async def async_update_game():
-    tasks = []
-    init_lst = [init_pcr_data, init_pretty_data, init_azur_data, init_prts_data, init_genshin_data, init_guardian_data,
-                init_fgo_data, init_onmyoji_data]
-    if draw_config.PRTS_FLAG and not (DRAW_DATA_PATH / 'prts.json').exists():
-        tasks.append(asyncio.ensure_future(update_prts_info()))
-        init_lst.remove(init_prts_data)
-
-    if draw_config.PRETTY_FLAG and (not (DRAW_DATA_PATH / 'pretty.json').exists() or
-                        not (DRAW_DATA_PATH / 'pretty_card.json').exists()):
-        tasks.append(asyncio.ensure_future(update_pretty_info()))
-        init_lst.remove(init_pretty_data)
-
-    if draw_config.GUARDIAN_FLAG and not (DRAW_DATA_PATH / 'guardian.json').exists():
-        tasks.append(asyncio.ensure_future(update_guardian_info()))
-        init_lst.remove(init_guardian_data)
-
-    if draw_config.PCR_FLAG and not (DRAW_DATA_PATH / 'pcr.json').exists():
-        tasks.append(asyncio.ensure_future(update_pcr_info()))
-        init_lst.remove(init_pcr_data)
-
-    if draw_config.GENSHIN_FLAG and (not (DRAW_DATA_PATH / 'genshin.json').exists() or
-                         not (DRAW_DATA_PATH / 'genshin_arms.json').exists()):
-        tasks.append(asyncio.ensure_future(update_genshin_info()))
-        init_lst.remove(init_genshin_data)
-
-    if draw_config.AZUR_FLAG and not (DRAW_DATA_PATH / 'azur.json').exists():
-        tasks.append(asyncio.ensure_future(update_azur_info()))
-        init_lst.remove(init_azur_data)
-
-    if draw_config.FGO_FLAG and (not (DRAW_DATA_PATH / 'fgo.json').exists() or
-                     not (DRAW_DATA_PATH / 'fgo_card.json').exists()):
-        tasks.append(asyncio.ensure_future(update_fgo_info()))
-        init_lst.remove(init_fgo_data)
-
-    if draw_config.ONMYOJI_FLAG and not (DRAW_DATA_PATH / 'onmyoji.json').exists():
-        tasks.append(asyncio.ensure_future(update_onmyoji_info()))
-        init_lst.remove(init_onmyoji_data)
-    try:
-        await asyncio.gather(*tasks)
-        for func in init_lst:
-            await func()
-    except asyncio.exceptions.CancelledError:
-        logger.warning('更新异常：CancelledError，再次更新...')
-        await async_update_game()

plugins/draw_card/azur_handle.py

@@ -1,62 +0,0 @@
-from nonebot.adapters.onebot.v11 import MessageSegment
-import random
-from .update_game_simple_info import update_simple_info
-from .util import generate_img, init_star_rst, BaseData, set_list, get_star, max_card, format_card_information
-from .config import draw_config, DRAW_DATA_PATH
-from dataclasses import dataclass
-from .init_card_pool import init_game_pool
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-ALL_CHAR = []
-
-
-@dataclass
-class AzurChar(BaseData):
-    type_: str      # 舰娘类型
-
-
-async def azur_draw(count: int, pool_name: str):
-    #            0      1      2
-    cnlist = ['金', '紫', '蓝', '白']
-    star_list = [0, 0, 0, 0]
-    char_list, char_dict, max_star_list, star_list, max_star_index_list = \
-        format_card_information(count, star_list, _get_azur_card, pool_name, guaranteed=False)
-    rst = init_star_rst(star_list, cnlist, max_star_list, max_star_index_list)
-    if count > 90:
-        char_list = set_list(char_list)
-    return MessageSegment.image("base64://" + await generate_img(char_list, 'azur', star_list)) \
-           + '\n' + rst[:-1] + '\n' + max_card(char_dict)
-
-
-async def update_azur_info():
-    global ALL_CHAR
-    url = 'https://wiki.biligame.com/blhx/舰娘图鉴'
-    data, code = await update_simple_info(url, 'azur')
-    if code == 200:
-        ALL_CHAR = init_game_pool('azur', data, AzurChar)
-
-
-async def init_azur_data():
-    global ALL_CHAR
-    if draw_config.AZUR_FLAG:
-        with (DRAW_DATA_PATH / 'azur.json').open('r', encoding='utf8') as f:
-            azur_dict = json.load(f)
-        ALL_CHAR = init_game_pool('azur', azur_dict, AzurChar)
-
-
-# 抽取卡池
-def _get_azur_card(pool_name: str, mode: int = 1):
-    global ALL_CHAR
-    azur_config = draw_config.azur
-    if pool_name == '轻型':
-        type_ = ['驱逐', '轻巡', '维修']
-    elif pool_name == '重型':
-        type_ = ['重巡', '战列', '战巡', '重炮']
-    else:
-        type_ = ['维修', '潜艇', '重巡', '轻航', '航母']
-    star = get_star([4, 3, 2, 1], [azur_config.AZUR_FOUR_P, azur_config.AZUR_THREE_P, azur_config.AZUR_TWO_P, azur_config.AZUR_ONE_P])
-    chars = [x for x in ALL_CHAR if x.star == star and x.type_ in type_ and not x.limited]
-    return random.choice(chars), 4 - star

plugins/draw_card/config.py

@@ -1,8 +1,9 @@
 import nonebot
+from pathlib import Path
 from nonebot.log import logger
-from pydantic import BaseModel, Extra, ValidationError
-from configs.path_config import IMAGE_PATH, DATA_PATH
-from configs.config import Config
+from pydantic import BaseModel, Extra
+from configs.config import Config as AConfig
+from configs.path_config import DATA_PATH
 
 try:
     import ujson as json
@@ -15,8 +16,8 @@ class GenshinConfig(BaseModel, extra=Extra.ignore):
     GENSHIN_FIVE_P: float = 0.006
     GENSHIN_FOUR_P: float = 0.051
     GENSHIN_THREE_P: float = 0.43
-    GENSHIN_G_FIVE_P: float = 0.13
-    GENSHIN_G_FOUR_P: float = 0.016
+    GENSHIN_G_FIVE_P: float = 0.016
+    GENSHIN_G_FOUR_P: float = 0.13
     I72_ADD: float = 0.0585
 
 
@@ -87,43 +88,20 @@ class OnmyojiConfig(BaseModel, extra=Extra.ignore):
     ONMYOJI_R: float = 0.7875
 
 
-class PathDict(BaseModel, extra=Extra.ignore):
-    genshin: str = "原神"
-    prts: str = "明日方舟"
-    pretty: str = "赛马娘"
-    guardian: str = "坎公骑冠剑"
-    pcr: str = "公主连结"
-    azur: str = "碧蓝航线"
-    fgo: str = "命运-冠位指定"
-    onmyoji: str = "阴阳师"
-
-
-class DrawConfig(BaseModel, extra=Extra.ignore):
+class Config(BaseModel, extra=Extra.ignore):
     # 开关
-    PRTS_FLAG: bool = Config.get_config("draw_card", "PRTS_FLAG")
-    GENSHIN_FLAG: bool = Config.get_config("draw_card", "GENSHIN_FLAG")
-    PRETTY_FLAG: bool = Config.get_config("draw_card", "PRETTY_FLAG")
-    GUARDIAN_FLAG: bool = Config.get_config("draw_card", "GUARDIAN_FLAG")
-    PCR_FLAG: bool = Config.get_config("draw_card", "PCR_FLAG")
-    AZUR_FLAG: bool = Config.get_config("draw_card", "AZUR_FLAG")
-    FGO_FLAG: bool = Config.get_config("draw_card", "FGO_FLAG")
-    ONMYOJI_FLAG: bool = Config.get_config("draw_card", "ONMYOJI_FLAG")
+    PRTS_FLAG: bool = AConfig.get_config("draw_card", "PRTS_FLAG")
+    GENSHIN_FLAG: bool = AConfig.get_config("draw_card", "GENSHIN_FLAG")
+    PRETTY_FLAG: bool = AConfig.get_config("draw_card", "PRETTY_FLAG")
+    GUARDIAN_FLAG: bool = AConfig.get_config("draw_card", "GUARDIAN_FLAG")
+    PCR_FLAG: bool = AConfig.get_config("draw_card", "PCR_FLAG")
+    AZUR_FLAG: bool = AConfig.get_config("draw_card", "AZUR_FLAG")
+    FGO_FLAG: bool = AConfig.get_config("draw_card", "FGO_FLAG")
+    ONMYOJI_FLAG: bool = AConfig.get_config("draw_card", "ONMYOJI_FLAG")
 
     # 其他配置
-    PCR_TAI: bool = Config.get_config("draw_card", "PCR_TAI")
-    SEMAPHORE: int = Config.get_config("draw_card", "SEMAPHORE")
-
-    # 路径
-    path_dict: dict = {
-        "genshin": "原神",
-        "prts": "明日方舟",
-        "pretty": "赛马娘",
-        "guardian": "坎公骑冠剑",
-        "pcr": "公主连结",
-        "azur": "碧蓝航线",
-        "fgo": "命运-冠位指定",
-        "onmyoji": "阴阳师",
-    }
+    PCR_TAI: bool = AConfig.get_config("draw_card", "PCR_TAI")
+    SEMAPHORE: int = AConfig.get_config("draw_card", "SEMAPHORE")
 
     # 抽卡概率
     prts: PrtsConfig = PrtsConfig()
@@ -137,27 +115,53 @@ class DrawConfig(BaseModel, extra=Extra.ignore):
 
 
 driver = nonebot.get_driver()
-global_config = driver.config
-DRAW_DATA_PATH = DATA_PATH / "draw_card"
-DRAW_IMAGE_PATH = IMAGE_PATH / "draw_card"
-# DRAW_PATH = Path(draw_path) if draw_path else Path("data/draw_card").absolute()
-config_path = DRAW_DATA_PATH / "draw_card_config" / "draw_card_config.json"
 
-draw_config: Config = DrawConfig()
+DRAW_PATH = DATA_PATH / "draw_card"
+config_path = DRAW_PATH / "draw_card_config" / "draw_card_config.json"
+
+draw_config: Config = Config()
+
+
+for game_flag, game_name in zip(
+    [
+        "PRTS_FLAG",
+        "GENSHIN_FLAG",
+        "PRETTY_FLAG",
+        "GUARDIAN_FLAG",
+        "PCR_FLAG",
+        "AZUR_FLAG",
+        "FGO_FLAG",
+        "ONMYOJI_FLAG",
+        "PCR_TAI",
+    ],
+    ["明日方舟", "原神", "赛马娘", "坎公骑冠剑", "公主连结", "碧蓝航线", "命运-冠位指定（FGO）", "阴阳师", "pcr台服卡池"],
+):
+    AConfig.add_plugin_config(
+        "draw_card",
+        game_flag,
+        True,
+        name="游戏抽卡",
+        help_=f"{game_name} 抽卡开关",
+        default_value=True,
+    )
+AConfig.add_plugin_config(
+    "draw_card", "SEMAPHORE", 5, help_=f"异步数据下载数量限制", default_value=5
+)
 
 
 @driver.on_startup
 def check_config():
     global draw_config
-
+    draw_config = Config()
     if not config_path.exists():
         config_path.parent.mkdir(parents=True, exist_ok=True)
-        draw_config = DrawConfig()
+        draw_config = Config()
         logger.warning("draw_card：配置文件不存在，已重新生成配置文件.....")
 
-    json.dump(
-        draw_config.dict(),
-        config_path.open("w", encoding="utf8"),
-        indent=4,
-        ensure_ascii=False,
-    )
+    with config_path.open("w", encoding="utf8") as fp:
+        json.dump(
+            draw_config.dict(),
+            fp,
+            indent=4,
+            ensure_ascii=False,
+        )

plugins/draw_card/count_manager.py

@@ -1,4 +1,12 @@
-from typing import Optional, Union
+from typing import Optional
+from pydantic import BaseModel
+import time
+
+
+class BaseUserCount(BaseModel):
+    count: int = 1  # 当前抽卡次数
+    time_: int = time.time()  # 抽卡时间，当超过一定时间时将重置抽卡次数
+    timeout: int = 60  # 超时时间60秒
 
 
 class DrawCountManager:
@@ -6,7 +14,9 @@ class DrawCountManager:
     抽卡统计保底
     """
 
-    def __init__(self, game_draw_count_rule: tuple, star2name: tuple):
+    def __init__(
+        self, game_draw_count_rule: tuple, star2name: tuple, max_draw_count: int
+    ):
         """
         初始化保底统计
 
@@ -14,26 +24,43 @@ class DrawCountManager:
 
         抽卡保底需要的次数和返回的对应名称，例如星级等
 
+        :param game_draw_count_rule：抽卡规则
+        :param star2name：星级对应的名称
+        :param max_draw_count：最大累计抽卡次数，当下次单次抽卡超过该次数时将会清空数据
+
         """
         # 只有保底
         self._data = {}
         self._guarantee_tuple = game_draw_count_rule
         self._star2name = star2name
+        self._max_draw_count = max_draw_count
 
     def increase(self, key: int, value: int = 1):
         """
         用户抽卡次数加1
         """
         if self._data.get(key) is None:
-            self._data[key] = {
-                "count": value,
-            }
-            for x in range(len(self._guarantee_tuple)):
-                self._data[key][f"count_{x}"] = 0
+            self._data[key] = BaseUserCount()
         else:
-            self._data[key][f"count"] += value
-            if self._data[key][f"count"] > self._guarantee_tuple[-1]:
-                self._data[key][f"count"] = self._data[key][f"count"] % self._guarantee_tuple[-1]
+            self._data[key].count += 1
+
+    def get_max_guarantee(self):
+        """
+        获取最大保底抽卡次数
+        """
+        return self._guarantee_tuple[-1]
+
+    def get_user_count(self, key: int) -> int:
+        """
+        获取当前抽卡次数
+        """
+        return self._data[key].count
+
+    def update_time(self, key: int):
+        """
+        更新抽卡时间
+        """
+        self._data[key].time_ = time.time()
 
     def reset(self, key: int):
         """
@@ -41,73 +68,102 @@ class DrawCountManager:
         """
         del self._data[key]
 
-    def set_count(self, key: int, type_: int, count: int):
-        if self._data.get(key):
-            self._data[key][f"count_{type_}"] = count
-
-    def check(self, key: int, *args) -> Optional[Union[str, int]]:
-        """
-        是否保底
-        """
-        pass
-
-    def get_user_count(self, key: int, type_: Optional[int] = None) -> int:
-        """
-        获取用户当前抽卡次数
-        """
-        if self._data.get(key):
-            if type_ is None:
-                return self._data[key]["count"]
-            return self._data[key][f"count_{type_}"]
-        return 0
-
-    def record_count(self, key: int, type_: int):
-        """
-        抽出对应星级后记录当前次数
-        """
-        if self._data.get(key):
-            self._data[key][f"count_{type_}"] = self._data[key]["count"]
-
 
 class GenshinCountManager(DrawCountManager):
+    class UserCount(BaseUserCount):
+        five_index: int = 0  # 获取五星时的抽卡次数
+        four_index: int = 0  # 获取四星时的抽卡次数
+        is_up: bool = False  # 下次五星是否必定为up
 
     def increase(self, key: int, value: int = 1):
         """
         用户抽卡次数加1
         """
         if self._data.get(key) is None:
-            self._data[key] = {
-                "is_up": False,
-                "count": value,
-            }
-            for x in range(len(self._guarantee_tuple)):
-                self._data[key][f"count_{x}"] = 0
+            self._data[key] = self.UserCount()
         else:
-            self._data[key][f"count"] += value
-            if self._data[key][f"count"] > self._guarantee_tuple[-1]:
-                self._data[key][f"count"] = self._data[key][f"count"] % 180
+            self._data[key].count += 1
 
     def set_is_up(self, key: int, value: bool):
-        if self._data.get(key):
-            self._data[key]["is_up"] = value
+        """
+        设置下次是否必定up
+        """
+        self._data[key].is_up = value
 
     def is_up(self, key: int) -> bool:
-        if self._data.get(key):
-            return self._data[key]["is_up"]
-        return False
+        """
+        判断该次保底是否必定为up
+        """
+        return self._data[key].is_up
 
-    def check(self, key: int, *args) -> Optional[Union[str, int]]:
+    def get_user_five_index(self, key: int) -> int:
+        """
+        获取用户上次获取五星的次数
+        """
+        return self._data[key].five_index
+
+    def get_user_four_index(self, key: int) -> int:
+        """
+        获取用户上次获取四星的次数
+        """
+        return self._data[key].four_index
+
+    def mark_five_index(self, key: int):
+        """
+        标记用户该次次数为五星
+        """
+        self._data[key].five_index = self._data[key].count
+
+    def mark_four_index(self, key: int):
+        """
+        标记用户该次次数为四星
+        """
+        self._data[key].four_index = self._data[key].count
+
+    def check_timeout(self, key: int):
+        """
+        检查用户距离上次抽卡是否超时
+        """
+        if key in self._data.keys() and self._is_timeout(key):
+            del self._data[key]
+
+    def check_count(self, key: int, count: int):
+        """
+        检查用户该次抽卡次数累计是否超过最大限制次数
+        """
+        if (
+            key in self._data.keys()
+            and self._data[key].count + count > self._max_draw_count
+        ):
+            del self._data[key]
+
+    def _is_timeout(self, key: int) -> bool:
+        return time.time() - self._data[key].time_ > self._data[key].timeout
+
+    def get_user_guarantee_count(self, key: int) -> int:
+        return (
+            self.get_max_guarantee()
+            - (
+                (
+                    self._data[key].count % self.get_max_guarantee()
+                    if self._data[key].count > 0
+                    else 0
+                )
+                - self._data[key].five_index
+            )
+        ) % self.get_max_guarantee() or self.get_max_guarantee()
+
+    def check(self, key: int) -> Optional[int]:
         """
         是否保底
         """
         # print(self._data)
-        if self._data.get(key):
-            for i in [1, 0]:
-                count = self._data[key]["count"]
-                if count - self._data[key][f"count_{i}"] == self._guarantee_tuple[i]:
-                    if i in [2, 1]:
-                        # print("clean four count")
-                        self._data[key][f"count_0"] = self._data[key]['count']
-                    self._data[key][f"count_{i}"] = self._data[key]['count']
-                    return self._star2name[i]
+        user: GenshinCountManager.UserCount = self._data[key]
+        if user.count - user.five_index == 90:
+            user.five_index = 90
+            return 5
+        if user.count - user.four_index == 10:
+            user.four_index = user.count
+            return 4
         return None
+

plugins/draw_card/fgo_handle.py

@@ -1,111 +0,0 @@
-from nonebot.adapters.onebot.v11 import MessageSegment
-import random
-from .update_game_requests_info import update_requests_info
-from .util import generate_img, init_star_rst, BaseData, set_list, get_star, max_card
-from .config import DRAW_DATA_PATH, draw_config
-from dataclasses import dataclass
-from .init_card_pool import init_game_pool
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-ALL_CHAR = []
-ALL_CARD = []
-
-
-@dataclass
-class FgoChar(BaseData):
-    pass
-
-
-async def fgo_draw(count: int):
-    #            0      1      2
-    cnlist = ['★★★★★', '★★★★', '★★★']
-    obj_list, obj_dict, max_star_list, star_list, max_star_index_list = _format_card_information(count)
-    rst = init_star_rst(star_list, cnlist, max_star_list, max_star_index_list)
-    if count > 90:
-        obj_list = set_list(obj_list)
-    return MessageSegment.image("base64://" + await generate_img(obj_list, 'fgo', star_list)) \
-           + '\n' + rst[:-1] + '\n' + max_card(obj_dict)
-
-
-async def update_fgo_info():
-    global ALL_CHAR, ALL_CARD
-    data, code = await update_requests_info('fgo')
-    if code == 200:
-        ALL_CHAR = init_game_pool('fgo', data, FgoChar)
-    data, code = await update_requests_info('fgo_card')
-    if code == 200:
-        ALL_CARD = init_game_pool('fgo_card', data, FgoChar)
-
-
-async def init_fgo_data():
-    global ALL_CHAR, ALL_CARD
-    if draw_config.FGO_FLAG:
-        with (DRAW_DATA_PATH / 'fgo.json').open('r', encoding='utf8') as f:
-            fgo_dict = json.load(f)
-        ALL_CHAR = init_game_pool('fgo', fgo_dict, FgoChar)
-        with (DRAW_DATA_PATH / 'fgo_card.json').open('r', encoding='utf8') as f:
-            fgo_dict = json.load(f)
-        ALL_CARD = init_game_pool('fgo', fgo_dict, FgoChar)
-
-
-# 抽取卡池
-def _get_fgo_card(mode: int = 1):
-    global ALL_CHAR, ALL_CARD
-    fgo_config = draw_config.fgo
-    if mode == 1:
-        star = get_star([8, 7, 6, 5, 4, 3], [fgo_config.FGO_SERVANT_FIVE_P, fgo_config.FGO_SERVANT_FOUR_P, fgo_config.FGO_SERVANT_THREE_P,
-                                             fgo_config.FGO_CARD_FIVE_P, fgo_config.FGO_CARD_FOUR_P, fgo_config.FGO_CARD_THREE_P])
-    elif mode == 2:
-        star = get_star([5, 4], [fgo_config.FGO_CARD_FIVE_P, fgo_config.FGO_CARD_FOUR_P])
-    else:
-        star = get_star([8, 7, 6], [fgo_config.FGO_SERVANT_FIVE_P, fgo_config.FGO_SERVANT_FOUR_P, fgo_config.FGO_SERVANT_THREE_P])
-    if star > 5:
-        type_ = 'servant'
-        star -= 3
-        chars = [x for x in ALL_CHAR if x.star == star if not x.limited]
-    else:
-        type_ = 'card'
-        chars = [x for x in ALL_CARD if x.star == star if not x.limited]
-    return random.choice(chars), 5 - star, type_
-
-
-# 整理数据
-def _format_card_information(count: int):
-    max_star_lst = []  # 获取的最高星级角色列表
-    max_index_lst = []  # 获取最高星级角色的次数
-    star_list = [0, 0, 0]
-    obj_list = []  # 获取所有角色
-    obj_dict = {}  # 获取角色次数字典
-    servant_count = 0  # 保底计算
-    card_count = 0  # 保底计算
-    for i in range(count):
-        servant_count += 1
-        card_count += 1
-        # 四星卡片保底
-        if card_count == 9:
-            obj, code, type_ = _get_fgo_card(2)
-        # 三星从者保底
-        elif servant_count == 10:
-            obj, code, type_ = _get_fgo_card(3)
-            _count = 0
-        # 普通抽
-        else:
-            obj, code, type_ = _get_fgo_card()
-        star_list[code] += 1
-        if type_ == 'card' and code < 2:
-            card_count = 0
-        if type_ == 'servant':
-            servant_count = 0
-        if code == 0:
-            max_star_lst.append(obj.name)
-            max_index_lst.append(i)
-        try:
-            obj_dict[obj.name] += 1
-        except KeyError:
-            obj_dict[obj.name] = 1
-        obj_list.append(obj)
-    return obj_list, obj_dict, max_star_lst, star_list, max_index_lst

plugins/draw_card/genshin_handle.py

@@ -1,288 +0,0 @@
-from nonebot.adapters.onebot.v11 import MessageSegment, Message
-import random
-from .update_game_info import update_info
-from .util import (
-    generate_img,
-    init_rst,
-    BaseData,
-    set_list,
-    get_star,
-    init_up_char,
-)
-from .config import DRAW_DATA_PATH, draw_config
-from .count_manager import GenshinCountManager
-from dataclasses import dataclass
-from .init_card_pool import init_game_pool
-from .announcement import GenshinAnnouncement
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-announcement = GenshinAnnouncement()
-
-draw_count_manager = GenshinCountManager((10, 90), ("4", "5"))
-
-# genshin_five = {}
-# genshin_count = {}
-# genshin_pl_count = {}
-
-ALL_CHAR = []
-ALL_ARMS = []
-
-UP_CHAR = []
-UP_ARMS = []
-
-
-_CURRENT_CHAR_POOL_TITLE = ""
-_CURRENT_ARMS_POOL_TITLE = ""
-POOL_IMG = ""
-
-
-@dataclass
-class GenshinChar(BaseData):
-    pass
-
-
-async def genshin_draw(user_id: int, count: int, pool_name: str):
-    #                   0      1      2
-    star = ["★★★★★", "★★★★", "★★★"]
-    (
-        char_list,
-        five_dict,
-        star_num_list,
-    ) = _format_card_information(count, user_id, pool_name)
-    title = ""
-    up_type = []
-    up_list = []
-    if pool_name == "char" and _CURRENT_CHAR_POOL_TITLE:
-        up_type = UP_CHAR
-        title = _CURRENT_CHAR_POOL_TITLE
-    elif pool_name == "arms" and _CURRENT_ARMS_POOL_TITLE:
-        up_type = UP_ARMS
-        title = _CURRENT_ARMS_POOL_TITLE
-    tmp = ""
-    if up_type:
-        for x in up_type:
-            for operator in x.operators:
-                up_list.append(operator)
-            if x.star == 5:
-                tmp += f'五星UP：{" ".join(x.operators)} \n'
-            elif x.star == 4:
-                tmp += f'四星UP：{" ".join(x.operators)}'
-    rst = init_rst(five_dict, star_num_list, star, up_list)
-    pool_info = f"当前up池：{title}\n{tmp}" if title else ""
-    if count > 90:
-        char_list = set_list(char_list)
-    return (
-        pool_info
-        + "\n"
-        + MessageSegment.image(
-            "base64://" + await generate_img(char_list, "genshin", star_num_list)
-        )
-        + rst
-        + f'\n距离保底发还剩 {draw_count_manager.get_user_count(user_id, 1) % 90} 抽'
-        + "\n【五星：0.6%，四星：5.1%\n第72抽开始五星概率每抽加0.585%】"
-    )
-
-
-async def update_genshin_info():
-    global ALL_CHAR, ALL_ARMS
-    url = "https://wiki.biligame.com/ys/角色筛选"
-    data, code = await update_info(url, "genshin")
-    if code == 200:
-        ALL_CHAR = init_game_pool("genshin", data, GenshinChar)
-    url = "https://wiki.biligame.com/ys/武器图鉴"
-    data, code = await update_info(
-        url,
-        "genshin_arms",
-    )
-    if code == 200:
-        ALL_ARMS = init_game_pool("genshin_arms", data, GenshinChar)
-    await _genshin_init_up_char()
-
-
-async def init_genshin_data():
-    global ALL_CHAR, ALL_ARMS
-    if draw_config.GENSHIN_FLAG:
-        if not (DRAW_DATA_PATH / "genshin.json").exists() or not (DRAW_DATA_PATH / "genshin_arms.json").exists():
-            await update_genshin_info()
-        else:
-            with (DRAW_DATA_PATH / "genshin.json").open("r", encoding="utf8") as f:
-                genshin_dict = json.load(f)
-            with (DRAW_DATA_PATH / "genshin_arms.json").open("r", encoding="utf8") as f:
-                genshin_ARMS_dict = json.load(f)
-            ALL_CHAR = init_game_pool("genshin", genshin_dict, GenshinChar)
-            ALL_ARMS = init_game_pool("genshin_arms", genshin_ARMS_dict, GenshinChar)
-        await _genshin_init_up_char()
-
-
-# 抽取卡池
-def _get_genshin_card(mode: int = 1, pool_name: str = "", add: float = 0.0, is_up: bool = False):
-    """
-    mode 1：普通抽 2：四星保底 3：五星保底
-    """
-    global ALL_ARMS, ALL_CHAR, UP_ARMS, UP_CHAR, _CURRENT_ARMS_POOL_TITLE, _CURRENT_CHAR_POOL_TITLE
-    genshin_config = draw_config.genshin
-    if mode == 1:
-        star = get_star(
-            [5, 4, 3], [genshin_config.GENSHIN_FIVE_P + add, genshin_config.GENSHIN_FOUR_P, genshin_config.GENSHIN_THREE_P]
-        )
-    elif mode == 2:
-        star = get_star([5, 4], [genshin_config.GENSHIN_G_FIVE_P + add, genshin_config.GENSHIN_G_FOUR_P])
-    else:
-        star = 5
-    if pool_name == "char":
-        data_lst = UP_CHAR
-        flag = _CURRENT_CHAR_POOL_TITLE
-        type_all_lst = ALL_CHAR + [
-            x for x in ALL_ARMS if x.star == star and x.star < 5
-        ]
-    elif pool_name == "arms":
-        data_lst = UP_ARMS
-        flag = _CURRENT_ARMS_POOL_TITLE
-        type_all_lst = ALL_ARMS + [
-            x for x in ALL_CHAR if x.star == star and x.star < 5
-        ]
-    else:
-        data_lst = ""
-        flag = ""
-        type_all_lst = ""
-    all_lst = ALL_ARMS + ALL_CHAR
-    # 是否UP
-    try:
-        if flag and star > 3:
-            # 获取up角色列表
-            up_char_lst = [x.operators for x in data_lst if x.star == star][0]
-            # print(up_char_lst)
-            # 成功获取up角色
-            if random.random() < 0.5 or is_up:
-                up_char_name = random.choice(up_char_lst)
-                acquire_char = [x for x in all_lst if x.name == up_char_name][0]
-            else:
-                # 无up
-                all_char_lst = [
-                    x
-                    for x in type_all_lst
-                    if x.star == star and x.name not in up_char_lst and not x.limited
-                ]
-                acquire_char = random.choice(all_char_lst)
-        else:
-            chars = [x for x in all_lst if x.star == star and not x.limited]
-            acquire_char = random.choice(chars)
-    except IndexError:
-        chars = [x for x in all_lst if x.star == star and not x.limited]
-        acquire_char = random.choice(chars)
-    return acquire_char, 5 - star
-
-
-def _format_card_information(_count: int, user_id, pool_name):
-    char_list = []              # 获取角色列表
-    star_num_list = [0, 0, 0]       # 各个星级数量
-    five_dict = {}              # 五星数量
-    add = 0.0
-    pool = UP_CHAR if pool_name == 'char' else UP_ARMS
-    for _ in range(_count):
-        draw_count_manager.increase(user_id)
-        star = draw_count_manager.check(user_id)
-        if (draw_count_manager.get_user_count(user_id) - draw_count_manager.get_user_count(user_id, 1)) % 90 >= 72:
-            add += draw_config.genshin.I72_ADD
-        if star:
-            star = int(star)
-            if star == 4:
-                char, code = _get_genshin_card(2, pool_name, add=add)
-                draw_count_manager.record_count(user_id, 0)
-            else:
-                char, code = _get_genshin_card(3, pool_name, add, draw_count_manager.is_up(user_id))
-        else:
-            char, code = _get_genshin_card(1, pool_name, add, draw_count_manager.is_up(user_id))
-        if code == 0:
-            add = 0
-            if not five_dict.get(char.name):
-                five_dict[char.name] = [draw_count_manager.get_user_count(user_id)]
-            else:
-                five_dict[char.name].append(draw_count_manager.get_user_count(user_id) % 90)
-            draw_count_manager.set_count(user_id, 2, draw_count_manager.get_user_count(user_id, 1))
-            draw_count_manager.record_count(user_id, 0)
-            draw_count_manager.record_count(user_id, 1)
-            if char.name not in [x.operators for x in pool if x.star == 5][0]:
-                draw_count_manager.set_is_up(user_id, True)
-            else:
-                draw_count_manager.set_is_up(user_id, False)
-        star_num_list[code] += 1
-        char_list.append(char)
-    return char_list, five_dict, star_num_list
-
-
-
-
-
-
-    # if genshin_count.get(user_id) and _count <= 90:
-    #     f_count = genshin_count[user_id]
-    # else:
-    #     f_count = 0
-    # if genshin_pl_count.get(user_id) and _count <= 90:
-    #     count = genshin_pl_count[user_id]
-    # else:
-    #     count = 0
-    # for i in range(_count):
-    #     count += 1
-    #     f_count += 1
-    #     # 十连保底
-    #     if count == 10 and f_count != 90:
-    #         if f_count >= 72:
-    #             add += I72_ADD
-    #         char, code = _get_genshin_card(2, pool_name, add=add)
-    #         count = 0
-    #     # 大保底
-    #     elif f_count == 90:
-    #         char, code = _get_genshin_card(3, pool_name)
-    #     else:
-    #         if f_count >= 72:
-    #             add += I72_ADD
-    #         char, code = _get_genshin_card(pool_name=pool_name, add=add)
-    #         if code == 1:
-    #             count = 0
-    #     star_list[code] += 1
-    #     if code == 0:
-    #         if _count <= 90:
-    #             genshin_five[user_id] = f_count
-    #         add = 0.0
-    #         f_count = 0
-    #         five_list.append(char.name)
-    #         five_index_list.append(i)
-    #         try:
-    #             five_dict[char.name] += 1
-    #         except KeyError:
-    #             five_dict[char.name] = 1
-    #     char_list.append(char)
-    # if _count <= 90:
-    #     genshin_count[user_id] = f_count
-    #     genshin_pl_count[user_id] = count
-    # return char_list, five_list, five_index_list, five_dict, star_list
-
-
-def reset_count(user_id: int):
-    draw_count_manager.reset(user_id)
-
-
-# 获取up和概率
-async def _genshin_init_up_char():
-    global _CURRENT_CHAR_POOL_TITLE, _CURRENT_ARMS_POOL_TITLE, UP_CHAR, UP_ARMS, POOL_IMG
-    (
-        _CURRENT_CHAR_POOL_TITLE,
-        _CURRENT_ARMS_POOL_TITLE,
-        POOL_IMG,
-        UP_CHAR,
-        UP_ARMS,
-    ) = await init_up_char(announcement)
-
-
-async def reload_genshin_pool():
-    await _genshin_init_up_char()
-    return Message(
-        f"当前UP池子：{_CURRENT_CHAR_POOL_TITLE} & {_CURRENT_ARMS_POOL_TITLE} {POOL_IMG}"
-    )

plugins/draw_card/guardian_handle.py

@@ -1,159 +0,0 @@
-from nonebot.adapters.onebot.v11 import MessageSegment, Message
-from .update_game_info import update_info
-from .util import init_star_rst, generate_img, max_card, BaseData,\
-    set_list, get_star, format_card_information, init_up_char
-import random
-from .config import DRAW_DATA_PATH, draw_config
-from dataclasses import dataclass
-from .init_card_pool import init_game_pool
-from .announcement import GuardianAnnouncement
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-announcement = GuardianAnnouncement()
-
-ALL_CHAR = []
-ALL_ARMS = []
-
-_CURRENT_CHAR_POOL_TITLE = ''
-_CURRENT_ARMS_POOL_TITLE = ''
-UP_CHAR = []
-UP_ARMS = []
-POOL_IMG = ''
-
-
-@dataclass
-class GuardianChar(BaseData):
-    pass
-
-
-@dataclass
-class GuardianArms(BaseData):
-    pass
-
-
-async def guardian_draw(count: int, pool_name):
-    if pool_name == 'arms':
-        cnlist = ['★★★★★', '★★★★', '★★★', '★★']
-        star_list = [0, 0, 0, 0]
-    else:
-        cnlist = ['★★★', '★★', '★']
-        star_list = [0, 0, 0]
-    title = ''
-    up_type = []
-    up_list = []
-    if pool_name == 'char' and _CURRENT_CHAR_POOL_TITLE:
-        up_type = UP_CHAR
-        title = _CURRENT_CHAR_POOL_TITLE
-    elif pool_name == 'arms' and _CURRENT_ARMS_POOL_TITLE:
-        up_type = UP_ARMS
-        title = _CURRENT_ARMS_POOL_TITLE
-    tmp = ''
-    if up_type:
-        for x in up_type:
-            for operator in x.operators:
-                up_list.append(operator)
-            if pool_name == 'char':
-                if x.star == 3:
-                    tmp += f'三星UP：{" ".join(x.operators)} \n'
-            else:
-                if x.star == 5:
-                    tmp += f'五星UP：{" ".join(x.operators)}'
-    obj_list, obj_dict, max_list, star_list, max_index_list = format_card_information(count, star_list,
-                                                                                      _get_guardian_card, pool_name)
-    rst = init_star_rst(star_list, cnlist, max_list, max_index_list, up_list)
-    pool_info = f'当前up池：{title}\n{tmp}' if title else ''
-    if count > 90:
-        obj_list = set_list(obj_list)
-    return pool_info + '\n' + MessageSegment.image(
-        "base64://" + await generate_img(obj_list, 'guardian', star_list)) \
-           + '\n' + rst[:-1] + '\n' + max_card(obj_dict)
-
-
-async def update_guardian_info():
-    global ALL_CHAR, ALL_ARMS
-    url = 'https://wiki.biligame.com/gt/英雄筛选表'
-    data, code = await update_info(url, 'guardian')
-    if code == 200:
-        ALL_CHAR = init_game_pool('guardian', data, GuardianChar)
-    url = 'https://wiki.biligame.com/gt/武器'
-    tmp, code_1 = await update_info(url, 'guardian_arms')
-    url = 'https://wiki.biligame.com/gt/盾牌'
-    data, code_2 = await update_info(url, 'guardian_arms')
-    if code_1 == 200 and code_2 == 200:
-        data.update(tmp)
-        ALL_ARMS = init_game_pool('guardian_arms', data, GuardianArms)
-    await _guardian_init_up_char()
-
-
-async def init_guardian_data():
-    global ALL_CHAR, ALL_ARMS
-    if draw_config.GUARDIAN_FLAG:
-        if not (DRAW_DATA_PATH / 'guardian.json').exists() or not (DRAW_DATA_PATH / 'guardian_arms.json').exists():
-            await update_guardian_info()
-        else:
-            with (DRAW_DATA_PATH / 'guardian.json').open('r', encoding='utf8') as f:
-                guardian_char_dict = json.load(f)
-            with (DRAW_DATA_PATH / 'guardian_arms.json').open('r', encoding='utf8') as f:
-                guardian_arms_dict = json.load(f)
-            ALL_CHAR = init_game_pool('guardian', guardian_char_dict, GuardianChar)
-            ALL_ARMS = init_game_pool('guardian_arms', guardian_arms_dict, GuardianArms)
-        await _guardian_init_up_char()
-
-
-# 抽取卡池
-def _get_guardian_card(pool_name: str = '', mode: int = 1):
-    global ALL_ARMS, ALL_CHAR, UP_ARMS, UP_CHAR, _CURRENT_ARMS_POOL_TITLE, _CURRENT_CHAR_POOL_TITLE
-    guardian_config = draw_config.guardian
-    if pool_name == 'char':
-        if mode == 1:
-            star = get_star([3, 2, 1], [guardian_config.GUARDIAN_THREE_CHAR_P, guardian_config.GUARDIAN_TWO_CHAR_P, guardian_config.GUARDIAN_ONE_CHAR_P])
-        else:
-            star = get_star([3, 2], [guardian_config.GUARDIAN_THREE_CHAR_P, guardian_config.GUARDIAN_TWO_CHAR_P])
-        up_lst = UP_CHAR
-        flag = _CURRENT_CHAR_POOL_TITLE
-        _max_star = 3
-        all_data = ALL_CHAR
-    else:
-        if mode == 1:
-            star = get_star([5, 4, 3, 2], [guardian_config.GUARDIAN_FIVE_ARMS_P, guardian_config.GUARDIAN_FOUR_ARMS_P,
-                                           guardian_config.GUARDIAN_THREE_ARMS_P, guardian_config.GUARDIAN_TWO_ARMS_P])
-        else:
-            star = get_star([5, 4], [guardian_config.GUARDIAN_FIVE_ARMS_P, guardian_config.GUARDIAN_FOUR_ARMS_P])
-        up_lst = UP_ARMS
-        flag = _CURRENT_ARMS_POOL_TITLE
-        _max_star = 5
-        all_data = ALL_ARMS
-    # 是否UP
-    if flag and star == _max_star and pool_name:
-        # 获取up角色列表
-        up_char_lst = [x.operators for x in up_lst if x.star == star][0]
-        # 成功获取up角色
-        if random.random() < 0.5:
-            up_char_name = random.choice(up_char_lst)
-            acquire_char = [x for x in all_data if x.name == up_char_name][0]
-        else:
-            # 无up
-            all_char_lst = [x for x in all_data if x.star == star and x.name not in up_char_lst and not x.limited]
-            acquire_char = random.choice(all_char_lst)
-    else:
-        chars = [x for x in all_data if x.star == star and not x.limited]
-        acquire_char = random.choice(chars)
-    return acquire_char, _max_star - star
-
-
-# 获取up和概率
-async def _guardian_init_up_char():
-    global _CURRENT_CHAR_POOL_TITLE, _CURRENT_ARMS_POOL_TITLE, UP_CHAR, UP_ARMS, POOL_IMG
-    _CURRENT_CHAR_POOL_TITLE, _CURRENT_ARMS_POOL_TITLE, POOL_IMG, UP_CHAR, UP_ARMS = await init_up_char(announcement)
-
-
-async def reload_guardian_pool():
-    await _guardian_init_up_char()
-    return Message(f'当前UP池子：{_CURRENT_CHAR_POOL_TITLE} & {_CURRENT_ARMS_POOL_TITLE}')
-
-
-

plugins/draw_card/handles/azur_handle.py

@@ -0,0 +1,317 @@
+import random
+import dateparser
+from lxml import etree
+from typing import List, Optional
+from urllib.parse import unquote
+from pydantic import ValidationError
+from nonebot.log import logger
+from nonebot.adapters.onebot.v11 import Message
+from utils.message_builder import image
+
+from .base_handle import BaseHandle, BaseData, UpEvent as _UpEvent, UpChar as _UpChar
+from ..config import draw_config
+from ..util import remove_prohibited_str, cn2py
+from utils.image_utils import BuildImage
+import asyncio
+
+try:
+    import ujson as json
+except ModuleNotFoundError:
+    import json
+
+
+class AzurChar(BaseData):
+    type_: str  # 舰娘类型
+
+    @property
+    def star_str(self) -> str:
+        return ["白", "蓝", "紫", "金"][self.star - 1]
+
+
+class UpChar(_UpChar):
+    type_: str   # 舰娘类型
+
+
+class UpEvent(_UpEvent):
+    up_char: List[UpChar]  # up对象
+
+
+class AzurHandle(BaseHandle[AzurChar]):
+    def __init__(self):
+        super().__init__("azur", "碧蓝航线")
+        self.max_star = 4
+        self.config = draw_config.azur
+        self.ALL_CHAR: List[AzurChar] = []
+        self.UP_EVENT: Optional[UpEvent] = None
+
+    def get_card(self, pool_name: str, **kwargs) -> AzurChar:
+        if pool_name == "轻型":
+            type_ = ["驱逐", "轻巡", "维修"]
+        elif pool_name == "重型":
+            type_ = ["重巡", "战列", "战巡", "重炮"]
+        else:
+            type_ = ["维修", "潜艇", "重巡", "轻航", "航母"]
+        up_pool_flag = pool_name == "活动"
+        # Up
+        up_ship = [x for x in self.UP_EVENT.up_char if x.zoom > 0]
+        # print(up_ship)
+        acquire_char = None
+        if up_ship and up_pool_flag:
+            up_zoom = [(0, up_ship[0].zoom / 100)]
+            # 初始化概率
+            cur_ = up_ship[0].zoom / 100
+            for i in range(len(up_ship)):
+                try:
+                    up_zoom.append((cur_, cur_ + up_ship[i+1].zoom / 100))
+                    cur_ += up_ship[i+1].zoom / 100
+                except IndexError:
+                    pass
+            rand = random.random()
+            # 抽取up
+            for i, zoom in enumerate(up_zoom):
+                if zoom[0] <= rand <= zoom[1]:
+                    try:
+                        acquire_char = [x for x in self.ALL_CHAR if x.name == up_ship[i].name][0]
+                    except IndexError:
+                        pass
+        # 没有up或者未抽取到up
+        if not acquire_char:
+            star = self.get_star(
+                [4, 3, 2, 1],
+                [
+                    self.config.AZUR_FOUR_P,
+                    self.config.AZUR_THREE_P,
+                    self.config.AZUR_TWO_P,
+                    self.config.AZUR_ONE_P,
+                ],
+            )
+            acquire_char = random.choice([
+                x
+                for x in self.ALL_CHAR
+                if x.star == star and x.type_ in type_ and not x.limited
+            ])
+        return acquire_char
+
+    # async def draw(self, count: int, **kwargs) -> Message:
+    #     return await asyncio.get_event_loop().run_in_executor(None, self._draw, count)
+
+    async def draw(self, count: int, **kwargs) -> Message:
+        index2card = self.get_cards(count, **kwargs)
+        cards = [card[0] for card in index2card]
+        up_list = [x.name for x in self.UP_EVENT.up_char] if self.UP_EVENT.up_char else []
+        result = self.format_result(index2card, **{**kwargs, "up_list": up_list})
+        return image(b64=self.generate_img(cards).pic2bs4()) + result
+
+    def generate_card_img(self, card: AzurChar) -> BuildImage:
+        sep_w = 5
+        sep_t = 5
+        sep_b = 20
+        w = 100
+        h = 100
+        bg = BuildImage(w + sep_w * 2, h + sep_t + sep_b, font="msyh.ttf")
+        frame_path = self.img_path / f"{card.star}_star.png"
+        frame = BuildImage(w, h, background=frame_path)
+        img_path = self.img_path / f"{cn2py(card.name)}.png"
+        img = BuildImage(w, h, background=img_path)
+        # 加圆角
+        img.circle_corner(6)
+        bg.paste(img, (sep_w, sep_t), alpha=True)
+        bg.paste(frame, (sep_w, sep_t), alpha=True)
+        bg.circle_corner(6)
+        # 加名字
+        text = card.name[:6] + "..." if len(card.name) > 7 else card.name
+        text_w, text_h = bg.getsize(text)
+        bg.text(
+            (sep_w + (w - text_w) / 2, h + sep_t + (sep_b - text_h) / 2),
+            text,
+            fill=["#808080", "#3b8bff", "#8000ff", "#c90", "#ee494c"][card.star - 1],
+        )
+        return bg
+
+    def _init_data(self):
+        self.ALL_CHAR = [
+            AzurChar(
+                name=value["名称"],
+                star=int(value["星级"]),
+                limited="可以建造" not in value["获取途径"],
+                type_=value["类型"],
+            )
+            for value in self.load_data().values()
+        ]
+        self.load_up_char()
+
+    def load_up_char(self):
+        try:
+            data = self.load_data(f"draw_card_up/{self.game_name}_up_char.json")
+            self.UP_EVENT = UpEvent.parse_obj(data.get("char", {}))
+        except ValidationError:
+            logger.warning(f"{self.game_name}_up_char 解析出错")
+
+    def dump_up_char(self):
+        if self.UP_EVENT:
+            data = {"char": json.loads(self.UP_EVENT.json())}
+            self.dump_data(data, f"draw_card_up/{self.game_name}_up_char.json")
+
+    async def _update_info(self):
+        info = {}
+        # 更新图鉴
+        url = "https://wiki.biligame.com/blhx/舰娘图鉴"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 出错")
+            return
+        dom = etree.HTML(result, etree.HTMLParser())
+        contents = dom.xpath(
+            "//div[@class='resp-tabs-container']/div[@class='resp-tab-content']"
+        )
+        for index, content in enumerate(contents):
+            char_list = content.xpath("./table/tbody/tr[2]/td/div/div/div/div")
+            for char in char_list:
+                try:
+                    name = char.xpath("./a/@title")[0]
+                    frame = char.xpath("./div/a/img/@alt")[0]
+                    avatar = char.xpath("./a/img/@srcset")[0]
+                except IndexError:
+                    continue
+                member_dict = {
+                    "名称": remove_prohibited_str(name),
+                    "头像": unquote(str(avatar).split(" ")[-2]),
+                    "星级": self.parse_star(frame),
+                    "类型": self.parse_type(index),
+                }
+                info[member_dict["名称"]] = member_dict
+        # 更新额外信息
+        for key in info.keys():
+            url = f"https://wiki.biligame.com/blhx/{key}"
+            result = await self.get_url(url)
+            if not result:
+                info[key]["获取途径"] = []
+                logger.warning(f"{self.game_name_cn} 获取额外信息错误 {key}")
+                continue
+            try:
+                dom = etree.HTML(result, etree.HTMLParser())
+                time = dom.xpath(
+                    "//table[@class='wikitable sv-general']/tbody[1]/tr[4]/td[2]//text()"
+                )[0]
+                sources = []
+                if "无法建造" in time:
+                    sources.append("无法建造")
+                elif "活动已关闭" in time:
+                    sources.append("活动限定")
+                else:
+                    sources.append("可以建造")
+                info[key]["获取途径"] = sources
+            except IndexError:
+                info[key]["获取途径"] = []
+                logger.warning(f"{self.game_name_cn} 获取额外信息错误 {key}")
+        self.dump_data(info)
+        logger.info(f"{self.game_name_cn} 更新成功")
+        # 下载头像
+        for value in info.values():
+            await self.download_img(value["头像"], value["名称"])
+        # 下载头像框
+        idx = 1
+        BLHX_URL = "https://patchwiki.biligame.com/images/blhx"
+        for url in [
+            "/1/15/pxho13xsnkyb546tftvh49etzdh74cf.png",
+            "/a/a9/k8t7nx6c8pan5vyr8z21txp45jxeo66.png",
+            "/a/a5/5whkzvt200zwhhx0h0iz9qo1kldnidj.png",
+            "/a/a2/ptog1j220x5q02hytpwc8al7f229qk9.png",
+            "/6/6d/qqv5oy3xs40d3055cco6bsm0j4k4gzk.png",
+        ]:
+            await self.download_img(BLHX_URL + url, f"{idx}_star")
+            idx += 1
+        await self.update_up_char()
+
+    @staticmethod
+    def parse_star(star: str) -> int:
+        if star in ["舰娘头像外框普通.png", "舰娘头像外框白色.png"]:
+            return 1
+        elif star in ["舰娘头像外框稀有.png", "舰娘头像外框蓝色.png"]:
+            return 2
+        elif star in ["舰娘头像外框精锐.png", "舰娘头像外框紫色.png"]:
+            return 3
+        elif star in ["舰娘头像外框超稀有.png", "舰娘头像外框金色.png"]:
+            return 4
+        elif star in ["舰娘头像外框海上传奇.png", "舰娘头像外框彩色.png"]:
+            return 5
+        elif star in [
+            "舰娘头像外框最高方案.png",
+            "舰娘头像外框决战方案.png",
+            "舰娘头像外框超稀有META.png",
+            "舰娘头像外框精锐META.png",
+        ]:
+            return 6
+        else:
+            return 6
+
+    @staticmethod
+    def parse_type(index: int) -> str:
+        azur_types = [
+            "驱逐",
+            "轻巡",
+            "重巡",
+            "超巡",
+            "战巡",
+            "战列",
+            "航母",
+            "航站",
+            "轻航",
+            "重炮",
+            "维修",
+            "潜艇",
+            "运输",
+        ]
+        try:
+            return azur_types[index]
+        except IndexError:
+            return azur_types[0]
+
+    async def update_up_char(self):
+        url = "https://wiki.biligame.com/blhx/游戏活动表"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"{self.game_name_cn}获取活动表出错")
+            return
+        try:
+            dom = etree.HTML(result, etree.HTMLParser())
+            dd = dom.xpath("//div[@class='timeline2']/dl/dd/a")[0]
+            url = "https://wiki.biligame.com" + dd.xpath("./@href")[0]
+            title = dd.xpath("string(.)")
+            result = await self.get_url(url)
+            if not result:
+                logger.warning(f"{self.game_name_cn}获取活动页面出错")
+                return
+            dom = etree.HTML(result, etree.HTMLParser())
+            timer = dom.xpath("//span[@class='eventTimer']")[0]
+            start_time = dateparser.parse(timer.xpath("./@data-start")[0])
+            end_time = dateparser.parse(timer.xpath("./@data-end")[0])
+            ships = dom.xpath("//table[@class='shipinfo']")
+            up_chars = []
+            for ship in ships:
+                name = ship.xpath("./tbody/tr/td[2]/p/a/@title")[0]
+                type_ = ship.xpath("./tbody/tr/td[2]/p/small/text()")[0]        # 舰船类型
+                try:
+                    p = float(str(ship.xpath(".//sup/text()")[0]).strip("%"))
+                except IndexError:
+                    p = 0
+                star = self.parse_star(
+                    ship.xpath("./tbody/tr/td[1]/div/div/div/a/img/@alt")[0]
+                )
+                up_chars.append(UpChar(name=name, star=star, limited=False, zoom=p, type_=type_))
+            self.UP_EVENT = UpEvent(
+                title=title,
+                pool_img="",
+                start_time=start_time,
+                end_time=end_time,
+                up_char=up_chars,
+            )
+            self.dump_up_char()
+        except Exception as e:
+            logger.warning(f"{self.game_name_cn}UP更新出错 {type(e)}：{e}")
+
+    async def _reload_pool(self) -> Optional[Message]:
+        await self.update_up_char()
+        self.load_up_char()
+        if self.UP_EVENT:
+            return Message(f"重载成功！\n当前活动：{self.UP_EVENT.title}")

plugins/draw_card/handles/base_handle.py

@@ -0,0 +1,298 @@
+import math
+import random
+import aiohttp
+import asyncio
+import aiofiles
+from PIL import Image
+from datetime import datetime
+from pydantic import BaseModel, Extra
+from asyncio.exceptions import TimeoutError
+from typing import Dict, List, Optional, TypeVar, Generic, Tuple
+from nonebot.adapters.onebot.v11 import Message
+from configs.path_config import IMAGE_PATH
+from utils.message_builder import image
+from nonebot.log import logger
+import asyncio
+
+try:
+    import ujson as json
+except ModuleNotFoundError:
+    import json
+
+from utils.image_utils import BuildImage
+from ..config import DRAW_PATH, draw_config
+from ..util import cn2py, circled_number
+
+
+class BaseData(BaseModel, extra=Extra.ignore):
+    name: str  # 名字
+    star: int  # 星级
+    limited: bool  # 限定
+
+    def __eq__(self, other: "BaseData"):
+        return self.name == other.name
+
+    def __hash__(self):
+        return hash(self.name)
+
+    @property
+    def star_str(self) -> str:
+        return "".join(["★" for _ in range(self.star)])
+
+
+class UpChar(BaseData):
+    zoom: float  # up提升倍率
+
+
+class UpEvent(BaseModel):
+    title: str  # up池标题
+    pool_img: str  # up池封面
+    start_time: Optional[datetime]  # 开始时间
+    end_time: Optional[datetime]  # 结束时间
+    up_char: List[UpChar]  # up对象
+
+
+TC = TypeVar("TC", bound="BaseData")
+
+
+class BaseHandle(Generic[TC]):
+    def __init__(self, game_name: str, game_name_cn: str, game_card_color: str = "#ffffff"):
+        self.game_name = game_name
+        self.game_name_cn = game_name_cn
+        self.max_star = 1  # 最大星级
+        self.data_path = DRAW_PATH
+        self.img_path = IMAGE_PATH / f"draw_card/{self.game_name}"
+        self.up_path = DRAW_PATH / "draw_card_up"
+        self.img_path.mkdir(parents=True, exist_ok=True)
+        self.up_path.mkdir(parents=True, exist_ok=True)
+        self.data_files: List[str] = [f"{self.game_name}.json"]
+        self.game_card_color: str = game_card_color
+
+    async def draw(self, count: int, **kwargs) -> Message:
+        return await asyncio.get_event_loop().run_in_executor(None, self._draw, count)
+
+    def _draw(self, count: int, **kwargs) -> Message:
+        index2card = self.get_cards(count, **kwargs)
+        cards = [card[0] for card in index2card]
+        result = self.format_result(index2card)
+        return image(b64=self.generate_img(cards).pic2bs4()) + result
+
+    # 抽取卡池
+    def get_card(self, **kwargs) -> TC:
+        raise NotImplementedError
+
+    def get_cards(self, count: int, **kwargs) -> List[Tuple[TC, int]]:
+        return [(self.get_card(**kwargs), i) for i in range(count)]
+
+    # 获取星级
+    @staticmethod
+    def get_star(star_list: List[int], probability_list: List[float]) -> int:
+        return random.choices(star_list, weights=probability_list, k=1)[0]
+
+    def format_result(self, index2card: List[Tuple[TC, int]], **kwargs) -> str:
+        card_list = [card[0] for card in index2card]
+        results = [
+            self.format_star_result(card_list, **kwargs),
+            self.format_max_star(index2card, **kwargs),
+            self.format_max_card(card_list, **kwargs),
+        ]
+        results = [rst for rst in results if rst]
+        return "\n".join(results)
+
+    def format_star_result(self, card_list: List[TC], **kwargs) -> str:
+        star_dict: Dict[str, int] = {}  # 记录星级及其次数
+
+        card_list_sorted = sorted(card_list, key=lambda c: c.star, reverse=True)
+        for card in card_list_sorted:
+            try:
+                star_dict[card.star_str] += 1
+            except KeyError:
+                star_dict[card.star_str] = 1
+
+        rst = ""
+        for star_str, count in star_dict.items():
+            rst += f"[{star_str}×{count}] "
+        return rst.strip()
+
+    def format_max_star(
+        self, card_list: List[Tuple[TC, int]], up_list: List[str] = [], **kwargs
+    ) -> str:
+        up_list = up_list or kwargs.get("up_list", [])
+        rst = ""
+        for card, index in card_list:
+            if card.star == self.max_star:
+                if card.name in up_list:
+                    rst += f"第 {index} 抽获取UP {card.name}\n"
+                else:
+                    rst += f"第 {index} 抽获取 {card.name}\n"
+        return rst.strip()
+
+    def format_max_card(self, card_list: List[TC], **kwargs) -> str:
+        card_dict: Dict[TC, int] = {}  # 记录卡牌抽取次数
+
+        for card in card_list:
+            try:
+                card_dict[card] += 1
+            except KeyError:
+                card_dict[card] = 1
+
+        max_count = max(card_dict.values())
+        max_card = list(card_dict.keys())[list(card_dict.values()).index(max_count)]
+        if max_count <= 1:
+            return ""
+        return f"抽取到最多的是{max_card.name}，共抽取了{max_count}次"
+
+    def generate_img(
+        self,
+        cards: List[TC],
+        num_per_line: int = 5,
+        max_per_line: Tuple[int, int] = (40, 10),
+    ) -> BuildImage:
+        """
+        生成统计图片
+        :param cards: 卡牌列表
+        :param num_per_line: 单行角色显示数量
+        :param max_per_line: 当card_list超过一定数值时，更改单行数量
+        """
+        if len(cards) > max_per_line[0]:
+            num_per_line = max_per_line[1]
+        if len(cards) > 90:
+            card_dict: Dict[TC, int] = {}  # 记录卡牌抽取次数
+            for card in cards:
+                try:
+                    card_dict[card] += 1
+                except KeyError:
+                    card_dict[card] = 1
+            card_list = list(card_dict)
+            num_list = list(card_dict.values())
+        else:
+            card_list = cards
+            num_list = [1] * len(cards)
+
+        card_imgs: List[BuildImage] = []
+        for card, num in zip(card_list, num_list):
+            card_img = self.generate_card_img(card)
+
+            # 数量 > 1 时加数字上标
+            if num > 1:
+                label = circled_number(num)
+                label_w = int(min(card_img.w, card_img.h) / 7)
+                label = label.resize(
+                    (
+                        int(label_w * label.width / label.height),
+                        label_w,
+                    ),
+                    Image.ANTIALIAS,
+                )
+                card_img.paste(label, alpha=True)
+
+            card_imgs.append(card_img)
+
+        img_w = card_imgs[0].w
+        img_h = card_imgs[0].h
+        if len(card_imgs) < num_per_line:
+            w = img_w * len(card_imgs)
+        else:
+            w = img_w * num_per_line
+        h = img_h * math.ceil(len(card_imgs) / num_per_line)
+        img = BuildImage(w, h, img_w, img_h, color=self.game_card_color)
+        for card_img in card_imgs:
+            img.paste(card_img)
+        return img
+
+    def generate_card_img(self, card: TC) -> BuildImage:
+        img = str(self.img_path / f"{cn2py(card.name)}.png")
+        return BuildImage(100, 100, background=img)
+
+    def load_data(self, filename: str = "") -> dict:
+        if not filename:
+            filename = f"{self.game_name}.json"
+        filepath = self.data_path / filename
+        if not filepath.exists():
+            return {}
+        with filepath.open("r", encoding="utf8") as f:
+            return json.load(f)
+
+    def dump_data(self, data: dict, filename: str = ""):
+        if not filename:
+            filename = f"{self.game_name}.json"
+        filepath = self.data_path / filename
+        with filepath.open("w", encoding="utf8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=4)
+
+    def data_exists(self) -> bool:
+        for file in self.data_files:
+            if not (self.data_path / file).exists():
+                return False
+        return True
+
+    def _init_data(self):
+        raise NotImplementedError
+
+    def init_data(self):
+        try:
+            self._init_data()
+        except Exception as e:
+            logger.warning(f"{self.game_name_cn} 导入角色数据错误：{type(e)}：{e}")
+
+    async def _update_info(self):
+        raise NotImplementedError
+
+    def client(self) -> aiohttp.ClientSession:
+        headers = {
+            "User-Agent": '"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; TencentTraveler 4.0)"'
+        }
+        return aiohttp.ClientSession(headers=headers)
+
+    async def update_info(self):
+        try:
+            async with asyncio.Semaphore(draw_config.SEMAPHORE):
+                async with self.client() as session:
+                    self.session = session
+                    await self._update_info()
+        except Exception as e:
+            logger.warning(f"{self.game_name_cn} 更新数据错误：{type(e)}：{e}")
+        self.init_data()
+
+    async def get_url(self, url: str) -> str:
+        result = ""
+        retry = 5
+        for i in range(retry):
+            try:
+                async with self.session.get(url, timeout=10) as response:
+                    result = await response.text()
+                break
+            except TimeoutError:
+                logger.warning(f"访问 {url} 超时, 重试 {i + 1}/{retry}")
+                await asyncio.sleep(1)
+        return result
+
+    async def download_img(self, url: str, name: str) -> bool:
+        img_path = self.img_path / f"{cn2py(name)}.png"
+        if img_path.exists():
+            return True
+        try:
+            async with self.session.get(url, timeout=10) as response:
+                async with aiofiles.open(str(img_path), "wb") as f:
+                    await f.write(await response.read())
+            return True
+        except TimeoutError:
+            logger.warning(f"下载 {self.game_name_cn} 图片超时，名称：{name}，url：{url}")
+            return False
+        except:
+            logger.warning(f"下载 {self.game_name_cn} 链接错误，名称：{name}，url：{url}")
+            return False
+
+    async def _reload_pool(self) -> Optional[Message]:
+        return None
+
+    async def reload_pool(self) -> Optional[Message]:
+        try:
+            async with self.client() as session:
+                self.session = session
+                return await self._reload_pool()
+        except Exception as e:
+            logger.warning(f"{self.game_name_cn} 重载UP池错误：{type(e)}：{e}")
+
+    def reset_count(self, user_id: int) -> bool:
+        return False

plugins/draw_card/handles/fgo_handle.py

@@ -0,0 +1,221 @@
+import random
+from lxml import etree
+from typing import List, Tuple
+from PIL import ImageDraw
+from nonebot.log import logger
+
+try:
+    import ujson as json
+except ModuleNotFoundError:
+    import json
+
+from .base_handle import BaseHandle, BaseData
+from ..config import draw_config
+from ..util import remove_prohibited_str, cn2py, load_font
+from utils.image_utils import BuildImage
+
+
+class FgoData(BaseData):
+    pass
+
+
+class FgoChar(FgoData):
+    pass
+
+
+class FgoCard(FgoData):
+    pass
+
+
+class FgoHandle(BaseHandle[FgoData]):
+    def __init__(self):
+        super().__init__("fgo", "命运-冠位指定")
+        self.data_files.append("fgo_card.json")
+        self.max_star = 5
+        self.config = draw_config.fgo
+        self.ALL_CHAR: List[FgoChar] = []
+        self.ALL_CARD: List[FgoCard] = []
+
+    def get_card(self, mode: int = 1) -> FgoData:
+        if mode == 1:
+            star = self.get_star(
+                [8, 7, 6, 5, 4, 3],
+                [
+                    self.config.FGO_SERVANT_FIVE_P,
+                    self.config.FGO_SERVANT_FOUR_P,
+                    self.config.FGO_SERVANT_THREE_P,
+                    self.config.FGO_CARD_FIVE_P,
+                    self.config.FGO_CARD_FOUR_P,
+                    self.config.FGO_CARD_THREE_P,
+                ],
+            )
+        elif mode == 2:
+            star = self.get_star(
+                [5, 4], [self.config.FGO_CARD_FIVE_P, self.config.FGO_CARD_FOUR_P]
+            )
+        else:
+            star = self.get_star(
+                [8, 7, 6],
+                [
+                    self.config.FGO_SERVANT_FIVE_P,
+                    self.config.FGO_SERVANT_FOUR_P,
+                    self.config.FGO_SERVANT_THREE_P,
+                ],
+            )
+        if star > 5:
+            star -= 3
+            chars = [x for x in self.ALL_CHAR if x.star == star and not x.limited]
+        else:
+            chars = [x for x in self.ALL_CARD if x.star == star and not x.limited]
+        return random.choice(chars)
+
+    def get_cards(self, count: int, **kwargs) -> List[Tuple[FgoData, int]]:
+        card_list = []  # 获取所有角色
+        servant_count = 0  # 保底计算
+        card_count = 0  # 保底计算
+        for i in range(count):
+            servant_count += 1
+            card_count += 1
+            if card_count == 9:  # 四星卡片保底
+                mode = 2
+            elif servant_count == 10:  # 三星从者保底
+                mode = 3
+            else:  # 普通抽
+                mode = 1
+            card = self.get_card(mode)
+            if isinstance(card, FgoCard) and card.star > self.max_star - 2:
+                card_count = 0
+            if isinstance(card, FgoChar):
+                servant_count = 0
+            card_list.append((card, i + 1))
+        return card_list
+
+    def generate_card_img(self, card: FgoData) -> BuildImage:
+        sep_w = 5
+        sep_t = 5
+        sep_b = 20
+        w = 128
+        h = 140
+        bg = BuildImage(w + sep_w * 2, h + sep_t + sep_b)
+        img_path = str(self.img_path / f"{cn2py(card.name)}.png")
+        img = BuildImage(w, h, background=img_path)
+        bg.paste(img, (sep_w, sep_t), alpha=True)
+        # 加名字
+        text = card.name[:6] + "..." if len(card.name) > 7 else card.name
+        font = load_font(fontsize=16)
+        text_w, text_h = font.getsize(text)
+        draw = ImageDraw.Draw(bg.markImg)
+        draw.text(
+            (sep_w + (w - text_w) / 2, h + sep_t + (sep_b - text_h) / 2),
+            text,
+            font=font,
+            fill="gray",
+        )
+        return bg
+
+    def _init_data(self):
+        self.ALL_CHAR = [
+            FgoChar(
+                name=value["名称"],
+                star=int(value["星级"]),
+                limited=True
+                if not ("圣晶石召唤" in value["入手方式"] or "圣晶石召唤（Story卡池）" in value["入手方式"])
+                else False,
+            )
+            for value in self.load_data().values()
+        ]
+        self.ALL_CARD = [
+            FgoCard(name=value["名称"], star=int(value["星级"]), limited=False)
+            for value in self.load_data("fgo_card.json").values()
+        ]
+
+    async def _update_info(self):
+        # fgo.json
+        fgo_info = {}
+        for i in range(500):
+            url = f"http://fgo.vgtime.com/servant/ajax?card=&wd=&ids=&sort=12777&o=desc&pn={i}"
+            result = await self.get_url(url)
+            if not result:
+                logger.warning(f"更新 {self.game_name_cn} page {i} 出错")
+                continue
+            fgo_data = json.loads(result)
+            if int(fgo_data["nums"]) <= 0:
+                break
+            for x in fgo_data["data"]:
+                name = remove_prohibited_str(x["name"])
+                member_dict = {
+                    "id": x["id"],
+                    "card_id": x["charid"],
+                    "头像": x["icon"],
+                    "名称": remove_prohibited_str(x["name"]),
+                    "职阶": x["classes"],
+                    "星级": int(x["star"]),
+                    "hp": x["lvmax4hp"],
+                    "atk": x["lvmax4atk"],
+                    "card_quick": x["cardquick"],
+                    "card_arts": x["cardarts"],
+                    "card_buster": x["cardbuster"],
+                    "宝具": x["tprop"],
+                }
+                fgo_info[name] = member_dict
+        # 更新额外信息
+        for key in fgo_info.keys():
+            url = f'http://fgo.vgtime.com/servant/{fgo_info[key]["id"]}'
+            result = await self.get_url(url)
+            if not result:
+                fgo_info[key]["入手方式"] = ["圣晶石召唤"]
+                logger.warning(f"{self.game_name_cn} 获取额外信息错误 {key}")
+                continue
+            try:
+                dom = etree.HTML(result, etree.HTMLParser())
+                obtain = dom.xpath(
+                    "//table[contains(string(.),'入手方式')]/tr[8]/td[3]/text()"
+                )[0]
+                obtain = str(obtain).strip()
+                if "限时活动免费获取 活动结束后无法获得" in obtain:
+                    obtain = ["活动获取"]
+                elif "非限时UP无法获得" in obtain:
+                    obtain = ["限时召唤"]
+                else:
+                    if "&" in obtain:
+                        obtain = obtain.split("&")
+                    else:
+                        obtain = obtain.split(" ")
+                obtain = [s.strip() for s in obtain if s.strip()]
+                fgo_info[key]["入手方式"] = obtain
+            except IndexError:
+                fgo_info[key]["入手方式"] = ["圣晶石召唤"]
+                logger.warning(f"{self.game_name_cn} 获取额外信息错误 {key}")
+        self.dump_data(fgo_info)
+        logger.info(f"{self.game_name_cn} 更新成功")
+        # fgo_card.json
+        fgo_card_info = {}
+        for i in range(500):
+            url = f"http://fgo.vgtime.com/equipment/ajax?wd=&ids=&sort=12958&o=desc&pn={i}"
+            result = await self.get_url(url)
+            if not result:
+                logger.warning(f"更新 {self.game_name_cn}卡牌 page {i} 出错")
+                continue
+            fgo_data = json.loads(result)
+            if int(fgo_data["nums"]) <= 0:
+                break
+            for x in fgo_data["data"]:
+                name = remove_prohibited_str(x["name"])
+                member_dict = {
+                    "id": x["id"],
+                    "card_id": x["equipid"],
+                    "头像": x["icon"],
+                    "名称": name,
+                    "星级": int(x["star"]),
+                    "hp": x["lvmax_hp"],
+                    "atk": x["lvmax_atk"],
+                    "skill_e": str(x["skill_e"]).split("<br />")[:-1],
+                }
+                fgo_card_info[name] = member_dict
+        self.dump_data(fgo_card_info, "fgo_card.json")
+        logger.info(f"{self.game_name_cn} 卡牌更新成功")
+        # 下载头像
+        for value in fgo_info.values():
+            await self.download_img(value["头像"], value["名称"])
+        for value in fgo_card_info.values():
+            await self.download_img(value["头像"], value["名称"])

plugins/draw_card/handles/genshin_handle.py

@@ -0,0 +1,429 @@
+import random
+import dateparser
+from lxml import etree
+from PIL import Image, ImageDraw
+from urllib.parse import unquote
+from typing import List, Optional, Tuple
+from pydantic import ValidationError
+from datetime import datetime, timedelta
+from nonebot.adapters.onebot.v11 import Message
+from utils.message_builder import image
+from nonebot.log import logger
+import asyncio
+
+try:
+    import ujson as json
+except ModuleNotFoundError:
+    import json
+
+from .base_handle import BaseHandle, BaseData, UpChar, UpEvent
+from ..config import draw_config
+from ..count_manager import GenshinCountManager
+from ..util import remove_prohibited_str, cn2py, load_font
+from utils.image_utils import BuildImage
+
+
+class GenshinData(BaseData):
+    pass
+
+
+class GenshinChar(GenshinData):
+    pass
+
+
+class GenshinArms(GenshinData):
+    pass
+
+
+class GenshinHandle(BaseHandle[GenshinData]):
+    def __init__(self):
+        super().__init__("genshin", "原神", "#ebebeb")
+        self.data_files.append("genshin_arms.json")
+        self.max_star = 5
+        self.config = draw_config.genshin
+
+        self.ALL_CHAR: List[GenshinData] = []
+        self.ALL_ARMS: List[GenshinData] = []
+        self.UP_CHAR: Optional[UpEvent] = None
+        self.UP_ARMS: Optional[UpEvent] = None
+
+        self.count_manager = GenshinCountManager((10, 90), ("4", "5"), 180)
+
+    # 抽取卡池
+    def get_card(
+        self, pool_name: str, mode: int = 1, add: float = 0.0, is_up: bool = False
+    ):
+        """
+        mode 1：普通抽 2：四星保底 3：五星保底
+        """
+        if mode == 1:
+            star = self.get_star(
+                [5, 4, 3],
+                [
+                    self.config.GENSHIN_FIVE_P + add,
+                    self.config.GENSHIN_FOUR_P,
+                    self.config.GENSHIN_THREE_P,
+                ],
+            )
+        elif mode == 2:
+            star = self.get_star(
+                [5, 4],
+                [self.config.GENSHIN_G_FIVE_P + add, self.config.GENSHIN_G_FOUR_P],
+            )
+        else:
+            star = 5
+
+        if pool_name == "char":
+            up_event = self.UP_CHAR
+            all_list = self.ALL_CHAR + [
+                x for x in self.ALL_ARMS if x.star == star and x.star < 5
+            ]
+        elif pool_name == "arms":
+            up_event = self.UP_ARMS
+            all_list = self.ALL_ARMS + [
+                x for x in self.ALL_CHAR if x.star == star and x.star < 5
+            ]
+        else:
+            up_event = None
+            all_list = self.ALL_ARMS + self.ALL_CHAR
+
+        acquire_char = None
+        # 是否UP
+        if up_event and star > 3:
+            # 获取up角色列表
+            up_list = [x.name for x in up_event.up_char if x.star == star]
+            # 成功获取up角色
+            if random.random() < 0.5 or is_up:
+                up_name = random.choice(up_list)
+                try:
+                    acquire_char = [x for x in all_list if x.name == up_name][0]
+                except IndexError:
+                    pass
+        if not acquire_char:
+            chars = [x for x in all_list if x.star == star and not x.limited]
+            acquire_char = random.choice(chars)
+        return acquire_char
+
+    def get_cards(
+        self, count: int, user_id: int, pool_name: str
+    ) -> List[Tuple[GenshinData, int]]:
+        card_list = []  # 获取角色列表
+        add = 0.0
+        count_manager = self.count_manager
+        count_manager.check_timeout(user_id)  # 检查上次抽卡次数是否超时
+        count_manager.check_count(user_id, count)  # 检查次数累计
+        pool = self.UP_CHAR if pool_name == "char" else self.UP_ARMS
+        for i in range(count):
+            count_manager.increase(user_id)
+            star = count_manager.check(user_id)  # 是否有四星或五星保底
+            if (
+                count_manager.get_user_count(user_id)
+                - count_manager.get_user_five_index(user_id)
+            ) % count_manager.get_max_guarantee() >= 72:
+                add += draw_config.genshin.I72_ADD
+            if star:
+                if star == 4:
+                    card = self.get_card(pool_name, 2, add=add)
+                else:
+                    card = self.get_card(
+                        pool_name, 3, add, count_manager.is_up(user_id)
+                    )
+            else:
+                card = self.get_card(pool_name, 1, add, count_manager.is_up(user_id))
+            # print(f"{count_manager.get_user_count(user_id)}：",
+            # count_manager.get_user_five_index(user_id), star, card.star, add)
+            # 四星角色
+            if card.star == 4:
+                count_manager.mark_four_index(user_id)
+            # 五星角色
+            elif card.star == self.max_star:
+                add = 0
+                count_manager.mark_five_index(user_id)  # 记录五星保底
+                count_manager.mark_four_index(user_id)  # 记录四星保底
+            if pool and card.name in [
+                x.name for x in pool.up_char if x.star == self.max_star
+            ]:
+                count_manager.set_is_up(user_id, True)
+            else:
+                count_manager.set_is_up(user_id, False)
+            card_list.append((card, count_manager.get_user_count(user_id)))
+        count_manager.update_time(user_id)
+        return card_list
+
+    def generate_card_img(self, card: GenshinData) -> BuildImage:
+        sep_w = 10
+        sep_h = 5
+        frame_w = 112
+        frame_h = 132
+        img_w = 106
+        img_h = 106
+        bg = BuildImage(frame_w + sep_w * 2, frame_h + sep_h * 2, color="#EBEBEB")
+        frame_path = str(self.img_path / "avatar_frame.png")
+        frame = Image.open(frame_path)
+        # 加名字
+        text = card.name
+        font = load_font(fontsize=14)
+        text_w, text_h = font.getsize(text)
+        draw = ImageDraw.Draw(frame)
+        draw.text(
+            ((frame_w - text_w) / 2, frame_h - 15 - text_h / 2),
+            text,
+            font=font,
+            fill="gray",
+        )
+        img_path = str(self.img_path / f"{cn2py(card.name)}.png")
+        img = BuildImage(img_w, img_h, background=img_path)
+        if isinstance(card, GenshinArms):
+            # 武器卡背景不是透明的，切去上方两个圆弧
+            r = 12
+            circle = Image.new("L", (r * 2, r * 2), 0)
+            alpha = Image.new("L", img.size, 255)
+            alpha.paste(circle, (-r - 3, -r - 3))  # 左上角
+            alpha.paste(circle, (img_h - r + 3, -r - 3))  # 右上角
+            img.markImg.putalpha(alpha)
+        star_path = str(self.img_path / f"{card.star}_star.png")
+        star = Image.open(star_path)
+        bg.paste(frame, (sep_w, sep_h), alpha=True)
+        bg.paste(img, (sep_w + 3, sep_h + 3), alpha=True)
+        bg.paste(star, (sep_w + int((frame_w - star.width) / 2), sep_h - 6), alpha=True)
+        return bg
+
+    def format_pool_info(self, pool_name: str) -> str:
+        info = ""
+        up_event = None
+        if pool_name == "char":
+            up_event = self.UP_CHAR
+        elif pool_name == "arms":
+            up_event = self.UP_ARMS
+        if up_event:
+            star5_list = [x.name for x in up_event.up_char if x.star == 5]
+            star4_list = [x.name for x in up_event.up_char if x.star == 4]
+            if star5_list:
+                info += f"五星UP：{' '.join(star5_list)}\n"
+            if star4_list:
+                info += f"四星UP：{' '.join(star4_list)}\n"
+            info = f"当前up池：{up_event.title}\n{info}"
+        return info.strip()
+
+    async def draw(self, count: int, user_id: int, pool_name: str = "", **kwargs) -> Message:
+        return await asyncio.get_event_loop().run_in_executor(None, self._draw, count, user_id, pool_name)
+
+    def _draw(self, count: int, user_id: int, pool_name: str = "", **kwargs) -> Message:
+        index2cards = self.get_cards(count, user_id, pool_name)
+        cards = [card[0] for card in index2cards]
+        up_event = None
+        if pool_name == "char":
+            up_event = self.UP_CHAR
+        elif pool_name == "arms":
+            up_event = self.UP_ARMS
+        up_list = [x.name for x in up_event.up_char] if up_event else []
+        result = self.format_star_result(cards)
+        result += (
+            "\n" + max_star_str
+            if (max_star_str := self.format_max_star(index2cards, up_list=up_list))
+            else ""
+        )
+        result += f"\n距离保底发还剩 {self.count_manager.get_user_guarantee_count(user_id)} 抽"
+        # result += "\n【五星：0.6%，四星：5.1%，第72抽开始五星概率每抽加0.585%】"
+        pool_info = self.format_pool_info(pool_name)
+        img = self.generate_img(cards)
+        bk = BuildImage(img.w, img.h + 50, font_size=20, color="#ebebeb")
+        bk.paste(img)
+        bk.text((0, img.h + 10), "【五星：0.6%，四星：5.1%，第72抽开始五星概率每抽加0.585%】")
+        return pool_info + image(b64=bk.pic2bs4()) + result
+
+    def _init_data(self):
+        self.ALL_CHAR = [
+            GenshinChar(
+                name=value["名称"],
+                star=int(value["星级"]),
+                limited=value["常驻/限定"] == "限定UP",
+            )
+            for key, value in self.load_data().items()
+            if "旅行者" not in key
+        ]
+        self.ALL_ARMS = [
+            GenshinArms(
+                name=value["名称"],
+                star=int(value["星级"]),
+                limited="祈愿" not in value["获取途径"],
+            )
+            for value in self.load_data("genshin_arms.json").values()
+        ]
+        self.load_up_char()
+
+    def load_up_char(self):
+        try:
+            data = self.load_data(f"draw_card_up/{self.game_name}_up_char.json")
+            self.UP_CHAR = UpEvent.parse_obj(data.get("char", {}))
+            self.UP_ARMS = UpEvent.parse_obj(data.get("arms", {}))
+        except ValidationError:
+            logger.warning(f"{self.game_name}_up_char 解析出错")
+
+    def dump_up_char(self):
+        if self.UP_CHAR and self.UP_ARMS:
+            data = {
+                "char": json.loads(self.UP_CHAR.json()),
+                "arms": json.loads(self.UP_ARMS.json()),
+            }
+            self.dump_data(data, f"draw_card_up/{self.game_name}_up_char.json")
+
+    async def _update_info(self):
+        # genshin.json
+        char_info = {}
+        url = "https://wiki.biligame.com/ys/角色筛选"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 出错")
+        else:
+            dom = etree.HTML(result, etree.HTMLParser())
+            char_list = dom.xpath("//table[@id='CardSelectTr']/tbody/tr")
+            for char in char_list:
+                try:
+                    name = char.xpath("./td[1]/a/@title")[0]
+                    avatar = char.xpath("./td[1]/a/img/@srcset")[0]
+                    star = char.xpath("./td[3]/text()")[0]
+                except IndexError:
+                    continue
+                member_dict = {
+                    "头像": unquote(str(avatar).split(" ")[-2]),
+                    "名称": remove_prohibited_str(name),
+                    "星级": int(str(star).strip()[:1]),
+                }
+                char_info[member_dict["名称"]] = member_dict
+            # 更新额外信息
+            for key in char_info.keys():
+                result = await self.get_url(f"https://wiki.biligame.com/ys/{key}")
+                if not result:
+                    char_info[key]["常驻/限定"] = "未知"
+                    logger.warning(f"{self.game_name_cn} 获取额外信息错误 {key}")
+                    continue
+                try:
+                    dom = etree.HTML(result, etree.HTMLParser())
+                    limit = dom.xpath(
+                        "//table[contains(string(.),'常驻/限定')]/tbody/tr[6]/td/text()"
+                    )[0]
+                    char_info[key]["常驻/限定"] = str(limit).strip()
+                except IndexError:
+                    char_info[key]["常驻/限定"] = "未知"
+                    logger.warning(f"{self.game_name_cn} 获取额外信息错误 {key}")
+            self.dump_data(char_info)
+            logger.info(f"{self.game_name_cn} 更新成功")
+        # genshin_arms.json
+        arms_info = {}
+        url = "https://wiki.biligame.com/ys/武器图鉴"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 出错")
+        else:
+            dom = etree.HTML(result, etree.HTMLParser())
+            char_list = dom.xpath("//table[@id='CardSelectTr']/tbody/tr")
+            for char in char_list:
+                try:
+                    name = char.xpath("./td[1]/a/@title")[0]
+                    avatar = char.xpath("./td[1]/a/img/@srcset")[0]
+                    star = char.xpath("./td[4]/img/@alt")[0]
+                    sources = str(char.xpath("./td[5]/text()")[0]).split(",")
+                except IndexError:
+                    continue
+                member_dict = {
+                    "头像": unquote(str(avatar).split(" ")[-2]),
+                    "名称": remove_prohibited_str(name),
+                    "星级": int(str(star).strip()[:1]),
+                    "获取途径": [s.strip() for s in sources if s.strip()],
+                }
+                arms_info[member_dict["名称"]] = member_dict
+            self.dump_data(arms_info, "genshin_arms.json")
+            logger.info(f"{self.game_name_cn} 武器更新成功")
+        # 下载头像
+        for value in char_info.values():
+            await self.download_img(value["头像"], value["名称"])
+        for value in arms_info.values():
+            await self.download_img(value["头像"], value["名称"])
+        # 下载星星
+        idx = 1
+        YS_URL = "https://patchwiki.biligame.com/images/ys"
+        for url in [
+            "/1/13/7xzg7tgf8dsr2hjpmdbm5gn9wvzt2on.png",
+            "/b/bc/sd2ige6d7lvj7ugfumue3yjg8gyi0d1.png",
+            "/e/ec/l3mnhy56pyailhn3v7r873htf2nofau.png",
+            "/9/9c/sklp02ffk3aqszzvh8k1c3139s0awpd.png",
+            "/c/c7/qu6xcndgj6t14oxvv7yz2warcukqv1m.png",
+        ]:
+            await self.download_img(YS_URL + url, f"{idx}_star")
+            idx += 1
+        # 下载头像框
+        await self.download_img(
+            YS_URL + "/2/2e/opbcst4xbtcq0i4lwerucmosawn29ti.png", f"avatar_frame"
+        )
+        await self.update_up_char()
+
+    async def update_up_char(self):
+        url = "https://wiki.biligame.com/ys/祈愿"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"{self.game_name_cn}获取祈愿页面出错")
+            return
+        dom = etree.HTML(result, etree.HTMLParser())
+        tables = dom.xpath(
+            "//div[@class='mw-parser-output']/div[@class='row']/div/table[@class='wikitable']/tbody"
+        )
+        if not tables or len(tables) < 2:
+            logger.warning(f"{self.game_name_cn}获取活动祈愿出错")
+            return
+        try:
+            for index, table in enumerate(tables):
+                title = table.xpath("./tr[1]/th/img/@title")[0]
+                title = str(title).split("」")[0] + "」" if "」" in title else title
+                pool_img = str(table.xpath("./tr[1]/th/img/@srcset")[0]).split(" ")[-2]
+                time = table.xpath("./tr[2]/td/text()")[0]
+                star5_list = table.xpath("./tr[3]/td/a/@title")
+                star4_list = table.xpath("./tr[4]/td/a/@title")
+                start, end = str(time).split("~")
+                start_time = dateparser.parse(start)
+                end_time = dateparser.parse(end)
+                if not start_time and end_time:
+                    start_time = end_time - timedelta(days=20)
+                if start_time and end_time and start_time <= datetime.now() <= end_time:
+                    up_event = UpEvent(
+                        title=title,
+                        pool_img=pool_img,
+                        start_time=start_time,
+                        end_time=end_time,
+                        up_char=[
+                            UpChar(name=name, star=5, limited=False, zoom=50)
+                            for name in star5_list
+                        ]
+                        + [
+                            UpChar(name=name, star=4, limited=False, zoom=50)
+                            for name in star4_list
+                        ],
+                    )
+                    if index == 0:
+                        self.UP_CHAR = up_event
+                    elif index == 1:
+                        self.UP_ARMS = up_event
+            if self.UP_CHAR and self.UP_ARMS:
+                self.dump_up_char()
+                logger.info(
+                    f"成功获取{self.game_name_cn}当前up信息...当前up池: {self.UP_CHAR.title} & {self.UP_ARMS.title}"
+                )
+        except Exception as e:
+            logger.warning(f"{self.game_name_cn}UP更新出错 {type(e)}：{e}")
+
+    def reset_count(self, user_id: int) -> bool:
+        self.count_manager.reset(user_id)
+        return True
+
+    async def _reload_pool(self) -> Optional[Message]:
+        await self.update_up_char()
+        self.load_up_char()
+        if self.UP_CHAR and self.UP_ARMS:
+            return Message(
+                Message.template("重载成功！\n当前UP池子：{} & {}{:image}{:image}").format(
+                    self.UP_CHAR.title,
+                    self.UP_ARMS.title,
+                    self.UP_CHAR.pool_img,
+                    self.UP_ARMS.pool_img,
+                )
+            )

plugins/draw_card/handles/guardian_handle.py

@@ -0,0 +1,400 @@
+import re
+import random
+import dateparser
+from lxml import etree
+from PIL import ImageDraw
+from datetime import datetime
+from urllib.parse import unquote
+from typing import List, Optional, Tuple
+from pydantic import ValidationError
+from nonebot.adapters.onebot.v11 import Message
+from utils.message_builder import image
+from nonebot.log import logger
+import asyncio
+
+try:
+    import ujson as json
+except ModuleNotFoundError:
+    import json
+
+from .base_handle import BaseHandle, BaseData, UpChar, UpEvent
+from ..config import draw_config
+from ..util import remove_prohibited_str, cn2py, load_font
+from utils.image_utils import BuildImage
+
+
+class GuardianData(BaseData):
+    pass
+
+
+class GuardianChar(GuardianData):
+    pass
+
+
+class GuardianArms(GuardianData):
+    pass
+
+
+class GuardianHandle(BaseHandle[GuardianData]):
+    def __init__(self):
+        super().__init__("guardian", "坎公骑冠剑")
+        self.data_files.append("guardian_arms.json")
+        self.config = draw_config.guardian
+
+        self.ALL_CHAR: List[GuardianChar] = []
+        self.ALL_ARMS: List[GuardianArms] = []
+        self.UP_CHAR: Optional[UpEvent] = None
+        self.UP_ARMS: Optional[UpEvent] = None
+
+    def get_card(self, pool_name: str, mode: int = 1) -> GuardianData:
+        if pool_name == "char":
+            if mode == 1:
+                star = self.get_star(
+                    [3, 2, 1],
+                    [
+                        self.config.GUARDIAN_THREE_CHAR_P,
+                        self.config.GUARDIAN_TWO_CHAR_P,
+                        self.config.GUARDIAN_ONE_CHAR_P,
+                    ],
+                )
+            else:
+                star = self.get_star(
+                    [3, 2],
+                    [
+                        self.config.GUARDIAN_THREE_CHAR_P,
+                        self.config.GUARDIAN_TWO_CHAR_P,
+                    ],
+                )
+            up_event = self.UP_CHAR
+            self.max_star = 3
+            all_data = self.ALL_CHAR
+        else:
+            if mode == 1:
+                star = self.get_star(
+                    [5, 4, 3, 2],
+                    [
+                        self.config.GUARDIAN_FIVE_ARMS_P,
+                        self.config.GUARDIAN_FOUR_ARMS_P,
+                        self.config.GUARDIAN_THREE_ARMS_P,
+                        self.config.GUARDIAN_TWO_ARMS_P,
+                    ],
+                )
+            else:
+                star = self.get_star(
+                    [5, 4],
+                    [
+                        self.config.GUARDIAN_FIVE_ARMS_P,
+                        self.config.GUARDIAN_FOUR_ARMS_P,
+                    ],
+                )
+            up_event = self.UP_ARMS
+            self.max_star = 5
+            all_data = self.ALL_ARMS
+
+        acquire_char = None
+        # 是否UP
+        if up_event and star == self.max_star and pool_name:
+            # 获取up角色列表
+            up_list = [x.name for x in up_event.up_char if x.star == star]
+            # 成功获取up角色
+            if random.random() < 0.5:
+                up_name = random.choice(up_list)
+                try:
+                    acquire_char = [x for x in all_data if x.name == up_name][0]
+                except IndexError:
+                    pass
+        if not acquire_char:
+            chars = [x for x in all_data if x.star == star and not x.limited]
+            acquire_char = random.choice(chars)
+        return acquire_char
+
+    def get_cards(self, count: int, pool_name: str) -> List[Tuple[GuardianData, int]]:
+        card_list = []
+        card_count = 0  # 保底计算
+        for i in range(count):
+            card_count += 1
+            # 十连保底
+            if card_count == 10:
+                card = self.get_card(pool_name, 2)
+                card_count = 0
+            else:
+                card = self.get_card(pool_name, 1)
+                if card.star > self.max_star - 2:
+                    card_count = 0
+            card_list.append((card, i + 1))
+        return card_list
+
+    def format_pool_info(self, pool_name: str) -> str:
+        info = ""
+        up_event = self.UP_CHAR if pool_name == "char" else self.UP_ARMS
+        if up_event:
+            if pool_name == "char":
+                up_list = [x.name for x in up_event.up_char if x.star == 3]
+                info += f'三星UP：{" ".join(up_list)}\n'
+            else:
+                up_list = [x.name for x in up_event.up_char if x.star == 5]
+                info += f'五星UP：{" ".join(up_list)}\n'
+            info = f"当前up池：{up_event.title}\n{info}"
+        return info.strip()
+
+    async def draw(self, count: int, pool_name: str, **kwargs) -> Message:
+        return await asyncio.get_event_loop().run_in_executor(None, self._draw, count, pool_name)
+
+    def _draw(self, count: int, pool_name: str, **kwargs) -> Message:
+        index2card = self.get_cards(count, pool_name)
+        cards = [card[0] for card in index2card]
+        up_event = self.UP_CHAR if pool_name == "char" else self.UP_ARMS
+        up_list = [x.name for x in up_event.up_char] if up_event else []
+        result = self.format_result(index2card, up_list=up_list)
+        pool_info = self.format_pool_info(pool_name)
+        return pool_info + image(b64=self.generate_img(cards).pic2bs4()) + result
+
+    def generate_card_img(self, card: GuardianData) -> BuildImage:
+        sep_w = 1
+        sep_h = 1
+        block_w = 170
+        block_h = 90
+        img_w = 90
+        img_h = 90
+        if isinstance(card, GuardianChar):
+            block_color = "#2e2923"
+            font_color = "#e2ccad"
+            star_w = 90
+            star_h = 30
+            star_name = f"{card.star}_star.png"
+            frame_path = ""
+        else:
+            block_color = "#EEE4D5"
+            font_color = "#A65400"
+            star_w = 45
+            star_h = 45
+            star_name = f"{card.star}_star_rank.png"
+            frame_path = str(self.img_path / "avatar_frame.png")
+        bg = BuildImage(block_w + sep_w * 2, block_h + sep_h * 2, color="#F6F4ED")
+        block = BuildImage(block_w, block_h, color=block_color)
+        star_path = str(self.img_path / star_name)
+        star = BuildImage(star_w, star_h, background=star_path)
+        img_path = str(self.img_path / f"{cn2py(card.name)}.png")
+        img = BuildImage(img_w, img_h, background=img_path)
+        block.paste(img, (0, 0), alpha=True)
+        if frame_path:
+            frame = BuildImage(img_w, img_h, background=frame_path)
+            block.paste(frame, (0, 0), alpha=True)
+        block.paste(
+            star,
+            (int((block_w + img_w - star_w) / 2), block_h - star_h - 30),
+            alpha=True,
+        )
+        # 加名字
+        text = card.name[:4] + "..." if len(card.name) > 5 else card.name
+        font = load_font(fontsize=14)
+        text_w, _ = font.getsize(text)
+        draw = ImageDraw.Draw(block.markImg)
+        draw.text(
+            ((block_w + img_w - text_w) / 2, 55),
+            text,
+            font=font,
+            fill=font_color,
+        )
+        bg.paste(block, (sep_w, sep_h))
+        return bg
+
+    def _init_data(self):
+        self.ALL_CHAR = [
+            GuardianChar(name=value["名称"], star=int(value["星级"]), limited=False)
+            for value in self.load_data().values()
+        ]
+        self.ALL_ARMS = [
+            GuardianArms(name=value["名称"], star=int(value["星级"]), limited=False)
+            for value in self.load_data("guardian_arms.json").values()
+        ]
+        self.load_up_char()
+
+    def load_up_char(self):
+        try:
+            data = self.load_data(f"draw_card_up/{self.game_name}_up_char.json")
+            self.UP_CHAR = UpEvent.parse_obj(data.get("char", {}))
+            self.UP_ARMS = UpEvent.parse_obj(data.get("arms", {}))
+        except ValidationError:
+            logger.warning(f"{self.game_name}_up_char 解析出错")
+
+    def dump_up_char(self):
+        if self.UP_CHAR and self.UP_ARMS:
+            data = {
+                "char": json.loads(self.UP_CHAR.json()),
+                "arms": json.loads(self.UP_ARMS.json()),
+            }
+            self.dump_data(data, f"draw_card_up/{self.game_name}_up_char.json")
+
+    async def _update_info(self):
+        # guardian.json
+        guardian_info = {}
+        url = "https://wiki.biligame.com/gt/英雄筛选表"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 出错")
+        else:
+            dom = etree.HTML(result, etree.HTMLParser())
+            char_list = dom.xpath("//table[@id='CardSelectTr']/tbody/tr")
+            for char in char_list:
+                try:
+                    name = char.xpath("./td[1]/a/@title")[0]
+                    avatar = char.xpath("./td[1]/a/img/@src")[0]
+                    star = char.xpath("./td[1]/span/img/@alt")[0]
+                except IndexError:
+                    continue
+                member_dict = {
+                    "头像": unquote(str(avatar)),
+                    "名称": remove_prohibited_str(name),
+                    "星级": int(str(star).split(" ")[0].replace("Rank", "")),
+                }
+                guardian_info[member_dict["名称"]] = member_dict
+            self.dump_data(guardian_info)
+            logger.info(f"{self.game_name_cn} 更新成功")
+        # guardian_arms.json
+        guardian_arms_info = {}
+        url = "https://wiki.biligame.com/gt/武器"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 武器出错")
+        else:
+            dom = etree.HTML(result, etree.HTMLParser())
+            char_list = dom.xpath(
+                "//div[@class='resp-tabs-container']/div[1]/div/table[2]/tbody/tr"
+            )
+            for char in char_list:
+                try:
+                    name = char.xpath("./td[2]/a/@title")[0]
+                    avatar = char.xpath("./td[1]/div/div/div/a/img/@src")[0]
+                    star = char.xpath("./td[3]/text()")[0]
+                except IndexError:
+                    continue
+                member_dict = {
+                    "头像": unquote(str(avatar)),
+                    "名称": remove_prohibited_str(name),
+                    "星级": int(str(star).strip()),
+                }
+                guardian_arms_info[member_dict["名称"]] = member_dict
+            self.dump_data(guardian_arms_info, "guardian_arms.json")
+            logger.info(f"{self.game_name_cn} 武器更新成功")
+        url = "https://wiki.biligame.com/gt/盾牌"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 盾牌出错")
+        else:
+            dom = etree.HTML(result, etree.HTMLParser())
+            char_list = dom.xpath(
+                "//div[@class='resp-tabs-container']/div[2]/div/table[1]/tbody/tr"
+            )
+            for char in char_list:
+                try:
+                    name = char.xpath("./td[2]/a/@title")[0]
+                    avatar = char.xpath("./td[1]/div/div/div/a/img/@src")[0]
+                    star = char.xpath("./td[3]/text()")[0]
+                except IndexError:
+                    continue
+                member_dict = {
+                    "头像": unquote(str(avatar)),
+                    "名称": remove_prohibited_str(name),
+                    "星级": int(str(star).strip()),
+                }
+                guardian_arms_info[member_dict["名称"]] = member_dict
+            self.dump_data(guardian_arms_info, "guardian_arms.json")
+            logger.info(f"{self.game_name_cn} 盾牌更新成功")
+        # 下载头像
+        for value in guardian_info.values():
+            await self.download_img(value["头像"], value["名称"])
+        for value in guardian_arms_info.values():
+            await self.download_img(value["头像"], value["名称"])
+        # 下载星星
+        idx = 1
+        GT_URL = "https://patchwiki.biligame.com/images/gt"
+        for url in [
+            "/4/4b/ardr3bi2yf95u4zomm263tc1vke6i3i.png",
+            "/5/55/6vow7lh76gzus6b2g9cfn325d1sugca.png",
+            "/b/b9/du8egrd2vyewg0cuyra9t8jh0srl0ds.png",
+        ]:
+            await self.download_img(GT_URL + url, f"{idx}_star")
+            idx += 1
+        # 另一种星星
+        idx = 1
+        for url in [
+            "/6/66/4e2tfa9kvhfcbikzlyei76i9crva145.png",
+            "/1/10/r9ihsuvycgvsseyneqz4xs22t53026m.png",
+            "/7/7a/o0k86ru9k915y04azc26hilxead7xp1.png",
+            "/c/c9/rxz99asysz0rg391j3b02ta09mnpa7v.png",
+            "/2/2a/sfxz0ucv1s6ewxveycz9mnmrqs2rw60.png",
+        ]:
+            await self.download_img(GT_URL + url, f"{idx}_star_rank")
+            idx += 1
+        # 头像框
+        await self.download_img(
+            GT_URL + "/8/8e/ogbqslbhuykjhnc8trtoa0p0nhfzohs.png", f"avatar_frame"
+        )
+        await self.update_up_char()
+
+    async def update_up_char(self):
+        url = "https://wiki.biligame.com/gt/首页"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"{self.game_name_cn}获取公告出错")
+            return
+        try:
+            dom = etree.HTML(result, etree.HTMLParser())
+            announcement = dom.xpath(
+                "//div[@class='mw-parser-output']/div/div[3]/div[2]/div/div[2]/div[3]"
+            )[0]
+            title = announcement.xpath("./font/p/b/text()")[0]
+            match = re.search(r"从(.*?)开始.*?至(.*?)结束", title)
+            if not match:
+                logger.warning(f"{self.game_name_cn}找不到UP时间")
+                return
+            start, end = match.groups()
+            start_time = dateparser.parse(start.replace("月", "/").replace("日", ""))
+            end_time = dateparser.parse(end.replace("月", "/").replace("日", ""))
+            if not (start_time and end_time) or not (
+                start_time <= datetime.now() <= end_time
+            ):
+                return
+            divs = announcement.xpath("./font/div")
+            char_index = 0
+            arms_index = 0
+            for index, div in enumerate(divs):
+                if div.xpath("string(.)") == "角色":
+                    char_index = index
+                elif div.xpath("string(.)") == "武器":
+                    arms_index = index
+            chars = divs[char_index + 1 : arms_index]
+            arms = divs[arms_index + 1 :]
+            up_chars = []
+            up_arms = []
+            for char in chars:
+                name = char.xpath("./p/a/@title")[0]
+                up_chars.append(UpChar(name=name, star=3, limited=False, zoom=0))
+            for arm in arms:
+                name = arm.xpath("./p/a/@title")[0]
+                up_arms.append(UpChar(name=name, star=5, limited=False, zoom=0))
+            self.UP_CHAR = UpEvent(
+                title=title,
+                pool_img="",
+                start_time=start_time,
+                end_time=end_time,
+                up_char=up_chars,
+            )
+            self.UP_ARMS = UpEvent(
+                title=title,
+                pool_img="",
+                start_time=start_time,
+                end_time=end_time,
+                up_char=up_arms,
+            )
+            self.dump_up_char()
+            logger.info(f"成功获取{self.game_name_cn}当前up信息...当前up池: {title}")
+        except Exception as e:
+            logger.warning(f"{self.game_name_cn}UP更新出错 {type(e)}：{e}")
+
+    async def _reload_pool(self) -> Optional[Message]:
+        await self.update_up_char()
+        self.load_up_char()
+        if self.UP_CHAR and self.UP_ARMS:
+            return Message(f"重载成功！\n当前UP池子：{self.UP_CHAR.title}")

plugins/draw_card/handles/onmyoji_handle.py

@@ -0,0 +1,179 @@
+import random
+from lxml import etree
+from typing import List, Tuple
+from nonebot.log import logger
+from PIL import Image, ImageDraw
+from PIL.Image import Image as IMG
+
+try:
+    import ujson as json
+except ModuleNotFoundError:
+    import json
+
+from .base_handle import BaseHandle, BaseData
+from ..config import draw_config
+from ..util import remove_prohibited_str, cn2py, load_font
+from utils.image_utils import BuildImage
+
+
+class OnmyojiChar(BaseData):
+    @property
+    def star_str(self) -> str:
+        return ["N", "R", "SR", "SSR", "SP"][self.star - 1]
+
+
+class OnmyojiHandle(BaseHandle[OnmyojiChar]):
+    def __init__(self):
+        super().__init__("onmyoji", "阴阳师")
+        self.max_star = 5
+        self.config = draw_config.onmyoji
+        self.ALL_CHAR: List[OnmyojiChar] = []
+
+    def get_card(self, **kwargs) -> OnmyojiChar:
+        star = self.get_star(
+            [5, 4, 3, 2],
+            [
+                self.config.ONMYOJI_SP,
+                self.config.ONMYOJI_SSR,
+                self.config.ONMYOJI_SR,
+                self.config.ONMYOJI_R,
+            ],
+        )
+        chars = [x for x in self.ALL_CHAR if x.star == star and not x.limited]
+        return random.choice(chars)
+
+    def format_max_star(self, card_list: List[Tuple[OnmyojiChar, int]]) -> str:
+        rst = ""
+        for card, index in card_list:
+            if card.star == self.max_star:
+                rst += f"第 {index} 抽获取SP {card.name}\n"
+            elif card.star == self.max_star - 1:
+                rst += f"第 {index} 抽获取SSR {card.name}\n"
+        return rst.strip()
+
+    @staticmethod
+    def star_label(star: int) -> IMG:
+        text, color1, color2 = [
+            ("N", "#7E7E82", "#F5F6F7"),
+            ("R", "#014FA8", "#37C6FD"),
+            ("SR", "#6E0AA4", "#E94EFD"),
+            ("SSR", "#E5511D", "#FAF905"),
+            ("SP", "#FA1F2D", "#FFBBAF"),
+        ][star - 1]
+        w = 200
+        h = 110
+        # 制作渐变色图片
+        base = Image.new("RGBA", (w, h), color1)
+        top = Image.new("RGBA", (w, h), color2)
+        mask = Image.new("L", (w, h))
+        mask_data = []
+        for y in range(h):
+            mask_data.extend([int(255 * (y / h))] * w)
+        mask.putdata(mask_data)
+        base.paste(top, (0, 0), mask)
+        # 透明图层
+        font = load_font("gorga.otf", 100)
+        alpha = Image.new("L", (w, h))
+        draw = ImageDraw.Draw(alpha)
+        draw.text((20, -30), text, fill="white", font=font)
+        base.putalpha(alpha)
+        # stroke
+        bg = Image.new("RGBA", (w, h))
+        draw = ImageDraw.Draw(bg)
+        draw.text(
+            (20, -30),
+            text,
+            font=font,
+            fill="gray",
+            stroke_width=3,
+            stroke_fill="gray",
+        )
+        bg.paste(base, (0, 0), base)
+        return bg
+
+    def generate_img(self, card_list: List[OnmyojiChar]) -> BuildImage:
+        return super().generate_img(card_list, num_per_line=10)
+
+    def generate_card_img(self, card: OnmyojiChar) -> BuildImage:
+        bg = BuildImage(73, 240, color="#F1EFE9")
+        img_path = str(self.img_path / f"{cn2py(card.name)}_mark_btn.png")
+        img = BuildImage(0, 0, background=img_path)
+        img = Image.open(img_path).convert("RGBA")
+        label = self.star_label(card.star).resize((60, 33), Image.ANTIALIAS)
+        bg.paste(img, (0, 0), alpha=True)
+        bg.paste(label, (0, 135), alpha=True)
+        font = load_font("msyh.ttf", 16)
+        draw = ImageDraw.Draw(bg.markImg)
+        text = "\n".join([t for t in card.name[:4]])
+        _, text_h = font.getsize_multiline(text, spacing=0)
+        draw.text(
+            (40, 150 + (90 - text_h) / 2), text, font=font, fill="gray", spacing=0
+        )
+        return bg
+
+    def _init_data(self):
+        self.ALL_CHAR = [
+            OnmyojiChar(
+                name=value["名称"],
+                star=["N", "R", "SR", "SSR", "SP"].index(value["星级"]) + 1,
+                limited=True
+                if key
+                in [
+                    "奴良陆生",
+                    "卖药郎",
+                    "鬼灯",
+                    "阿香",
+                    "蜜桃&芥子",
+                    "犬夜叉",
+                    "杀生丸",
+                    "桔梗",
+                    "朽木露琪亚",
+                    "黑崎一护",
+                    "灶门祢豆子",
+                    "灶门炭治郎",
+                ]
+                else False,
+            )
+            for key, value in self.load_data().items()
+        ]
+
+    async def _update_info(self):
+        info = {}
+        url = "https://yys.res.netease.com/pc/zt/20161108171335/js/app/all_shishen.json?v74="
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 出错")
+            return
+        data = json.loads(result)
+        for x in data:
+            name = remove_prohibited_str(x["name"])
+            member_dict = {
+                "id": x["id"],
+                "名称": name,
+                "星级": x["level"],
+            }
+            info[name] = member_dict
+            # logger.info(f"{name} is update...")
+        # 更新头像
+        for key in info.keys():
+            url = f'https://yys.163.com/shishen/{info[key]["id"]}.html'
+            result = await self.get_url(url)
+            if not result:
+                info[key]["头像"] = ""
+                continue
+            try:
+                dom = etree.HTML(result, etree.HTMLParser())
+                avatar = dom.xpath("//div[@class='pic_wrap']/img/@src")[0]
+                avatar = "https:" + avatar
+                info[key]["头像"] = avatar
+            except IndexError:
+                info[key]["头像"] = ""
+                logger.warning(f"{self.game_name_cn} 获取头像错误 {key}")
+        self.dump_data(info)
+        logger.info(f"{self.game_name_cn} 更新成功")
+        # 下载头像
+        for value in info.values():
+            await self.download_img(value["头像"], value["名称"])
+            # 下载书签形式的头像
+            url = f"https://yys.res.netease.com/pc/zt/20161108171335/data/mark_btn/{value['id']}.png"
+            await self.download_img(url, value["名称"] + "_mark_btn")

plugins/draw_card/handles/pcr_handle.py

@@ -0,0 +1,147 @@
+import random
+from lxml import etree
+from typing import List, Tuple
+from PIL import ImageDraw
+from urllib.parse import unquote
+from nonebot.log import logger
+
+from .base_handle import BaseHandle, BaseData
+from ..config import draw_config
+from ..util import remove_prohibited_str, cn2py, load_font
+from utils.image_utils import BuildImage
+
+
+class PcrChar(BaseData):
+    pass
+
+
+class PcrHandle(BaseHandle[PcrChar]):
+    def __init__(self):
+        super().__init__("pcr", "公主连结")
+        self.max_star = 3
+        self.config = draw_config.pcr
+        self.ALL_CHAR: List[PcrChar] = []
+
+    def get_card(self, mode: int = 1) -> PcrChar:
+        if mode == 2:
+            star = self.get_star(
+                [3, 2], [self.config.PCR_G_THREE_P, self.config.PCR_G_TWO_P]
+            )
+        else:
+            star = self.get_star(
+                [3, 2, 1],
+                [self.config.PCR_THREE_P, self.config.PCR_TWO_P, self.config.PCR_ONE_P],
+            )
+        chars = [x for x in self.ALL_CHAR if x.star == star and not x.limited]
+        return random.choice(chars)
+
+    def get_cards(self, count: int, **kwargs) -> List[Tuple[PcrChar, int]]:
+        card_list = []
+        card_count = 0  # 保底计算
+        for i in range(count):
+            card_count += 1
+            # 十连保底
+            if card_count == 10:
+                card = self.get_card(2)
+                card_count = 0
+            else:
+                card = self.get_card(1)
+                if card.star > self.max_star - 2:
+                    card_count = 0
+            card_list.append((card, i + 1))
+        return card_list
+
+    def generate_card_img(self, card: PcrChar) -> BuildImage:
+        sep_w = 5
+        sep_h = 5
+        star_h = 15
+        img_w = 90
+        img_h = 90
+        font_h = 20
+        bg = BuildImage(img_w + sep_w * 2, img_h + font_h + sep_h * 2, color="#EFF2F5")
+        star_path = str(self.img_path / "star.png")
+        star = BuildImage(star_h, star_h, background=star_path)
+        img_path = str(self.img_path / f"{cn2py(card.name)}.png")
+        img = BuildImage(img_w, img_h, background=img_path)
+        bg.paste(img, (sep_w, sep_h), alpha=True)
+        for i in range(card.star):
+            bg.paste(star, (sep_w + img_w - star_h * (i + 1), sep_h), alpha=True)
+        # 加名字
+        text = card.name[:5] + "..." if len(card.name) > 6 else card.name
+        font = load_font(fontsize=14)
+        text_w, text_h = font.getsize(text)
+        draw = ImageDraw.Draw(bg.markImg)
+        draw.text(
+            (sep_w + (img_w - text_w) / 2, sep_h + img_h + (font_h - text_h) / 2),
+            text,
+            font=font,
+            fill="gray",
+        )
+        return bg
+
+    def _init_data(self):
+        self.ALL_CHAR = [
+            PcrChar(
+                name=value["名称"],
+                star=int(value["星级"]),
+                limited=True if "（" in key else False,
+            )
+            for key, value in self.load_data().items()
+        ]
+
+    async def _update_info(self):
+        info = {}
+        if draw_config.PCR_TAI:
+            url = "https://wiki.biligame.com/pcr/角色图鉴"
+            result = await self.get_url(url)
+            if not result:
+                logger.warning(f"更新 {self.game_name_cn} 出错")
+                return
+            dom = etree.HTML(result, etree.HTMLParser())
+            char_list = dom.xpath(
+                "//div[@class='resp-tab-content']/div[@class='unit-icon']"
+            )
+            for char in char_list:
+                try:
+                    name = char.xpath("./a/@title")[0]
+                    avatar = char.xpath("./a/img/@srcset")[0]
+                    star = len(char.xpath("./div[1]/img"))
+                except IndexError:
+                    continue
+                member_dict = {
+                    "头像": unquote(str(avatar).split(" ")[-2]),
+                    "名称": remove_prohibited_str(name),
+                    "星级": star,
+                }
+                info[member_dict["名称"]] = member_dict
+        else:
+            url = "https://wiki.biligame.com/pcr/角色筛选表"
+            result = await self.get_url(url)
+            if not result:
+                logger.warning(f"更新 {self.game_name_cn} 出错")
+                return
+            dom = etree.HTML(result, etree.HTMLParser())
+            char_list = dom.xpath("//table[@id='CardSelectTr']/tbody/tr")
+            for char in char_list:
+                try:
+                    name = char.xpath("./td[1]/a/@title")[0]
+                    avatar = char.xpath("./td[1]/a/img/@srcset")[0]
+                    star = char.xpath("./td[4]/text()")[0]
+                except IndexError:
+                    continue
+                member_dict = {
+                    "头像": unquote(str(avatar).split(" ")[-2]),
+                    "名称": remove_prohibited_str(name),
+                    "星级": int(str(star).strip()),
+                }
+                info[member_dict["名称"]] = member_dict
+        self.dump_data(info)
+        logger.info(f"{self.game_name_cn} 更新成功")
+        # 下载头像
+        for value in info.values():
+            await self.download_img(value["头像"], value["名称"])
+        # 下载星星
+        await self.download_img(
+            "https://patchwiki.biligame.com/images/pcr/0/02/s75ys2ecqhu2xbdw1wf1v9ccscnvi5g.png",
+            "star",
+        )

plugins/draw_card/handles/pretty_handle.py

@@ -0,0 +1,426 @@
+import re
+import random
+import dateparser
+from lxml import etree
+from PIL import ImageDraw
+from bs4 import BeautifulSoup
+from datetime import datetime
+from urllib.parse import unquote
+from typing import List, Optional, Tuple
+from pydantic import ValidationError
+from nonebot.adapters.onebot.v11 import Message
+from utils.message_builder import image
+from nonebot.log import logger
+import asyncio
+
+try:
+    import ujson as json
+except ModuleNotFoundError:
+    import json
+
+from .base_handle import BaseHandle, BaseData, UpChar, UpEvent
+from ..config import draw_config
+from ..util import remove_prohibited_str, cn2py, load_font
+from utils.image_utils import BuildImage
+
+
+class PrettyData(BaseData):
+    pass
+
+
+class PrettyChar(PrettyData):
+    pass
+
+
+class PrettyCard(PrettyData):
+    @property
+    def star_str(self) -> str:
+        return ["R", "SR", "SSR"][self.star - 1]
+
+
+class PrettyHandle(BaseHandle[PrettyData]):
+    def __init__(self):
+        super().__init__("pretty", "赛马娘", "#eff2f5")
+        self.data_files.append("pretty_card.json")
+        self.max_star = 3
+        self.config = draw_config.pretty
+
+        self.ALL_CHAR: List[PrettyChar] = []
+        self.ALL_CARD: List[PrettyCard] = []
+        self.UP_CHAR: Optional[UpEvent] = None
+        self.UP_CARD: Optional[UpEvent] = None
+
+    def get_card(self, pool_name: str, mode: int = 1) -> PrettyData:
+        if mode == 1:
+            star = self.get_star(
+                [3, 2, 1],
+                [
+                    self.config.PRETTY_THREE_P,
+                    self.config.PRETTY_TWO_P,
+                    self.config.PRETTY_ONE_P,
+                ],
+            )
+        else:
+            star = self.get_star(
+                [3, 2], [self.config.PRETTY_THREE_P, self.config.PRETTY_TWO_P]
+            )
+        up_pool = None
+        if pool_name == "char":
+            up_pool = self.UP_CHAR
+            all_list = self.ALL_CHAR
+        else:
+            up_pool = self.UP_CARD
+            all_list = self.ALL_CARD
+
+        all_char = [x for x in all_list if x.star == star and not x.limited]
+        acquire_char = None
+        # 有UP池子
+        if up_pool and star in [x.star for x in up_pool.up_char]:
+            up_list = [x.name for x in up_pool.up_char if x.star == star]
+            # 抽到UP
+            if random.random() < 1 / len(all_char) * (0.7 / 0.1385):
+                up_name = random.choice(up_list)
+                try:
+                    acquire_char = [x for x in all_list if x.name == up_name][0]
+                except IndexError:
+                    pass
+        if not acquire_char:
+            acquire_char = random.choice(all_char)
+        return acquire_char
+
+    def get_cards(self, count: int, pool_name: str) -> List[Tuple[PrettyData, int]]:
+        card_list = []
+        card_count = 0  # 保底计算
+        for i in range(count):
+            card_count += 1
+            # 十连保底
+            if card_count == 10:
+                card = self.get_card(pool_name, 2)
+                card_count = 0
+            else:
+                card = self.get_card(pool_name, 1)
+                if card.star > self.max_star - 2:
+                    card_count = 0
+            card_list.append((card, i + 1))
+        return card_list
+
+    def format_pool_info(self, pool_name: str) -> str:
+        info = ""
+        up_event = self.UP_CHAR if pool_name == "char" else self.UP_CARD
+        if up_event:
+            star3_list = [x.name for x in up_event.up_char if x.star == 3]
+            star2_list = [x.name for x in up_event.up_char if x.star == 2]
+            star1_list = [x.name for x in up_event.up_char if x.star == 1]
+            if star3_list:
+                if pool_name == "char":
+                    info += f'三星UP：{" ".join(star3_list)}\n'
+                else:
+                    info += f'SSR UP：{" ".join(star3_list)}\n'
+            if star2_list:
+                if pool_name == "char":
+                    info += f'二星UP：{" ".join(star2_list)}\n'
+                else:
+                    info += f'SR UP：{" ".join(star2_list)}\n'
+            if star1_list:
+                if pool_name == "char":
+                    info += f'一星UP：{" ".join(star1_list)}\n'
+                else:
+                    info += f'R UP：{" ".join(star1_list)}\n'
+            info = f"当前up池：{up_event.title}\n{info}"
+        return info.strip()
+
+    async def draw(self, count: int, pool_name: str, **kwargs) -> Message:
+        return await asyncio.get_event_loop().run_in_executor(None, self._draw, count, pool_name)
+
+    def _draw(self, count: int, pool_name: str, **kwargs) -> Message:
+        pool_name = "char" if not pool_name else pool_name
+        index2card = self.get_cards(count, pool_name)
+        cards = [card[0] for card in index2card]
+        up_event = self.UP_CHAR if pool_name == "char" else self.UP_CARD
+        up_list = [x.name for x in up_event.up_char] if up_event else []
+        result = self.format_result(index2card, up_list=up_list)
+        pool_info = self.format_pool_info(pool_name)
+        return pool_info + image(b64=self.generate_img(cards).pic2bs4()) + result
+
+    def generate_card_img(self, card: PrettyData) -> BuildImage:
+        if isinstance(card, PrettyChar):
+            star_h = 30
+            img_w = 200
+            img_h = 219
+            font_h = 50
+            bg = BuildImage(img_w, img_h + font_h, color="#EFF2F5")
+            star_path = str(self.img_path / "star.png")
+            star = BuildImage(star_h, star_h, background=star_path)
+            img_path = str(self.img_path / f"{cn2py(card.name)}.png")
+            img = BuildImage(img_w, img_h, background=img_path)
+            star_w = star_h * card.star
+            for i in range(card.star):
+                bg.paste(star, (int((img_w - star_w) / 2) + star_h * i, 0), alpha=True)
+            bg.paste(img, (0, 0), alpha=True)
+            # 加名字
+            text = card.name[:5] + "..." if len(card.name) > 6 else card.name
+            font = load_font(fontsize=30)
+            text_w, _ = font.getsize(text)
+            draw = ImageDraw.Draw(bg.markImg)
+            draw.text(
+                ((img_w - text_w) / 2, img_h),
+                text,
+                font=font,
+                fill="gray",
+            )
+            return bg
+        else:
+            sep_w = 10
+            img_w = 200
+            img_h = 267
+            font_h = 75
+            bg = BuildImage(img_w + sep_w * 2, img_h + font_h, color="#EFF2F5")
+            label_path = str(self.img_path / f"{card.star}_label.png")
+            label = BuildImage(40, 40, background=label_path)
+            img_path = str(self.img_path / f"{cn2py(card.name)}.png")
+            img = BuildImage(img_w, img_h, background=img_path)
+            bg.paste(img, (sep_w, 0), alpha=True)
+            bg.paste(label, (30, 3), alpha=True)
+            # 加名字
+            text = ""
+            texts = []
+            font = load_font(fontsize=25)
+            for t in card.name:
+                if font.getsize(text + t)[0] > 190:
+                    texts.append(text)
+                    text = ""
+                    if len(texts) >= 2:
+                        texts[-1] += "..."
+                        break
+                else:
+                    text += t
+            if text:
+                texts.append(text)
+            text = "\n".join(texts)
+            text_w, _ = font.getsize_multiline(text)
+            draw = ImageDraw.Draw(bg.markImg)
+            draw.text(
+                ((img_w - text_w) / 2, img_h),
+                text,
+                font=font,
+                align="center",
+                fill="gray",
+            )
+            return bg
+
+    def _init_data(self):
+        self.ALL_CHAR = [
+            PrettyChar(
+                name=value["名称"],
+                star=int(value["初始星级"]),
+                limited=False,
+            )
+            for value in self.load_data().values()
+        ]
+        self.ALL_CARD = [
+            PrettyCard(
+                name=value["中文名"],
+                star=["R", "SR", "SSR"].index(value["稀有度"]) + 1,
+                limited=True if "卡池" not in value["获取方式"] else False,
+            )
+            for value in self.load_data("pretty_card.json").values()
+        ]
+        self.load_up_char()
+
+    def load_up_char(self):
+        try:
+            data = self.load_data(f"draw_card_up/{self.game_name}_up_char.json")
+            self.UP_CHAR = UpEvent.parse_obj(data.get("char", {}))
+            self.UP_CARD = UpEvent.parse_obj(data.get("card", {}))
+        except ValidationError:
+            logger.warning(f"{self.game_name}_up_char 解析出错")
+
+    def dump_up_char(self):
+        if self.UP_CHAR and self.UP_CARD:
+            data = {
+                "char": json.loads(self.UP_CHAR.json()),
+                "card": json.loads(self.UP_CARD.json()),
+            }
+            self.dump_data(data, f"draw_card_up/{self.game_name}_up_char.json")
+
+    async def _update_info(self):
+        # pretty.json
+        pretty_info = {}
+        url = "https://wiki.biligame.com/umamusume/赛马娘图鉴"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 出错")
+        else:
+            dom = etree.HTML(result, etree.HTMLParser())
+            char_list = dom.xpath("//table[@id='CardSelectTr']/tbody/tr")
+            for char in char_list:
+                try:
+                    name = char.xpath("./td[1]/a/@title")[0]
+                    avatar = char.xpath("./td[1]/a/img/@srcset")[0]
+                    star = len(char.xpath("./td[3]/img"))
+                except IndexError:
+                    continue
+                member_dict = {
+                    "头像": unquote(str(avatar).split(" ")[-2]),
+                    "名称": remove_prohibited_str(name),
+                    "初始星级": star,
+                }
+                pretty_info[member_dict["名称"]] = member_dict
+            self.dump_data(pretty_info)
+            logger.info(f"{self.game_name_cn} 更新成功")
+        # pretty_card.json
+        pretty_card_info = {}
+        url = "https://wiki.biligame.com/umamusume/支援卡图鉴"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 卡牌出错")
+        else:
+            dom = etree.HTML(result, etree.HTMLParser())
+            char_list = dom.xpath("//table[@id='CardSelectTr']/tbody/tr")
+            for char in char_list:
+                try:
+                    name = char.xpath("./td[1]/div/a/@title")[0]
+                    name_cn = char.xpath("./td[3]/a/text()")[0]
+                    avatar = char.xpath("./td[1]/div/a/img/@srcset")[0]
+                    star = str(char.xpath("./td[5]/text()")[0]).strip()
+                    sources = str(char.xpath("./td[7]/text()")[0]).strip()
+                except IndexError:
+                    continue
+                member_dict = {
+                    "头像": unquote(str(avatar).split(" ")[-2]),
+                    "名称": remove_prohibited_str(name),
+                    "中文名": remove_prohibited_str(name_cn),
+                    "稀有度": star,
+                    "获取方式": [sources] if sources else [],
+                }
+                pretty_card_info[member_dict["中文名"]] = member_dict
+            self.dump_data(pretty_card_info, "pretty_card.json")
+            logger.info(f"{self.game_name_cn} 卡牌更新成功")
+        # 下载头像
+        for value in pretty_info.values():
+            await self.download_img(value["头像"], value["名称"])
+        for value in pretty_card_info.values():
+            await self.download_img(value["头像"], value["中文名"])
+        # 下载星星
+        PRETTY_URL = "https://patchwiki.biligame.com/images/umamusume"
+        await self.download_img(
+            PRETTY_URL + "/1/13/e1hwjz4vmhtvk8wlyb7c0x3ld1s2ata.png", "star"
+        )
+        # 下载稀有度标志
+        idx = 1
+        for url in [
+            "/f/f7/afqs7h4snmvovsrlifq5ib8vlpu2wvk.png",
+            "/3/3b/d1jmpwrsk4irkes1gdvoos4ic6rmuht.png",
+            "/0/06/q23szwkbtd7pfkqrk3wcjlxxt9z595o.png",
+        ]:
+            await self.download_img(PRETTY_URL + url, f"{idx}_label")
+            idx += 1
+        await self.update_up_char()
+
+    async def update_up_char(self):
+        announcement_url = "https://wiki.biligame.com/umamusume/公告"
+        result = await self.get_url(announcement_url)
+        if not result:
+            logger.warning(f"{self.game_name_cn}获取公告出错")
+            return
+        dom = etree.HTML(result, etree.HTMLParser())
+        announcements = dom.xpath("//div[@id='mw-content-text']/div/div/span/a")
+        title = ""
+        url = ""
+        for announcement in announcements:
+            try:
+                title = announcement.xpath("./@title")[0]
+                url = "https://wiki.biligame.com/" + announcement.xpath("./@href")[0]
+                if re.match(r".*?\d{8}$", title) or re.match(
+                    r"^\d{1,2}月\d{1,2}日.*?", title
+                ):
+                    break
+            except IndexError:
+                continue
+        if not title:
+            logger.warning(f"{self.game_name_cn}未找到新UP公告")
+            return
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"{self.game_name_cn}获取UP公告出错")
+            return
+        try:
+            start_time = None
+            end_time = None
+            char_img = ""
+            card_img = ""
+            up_chars = []
+            up_cards = []
+            soup = BeautifulSoup(result, "lxml")
+            heads = soup.find_all("span", {"class": "mw-headline"})
+            for head in heads:
+                if "时间" in head.text:
+                    time = head.find_next("p").text.split("\n")[0]
+                    if "～" in time:
+                        start, end = time.split("～")
+                        start_time = dateparser.parse(start)
+                        end_time = dateparser.parse(end)
+                elif "赛马娘" in head.text:
+                    char_img = head.find_next("a", {"class": "image"}).find("img")[
+                        "src"
+                    ]
+                    lines = str(head.find_next("p").text).split("\n")
+                    chars = [
+                        line
+                        for line in lines
+                        if "★" in line and "（" in line and "）" in line
+                    ]
+                    for char in chars:
+                        star = char.count("★")
+                        name = re.split(r"[（）]", char)[-2].strip()
+                        up_chars.append(
+                            UpChar(name=name, star=star, limited=False, zoom=70)
+                        )
+                elif "支援卡" in head.text:
+                    card_img = head.find_next("a", {"class": "image"}).find("img")[
+                        "src"
+                    ]
+                    lines = str(head.find_next("p").text).split("\n")
+                    cards = [
+                        line
+                        for line in lines
+                        if "R" in line and "（" in line and "）" in line
+                    ]
+                    for card in cards:
+                        star = 3 if "SSR" in card else 2 if "SR" in card else 1
+                        name = re.split(r"[（）]", card)[-2].strip()
+                        up_cards.append(
+                            UpChar(name=name, star=star, limited=False, zoom=70)
+                        )
+            if start_time and end_time:
+                if start_time <= datetime.now() <= end_time:
+                    self.UP_CHAR = UpEvent(
+                        title=title,
+                        pool_img=char_img,
+                        start_time=start_time,
+                        end_time=end_time,
+                        up_char=up_chars,
+                    )
+                    self.UP_CARD = UpEvent(
+                        title=title,
+                        pool_img=card_img,
+                        start_time=start_time,
+                        end_time=end_time,
+                        up_char=up_cards,
+                    )
+                    self.dump_up_char()
+                    logger.info(f"成功获取{self.game_name_cn}当前up信息...当前up池: {title}")
+        except Exception as e:
+            logger.warning(f"{self.game_name_cn}UP更新出错 {type(e)}：{e}")
+
+    async def _reload_pool(self) -> Optional[Message]:
+        await self.update_up_char()
+        self.load_up_char()
+        if self.UP_CHAR and self.UP_CARD:
+            return Message(
+                Message.template("重载成功！\n当前UP池子：{}{:image}{:image}").format(
+                    self.UP_CHAR.title,
+                    self.UP_CHAR.pool_img,
+                    self.UP_CARD.pool_img,
+                )
+            )

plugins/draw_card/handles/prts_handle.py

@@ -0,0 +1,292 @@
+import re
+import random
+import dateparser
+from lxml import etree
+from PIL import ImageDraw
+from bs4 import BeautifulSoup
+from datetime import datetime
+from urllib.parse import unquote
+from typing import List, Optional, Tuple
+from pydantic import ValidationError
+from nonebot.adapters.onebot.v11 import Message
+from utils.message_builder import image
+from nonebot.log import logger
+import asyncio
+
+try:
+    import ujson as json
+except ModuleNotFoundError:
+    import json
+
+from .base_handle import BaseHandle, BaseData, UpChar, UpEvent
+from ..config import draw_config
+from ..util import remove_prohibited_str, cn2py, load_font
+from utils.image_utils import BuildImage
+
+
+class Operator(BaseData):
+    recruit_only: bool  # 公招限定
+    event_only: bool  # 活动获得干员
+    # special_only: bool  # 升变/异格干员
+
+
+class PrtsHandle(BaseHandle[Operator]):
+    def __init__(self):
+        super().__init__("prts", "明日方舟", "#eff2f5")
+        self.max_star = 6
+        self.config = draw_config.prts
+
+        self.ALL_OPERATOR: List[Operator] = []
+        self.UP_EVENT: Optional[UpEvent] = None
+
+    def get_card(self, add: float) -> Operator:
+        star = self.get_star(
+            [6, 5, 4, 3],
+            [
+                self.config.PRTS_SIX_P + add,
+                self.config.PRTS_FIVE_P,
+                self.config.PRTS_FOUR_P,
+                self.config.PRTS_THREE_P,
+            ],
+        )
+
+        all_operators = [
+            x
+            for x in self.ALL_OPERATOR
+            if x.star == star and not any([x.limited, x.event_only, x.recruit_only])
+        ]
+        acquire_operator = None
+
+        if self.UP_EVENT:
+            up_operators = [x for x in self.UP_EVENT.up_char if x.star == star]
+            # UPs
+            try:
+                zooms = [x.zoom for x in up_operators]
+                zoom_sum = sum(zooms)
+                if random.random() < zoom_sum:
+                    up_name = random.choices(up_operators, weights=zooms, k=1)[0].name
+                    acquire_operator = [
+                        x for x in self.ALL_OPERATOR if x.name == up_name
+                    ][0]
+            except IndexError:
+                pass
+        if not acquire_operator:
+            acquire_operator = random.choice(all_operators)
+        return acquire_operator
+
+    def get_cards(self, count: int) -> List[Tuple[Operator, int]]:
+        card_list = []  # 获取所有角色
+        add = 0.0
+        count_idx = 0
+        for i in range(count):
+            count_idx += 1
+            card = self.get_card(add)
+            if card.star == self.max_star:
+                add = 0.0
+                count_idx = 0
+            elif count_idx > 50:
+                add += 0.02
+            card_list.append((card, i + 1))
+        return card_list
+
+    def format_pool_info(self) -> str:
+        info = ""
+        if self.UP_EVENT:
+            star6_list = [x.name for x in self.UP_EVENT.up_char if x.star == 6]
+            star5_list = [x.name for x in self.UP_EVENT.up_char if x.star == 5]
+            star4_list = [x.name for x in self.UP_EVENT.up_char if x.star == 4]
+            if star6_list:
+                info += f"六星UP：{' '.join(star6_list)}\n"
+            if star5_list:
+                info += f"五星UP：{' '.join(star5_list)}\n"
+            if star4_list:
+                info += f"四星UP：{' '.join(star4_list)}\n"
+            info = f"当前up池: {self.UP_EVENT.title}\n{info}"
+        return info.strip()
+
+    async def draw(self, count: int, **kwargs) -> Message:
+        return await asyncio.get_event_loop().run_in_executor(None, self._draw, count)
+
+    def _draw(self, count: int, **kwargs) -> Message:
+        index2card = self.get_cards(count)
+        cards = [card[0] for card in self.get_cards(count)]
+        up_list = [x.name for x in self.UP_EVENT.up_char] if self.UP_EVENT else []
+        result = self.format_result(index2card, up_list=up_list)
+        pool_info = self.format_pool_info()
+        return pool_info + image(b64=self.generate_img(cards).pic2bs4()) + result
+
+    def generate_card_img(self, card: Operator) -> BuildImage:
+        sep_w = 5
+        sep_h = 5
+        star_h = 15
+        img_w = 120
+        img_h = 120
+        font_h = 20
+        bg = BuildImage(img_w + sep_w * 2, img_h + font_h + sep_h * 2, color="#EFF2F5")
+        star_path = str(self.img_path / "star.png")
+        star = BuildImage(star_h, star_h, background=star_path)
+        img_path = str(self.img_path / f"{cn2py(card.name)}.png")
+        img = BuildImage(img_w, img_h, background=img_path)
+        bg.paste(img, (sep_w, sep_h), alpha=True)
+        for i in range(card.star):
+            bg.paste(star, (sep_w + img_w - 5 - star_h * (i + 1), sep_h), alpha=True)
+        # 加名字
+        text = card.name[:7] + "..." if len(card.name) > 8 else card.name
+        font = load_font(fontsize=16)
+        text_w, text_h = font.getsize(text)
+        draw = ImageDraw.Draw(bg.markImg)
+        draw.text(
+            (sep_w + (img_w - text_w) / 2, sep_h + img_h + (font_h - text_h) / 2),
+            text,
+            font=font,
+            fill="gray",
+        )
+        return bg
+
+    def _init_data(self):
+        self.ALL_OPERATOR = [
+            Operator(
+                name=value["名称"],
+                star=int(value["星级"]),
+                limited="干员寻访" not in value["获取途径"],
+                recruit_only=True
+                if "干员寻访" not in value["获取途径"] and "公开招募" in value["获取途径"]
+                else False,
+                event_only=True if "活动获取" in value["获取途径"] else False,
+            )
+            for key, value in self.load_data().items()
+            if "阿米娅" not in key
+        ]
+        self.load_up_char()
+
+    def load_up_char(self):
+        try:
+            data = self.load_data(f"draw_card_up/{self.game_name}_up_char.json")
+            self.UP_EVENT = UpEvent.parse_obj(data.get("char", {}))
+        except ValidationError:
+            logger.warning(f"{self.game_name}_up_char 解析出错")
+
+    def dump_up_char(self):
+        if self.UP_EVENT:
+            data = {"char": json.loads(self.UP_EVENT.json())}
+            self.dump_data(data, f"draw_card_up/{self.game_name}_up_char.json")
+
+    async def _update_info(self):
+        info = {}
+        url = "https://wiki.biligame.com/arknights/干员数据表"
+        result = await self.get_url(url)
+        if not result:
+            logger.warning(f"更新 {self.game_name_cn} 出错")
+            return
+        dom = etree.HTML(result, etree.HTMLParser())
+        char_list = dom.xpath("//table[@id='CardSelectTr']/tbody/tr")
+        for char in char_list:
+            try:
+                avatar = char.xpath("./td[1]/div/div/div/a/img/@srcset")[0]
+                name = char.xpath("./td[2]/a/text()")[0]
+                star = char.xpath("./td[5]/text()")[0]
+                sources = str(char.xpath("./td[8]/text()")[0]).split("\n")
+            except IndexError:
+                continue
+            member_dict = {
+                "头像": unquote(str(avatar).split(" ")[-2]),
+                "名称": remove_prohibited_str(str(name).strip()),
+                "星级": int(str(star).strip()),
+                "获取途径": [s for s in sources if s],
+            }
+            info[member_dict["名称"]] = member_dict
+        self.dump_data(info)
+        logger.info(f"{self.game_name_cn} 更新成功")
+        # 下载头像
+        for value in info.values():
+            await self.download_img(value["头像"], value["名称"])
+        # 下载星星
+        await self.download_img(
+            "https://patchwiki.biligame.com/images/pcr/0/02/s75ys2ecqhu2xbdw1wf1v9ccscnvi5g.png",
+            "star",
+        )
+        await self.update_up_char()
+
+    async def update_up_char(self):
+        announcement_url = "https://ak.hypergryph.com/news.html"
+        result = await self.get_url(announcement_url)
+        if not result:
+            logger.warning(f"{self.game_name_cn}获取公告出错")
+            return
+        dom = etree.HTML(result, etree.HTMLParser())
+        activity_urls = dom.xpath(
+            "//ol[@class='articleList' and @data-category-key='ACTIVITY']/li/a/@href"
+        )
+        start_time = None
+        end_time = None
+        up_chars = []
+        pool_img = ""
+        title = ""
+        for activity_url in activity_urls:
+            activity_url = f"https://ak.hypergryph.com{activity_url}"
+            result = await self.get_url(activity_url)
+            if not result:
+                logger.warning(f"{self.game_name_cn}获取公告 {activity_url} 出错")
+                continue
+            soup = BeautifulSoup(result, "lxml")
+            contents = soup.find_all("p")
+            for index, content in enumerate(contents):
+                if re.search("(.*)(寻访|复刻).*?开启", content.text):
+                    title = content.text
+                    if "【" in title and "】" in title:
+                        title = re.split(r"[【】]", title)[1]
+                    lines = [str(contents[index + i + 1].text) for i in range(5)]
+                    time = ""
+                    chars: List[str] = []
+                    for line in lines:
+                        match = re.search(
+                            r"(\d{1,2}月\d{1,2}日.*?-.*?\d{1,2}月\d{1,2}日.*?$)", line
+                        )
+                        if match:
+                            time = match.group(1)
+                        if "★" in line:
+                            chars.append(line)
+                    if not time:
+                        continue
+                    start, end = time.replace("月", "/").replace("日", "").split("-")[:2]
+                    start_time = dateparser.parse(start)
+                    end_time = dateparser.parse(end)
+                    pool_img = content.find_previous("img")["src"]
+                    for char in chars:
+                        star = char.split("（")[0].count("★")
+                        name = re.split(r"[：（]", char)[1]
+                        names = name.split("/") if "/" in name else [name]
+                        names = [name.replace("[限定]", "").strip() for name in names]
+                        if "权值" in char:
+                            match = re.search(r"（在.*?以.*?(\d+).*?倍权值.*?）", char)
+                        else:
+                            match = re.search(r"（占.*?的.*?(\d+).*?%）", char)
+                        zoom = 1
+                        if match:
+                            zoom = float(match.group(1))
+                            zoom = zoom / 100 if zoom > 10 else zoom
+                        for name in names:
+                            up_chars.append(
+                                UpChar(name=name, star=star, limited=False, zoom=zoom)
+                            )
+                    break
+            if title and start_time and end_time:
+                if start_time <= datetime.now() <= end_time:
+                    self.UP_EVENT = UpEvent(
+                        title=title,
+                        pool_img=pool_img,
+                        start_time=start_time,
+                        end_time=end_time,
+                        up_char=up_chars,
+                    )
+                    self.dump_up_char()
+                    logger.info(f"成功获取{self.game_name_cn}当前up信息...当前up池: {title}")
+                break
+
+    async def _reload_pool(self) -> Optional[Message]:
+        await self.update_up_char()
+        self.load_up_char()
+        if self.UP_EVENT:
+            return f"重载成功！\n当前UP池子：{self.UP_EVENT.title}" + image(
+                self.UP_EVENT.pool_img
+            )

plugins/draw_card/init_card_pool.py

@@ -1,204 +0,0 @@
-from typing import Any
-from .config import DRAW_DATA_PATH
-from .util import is_number
-from nonebot.log import logger
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-def init_game_pool(game: str, data: dict, operator: Any):
-    tmp_lst = []
-    if game == "prts":
-        for key in data.keys():
-            limited = False
-            recruit_only = False
-            event_only = False
-            if "限定寻访" in data[key]["获取途径"]:
-                limited = True
-            if "干员寻访" not in data[key]["获取途径"] and "公开招募" in data[key]["获取途径"]:
-                recruit_only = True
-            if "活动获取" in data[key]["获取途径"]:
-                event_only = True
-            if "干员寻访" not in data[key]["获取途径"] and "凭证交易所" == data[key]["获取途径"][0]:
-                limited = True
-            if "干员寻访" not in data[key]["获取途径"] and "信用累计奖励" == data[key]["获取途径"][0]:
-                limited = True
-            if key.find("阿米娅") != -1:
-                continue
-            try:
-                tmp_lst.append(
-                    operator(
-                        name=key,
-                        star=int(data[key]["星级"]),
-                        limited=limited,
-                        recruit_only=recruit_only,
-                        event_only=event_only,
-                    )
-                )
-            except Exception as e:
-                logger.warning(f"明日方舟导入角色 {key} 数据错误：{type(e)}：{e}")
-    if game == "genshin":
-        for key in data.keys():
-            if key.find("旅行者") != -1:
-                continue
-            limited = False
-            if data[key]["常驻/限定"] == "限定UP":
-                limited = True
-            try:
-                tmp_lst.append(
-                    operator(name=key, star=int(data[key]["稀有度"][:1]), limited=limited)
-                )
-            except Exception as e:
-                logger.warning(f"原神导入角色 {key} 数据错误：{type(e)}：{e}")
-    if game == "genshin_arms":
-        for key in data.keys():
-            if data[key]["获取途径"].find("祈愿") != -1:
-                limited = False
-                if data[key]["获取途径"].find("限定祈愿") != -1:
-                    limited = True
-                try:
-                    tmp_lst.append(
-                        operator(
-                            name=key, star=int(data[key]["稀有度"][:1]), limited=limited
-                        )
-                    )
-                except Exception as e:
-                    logger.warning(f"原神导入武器 {key} 数据错误：{type(e)}：{e}")
-    if game == "pretty":
-        for key in data.keys():
-            try:
-                tmp_lst.append(
-                    operator(name=key, star=data[key]["初始星级"], limited=False)
-                )
-            except Exception as e:
-                logger.warning(f"赛马娘导入角色 {key} 数据错误：{type(e)}：{e}")
-    if game == "pretty_card":
-        for key in data.keys():
-            limited = False
-            if "卡池" not in data[key]["获取方式"]:
-                limited = True
-            if not data[key]["获取方式"]:
-                limited = False
-            try:
-                tmp_lst.append(
-                    operator(
-                        name=data[key]["中文名"],
-                        star=len(data[key]["稀有度"]),
-                        limited=limited,
-                    )
-                )
-            except Exception as e:
-                logger.warning(f"赛马娘导入卡片 {key} 数据错误：{type(e)}：{e}")
-    if game in ["guardian", "guardian_arms"]:
-        for key in data.keys():
-            tmp_lst.append(
-                operator(name=data[key]["名称"], star=int(data[key]["星级"]), limited=False)
-            )
-    if game == "pcr":
-        for key in data.keys():
-            limited = False
-            if key.find("（") != -1:
-                limited = True
-            try:
-                tmp_lst.append(
-                    operator(
-                        name=data[key]["名称"], star=int(data[key]["星级"]), limited=limited
-                    )
-                )
-            except Exception as e:
-                logger.warning(f"公主连接导入角色 {key} 数据错误：{type(e)}：{e}")
-    if game == "azur":
-        for key in data.keys():
-            if is_number(data[key]["星级"]):
-                limited = False
-                if "可以建造" not in data[key]["获取途径"]:
-                    limited = True
-                try:
-                    tmp_lst.append(
-                        operator(
-                            name=data[key]["名称"],
-                            star=int(data[key]["星级"]),
-                            limited=limited,
-                            type_=data[key]["类型"],
-                        )
-                    )
-                except Exception as e:
-                    logger.warning(f"碧蓝航线导入角色 {key} 数据错误：{type(e)}：{e}")
-    if game in ["fgo", "fgo_card"]:
-        for key in data.keys():
-            limited = False
-            try:
-                if (
-                    "圣晶石召唤" not in data[key]["入手方式"]
-                    and "圣晶石召唤（Story卡池）" not in data[key]["入手方式"]
-                ):
-                    limited = True
-            except KeyError:
-                pass
-            try:
-                tmp_lst.append(
-                    operator(
-                        name=data[key]["名称"], star=int(data[key]["星级"]), limited=limited
-                    )
-                )
-            except Exception as e:
-                logger.warning(f"FGO导入角色 {key} 数据错误：{type(e)}：{e}")
-    if game == "onmyoji":
-        for key in data.keys():
-            limited = False
-            if key in [
-                "奴良陆生",
-                "卖药郎",
-                "鬼灯",
-                "阿香",
-                "蜜桃&芥子",
-                "犬夜叉",
-                "杀生丸",
-                "桔梗",
-                "朽木露琪亚",
-                "黑崎一护",
-                "灶门祢豆子",
-                "灶门炭治郎",
-            ]:
-                limited = True
-            try:
-                tmp_lst.append(
-                    operator(
-                        name=data[key]["名称"], star=data[key]["星级"], limited=limited
-                    )
-                )
-            except Exception as e:
-                logger.warning(f"阴阳师导入角色 {key} 数据错误：{type(e)}：{e}")
-    # print(tmp_lst)
-    char_name_lst = [x.name for x in tmp_lst]
-    up_char_file = (
-        DRAW_DATA_PATH
-        / f"draw_card"
-        / "draw_card_up"
-        / f"{game.split('_')[0]}_up_char.json"
-    )
-    if up_char_file.exists():
-        data = json.load(open(up_char_file, "r", encoding="utf8"))
-        if len(game.split("_")) == 1:
-            key = "char"
-        else:
-            key = list(data.keys())[1]
-        for x in data[key]["up_char"]:
-            for char in data[key]["up_char"][x]:
-                if char not in char_name_lst:
-                    if game.find("prts") != -1:
-                        tmp_lst.append(
-                            operator(
-                                name=char,
-                                star=int(x),
-                                recruit_only=False,
-                                event_only=False,
-                                limited=False,
-                            )
-                        )
-                    else:
-                        tmp_lst.append(operator(name=char, star=int(x), limited=False))
-    return tmp_lst

plugins/draw_card/onmyoji_handle.py

@@ -1,81 +0,0 @@
-from nonebot.adapters.onebot.v11 import MessageSegment
-import random
-from .update_game_requests_info import update_requests_info
-from .util import generate_img, init_star_rst, BaseData, set_list, get_star, max_card
-from .config import DRAW_DATA_PATH, draw_config
-from dataclasses import dataclass
-from .init_card_pool import init_game_pool
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-ALL_CHAR = []
-
-
-@dataclass
-class OnmyojiChar(BaseData):
-    pass
-
-
-async def onmyoji_draw(count: int):
-    #            0      1      2
-    cnlist = ['SP', 'SSR', 'SR', 'R']
-    obj_list, obj_dict, star_list, rst = format_card_information(count)
-    rst = init_star_rst(star_list, cnlist, [], []) + rst
-    if count > 90:
-        obj_list = set_list(obj_list)
-    return MessageSegment.image("base64://" + await generate_img(obj_list, 'onmyoji', star_list)) \
-           + '\n' + rst[:-1] + '\n' + max_card(obj_dict)
-
-
-async def update_onmyoji_info():
-    global ALL_CHAR
-    data, code = await update_requests_info('onmyoji')
-    if code == 200:
-        ALL_CHAR = init_game_pool('onmyoji', data, OnmyojiChar)
-
-
-async def init_onmyoji_data():
-    global ALL_CHAR
-    if draw_config.ONMYOJI_FLAG:
-        with (DRAW_DATA_PATH / 'onmyoji.json').open('r', encoding='utf8') as f:
-            azur_dict = json.load(f)
-        ALL_CHAR = init_game_pool('onmyoji', azur_dict, OnmyojiChar)
-
-
-onmyoji_star = {
-    5: 'SP',
-    4: 'SSR',
-    3: 'SR',
-    2: 'R',
-}
-
-
-# 抽取卡池
-def _get_onmyoji_card():
-    global ALL_CHAR
-    onmyoji_config = draw_config.onmyoji
-    star = get_star([5, 4, 3, 2], [onmyoji_config.ONMYOJI_SP, onmyoji_config.ONMYOJI_SSR, onmyoji_config.ONMYOJI_SR, onmyoji_config.ONMYOJI_R])
-    chars = [x for x in ALL_CHAR if x.star == onmyoji_star[star] and not x.limited]
-    return random.choice(chars), 5 - star
-
-
-def format_card_information(count: int):
-    star_list = [0, 0, 0, 0]
-    obj_list = []           # 获取所有角色
-    obj_dict = {}           # 获取角色次数字典
-    rst = ''
-    for i in range(count):
-        obj, code = _get_onmyoji_card()
-        star_list[code] += 1
-        if code == 0:
-            rst += f'第 {i+1} 抽获取SP {obj.name}\n'
-        elif code == 1:
-            rst += f'第 {i+1} 抽获取SSR {obj.name}\n'
-        try:
-            obj_dict[obj.name] += 1
-        except KeyError:
-            obj_dict[obj.name] = 1
-        obj_list.append(obj)
-    return obj_list, obj_dict, star_list, rst

plugins/draw_card/pcr_handle.py

@@ -1,93 +0,0 @@
-from nonebot.adapters.onebot.v11 import MessageSegment
-import random
-from .update_game_info import update_info
-from .update_game_simple_info import update_simple_info
-from .util import generate_img, init_star_rst, BaseData, set_list, get_star, max_card
-from .config import DRAW_DATA_PATH, draw_config
-from dataclasses import dataclass
-from .init_card_pool import init_game_pool
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-ALL_CHAR = []
-
-
-@dataclass
-class PcrChar(BaseData):
-    pass
-
-
-async def pcr_draw(count: int):
-    #            0      1      2
-    cnlist = ['★★★', '★★', '★']
-    char_list, three_list, three_index_list, char_dict, star_list = _format_card_information(count)
-    rst = init_star_rst(star_list, cnlist, three_list, three_index_list)
-    if count > 90:
-        char_list = set_list(char_list)
-    return MessageSegment.image("base64://" + await generate_img(char_list, 'pcr', star_list)) \
-           + '\n' + rst[:-1] + '\n' + max_card(char_dict)
-
-
-async def update_pcr_info():
-    global ALL_CHAR
-    if draw_config.PCR_TAI:
-        url = 'https://wiki.biligame.com/pcr/角色图鉴'
-        data, code = await update_simple_info(url, 'pcr')
-    else:
-        url = 'https://wiki.biligame.com/pcr/角色筛选表'
-        data, code = await update_info(url, 'pcr')
-    if code == 200:
-        ALL_CHAR = init_game_pool('pcr', data, PcrChar)
-
-
-async def init_pcr_data():
-    global ALL_CHAR
-    if draw_config.PCR_FLAG:
-        with (DRAW_DATA_PATH / 'pcr.json').open('r', encoding='utf8') as f:
-            pcr_dict = json.load(f)
-        ALL_CHAR = init_game_pool('pcr', pcr_dict, PcrChar)
-
-
-# 抽取卡池
-def _get_pcr_card(mode: int = 1):
-    global ALL_CHAR
-    pcr_config = draw_config.pcr
-    if mode == 2:
-        star = get_star([3, 2], [pcr_config.PCR_G_THREE_P, pcr_config.PCR_G_TWO_P])
-    else:
-        star = get_star([3, 2, 1], [pcr_config.PCR_THREE_P, pcr_config.PCR_TWO_P, pcr_config.PCR_ONE_P])
-    chars = [x for x in ALL_CHAR if x.star == star and not x.limited]
-    return random.choice(chars), 3 - star
-
-
-def _format_card_information(_count: int):
-    char_list = []
-    star_list = [0, 0, 0]
-    three_index_list = []
-    three_list = []
-    char_dict = {}
-    # 保底计算
-    count = 0
-    for i in range(_count):
-        count += 1
-        # 十连保底
-        if count == 10:
-            char, code = _get_pcr_card(2)
-            count = 0
-        else:
-            char, code = _get_pcr_card()
-            if code < 2:
-                count = 0
-        star_list[code] += 1
-        if code == 0:
-            three_list.append(char.name)
-            three_index_list.append(i)
-        try:
-            char_dict[char.name] += 1
-        except KeyError:
-            char_dict[char.name] = 1
-        char_list.append(char)
-    return char_list, three_list, three_index_list, char_dict, star_list

plugins/draw_card/pretty_handle.py

@@ -1,148 +0,0 @@
-from nonebot.adapters.onebot.v11 import MessageSegment
-from .announcement import PrettyAnnouncement
-from .update_game_info import update_info
-from .util import init_star_rst, generate_img, max_card, BaseData, \
-    set_list, get_star, format_card_information, init_up_char
-import random
-from .config import DRAW_DATA_PATH, draw_config
-from dataclasses import dataclass
-from .init_card_pool import init_game_pool
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-announcement = PrettyAnnouncement()
-
-ALL_CHAR = []
-ALL_CARD = []
-
-_CURRENT_CHAR_POOL_TITLE = ""
-_CURRENT_CARD_POOL_TITLE = ""
-UP_CHAR = []
-UP_CARD = []
-POOL_IMG = []
-
-
-@dataclass
-class PrettyChar(BaseData):
-    pass
-
-
-async def pretty_draw(count: int, pool_name):
-    if pool_name == 'card':
-        cnlist = ['SSR', 'SR', 'R']
-    else:
-        cnlist = ['★★★', '★★', '★']
-    star_list = [0, 0, 0]
-    obj_list, obj_dict, three_list, star_list, three_olist = format_card_information(count, star_list,
-                                                                                     _get_pretty_card, pool_name)
-    up_type = []
-    up_list = []
-    title = ''
-    if pool_name == 'char' and _CURRENT_CHAR_POOL_TITLE:
-        up_type = UP_CHAR
-        title = _CURRENT_CHAR_POOL_TITLE
-    elif pool_name == 'card' and _CURRENT_CARD_POOL_TITLE:
-        up_type = UP_CARD
-        title = _CURRENT_CARD_POOL_TITLE
-    tmp = ''
-    if up_type:
-        for x in up_type:
-            for operator in x.operators:
-                up_list.append(operator.split(']')[1] if pool_name == 'char' else operator)
-            if x.star == 3:
-                if pool_name == 'char':
-                    tmp += f'三星UP：{" ".join(x.operators)} \n'
-                else:
-                    tmp += f'SSR UP：{" ".join(x.operators)} \n'
-            elif x.star == 2:
-                if pool_name == 'char':
-                    tmp += f'二星UP：{" ".join(x.operators)} \n'
-                else:
-                    tmp += f'SR UP：{" ".join(x.operators)} \n'
-            elif x.star == 1:
-                if pool_name == 'char':
-                    tmp += f'一星UP：{" ".join(x.operators)} '
-                else:
-                    tmp += f'R UP：{" ".join(x.operators)} '
-    tmp = tmp[:-1] if tmp and tmp[-1] == '\n' else tmp
-    pool_info = f'当前up池：{title}\n{tmp}' if title else ''
-    rst = init_star_rst(star_list, cnlist, three_list, three_olist, up_list)
-    if count > 90:
-        obj_list = set_list(obj_list)
-    return pool_info + MessageSegment.image(
-        "base64://" + await generate_img(obj_list, 'pretty', star_list)) \
-           + '\n' + rst[:-1] + '\n' + max_card(obj_dict)
-
-
-async def update_pretty_info():
-    global ALL_CHAR, ALL_CARD
-    url = 'https://wiki.biligame.com/umamusume/赛马娘图鉴'
-    data, code = await update_info(url, 'pretty')
-    if code == 200:
-        ALL_CHAR = init_game_pool('pretty', data, PrettyChar)
-    url = 'https://wiki.biligame.com/umamusume/支援卡图鉴'
-    data, code = await update_info(url, 'pretty_card')
-    if code == 200:
-        ALL_CARD = init_game_pool('pretty_card', data, PrettyChar)
-    await _pretty_init_up_char()
-
-
-async def init_pretty_data():
-    global ALL_CHAR, ALL_CARD
-    if draw_config.PRETTY_FLAG:
-        with (DRAW_DATA_PATH / 'pretty.json').open('r', encoding='utf8') as f:
-            pretty_char_dict = json.load(f)
-        with (DRAW_DATA_PATH / 'pretty_card.json').open('r', encoding='utf8') as f:
-            pretty_card_dict = json.load(f)
-        ALL_CHAR = init_game_pool('pretty', pretty_char_dict, PrettyChar)
-        ALL_CARD = init_game_pool('pretty_card', pretty_card_dict, PrettyChar)
-        await _pretty_init_up_char()
-
-
-# 抽取卡池
-def _get_pretty_card(pool_name: str, mode: int = 1):
-    global ALL_CHAR, ALL_CARD, _CURRENT_CHAR_POOL_TITLE, _CURRENT_CARD_POOL_TITLE
-    pretty_config = draw_config.pretty
-    if mode == 1:
-        star = get_star([3, 2, 1], [pretty_config.PRETTY_THREE_P, pretty_config.PRETTY_TWO_P, pretty_config.PRETTY_ONE_P])
-    else:
-        star = get_star([3, 2], [pretty_config.PRETTY_THREE_P, pretty_config.PRETTY_TWO_P])
-    if pool_name == 'card':
-        title = _CURRENT_CARD_POOL_TITLE
-        up_data = UP_CARD
-        data = ALL_CARD
-    else:
-        title = _CURRENT_CHAR_POOL_TITLE
-        up_data = UP_CHAR
-        data = ALL_CHAR
-    # 有UP池子
-    if title and star in [x.star for x in up_data]:
-        all_char_lst = [x for x in data if x.star == star and not x.limited]
-        # 抽到UP
-        if random.random() < 1 / len(all_char_lst) * (0.7 / 0.1385):
-            all_up_star = [x.operators for x in up_data if x.star == star][0]
-            acquire_operator = random.choice(all_up_star)
-            if pool_name == 'char':
-                acquire_operator = acquire_operator.split(']')[1]
-            acquire_operator = [x for x in data if x.name == acquire_operator][0]
-        else:
-            acquire_operator = random.choice([x for x in data if x.star == star and not x.limited])
-    else:
-        acquire_operator = random.choice([x for x in data if x.star == star and not x.limited])
-    return acquire_operator, 3 - star
-
-
-# 获取up和概率
-async def _pretty_init_up_char():
-    global _CURRENT_CHAR_POOL_TITLE, _CURRENT_CARD_POOL_TITLE, UP_CHAR, UP_CARD, POOL_IMG
-    _CURRENT_CHAR_POOL_TITLE, _CURRENT_CARD_POOL_TITLE, POOL_IMG, UP_CHAR, UP_CARD = await init_up_char(announcement)
-
-
-async def reload_pretty_pool():
-    await _pretty_init_up_char()
-    return f'当前UP池子：{_CURRENT_CHAR_POOL_TITLE} & {_CURRENT_CARD_POOL_TITLE} {POOL_IMG}'
-

plugins/draw_card/prts_handle.py

@@ -1,171 +0,0 @@
-from nonebot.adapters.onebot.v11 import MessageSegment, Message
-import random
-from .config import DRAW_DATA_PATH, draw_config
-from .update_game_info import update_info
-from .util import generate_img, init_star_rst, max_card, BaseData, UpEvent, set_list, get_star
-from .init_card_pool import init_game_pool
-from .announcement import PrtsAnnouncement
-from dataclasses import dataclass
-from nonebot.log import logger
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-announcement = PrtsAnnouncement()
-
-prts_dict = {}
-UP_OPERATOR = []
-ALL_OPERATOR = []
-_CURRENT_POOL_TITLE = ''
-POOL_IMG = ''
-
-
-@dataclass
-class Operator(BaseData):
-    recruit_only: bool  # 公招限定
-    event_only: bool  # 活动获得干员
-    # special_only: bool  # 升变/异格干员
-
-
-async def prts_draw(count: int = 300):
-    cnlist = ['★★★★★★', '★★★★★', '★★★★', '★★★']
-    star_list = [0, 0, 0, 0]
-    operator_list, operator_dict, six_list, star_list, six_index_list = format_card_information(count, star_list)
-    up_list = []
-    tmp = ''
-    if _CURRENT_POOL_TITLE:
-        for x in UP_OPERATOR:
-            for operator in x.operators:
-                up_list.append(operator)
-            if x.star == 6:
-                tmp += f'六星UP：{" ".join(x.operators)} \n'
-            elif x.star == 5:
-                tmp += f'五星UP：{" ".join(x.operators)} \n'
-            elif x.star == 4:
-                tmp += f'四星UP：{" ".join(x.operators)}'
-    rst = init_star_rst(star_list, cnlist, six_list, six_index_list, up_list)
-    if count > 90:
-        operator_list = set_list(operator_list)
-    pool_info = f"当前up池: {_CURRENT_POOL_TITLE}\n{tmp}" if _CURRENT_POOL_TITLE else ""
-    return pool_info + MessageSegment.image(
-        "base64://" + await generate_img(operator_list, 'prts', star_list)) \
-           + '\n' + rst[:-1] + '\n' + max_card(operator_dict)
-
-
-async def update_prts_info():
-    global prts_dict, ALL_OPERATOR
-    url = 'https://wiki.biligame.com/arknights/干员数据表'
-    data, code = await update_info(url, 'prts', ['头像', '名称', '阵营', '星级', '性别', '是否感染', '获取途径', '初始生命', '初始防御',
-                                                 '初始法抗', '再部署', '部署费用', '阻挡数', '攻击速度', '标签'])
-    if code == 200:
-        prts_dict = data
-        ALL_OPERATOR = init_game_pool('prts', prts_dict, Operator)
-        await _init_up_char()
-
-
-async def init_prts_data():
-    global prts_dict, ALL_OPERATOR
-    if draw_config.PRTS_FLAG:
-        with (DRAW_DATA_PATH / 'prts.json').open('r', encoding='utf8') as f:
-            prts_dict = json.load(f)
-        ALL_OPERATOR = init_game_pool('prts', prts_dict, Operator)
-        await _init_up_char()
-
-
-# 抽取干员
-def _get_operator_card(add: float):
-    prts_config = draw_config.prts
-    star = get_star([6, 5, 4, 3], [prts_config.PRTS_SIX_P + add, prts_config.PRTS_FIVE_P, prts_config.PRTS_FOUR_P, prts_config.PRTS_THREE_P])
-    if _CURRENT_POOL_TITLE:
-        zooms = [x.zoom for x in UP_OPERATOR if x.star == star]
-        zoom = 0
-        weight = 0
-        # 分配概率和权重
-        for z in zooms:
-            if z < 1:
-                zoom = z
-            else:
-                weight = z
-        up_operator_name = ""
-        # UPs
-        try:
-            if 0 < zoom:
-                up_operators = [x.operators for x in UP_OPERATOR if x.star == star and x.zoom < 1][0]
-                up_operator_name = random.choice(up_operators)
-                acquire_operator = [x for x in ALL_OPERATOR if x.name == up_operator_name][0]
-            else:
-                all_star_operators = [x for x in ALL_OPERATOR if x.star == star
-                                      and not any([x.limited, x.event_only, x.recruit_only])]
-                weight_up_operators = [x.operators for x in UP_OPERATOR if x.star == star and x.zoom > 1]
-                # 权重
-                if weight_up_operators and random.random() < 1.0 / float(len(all_star_operators)) * weight:
-                    up_operator_name = random.choice(weight_up_operators[0])
-                    acquire_operator = [x for x in ALL_OPERATOR if x.name == up_operator_name][0]
-                else:
-                    acquire_operator = random.choice(all_star_operators)
-        except IndexError:
-            acquire_operator = Operator(up_operator_name, star, True, False, False)
-    else:
-        acquire_operator = random.choice([x for x in ALL_OPERATOR if x.star == star
-                                          and not any([x.limited, x.event_only, x.recruit_only])])
-    return acquire_operator, 6 - star
-
-
-# 整理数据
-def format_card_information(count: int, star_list: list):
-    max_star_lst = []       # 获取的最高星级角色列表
-    max_index_lst = []      # 获取最高星级角色的次数
-    obj_list = []           # 获取所有角色
-    obj_dict = {}           # 获取角色次数字典
-    add = 0.0
-    count_idx = 0
-    for i in range(count):
-        count_idx += 1
-        obj, code = _get_operator_card(add)
-        star_list[code] += 1
-        if code == 0:
-            max_star_lst.append(obj.name)
-            max_index_lst.append(i)
-            add = 0.0
-            count_idx = 0
-        elif count_idx > 50:
-            add += 0.02
-        try:
-            obj_dict[obj.name] += 1
-        except KeyError:
-            obj_dict[obj.name] = 1
-        obj_list.append(obj)
-    return obj_list, obj_dict, max_star_lst, star_list, max_index_lst
-
-
-# 获取up干员和概率
-async def _init_up_char():
-    global _CURRENT_POOL_TITLE, POOL_IMG, UP_OPERATOR
-    UP_OPERATOR = []
-    up_char_dict = await announcement.update_up_char()
-    _CURRENT_POOL_TITLE = up_char_dict['char']['title']
-    if _CURRENT_POOL_TITLE:
-        POOL_IMG = MessageSegment.image(up_char_dict['char']['pool_img'])
-    up_char_dict = up_char_dict['char']['up_char']
-    logger.info(f'成功获取明日方舟当前up信息...当前up池: {_CURRENT_POOL_TITLE}')
-    average_dict = {'6': {}, '5': {}, '4': {}}
-    for star in up_char_dict.keys():
-        for key in up_char_dict[star].keys():
-            if average_dict[star].get(up_char_dict[star][key]):
-                average_dict[star][up_char_dict[star][key]].append(key)
-            else:
-                average_dict[star][up_char_dict[star][key]] = [key]
-    for star in average_dict.keys():
-        for str_zoom in average_dict[star].keys():
-            if str_zoom[0] == '权':
-                zoom = float(str_zoom[1:])
-            else:
-                zoom = float(str_zoom) / 100
-            UP_OPERATOR.append(UpEvent(star=int(star), operators=average_dict[star][str_zoom], zoom=zoom))
-
-
-async def reload_prts_pool():
-    await _init_up_char()
-    return Message(f'当前UP池：{_CURRENT_POOL_TITLE} {POOL_IMG}')

plugins/draw_card/rule.py

@@ -1,29 +0,0 @@
-from nonebot.rule import Rule
-from nonebot.adapters.onebot.v11 import Bot, MessageEvent
-from nonebot.typing import T_State
-from .config import draw_config
-
-
-def is_switch(game_name: str) -> Rule:
-
-    async def _is_switch(bot: Bot, event: MessageEvent, state: T_State) -> bool:
-        if game_name == 'prts':
-            return draw_config.PRTS_FLAG
-        if game_name == 'genshin':
-            return draw_config.GENSHIN_FLAG
-        if game_name == 'pretty':
-            return draw_config.PRETTY_FLAG
-        if game_name == 'guardian':
-            return draw_config.GUARDIAN_FLAG
-        if game_name == 'pcr':
-            return draw_config.PCR_FLAG
-        if game_name == 'azur':
-            return draw_config.AZUR_FLAG
-        if game_name == 'fgo':
-            return draw_config.FGO_FLAG
-        if game_name == 'onmyoji':
-            return draw_config.ONMYOJI_FLAG
-        else:
-            return False
-
-    return Rule(_is_switch)

plugins/draw_card/update_game_info.py

@@ -1,295 +0,0 @@
-from typing import Tuple
-from .config import DRAW_DATA_PATH
-from asyncio.exceptions import TimeoutError
-from bs4 import BeautifulSoup
-from .util import download_img
-from urllib.parse import unquote
-from .util import remove_prohibited_str
-from utils.http_utils import AsyncHttpx
-from nonebot.log import logger
-import bs4
-import re
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-headers = {'User-Agent': '"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; TencentTraveler 4.0)"'}
-
-
-async def update_info(url: str, game_name: str, info_list: list = None) -> Tuple[dict, int]:
-    info_path = DRAW_DATA_PATH / f"{game_name}.json"
-    try:
-        with info_path.open('r', encoding='utf8') as f:
-            data = json.load(f)
-    except (ValueError, FileNotFoundError):
-        data = {}
-    try:
-        response = await AsyncHttpx.get(url, timeout=7)
-        soup = BeautifulSoup(response.text, 'lxml')
-        _tbody = get_tbody(soup, game_name, url)
-        trs = _tbody.find_all('tr')
-        att_dict, start_index, index = init_attr(game_name)
-        if game_name == 'guardian':
-            start_index = 1
-        if game_name == 'azur':
-            start_index = 0
-        for th in trs[0].find_all('th')[start_index:]:
-            text = th.text
-            if text[-1] == '\n':
-                text = text[:-1]
-            att_dict[text] = index
-            index += 1
-        for tr in trs[1:]:
-            member_dict = {}
-            tds = tr.find_all('td')
-            if not info_list:
-                info_list = att_dict.keys()
-            for key in info_list:
-                key, attr = parse_key(key, game_name)
-                td = tds[att_dict[key]]
-                last_tag = unquote(_find_last_tag(td, attr, game_name), 'utf-8')
-                member_dict[key] = last_tag
-                member_dict = intermediate_check(member_dict, key, game_name, td)
-            avatar_img = await _modify_avatar_url(game_name, member_dict["名称"])
-            member_dict['头像'] = avatar_img if avatar_img else member_dict['头像']
-            member_dict, name = replace_update_name(member_dict, game_name)
-            await download_img(member_dict['头像'], game_name, name)
-            data[name] = member_dict
-            logger.info(f'{name} is update...')
-        data = await _last_check(data, game_name)
-    except TimeoutError:
-        logger.warning(f'更新 {game_name} 超时...')
-        return {}, 999
-    with info_path.open('w', encoding='utf8') as wf:
-        wf.write(json.dumps(data, ensure_ascii=False, indent=4))
-    return data, 200
-
-
-def _find_last_tag(element: bs4.element.Tag, attr: str, game_name: str) -> str:
-    last_tag = []
-    for des in element.descendants:
-        last_tag.append(des)
-    if len(last_tag) == 1 and last_tag[0] == '\n':
-        last_tag = ''
-    elif last_tag[-1] == '\n':
-        last_tag = last_tag[-2]
-    else:
-        last_tag = last_tag[-1]
-    if attr and str(last_tag):
-        last_tag = last_tag[attr]
-    elif str(last_tag).find('<img') != -1:
-        if last_tag.get('srcset'):
-            last_tag = str(last_tag.get('srcset')).strip().split(' ')[-2].strip()
-        else:
-            last_tag = last_tag['src']
-    else:
-        last_tag = str(last_tag)
-    if str(last_tag) and str(last_tag)[-1] == '\n':
-        last_tag = str(last_tag)[:-1]
-
-    if game_name not in ['pretty', 'pretty_card', 'guardian'] and last_tag.find('http') == -1:
-        last_tag = last_tag.split('.')[0]
-
-    return last_tag
-
-
-# 获取大图（小图快爬）
-async def _modify_avatar_url(game_name: str, char_name: str):
-    if game_name == 'prts':
-        res = await AsyncHttpx.get(f'https://wiki.biligame.com/arknights/{char_name}', timeout=7)
-        soup = BeautifulSoup(res.text, 'lxml')
-        try:
-            img_url = str(soup.find('img', {'class': 'img-bg'})['srcset']).split(' ')[-2]
-        except KeyError:
-            img_url = str(soup.find('img', {'class': 'img-bg'})['src'])
-        return img_url
-    if game_name == 'genshin':
-        return None
-    if game_name == 'pretty_card':
-        res = await AsyncHttpx.get(f'https://wiki.biligame.com/umamusume/{char_name}', timeout=7)
-        soup = BeautifulSoup(res.text, 'lxml')
-        try:
-            img_url = soup.find('div', {'class': 'support_card-left'}).find('div').find('img').get('src')
-            return img_url
-        except AttributeError:
-            logger.warning("pretty_card 获取大图像失败")
-        return None
-    if game_name == 'guardian':
-        # 未上传图片太多，换成像素图
-        # async with session.get(f'https://wiki.biligame.com/gt/{char_name}', timeout=7) as res:
-        #     soup = BeautifulSoup(await res.text(), 'lxml')
-        #     soup = soup.find('table', {'class': 'wikitable'}).find('tbody').find('tr')
-        #     try:
-        #         img_url = str(soup.find('img', {'class': 'img-kk'})['srcset']).split(' ')[-2]
-        #     except KeyError:
-        #         img_url = str(soup.find('img', {'class': 'img-kk'})['src'])
-        #     except TypeError:
-        #         print(f'{char_name} 图片还未上传，跳过...')
-        #         img_url = ''
-        #     return img_url
-        return None
-
-
-# 数据最后处理（是否需要额外数据或处理数据）
-async def _last_check(data: dict, game_name: str):
-    # if game_name == 'prts':
-    #     tasks = []
-    #     for key in data.keys():
-    #         tasks.append(asyncio.ensure_future(_async_update_prts_extra_info(key, session)))
-    #     asyResult = await asyncio.gather(*tasks)
-    #     for x in asyResult:
-    #         for key in x.keys():
-    #             data[key]['获取途径'] = x[key]['获取途径']
-    if game_name == 'genshin':
-        for key in data.keys():
-            res = await AsyncHttpx.get(f'https://wiki.biligame.com/ys/{key}', timeout=7)
-            soup = BeautifulSoup(res.text, 'lxml')
-            _trs = ''
-            for table in soup.find_all('table', {'class': 'wikitable'}):
-                if str(table).find('常驻/限定') != -1:
-                    _trs = table.find('tbody').find_all('tr')
-                    break
-            for tr in _trs:
-                data[key]['常驻/限定'] = '未知'
-                if str(tr).find('限定UP') != -1:
-                    data[key]['常驻/限定'] = '限定UP'
-                    logger.info(f'原神获取额外数据 {key}...{data[key]["常驻/限定"]}')
-                    break
-                elif str(tr).find('常驻UP') != -1:
-                    data[key]['常驻/限定'] = '常驻UP'
-                    logger.info(f'原神获取额外数据 {key}...{data[key]["常驻/限定"]}')
-                    break
-    if game_name == 'pretty':
-        for keys in data.keys():
-            for key in data[keys].keys():
-                r = re.search(r'.*?40px-(.*)图标.png', str(data[keys][key]))
-                if r:
-                    data[keys][key] = r.group(1)
-                    logger.info(f'赛马娘额外修改数据...{keys}[{key}]=> {r.group(1)}')
-    if game_name == 'guardian':
-        for keys in data.keys():
-            for key in data[keys].keys():
-                r = re.search(r'.*?-star_(.*).png', str(data[keys][key]))
-                if r:
-                    data[keys][key] = r.group(1)
-                    logger.info(f'坎公骑士剑额外修改数据...{keys}[{key}] => {r.group(1)}')
-    return data
-
-
-# 对抓取每行数据是否需要额外处理？
-def intermediate_check(member_dict: dict, key: str, game_name: str, td: bs4.element.Tag):
-    if game_name == "genshin_arms":
-        if key == "稀有度":
-            member_dict["稀有度"] = td.find("img")["alt"].split('.')[0]
-    if game_name == 'prts':
-        if key == '获取途径':
-            msg = re.search('<td.*?>([\\s\\S]*)</td>', str(td)).group(1).strip()
-            msg = msg[:-1] if msg and msg[-1] == '\n' else msg
-            if msg.find('<a') != -1:
-                for a in td.find_all('a'):
-                    msg = msg.replace(str(a), a.text)
-            member_dict['获取途径'] = msg.split('<br/>')
-    if game_name == 'pretty':
-        if key == '初始星级':
-            member_dict['初始星级'] = len(td.find_all('img'))
-    if game_name == 'pretty_card':
-        if key == '获取方式':
-            obtain = []
-            for x in str(td.text).replace('\n', '').strip().split('、'):
-                if x:
-                    obtain.append(x)
-            member_dict['获取方式'] = obtain
-    if game_name == 'guardian':
-        if key == '头像':
-            member_dict['星级'] = str(td.find('span').find('img')['alt'])[-5]
-            try:
-                member_dict['头像'] = str(td.find('img')['srcset']).split(' ')[0]
-            except KeyError:
-                member_dict['头像'] = str(td.find('img')['src'])
-    return member_dict
-
-
-def init_attr(game_name: str):
-    att_dict = {'头像': 0, '名称': 1}
-    start_index = 2
-    index = 2
-    if game_name == 'guardian':
-        att_dict = {'头像': 0, '名称': 0}
-        start_index = 1
-        index = 1
-    return att_dict, start_index, index
-
-
-# 解析key
-def parse_key(key: str, game_name):
-    attr = ''
-    if game_name == 'genshin_arms':
-        if key.find('.') != -1:
-            key = key.split('.')
-            attr = key[-1]
-            key = key[0]
-    return key, attr
-
-
-# 拿到名称
-def replace_update_name(member_dict: dict, game_name: str):
-    name = member_dict['名称']
-    if game_name == 'pretty_card':
-        name = member_dict['中文名']
-        name = remove_prohibited_str(name)
-        member_dict['中文名'] = name
-    else:
-        name = remove_prohibited_str(name)
-        member_dict['名称'] = name
-    return member_dict, name
-
-
-# 拿到tbody，不同游戏tbody可能不同
-def get_tbody(soup: bs4.BeautifulSoup, game_name: str, url: str):
-    max_count = 0
-    _tbody = None
-    if game_name == 'guardian_arms':
-        if url[-2:] == '盾牌':
-            div = soup.find('div', {'class': 'resp-tabs-container'}).find_all('div', {'class': 'resp-tab-content'})[1]
-            _tbody = div.find('tbody')
-        else:
-            div = soup.find('div', {'class': 'resp-tabs-container'}).find_all('div', {'class': 'resp-tab-content'})[0]
-            _tbody = div.find('table', {'id': 'CardSelectTr'}).find('tbody')
-    else:
-        for tbody in soup.find_all('tbody'):
-            if len(tbody.find_all('tr')) > max_count:
-                _tbody = tbody
-                max_count = len(tbody.find_all('tr'))
-    return _tbody
-
-
-# async def _async_update_prts_extra_info(key: str, session: aiohttp.ClientSession):
-#     for i in range(10):
-#         try:
-#             async with session.get(f'https://wiki.biligame.com/arknights/{key}', timeout=7) as res:
-#                 soup = BeautifulSoup(await res.text(), 'lxml')
-#                 obtain = str(soup.find('table', {'class': 'wikitable'}).find('tbody').find_all('td')[-1])
-#                 obtain = re.search(r'<td.*?>([\s\S]*)</.*?', obtain).group(1)
-#                 obtain = obtain[:-1] if obtain[-1] == '\n' else obtain
-#                 if obtain.find('<br/>'):
-#                     obtain = obtain.split('<br/>')
-#                 elif obtain.find('<br>'):
-#                     obtain = obtain.split('<br>')
-#                 for i in range(len(obtain)):
-#                     if obtain[i].find('<a') != -1:
-#                         text = ''
-#                         for msg in obtain[i].split('</a>'):
-#                             r = re.search('>(.*)', msg)
-#                             if r:
-#                                 text += r.group(1) + ' '
-#                         obtain[i] = obtain[i].split('<a')[0] + text[:-1] + obtain[i].split('</a>')[-1]
-#                 print(f'明日方舟获取额外信息 {key}...{obtain}')
-#                 x = {key: {}}
-#                 x[key]['获取途径'] = obtain
-#                 return x
-#         except TimeoutError:
-#             print(f'访问 https://wiki.biligame.com/arknights/{key} 第 {i}次 超时...已再次访问')
-#     return {}
-

plugins/draw_card/update_game_requests_info.py

@@ -1,156 +0,0 @@
-from .config import DRAW_DATA_PATH, draw_config
-from asyncio.exceptions import TimeoutError
-from .util import download_img
-from bs4 import BeautifulSoup
-from .util import remove_prohibited_str
-from utils.http_utils import AsyncHttpx
-from nonebot.log import logger
-import asyncio
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-headers = {'User-Agent': '"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; TencentTraveler 4.0)"'}
-
-
-async def update_requests_info(game_name: str):
-    info_path = DRAW_DATA_PATH / f"{game_name}.json"
-    try:
-        with info_path.open('r', encoding='utf8') as f:
-            data = json.load(f)
-    except (ValueError, FileNotFoundError):
-        data = {}
-    try:
-        if game_name in ['fgo', 'fgo_card']:
-            if game_name == 'fgo':
-                url = 'http://fgo.vgtime.com/servant/ajax?card=&wd=&ids=&sort=12777&o=desc&pn='
-            else:
-                url = 'http://fgo.vgtime.com/equipment/ajax?wd=&ids=&sort=12958&o=desc&pn='
-            for i in range(9999):
-                response = await AsyncHttpx.get(f'{url}{i}', timeout=7)
-                fgo_data = json.loads(response.text)
-                if int(fgo_data['nums']) == 0:
-                    break
-                for x in fgo_data['data']:
-                    x['name'] = remove_prohibited_str(x['name'])
-                    key = x['name']
-                    data = add_to_data(data, x, game_name)
-                    await download_img(data[key]['头像'], game_name, key)
-                    logger.info(f'{key} is update...')
-        if game_name == 'onmyoji':
-            url = 'https://yys.res.netease.com/pc/zt/20161108171335/js/app/all_shishen.json?v74='
-            response = await AsyncHttpx.get(url, timeout=7)
-            onmyoji_data = response.json()
-            for x in onmyoji_data:
-                x['name'] = remove_prohibited_str(x['name'])
-                key = x['name']
-                data = add_to_data(data, x, game_name)
-                logger.info(f'{key} is update...')
-        data = await _last_check(data, game_name)
-    except TimeoutError:
-        logger.warning(f'更新 {game_name} 超时...')
-        return {}, 999
-    except Exception as e:
-        logger.warning(f'更新 {game_name} 失败 {type(e)}：{e}...')
-        return {}, 999
-    with info_path.open('w', encoding='utf8') as wf:
-        json.dump(data, wf, ensure_ascii=False, indent=4)
-    return data, 200
-
-
-# 添加到字典
-def add_to_data(data: dict, x: dict, game_name: str) -> dict:
-    member_dict = {}
-    if game_name == 'fgo':
-        member_dict = {
-            'id': x['id'],
-            'card_id': x['charid'],
-            '头像': x['icon'],
-            '名称': x['name'],
-            '职阶': x['classes'],
-            '星级': x['star'],
-            'hp': x['lvmax4hp'],
-            'atk': x['lvmax4atk'],
-            'card_quick': x['cardquick'],
-            'card_arts': x['cardarts'],
-            'card_buster': x['cardbuster'],
-            '宝具': x['tprop'],
-        }
-    if game_name == 'fgo_card':
-        member_dict = {
-            'id': x['id'],
-            'card_id': x['equipid'],
-            '头像': x['icon'],
-            '名称': x['name'],
-            '星级': x['star'],
-            'hp': x['lvmax_hp'],
-            'atk': x['lvmax_atk'],
-            'skill_e': x['skill_e'].split('<br />')[: -1],
-        }
-    if game_name == 'onmyoji':
-        member_dict = {
-            'id': x['id'],
-            '名称': x['name'],
-            '星级': x['level'],
-        }
-    data[member_dict['名称']] = member_dict
-    return data
-
-
-# 获取额外数据
-async def _last_check(data: dict, game_name: str) -> dict:
-    if game_name == 'fgo':
-        url = 'http://fgo.vgtime.com/servant/'
-        tasks = []
-        semaphore = asyncio.Semaphore(draw_config.SEMAPHORE)
-        for key in data.keys():
-            tasks.append(asyncio.ensure_future(
-                _async_update_fgo_extra_info(url, key, data[key]['id'], semaphore)))
-        result = await asyncio.gather(*tasks)
-        for x in result:
-            for key in x.keys():
-                data[key]['入手方式'] = x[key]['入手方式']
-    if game_name == 'onmyoji':
-        url = 'https://yys.163.com/shishen/{}.html'
-        for key in data.keys():
-            response = await AsyncHttpx.get(f'{url.format(data[key]["id"])}', timeout=7)
-            soup = BeautifulSoup(response.text, 'lxml')
-            data[key]['头像'] = "https:" + soup.find('div', {'class': 'pic_wrap'}).find('img')['src']
-            await download_img(data[key]['头像'], game_name, key)
-    return data
-
-
-async def _async_update_fgo_extra_info(url: str, key: str, _id: str, semaphore):
-    # 防止访问超时
-    async with semaphore:
-        for i in range(10):
-            try:
-                response = await AsyncHttpx.get(f'{url}{_id}', timeout=7)
-                soup = BeautifulSoup(response.text, 'lxml')
-                obtain = soup.find('table', {'class': 'uk-table uk-codex-table'}).find_all('td')[-1].text
-                if obtain.find('限时活动免费获取 活动结束后无法获得') != -1:
-                    obtain = ['活动获取']
-                elif obtain.find('非限时UP无法获得') != -1:
-                    obtain = ['限时召唤']
-                else:
-                    if obtain.find('&') != -1:
-                        obtain = obtain.strip().split('&')
-                    else:
-                        obtain = obtain.strip().split(' ')
-                logger.info(f'Fgo获取额外信息 {key}....{obtain}')
-                x = {key: {}}
-                x[key]['入手方式'] = obtain
-                return x
-            except TimeoutError:
-                logger.warning(f'访问{url}{_id} 第 {i}次 超时...已再次访问')
-            except Exception as e:
-                logger.warning(f'访问{url}{_id} 第 {i}次 发生错误：{e}...已再次访问')
-    return {}
-
-
-
-
-
-

plugins/draw_card/update_game_simple_info.py

@@ -1,225 +0,0 @@
-from typing import Tuple
-from .config import DRAW_DATA_PATH, draw_config
-from asyncio.exceptions import TimeoutError
-from bs4 import BeautifulSoup
-from .util import download_img
-from .util import remove_prohibited_str
-from urllib.parse import unquote
-from utils.http_utils import AsyncHttpx
-from nonebot.log import logger
-import bs4
-import asyncio
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-headers = {
-    "User-Agent": '"Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; TencentTraveler 4.0)"'
-}
-
-
-async def update_simple_info(url: str, game_name: str) -> Tuple[dict, int]:
-    info_path = DRAW_DATA_PATH / f"{game_name}.json"
-    try:
-        with info_path.open("r", encoding="utf8") as f:
-            data = json.load(f)
-    except (ValueError, FileNotFoundError):
-        data = {}
-    try:
-        response = await AsyncHttpx.get(url, timeout=7)
-        soup = BeautifulSoup(response.text, "lxml")
-        divs = get_char_divs(soup, game_name)
-        for div in divs:
-            type_lst = get_type_lst(div, game_name)
-            index = 0
-            for char_lst in type_lst:
-                try:
-                    contents = get_char_lst_contents(char_lst, game_name)
-                except AttributeError:
-                    continue
-                for char in contents[1:]:
-                    try:
-                        data = await retrieve_char_data(
-                            char, game_name, data, index
-                        )
-                    except AttributeError:
-                        continue
-                index += 1
-        data = await _last_check(data, game_name)
-    except TimeoutError:
-        logger.warning(f"更新 {game_name} 超时...")
-        return {}, 999
-    with info_path.open("w", encoding="utf8") as wf:
-        wf.write(json.dumps(data, ensure_ascii=False, indent=4))
-    return data, 200
-
-
-# 获取所有包含需要图片的divs
-def get_char_divs(soup: bs4.BeautifulSoup, game_name: str) -> bs4.element.ResultSet:
-    # if game_name == "pcr":
-    #     return soup.find_all("div", {"class": "tabbertab"})
-    if game_name in ["azur", "pcr"]:
-        return soup.find_all("div", {"class": "resp-tabs"})
-
-
-# 拿到所有类型
-def get_type_lst(div: bs4.element.Tag, game_name: str):
-    if game_name in ["pcr", "azur"]:
-        return div.find("div", {"class": "resp-tabs-container"}).find_all(
-            "div", {"class": "resp-tab-content"}
-        )
-
-
-# 获取所有角色div
-def get_char_lst_contents(char_lst: bs4.element.Tag, game_name: str):
-    contents = []
-    # print(len(char_lst.find_all('tr')))
-    if game_name == "pcr":
-        contents = char_lst.contents
-    if game_name == "azur":
-        contents = char_lst.find("table").find("tbody").contents[-1].find("td").contents
-    return [x for x in contents if x != "\n"]
-
-
-# 额外数据
-async def _last_check(
-    data: dict, game_name: str
-) -> dict:
-    if game_name == "azur":
-        idx = 1
-        for url in [
-            "https://patchwiki.biligame.com/images/blhx/thumb/1/15/pxho13xsnkyb546tftvh49etzdh74cf.png/60px"
-            "-舰娘头像外框普通.png",
-            "https://patchwiki.biligame.com/images/blhx/thumb/a/a9/k8t7nx6c8pan5vyr8z21txp45jxeo66.png/60px"
-            "-舰娘头像外框稀有.png",
-            "https://patchwiki.biligame.com/images/blhx/thumb/a/a5/5whkzvt200zwhhx0h0iz9qo1kldnidj.png/60px"
-            "-舰娘头像外框精锐.png",
-            "https://patchwiki.biligame.com/images/blhx/thumb/a/a2/ptog1j220x5q02hytpwc8al7f229qk9.png/60px-"
-            "舰娘头像外框超稀有.png",
-        ]:
-            await download_img(url, "azur", f"{idx}_star")
-            idx += 1
-        tasks = []
-        semaphore = asyncio.Semaphore(draw_config.SEMAPHORE)
-        for key in data.keys():
-            tasks.append(
-                asyncio.ensure_future(
-                    _async_update_azur_extra_info(key, semaphore)
-                )
-            )
-        result = await asyncio.gather(*tasks)
-        for x in result:
-            for key in x.keys():
-                data[key]["获取途径"] = x[key]["获取途径"]
-    return data
-
-
-azur_type = {
-    "0": "驱逐",
-    "1": "轻巡",
-    "2": "重巡",
-    "3": "超巡",
-    "4": "战巡",
-    "5": "战列",
-    "6": "航母",
-    "7": "航站",
-    "8": "轻航",
-    "9": "重炮",
-    "10": "维修",
-    "11": "潜艇",
-    "12": "运输",
-}
-
-
-# 整理数据
-async def retrieve_char_data(
-    char: bs4.element.Tag,
-    game_name: str,
-    data: dict,
-    index: int = 0,
-) -> dict:
-    member_dict = {}
-    if game_name == "pcr":
-        member_dict = {
-            "头像": unquote(char.find("a").find("img")["src"]),
-            "名称": remove_prohibited_str(char.find("a")["title"]),
-            "星级": 3 - index,
-        }
-    if game_name == "azur":
-        char = char.find("div").find("div").find("div")
-        avatar_img = char.find("a").find("img")
-        char = char.find("div")
-        try:
-            member_dict["名称"] = remove_prohibited_str(char.find("a")["title"])
-        except TypeError:
-            member_dict["名称"] = char.find("a")["title"][:-4]
-        try:
-            member_dict["头像"] = unquote(str(avatar_img["srcset"]).split(" ")[-2])
-        except KeyError:
-            member_dict["头像"] = unquote(str(avatar_img["src"]).split(" ")[-2])
-        except TypeError:
-            member_dict["头像"] = "img link not find..."
-            logger.warning(f'{member_dict["名称"]} 图片缺失....')
-        star = char.find("img")["alt"]
-        if star == "舰娘头像外框普通.png":
-            star = 1
-        elif star == "舰娘头像外框稀有.png":
-            star = 2
-        elif star == "舰娘头像外框精锐.png":
-            star = 3
-        elif star == "舰娘头像外框超稀有.png":
-            star = 4
-        elif star == "舰娘头像外框海上传奇.png":
-            star = 5
-        elif star in [
-            "舰娘头像外框最高方案.png",
-            "舰娘头像外框决战方案.png",
-            "舰娘头像外框超稀有META.png",
-            "舰娘头像外框精锐META.png",
-        ]:
-            star = 6
-        else:
-            star = 6
-        member_dict["星级"] = star
-        member_dict["类型"] = azur_type[str(index)]
-    await download_img(member_dict["头像"], game_name, member_dict["名称"])
-    data[member_dict["名称"]] = member_dict
-    logger.info(f'{member_dict["名称"]} is update...')
-    return data
-
-
-async def _async_update_azur_extra_info(
-    key: str, semaphore
-):
-    if key[-1] == "改":
-        return {key: {"获取途径": ["无法建造"]}}
-    async with semaphore:
-        for i in range(20):
-            try:
-                res = await AsyncHttpx.get(f"https://wiki.biligame.com/blhx/{key}", timeout=7)
-                soup = BeautifulSoup(res.text, "lxml")
-                try:
-                    construction_time = str(
-                        soup.find("table", {"class": "wikitable sv-general"}).find(
-                            "tbody"
-                        )
-                    )
-                    x = {key: {"获取途径": []}}
-                    if construction_time.find("无法建造") != -1:
-                        x[key]["获取途径"].append("无法建造")
-                    elif construction_time.find("活动已关闭") != -1:
-                        x[key]["获取途径"].append("活动限定")
-                    else:
-                        x[key]["获取途径"].append("可以建造")
-                    logger.info(f'碧蓝航线获取额外信息 {key}...{x[key]["获取途径"]}')
-                except AttributeError:
-                    x = {key: {"获取途径": []}}
-                    logger.warning(f"碧蓝航线获取额外信息错误 {key}...{[]}")
-                return x
-            except TimeoutError:
-                logger.warning(
-                    f"访问 https://wiki.biligame.com/blhx/{key} 第 {i}次 超时...已再次访问"
-                )
-    return {}

plugins/draw_card/util.py

@@ -1,346 +1,16 @@
 import platform
-from asyncio.exceptions import TimeoutError
-from utils.utils import cn2py
-from utils.http_utils import AsyncHttpx
-from typing import List, Tuple, Union, Set
-from .config import draw_config, DRAW_IMAGE_PATH
-import nonebot
-from PIL import UnidentifiedImageError
-from utils.image_utils import BuildImage
-from nonebot.adapters.onebot.v11 import MessageSegment
-from nonebot.log import logger
-import random
-from dataclasses import dataclass
-import os
-import asyncio
+import pypinyin
+from PIL.ImageFont import FreeTypeFont
+from PIL import Image, ImageDraw, ImageFont
+from PIL.Image import Image as IMG
+from configs.path_config import FONT_PATH
 
 
-driver = nonebot.get_driver()
-
-
-loop = asyncio.get_event_loop()
-
-
-@dataclass
-class BaseData:
-    name: str
-    star: int
-    limited: bool  # 限定
-
-
-@dataclass
-class UpEvent:
-    star: int  # 对应up星级
-    operators: List[BaseData]  # 干员列表
-    zoom: float  # up提升倍率
-
-
-async def download_img(url: str, path: str, name: str) -> bool:
-    path = path.split("_")[0]
-    codename = cn2py(name)
-    img_path = DRAW_IMAGE_PATH / f"{path}" / f"{codename}.png"
-    if not img_path.exists():
-        try:
-            if await AsyncHttpx.download_file(url, img_path):
-                logger.info(
-                    f"下载 {draw_config.path_dict[path]} 图片成功，名称：{name}，url：{url}"
-                )
-                return True
-        except TimeoutError:
-            logger.warning(f"下载 {draw_config.path_dict[path]} 图片超时，名称：{name}，url：{url}")
-        # logger.info(f'{path_dict[path]} 图片 {name} 已存在')
-    return False
-
-
-@driver.on_startup
-def _check_dir():
-    for dir_name in draw_config.path_dict.keys():
-        dir_path = DRAW_IMAGE_PATH / f"{dir_name}"
-        if not dir_path.exists():
-            dir_path.mkdir(parents=True, exist_ok=True)
-
-
-async def generate_img(
-    card_set: Union[Set[BaseData], List[BaseData]], game_name: str, star_list: list
-) -> str:
-    # try:
-    img_list = []
-    background_list = []
-    for x in card_set:
-        if game_name == "prts":
-            if x.star == 6:
-                background_list.append("#FFD700")
-            elif x.star == 5:
-                background_list.append("#DAA520")
-            elif x.star == 4:
-                background_list.append("#9370D8")
-            else:
-                background_list.append("white")
-        img_path = DRAW_IMAGE_PATH / f"{game_name}" / f"{x.star}_star.png"
-        if game_name == "azur":
-            if img_path.exists():
-                background_list.append(str(img_path))
-        py_name = cn2py(x.name)
-        img_list.append(str(DRAW_IMAGE_PATH / f"{game_name}" / f"{py_name}.png"))
-    img_len = len(img_list)
-    w = 100 * 10
-    if img_len <= 10:
-        w = 100 * img_len
-        h = 100
-    elif img_len % 10 == 0:
-        h = 100 * int(img_len / 10)
-    else:
-        h = 100 * int(img_len / 10) + 100
-    card_img = await asyncio.get_event_loop().run_in_executor(
-        None, _pst, h, img_list, game_name, background_list
-    )
-    num = 0
-    for n in star_list:
-        num += n
-    A = BuildImage(w, h)
-    A.paste(card_img)
-    return A.pic2bs4()
-
-
-def _pst(h: int, img_list: list, game_name: str, background_list: list):
-    card_img = BuildImage(100 * 10, h, 100, 100)
-    idx = 0
-    for img in img_list:
-        try:
-            if game_name == "prts":
-                bk = BuildImage(100, 100, color=background_list[idx])
-                b = BuildImage(94, 94, background=img)
-                bk.paste(b, (3, 3))
-                b = bk
-            elif game_name == "azur" and background_list:
-                bk = BuildImage(100, 100, background=background_list[idx])
-                b = BuildImage(98, 90, background=img)
-                bk.paste(b, (1, 5))
-                b = bk
-            else:
-                try:
-                    b = BuildImage(100, 100, background=img)
-                except UnidentifiedImageError as e:
-                    logger.warning(f"无法识别图片 已删除图片，下次更新重新下载... e：{e}")
-                    if os.path.exists(img):
-                        os.remove(img)
-                    b = BuildImage(100, 100, color="black")
-        except FileNotFoundError:
-            logger.warning(f"{img} not exists")
-            b = BuildImage(100, 100, color="black")
-        card_img.paste(b)
-        idx += 1
-    return card_img
-
-
-# 初始化输出数据
-def init_star_rst(
-    star_list: list,
-    cnlist: list,
-    max_star_list: list,
-    max_star_index_list: list,
-    up_list: list = None,
-) -> str:
-    if not up_list:
-        up_list = []
-    rst = ""
-    for i in range(len(star_list)):
-        if star_list[i]:
-            rst += f"[{cnlist[i]}×{star_list[i]}] "
-    rst += "\n"
-    for i in range(len(max_star_list)):
-        if max_star_list[i] in up_list:
-            rst += f"第 {max_star_index_list[i]+1} 抽获取UP {max_star_list[i]}\n"
-        else:
-            rst += f"第 {max_star_index_list[i]+1} 抽获取 {max_star_list[i]}\n"
-    return rst
-
-
-# 更好的初始化
-def init_rst(
-    max_star_char_dict: dict,
-    star_num_list: List[int],
-    star: List[str],
-    up_list: list = None,
-):
-    # print(max_star_char_dict)
-    # print(star_num_list)
-    # print(up_list)
-    up_list = up_list if up_list else []
-    rst = ""
-    for i in range(len(star_num_list)):
-        if star_num_list[i]:
-            rst += f"[{star[i]}×{star_num_list[i]}] "
-    rst += "\n"
-    _tmp = []
-    for name in max_star_char_dict.keys():
-        _tmp += max_star_char_dict[name]
-    for index in sorted(_tmp):
-        for name in max_star_char_dict.keys():
-            if index in max_star_char_dict[name]:
-                if name in up_list:
-                    rst += f"第 {index} 抽获取UP {name}\n"
-                else:
-                    rst += f"第 {index} 抽获取 {name}\n"
-    return rst[:-1] if rst else ""
-
-
-def max_card(_dict: dict):
-    _max_value = max(_dict.values())
-    _max_user = list(_dict.keys())[list(_dict.values()).index(_max_value)]
-    return f"抽取到最多的是{_max_user}，共抽取了{_max_value}次"
-    # ThreeHighest = nlargest(3, operator_dict, key=operator_dict.get)
-    # rst = '最喜欢你的前三位是干员是：\n'
-    # for name in ThreeHighest:
-    #     rst += f'{name} 共投了 {operator_dict[name]} 份简历\n'
-    # return rst[:-1]
-
-
-# 获取up和概率
-async def init_up_char(announcement):
-    UP_CHAR = []
-    UP_ARMS = []
-    tmp = ""
-    up_char_dict = await announcement.update_up_char()
-    for x in list(up_char_dict.keys()):
-        tmp += up_char_dict[x]["title"] + "[\n]"
-    tmp = tmp.split("[\n]")
-    _CURRENT_CHAR_POOL_TITLE = tmp[0]
-    if len(up_char_dict) > 1:
-        _CURRENT_ARMS_POOL_TITLE = tmp[1]
-    else:
-        _CURRENT_ARMS_POOL_TITLE = ""
-    POOL_IMG = ""
-    x = [x for x in list(up_char_dict.keys())]
-    if _CURRENT_CHAR_POOL_TITLE:
-        POOL_IMG += MessageSegment.image(up_char_dict[x[0]]["pool_img"])
-    try:
-        if _CURRENT_ARMS_POOL_TITLE:
-            POOL_IMG += MessageSegment.image(up_char_dict[x[1]]["pool_img"])
-    except (IndexError, KeyError):
-        pass
-    logger.info(
-        f"成功获取{announcement.game_name}当前up信息...当前up池: {_CURRENT_CHAR_POOL_TITLE} & {_CURRENT_ARMS_POOL_TITLE}"
-    )
-    for key in up_char_dict.keys():
-        for star in up_char_dict[key]["up_char"].keys():
-            up_char_lst = []
-            for char in up_char_dict[key]["up_char"][star].keys():
-                up_char_lst.append(char)
-            if up_char_lst:
-                if key == "char":
-                    UP_CHAR.append(
-                        UpEvent(star=int(star), operators=up_char_lst, zoom=0)
-                    )
-                else:
-                    UP_ARMS.append(
-                        UpEvent(star=int(star), operators=up_char_lst, zoom=0)
-                    )
-    return (
-        _CURRENT_CHAR_POOL_TITLE,
-        _CURRENT_ARMS_POOL_TITLE,
-        POOL_IMG,
-        UP_CHAR,
-        UP_ARMS,
-    )
-
-
-def is_number(s) -> bool:
-    try:
-        float(s)
-        return True
-    except ValueError:
-        pass
-    try:
-        import unicodedata
-
-        unicodedata.numeric(s)
-        return True
-    except (TypeError, ValueError):
-        pass
-    return False
-
-
-def set_list(lst: List[BaseData]) -> list:
-    tmp = []
-    name_lst = []
-    for x in lst:
-        if x.name not in name_lst:
-            tmp.append(x)
-            name_lst.append(x.name)
-    return tmp
-
-
-# 获取星级
-def get_star(star_lst: List[int], probability_lst: List[float]) -> int:
-    rand = random.random()
-    add = 0
-    tmp_lst = [(0, probability_lst[0])]
-    for i in range(1, len(probability_lst) - 1):
-        add += probability_lst[i - 1]
-        tmp_lst.append((tmp_lst[i - 1][1], probability_lst[i] + add))
-    tmp_lst.append((tmp_lst[-1][1], 1))
-    for i in range(len(tmp_lst)):
-        if tmp_lst[i][0] <= rand <= tmp_lst[i][1]:
-            return star_lst[i]
-
-
-# 整理数据
-def format_card_information(
-    count: int, star_list: List[int], func, pool_name: str = "", guaranteed: bool = True
-):
-    max_star_lst = []  # 获取的最高星级角色列表
-    max_index_lst = []  # 获取最高星级角色的次数
-    obj_list = []  # 获取所有角色
-    obj_dict = {}  # 获取角色次数字典
-    _count = -1
-    if guaranteed:
-        _count = 0
-    for i in range(count):
-        if guaranteed:
-            _count += 1
-        if pool_name:
-            if _count == 10:
-                obj, code = func(pool_name, 2)
-                _count = 0
-            else:
-                obj, code = func(pool_name)
-        else:
-            if _count == 10:
-                obj, code = func(mode=2)
-                _count = 0
-            else:
-                obj, code = func()
-        star_list[code] += 1
-        if code == 0:
-            max_star_lst.append(obj.name)
-            max_index_lst.append(i)
-            if guaranteed:
-                _count = 0
-        if code == 1:
-            if guaranteed:
-                _count = 0
-        try:
-            obj_dict[obj.name] += 1
-        except KeyError:
-            obj_dict[obj.name] = 1
-        obj_list.append(obj)
-    return obj_list, obj_dict, max_star_lst, star_list, max_index_lst
-
-
-# 检测次数是否合法
-def check_num(num: str, max_num: int) -> Tuple[str, bool]:
-    if is_number(num):
-        try:
-            num = int(num)
-        except ValueError:
-            return "必！须！是！数！字！", False
-    if num > max_num:
-        return "一井都满不足不了你嘛！快爬开！", False
-    if num < 1:
-        return "虚空抽卡？？？", False
-    else:
-        return str(num), True
+def cn2py(word) -> str:
+    temp = ""
+    for i in pypinyin.pinyin(word, style=pypinyin.NORMAL):
+        temp += "".join(i)
+    return temp
 
 
 # 移除windows和linux下特殊字符
@@ -354,3 +24,32 @@ def remove_prohibited_str(name: str) -> str:
     else:
         name = name.replace("/", "\\")
     return name
+
+
+def load_font(font_name: str = "msyh.ttf", fontsize: int = 16) -> FreeTypeFont:
+    return ImageFont.truetype(
+        str(FONT_PATH / f"{font_name}"), fontsize, encoding="utf-8"
+    )
+
+
+def circled_number(num: int) -> IMG:
+    font = load_font(fontsize=450)
+    text = str(num)
+    text_w = font.getsize(text)[0]
+    w = 240 + text_w
+    w = w if w >= 500 else 500
+    img = Image.new("RGBA", (w, 500))
+    draw = ImageDraw.Draw(img)
+    draw.ellipse(((0, 0), (500, 500)), fill="red")
+    draw.ellipse(((w - 500, 0), (w, 500)), fill="red")
+    draw.rectangle(((250, 0), (w - 250, 500)), fill="red")
+    draw.text(
+        (120, -60),
+        text,
+        font=font,
+        fill="white",
+        stroke_width=10,
+        stroke_fill="white",
+    )
+    return img
+

plugins/fudu.py

@@ -132,4 +132,4 @@ async def get_fudu_img_hash(url, group_id):
             logger.warning(f"复读下载图片失败...")
     except Exception as e:
         logger.warning(f"复读读取图片Hash出错 {type(e)}：{e}")
-        return ""
+    return ""

plugins/genshin/query_user/_models/__init__.py

@@ -254,10 +254,9 @@ class Genshin(db.Model):
         query = cls.query.where(cls.today_query_uid.contains(str(uid)))
         x = await query.gino.first()
         if x:
+            await cls._add_query_uid(uid, uid)
             return x.cookie
-        for u in [
-            x for x in await cls.query.order_by(db.func.random()).gino.all() if x.cookie
-        ]:
+        for u in await cls.query.where(cls.cookie != "").order_by(db.func.random()).gino.all():
             if not u.today_query_uid or len(u.today_query_uid[:-1].split()) < 30:
                 await cls._add_query_uid(uid, u.uid)
                 return u.cookie
@@ -356,7 +355,7 @@ class Genshin(db.Model):
         """
         query = cls.query.where(cls.uid == cookie_uid).with_for_update()
         user = await query.gino.first()
-        await user.update(today_query_uid=cls.today_query_uid + f"{uid} ").apply()
+        await user.update(today_query_uid=user.today_query_uid + f"{uid} ").apply()
 
     @classmethod
     async def _get_user_data(

plugins/genshin/query_user/genshin_sign/init_task.py

@@ -23,17 +23,17 @@ async def _():
     g_list = await Genshin.get_all_auto_sign_user()
     for u in g_list:
         if u.auto_sign_time:
-            date = await Genshin.random_sign_time(u.uid)
-            scheduler.add_job(
-                _sign,
-                "date",
-                run_date=date.replace(microsecond=0),
-                id=f"genshin_auto_sign_{u.uid}_{u.user_qq}_0",
-                args=[u.user_qq, u.uid, 0],
-            )
-            logger.info(
-                f"genshin_sign add_job：USER：{u.user_qq} UID：{u.uid} " f"{date} 原神自动签到"
-            )
+            if date := await Genshin.random_sign_time(u.uid):
+                scheduler.add_job(
+                    _sign,
+                    "date",
+                    run_date=date.replace(microsecond=0),
+                    id=f"genshin_auto_sign_{u.uid}_{u.user_qq}_0",
+                    args=[u.user_qq, u.uid, 0],
+                )
+                logger.info(
+                    f"genshin_sign add_job：USER：{u.user_qq} UID：{u.uid} " f"{date} 原神自动签到"
+                )
 
 
 def add_job(user_id: int, uid: int, date: datetime):

plugins/genshin/query_user/query_memo/data_source.py

@@ -200,7 +200,7 @@ def _parse_data_and_draw(
         file_name = x["avatar_side_icon"].split("_")[-1]
         role_avatar = memo_path / "role_avatar" / file_name
         _ava_img = BuildImage(75, 75, background=role_avatar)
-        _ava_img.circle()
+        # _ava_img.circle()
         if x["status"] == "Finished":
             msg = "探索完成"
             font_color = (146, 188, 63)
@@ -218,10 +218,10 @@ def _parse_data_and_draw(
         a_circle.circle()
         b_circle = BuildImage(47, 47)
         b_circle.circle()
-        a_circle.paste(b_circle, (4, 4), alpha=True)
-        _circle_bk.paste(a_circle, (4, 4), alpha=True)
+        a_circle.paste(b_circle, (4, 4), True)
+        _circle_bk.paste(a_circle, (4, 4), True)
 
-        _bk.paste(_circle_bk, (25, 0), True, center_type="by_height")
+        _bk.paste(_circle_bk, (25, 0), True, "by_height")
         _bk.paste(_ava_img, (19, -13), True)
         _bk.text((100, 0), msg, font_color, "by_height")
         _bk.circle_corner(20)

plugins/genshin/query_user/query_role/draw_image.py

@@ -296,9 +296,10 @@ def get_country_data_image(world_data_dict: Dict) -> BuildImage:
     画出国家探索供奉等图像
     :param world_data_dict: 国家数据字典
     """
-    region = BuildImage(790, 267 * len(world_data_dict), color="#F9F6F2")
+    # 层岩巨渊 和 地下矿区 算一个
+    region = BuildImage(790, 267 * (len(world_data_dict) - 1), color="#F9F6F2")
     height = 0
-    for country in ["蒙德", "龙脊雪山", "璃月", "稻妻", "渊下宫"]:
+    for country in ["蒙德", "龙脊雪山", "璃月", "层岩巨渊", "稻妻", "渊下宫"]:
         x = BuildImage(790, 250, color="#3A4467")
         logo = BuildImage(180, 180, background=image_path / "logo" / f"{country}.png")
         tmp_bk = BuildImage(770, 230, color="#606779")
@@ -320,6 +321,25 @@ def get_country_data_image(world_data_dict: Dict) -> BuildImage:
                 f"Lv.{world_data_dict[country]['level']}",
                 fill=(255, 255, 255),
             )
+        elif country in ["层岩巨渊"]:
+            content_bk.text((300, 20), "层岩巨渊探索", fill=(239, 211, 114))
+            content_bk.text(
+                (570, 20),
+                f"{world_data_dict['层岩巨渊']['exploration_percentage'] / 10}%",
+                fill=(255, 255, 255),
+            )
+            content_bk.text((300, 85), "地下矿区探索", fill=(239, 211, 114))
+            content_bk.text(
+                (570, 85),
+                f"{world_data_dict['层岩巨渊·地下矿区']['exploration_percentage'] / 10}%",
+                fill=(255, 255, 255),
+            )
+            content_bk.text((300, 150), "流明石触媒", fill=(239, 211, 114))
+            content_bk.text(
+                (570, 150),
+                f"LV.{world_data_dict['层岩巨渊·地下矿区']['offerings'][0]['level']}",
+                fill=(255, 255, 255),
+            )
         elif country in ["龙脊雪山"]:
             content_bk.text((300, 40), "探索", fill=(239, 211, 114))
             content_bk.text(

plugins/genshin/query_user/resin_remind/__init__.py

@@ -55,7 +55,7 @@ async def _(event: MessageEvent, cmd: Tuple[str, ...] = Command()):
         scheduler.remove_job(f"genshin_resin_remind_{uid}_{event.user_id}")
     except JobLookupError:
         pass
-    if cmd == "开":
+    if cmd[0] == "开":
         await Genshin.set_resin_remind(uid, True)
         add_job(event.user_id, uid)
         logger.info(

plugins/genshin/query_user/resin_remind/init_task.py

@@ -5,6 +5,7 @@ from apscheduler.jobstores.base import ConflictingIdError
 from nonebot import Driver
 from .._models import Genshin
 from datetime import datetime, timedelta
+from apscheduler.jobstores.base import JobLookupError
 from services.log import logger
 from nonebot.plugin import require
 from configs.config import Config
@@ -19,6 +20,9 @@ driver: Driver = nonebot.get_driver()
 get_memo = require("query_memo").get_memo
 
 
+global_map = {}
+
+
 class UserManager:
     def __init__(self, max_error_count: int = 3):
         self._data = []
@@ -108,6 +112,11 @@ async def _():
 
 
 def add_job(user_id: int, uid: int):
+    # 移除
+    try:
+        scheduler.remove_job(f"genshin_resin_remind_{uid}_{user_id}")
+    except JobLookupError:
+        pass
     date = datetime.now(pytz.timezone("Asia/Shanghai")) + timedelta(seconds=30)
     try:
         scheduler.add_job(
@@ -140,8 +149,8 @@ async def _remind(user_id: int, uid: str):
         if current_resin < max_resin:
             user_manager.remove(uid)
             user_manager.remove_overflow(uid)
-        if max_resin - 40 <= current_resin <= max_resin - 20:
-            next_time = now + timedelta(minutes=(max_resin - 20 - current_resin) * 8, seconds=10)
+        if max_resin - 40 < current_resin <= max_resin - 20:
+            next_time = now + timedelta(minutes=(max_resin - 20 - current_resin + 1) * 8, seconds=10)
         elif current_resin < max_resin:
             next_time = now + timedelta(minutes=(max_resin - current_resin) * 8, seconds=10)
         elif current_resin == max_resin:
@@ -183,6 +192,7 @@ async def _remind(user_id: int, uid: str):
         user_manager.remove_error_count(uid)
     await Genshin.set_user_resin_recovery_time(int(uid), next_time)
     scheduler.add_job(
+        _remind,
         _remind,
         "date",
         run_date=next_time,

plugins/group_welcome_msg.py

@@ -37,7 +37,7 @@ async def _(event: GroupMessageEvent):
     img = ""
     msg = ""
     if (DATA_PATH / "custom_welcome_msg" / f"{event.group_id}.jpg").exists():
-        img = image(abspath=DATA_PATH / "custom_welcome_msg" / f"{event.group_id}.jpg")
+        img = image(DATA_PATH / "custom_welcome_msg" / f"{event.group_id}.jpg")
     custom_welcome_msg_json = (
        DATA_PATH / "custom_welcome_msg" / "custom_welcome_msg.json"
     )

plugins/music/__init__.py

@@ -0,0 +1,54 @@
+from .music_163 import get_song_id, get_song_info
+from nonebot.adapters.onebot.v11 import Bot, MessageEvent, GroupMessageEvent, Message
+from nonebot.params import CommandArg
+from nonebot.typing import T_State
+from services.log import logger
+from nonebot import on_command
+from utils.message_builder import music
+
+
+__zx_plugin_name__ = "点歌"
+__plugin_usage__ = """
+usage：
+    在线点歌
+    指令：
+        点歌 [歌名]
+""".strip()
+__plugin_des__ = "为你点播了一首曾经的歌"
+__plugin_cmd__ = ["点歌 [歌名]"]
+__plugin_type__ = ("一些工具",)
+__plugin_version__ = 0.1
+__plugin_author__ = "HibiKier"
+__plugin_settings__ = {
+    "level": 5,
+    "default_status": True,
+    "limit_superuser": False,
+    "cmd": ["点歌"],
+}
+
+
+music_handler = on_command("点歌", priority=5, block=True)
+
+
+@music_handler.handle()
+async def handle_first_receive(state: T_State, arg: Message = CommandArg()):
+    if args := arg.extract_plain_text().strip():
+        state["song_name"] = args
+
+
+@music_handler.got("song_name", prompt="歌名是？")
+async def _(bot: Bot, event: MessageEvent, state: T_State):
+    song = state["song_name"]
+    song_id = await get_song_id(song)
+    if not song_id:
+        await music_handler.finish("没有找到这首歌！", at_sender=True)
+    await music_handler.send(music("163", song_id))
+    logger.info(
+        f"(USER {event.user_id}, GROUP "
+        f"{event.group_id if isinstance(event, GroupMessageEvent) else 'private'})"
+        f" 点歌 :{song}"
+    )
+
+
+
+

plugins/music/music_163.py

@@ -1,41 +1,41 @@
-from utils.http_utils import AsyncHttpx
-import json
-
-
-headers = {"referer": "http://music.163.com"}
-cookies = {"appver": "2.0.2"}
-
-
-async def search_song(song_name: str):
-    """
-    搜索歌曲
-    :param song_name: 歌名
-    """
-    r = await AsyncHttpx.post(
-        f"http://music.163.com/api/search/get/",
-        data={"s": song_name, "limit": 1, "type": 1, "offset": 0},
-    )
-    if r.status_code != 200:
-        return None
-    return json.loads(r.text)
-
-
-async def get_song_id(song_name: str) -> int:
-    """ """
-    r = await search_song(song_name)
-    try:
-        return r["result"]["songs"][0]["id"]
-    except KeyError:
-        return 0
-
-
-async def get_song_info(songId: int):
-    """
-    获取歌曲信息
-    """
-    r = await AsyncHttpx.post(
-        f"http://music.163.com/api/song/detail/?id={songId}&ids=%5B{songId}%5D",
-    )
-    if r.status_code != 200:
-        return None
-    return json.loads(r.text)
+from utils.http_utils import AsyncHttpx
+import json
+
+
+headers = {"referer": "http://music.163.com"}
+cookies = {"appver": "2.0.2"}
+
+
+async def search_song(song_name: str):
+    """
+    搜索歌曲
+    :param song_name: 歌名
+    """
+    r = await AsyncHttpx.post(
+        f"http://music.163.com/api/search/get/",
+        data={"s": song_name, "limit": 1, "type": 1, "offset": 0},
+    )
+    if r.status_code != 200:
+        return None
+    return json.loads(r.text)
+
+
+async def get_song_id(song_name: str) -> int:
+    """ """
+    r = await search_song(song_name)
+    try:
+        return r["result"]["songs"][0]["id"]
+    except KeyError:
+        return 0
+
+
+async def get_song_info(songId: int):
+    """
+    获取歌曲信息
+    """
+    r = await AsyncHttpx.post(
+        f"http://music.163.com/api/song/detail/?id={songId}&ids=%5B{songId}%5D",
+    )
+    if r.status_code != 200:
+        return None
+    return json.loads(r.text)

plugins/one_friend/__init__.py

@@ -1,9 +1,8 @@
 from io import BytesIO
 from random import choice
 from nonebot import on_regex
-from nonebot.typing import T_State
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent
-from utils.utils import get_message_at, get_user_avatar
+from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, Message
+from utils.utils import get_message_at, get_user_avatar, get_message_text
 from utils.message_builder import image
 from utils.image_utils import BuildImage
 from nonebot.params import RegexGroup
@@ -28,14 +27,14 @@ __plugin_settings__ = {
 }
 
 one_friend = on_regex(
-    "^我.*?朋友.*?(想问问|说|让我问问|想问|让我问|想知道|让我帮他问问|让我帮他问|让我帮忙问|让我帮忙问问|问)(.*)",
+    "^我.*?朋友.*?[想问问|说|让我问问|想问|让我问|想知道|让我帮他问问|让我帮他问|让我帮忙问|让我帮忙问问|问](.*)",
     priority=4,
     block=True,
 )
 
 
 @one_friend.handle()
-async def _(bot: Bot, event: GroupMessageEvent, state: T_State, reg_group: Tuple[Any, ...] = RegexGroup()):
+async def _(bot: Bot, event: GroupMessageEvent, reg_group: Tuple[Any, ...] = RegexGroup()):
     qq = get_message_at(event.json())
     if not qq:
         qq = choice(
@@ -51,7 +50,7 @@ async def _(bot: Bot, event: GroupMessageEvent, state: T_State, reg_group: Tuple
         qq = qq[0]
         at_user = await bot.get_group_member_info(group_id=event.group_id, user_id=qq)
         user_name = at_user["card"] or at_user["nickname"]
-    msg = reg_group[1]
+    msg = get_message_text(Message(reg_group[0])).strip()
     if not msg:
         msg = "都不知道问什么"
     msg = msg.replace("他", "我").replace("她", "我").replace("它", "我")

plugins/pid_search.py

@@ -84,7 +84,7 @@ async def _(event: MessageEvent, state: T_State, pid: str = Arg("pid")):
                     f"pid：{pid}\n"
                     f"author：{author}\n"
                     f"author_id：{author_id}\n"
-                    f'{image(f"pid_search_{event.user_id}.png", "temp")}'
+                    f'{image(TEMP_PATH / f"pid_search_{event.user_id}.png")}'
                     f"{tmp}"
                 )
             )

plugins/pix_gallery/_data_source.py

@@ -235,10 +235,10 @@ async def get_image(img_url: str, user_id: int) -> Optional[str]:
                 img_url = old_img_url
                 continue
             async with aiofiles.open(
-                TEMP_PATH / f"pix_{user_id}_{img_url[-10:-4]}.jpg", "wb"
+                TEMP_PATH / f"pix_{user_id}_{img_url.split('/')[-1][:-4]}.jpg", "wb"
             ) as f:
                 await f.write(response.content)
-            return TEMP_PATH / f"pix_{user_id}_{img_url[-10:-4]}.jpg"
+            return TEMP_PATH / f"pix_{user_id}_{img_url.split('/')[-1][:-4]}.jpg"
         except TimeoutError:
             logger.warning(f"PIX：{img_url} 图片下载超时...")
             pass

plugins/pix_gallery/pix.py

@@ -1,15 +1,10 @@
 from utils.utils import is_number
 from configs.config import Config
 from ._model.omega_pixiv_illusts import OmegaPixivIllusts
-from utils.message_builder import image
+from utils.message_builder import image, custom_forward_msg
 from utils.manager import withdraw_message_manager
 from services.log import logger
-from nonebot.adapters.onebot.v11 import (
-    Bot,
-    MessageEvent,
-    GroupMessageEvent,
-    Message
-)
+from nonebot.adapters.onebot.v11 import Bot, MessageEvent, GroupMessageEvent, Message
 from nonebot.params import CommandArg
 from ._data_source import get_image
 from ._model.pixiv import Pixiv
@@ -49,6 +44,13 @@ __plugin_settings__ = {
     "cmd": ["pix", "Pix", "PIX", "pIx"],
 }
 __plugin_block_limit__ = {"rst": "您有PIX图片正在处理，请稍等..."}
+__plugin_configs__ = {
+    "MAX_ONCE_NUM2FORWARD": {
+        "value": None,
+        "help": "单次发送的图片数量达到指定值时转发为合并消息",
+        "default_value": None,
+    }
+}
 
 
 pix = on_command("pix", aliases={"PIX", "Pix"}, priority=5, block=True)
@@ -64,12 +66,12 @@ async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
     if PIX_RATIO is None:
         pix_omega_pixiv_ratio = Config.get_config("pix", "PIX_OMEGA_PIXIV_RATIO")
         PIX_RATIO = pix_omega_pixiv_ratio[0] / (
-                pix_omega_pixiv_ratio[0] + pix_omega_pixiv_ratio[1]
+            pix_omega_pixiv_ratio[0] + pix_omega_pixiv_ratio[1]
         )
         OMEGA_RATIO = 1 - PIX_RATIO
     num = 1
     keyword = arg.extract_plain_text().strip()
-    x = keyword.split(" ")
+    x = keyword.split()
     if "-s" in x:
         x.remove("-s")
         nsfw_tag = 1
@@ -80,12 +82,15 @@ async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
         nsfw_tag = 0
     if nsfw_tag != 0 and str(event.user_id) not in bot.config.superusers:
         await pix.finish("你不能看这些噢，这些都是是留给管理员看的...")
-    if len(x) > 1:
+    if n := len(x) == 1 and is_number(x[0]):
+        num = int(x[-1])
+        keyword = ""
+    elif n > 1:
         if is_number(x[-1]):
             num = int(x[-1])
             if num > 10:
                 if str(event.user_id) not in bot.config.superusers or (
-                        str(event.user_id) in bot.config.superusers and num > 30
+                    str(event.user_id) in bot.config.superusers and num > 30
                 ):
                     num = random.randint(1, 10)
                     await pix.send(f"太贪心了，就给你发 {num}张 好了")
@@ -125,11 +130,12 @@ async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
                 tmp_.append(x.pid)
     if not all_image:
         await pix.finish(f"未在图库中找到与 {keyword} 相关Tag/UID/PID的图片...", at_sender=True)
+    msg_list = []
     for _ in range(num):
         img_url = None
         author = None
-        if not all_image:
-            await pix.finish("坏了...发完了，没图了...")
+        # if not all_image:
+        #     await pix.finish("坏了...发完了，没图了...")
         img = random.choice(all_image)
         all_image.remove(img)
         if isinstance(img, OmegaPixivIllusts):
@@ -144,7 +150,7 @@ async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
         _img = await get_image(img_url, event.user_id)
         if _img:
             if Config.get_config("pix", "SHOW_INFO"):
-                msg_id = await pix.send(
+                msg_list.append(
                     Message(
                         f"title：{title}\n"
                         f"author：{author}\n"
@@ -153,16 +159,31 @@ async def _(bot: Bot, event: MessageEvent, arg: Message = CommandArg()):
                     )
                 )
             else:
-                msg_id = await pix.send(image(_img))
+                msg_list.append(image(_img))
             logger.info(
                 f"(USER {event.user_id}, GROUP {event.group_id if isinstance(event, GroupMessageEvent) else 'private'})"
                 f" 查看PIX图库PID: {pid}"
             )
         else:
-            msg_id = await pix.send(f"下载图片似乎出了一点问题，PID：{pid}")
+            msg_list.append("这张图似乎下载失败了")
             logger.info(
                 f"(USER {event.user_id}, GROUP {event.group_id if isinstance(event, GroupMessageEvent) else 'private'})"
                 f" 查看PIX图库PID: {pid}，下载图片出错"
             )
-        withdraw_message_manager.withdraw_message(event, msg_id, Config.get_config("pix", "WITHDRAW_PIX_MESSAGE"))
-
+    if (
+        Config.get_config("pix", "MAX_ONCE_NUM2FORWARD")
+        and num >= Config.get_config("pix", "MAX_ONCE_NUM2FORWARD")
+        and isinstance(event, GroupMessageEvent)
+    ):
+        msg_id = await bot.send_group_forward_msg(
+            group_id=event.group_id, messages=custom_forward_msg(msg_list, bot.self_id)
+        )
+        withdraw_message_manager.withdraw_message(
+            event, msg_id, Config.get_config("pix", "WITHDRAW_PIX_MESSAGE")
+        )
+    else:
+        for msg in msg_list:
+            msg_id = await pix.send(msg)
+            withdraw_message_manager.withdraw_message(
+                event, msg_id, Config.get_config("pix", "WITHDRAW_PIX_MESSAGE")
+            )

plugins/poke/__init__.py

@@ -64,8 +64,8 @@ async def _poke_event(event: PokeNotifyEvent):
         rand = random.random()
         if rand <= 0.3:
             path = random.choice(["luoli", "meitu"])
-            index = random.randint(0, len(os.listdir(IMAGE_PATH / path)))
-            result = f"id：{index}" + image(f"{index}.jpg", path)
+            index = random.randint(0, len(os.listdir(IMAGE_PATH / "image_management" / path)))
+            result = f"id：{index}" + image(f"{index}.jpg", "image_management/" + path)
             await poke_.send(result)
             logger.info(f"USER {event.user_id} 戳了戳我 回复: {result} \n {result}")
         elif 0.3 < rand < 0.6:

plugins/search_image/__init__.py

@@ -0,0 +1,91 @@
+from nonebot.plugin import on_command
+from nonebot.adapters.onebot.v11 import Bot, MessageEvent, GroupMessageEvent, Message
+from nonebot.typing import T_State
+from services.log import logger
+from utils.utils import get_message_img
+from utils.message_builder import custom_forward_msg
+from nonebot.params import CommandArg, Arg, ArgStr, Depends
+from .saucenao import get_saucenao_image
+
+
+__zx_plugin_name__ = "识图"
+__plugin_usage__ = """
+usage：
+    识别图片 [二次元图片]
+    指令：
+        识图 [图片]
+""".strip()
+__plugin_des__ = "以图搜图，看破本源"
+__plugin_cmd__ = ["识图"]
+__plugin_type__ = ("一些工具",)
+__plugin_version__ = 0.1
+__plugin_author__ = "HibiKier"
+__plugin_settings__ = {
+    "level": 5,
+    "default_status": True,
+    "limit_superuser": False,
+    "cmd": ["识图"],
+}
+__plugin_configs__ = {
+    "MAX_FIND_IMAGE_COUNT": {"value": 3, "help": "识图返回的最大结果数", "default_value": 3},
+    "API_KEY": {
+        "value": None,
+        "help": "Saucenao的API_KEY，通过 https://saucenao.com/user.php?page=search-api 注册获取",
+    },
+}
+
+
+search_image = on_command("识图", block=True, priority=5)
+
+
+async def get_image_info(mod: str, url: str):
+    if mod == "saucenao":
+        return await get_saucenao_image(url)
+
+
+def parse_image(key: str):
+    async def _key_parser(
+        state: T_State, img: Message = Arg(key)
+    ):
+        if not get_message_img(img):
+            await search_image.reject_arg(key, "请发送要识别的图片！")
+        state[key] = img
+    return _key_parser
+
+
+@search_image.handle()
+async def _(bot: Bot, event: MessageEvent, state: T_State, arg: Message = CommandArg()):
+    msg = arg.extract_plain_text().strip()
+    if msg:
+        state["mod"] = msg
+    else:
+        state["mod"] = "saucenao"
+    if get_message_img(event.json()):
+        state["img"] = event.message
+
+
+@search_image.got("img", prompt="图来！", parameterless=[Depends(parse_image("img"))])
+async def _(
+    bot: Bot,
+    event: MessageEvent,
+    state: T_State,
+    mod: str = ArgStr("mod"),
+    img: Message = Arg("img"),
+):
+    img = get_message_img(img)[0]
+    await search_image.send("开始处理图片...")
+    msg = await get_image_info(mod, img)
+    if isinstance(msg, str):
+        await search_image.finish(msg, at_sender=True)
+    if isinstance(event, GroupMessageEvent):
+        await bot.send_group_forward_msg(
+            group_id=event.group_id, messages=custom_forward_msg(msg, bot.self_id)
+        )
+    else:
+        for m in msg[1:]:
+            await search_image.send(m)
+    logger.info(
+        f"(USER {event.user_id}, GROUP "
+        f"{event.group_id if isinstance(event, GroupMessageEvent) else 'private'})"
+        f" 识图:" + img
+    )

plugins/search_image/saucenao.py

@@ -0,0 +1,50 @@
+from utils.http_utils import AsyncHttpx
+from configs.config import Config
+from configs.path_config import TEMP_PATH
+from utils.message_builder import image
+from typing import Union, List
+import random
+
+API_URL_SAUCENAO = "https://saucenao.com/search.php"
+API_URL_ASCII2D = "https://ascii2d.net/search/url/"
+API_URL_IQDB = "https://iqdb.org/"
+
+
+async def get_saucenao_image(url: str) -> Union[str, List[str]]:
+    api_key = Config.get_config("search_image", "API_KEY")
+    if not api_key:
+        return "Saucenao 缺失API_KEY！"
+
+    params = {
+        "output_type": 2,
+        "api_key": api_key,
+        "testmode": 1,
+        "numres": 6,
+        "db": 999,
+        "url": url,
+    }
+    data = (await AsyncHttpx.post(API_URL_SAUCENAO, params=params)).json()
+    if data["header"]["status"] != 0:
+        return "Saucenao识图失败.."
+    data = data["results"]
+    data = (
+        data
+        if len(data) < Config.get_config("search_image", "MAX_FIND_IMAGE_COUNT")
+        else data[: Config.get_config("search_image", "MAX_FIND_IMAGE_COUNT")]
+    )
+    msg_list = []
+    index = random.randint(0, 10000)
+    if await AsyncHttpx.download_file(
+            url, TEMP_PATH / f"saucenao_search_{index}.jpg"
+    ):
+        msg_list.append(image(TEMP_PATH / f"saucenao_search_{index}.jpg"))
+    for info in data:
+        similarity = info["header"]["similarity"]
+        tmp = f"相似度：{similarity}%\n"
+        for x in info["data"].keys():
+            if x != "ext_urls":
+                tmp += f"{x}：{info['data'][x]}\n"
+        if "source" not in info["data"].keys():
+            tmp += f'source：{info["data"]["ext_urls"][0]}\n'
+        msg_list.append(tmp[:-1])
+    return msg_list

plugins/send_setu_/_model.py

@@ -144,7 +144,6 @@ class Setu(db.Model):
             return _tmp_local_id
         return -1
 
-
     @classmethod
     async def update_setu_data(
         cls,

plugins/statistics/statistics_handle.py

@@ -1,280 +1,279 @@
-from nonebot import on_command
-from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, MessageEvent, Message
-from models.group_info import GroupInfo
-from configs.path_config import DATA_PATH, IMAGE_PATH
-from nonebot.params import CommandArg, Command
-from utils.image_utils import BuildMat
-from utils.message_builder import image
-from utils.manager import plugins2settings_manager
-from typing import Tuple
-import asyncio
-import os
-
-try:
-    import ujson as json
-except ModuleNotFoundError:
-    import json
-
-
-__zx_plugin_name__ = "功能调用统计可视化"
-__plugin_usage__ = """
-usage：
-    功能调用统计可视化
-    指令：
-        功能调用统计
-        日功能调用统计
-        周功能调用统计 ?[功能]
-        月功能调用统计 ?[功能]
-        我的功能调用统计
-        我的日功能调用统计 ?[功能]
-        我的周功能调用统计 ?[功能]
-        我的月功能调用统计 ?[功能]
-""".strip()
-__plugin_superuser_usage__ = """
-usage：
-    功能调用统计可视化
-    指令：
-        全局功能调用统计
-        全局日功能调用统计
-        全局周功能调用统计 ?[功能]
-        全局月功能调用统计 ?[功能]
-""".strip()
-__plugin_des__ = "功能调用统计可视化"
-__plugin_cmd__ = [
-    "功能调用统计",
-    "全局功能调用统计 [_superuser]",
-    "全局日功能调用统计 [_superuser]",
-    "全局周功能调用统计 ?[功能] [_superuser]",
-    "全局月功能调用统计 ?[功能] [_superuser]",
-    "周功能调用统计 ?[功能]",
-    "月功能调用统计 ?[功能]",
-    "我的功能调用统计",
-    "我的日功能调用统计 ?[功能]",
-    "我的周功能调用统计 ?[功能]",
-    "我的月功能调用统计 ?[功能]",
-]
-__plugin_type__ = ("功能调用统计可视化", 1)
-__plugin_version__ = 0.1
-__plugin_author__ = "HibiKier"
-__plugin_settings__ = {
-    "level": 5,
-    "default_status": True,
-    "limit_superuser": False,
-    "cmd": ["功能调用统计"],
-}
-
-
-statistics = on_command(
-    "功能调用统计",
-    aliases={
-        "全局功能调用统计",
-        "全局日功能调用统计",
-        "全局周功能调用统计",
-        "全局月功能调用统计",
-        "日功能调用统计",
-        "周功能调用统计",
-        "月功能调用统计",
-        "我的功能调用统计",
-        "我的日功能调用统计",
-        "我的周功能调用统计",
-        "我的月功能调用统计",
-    },
-    priority=5,
-    block=True,
-)
-
-
-statistics_group_file = DATA_PATH / "statistics" / "_prefix_count.json"
-statistics_user_file = DATA_PATH / "statistics" / "_prefix_user_count.json"
-
-
-@statistics.handle()
-async def _(bot: Bot, event: MessageEvent, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    if cmd[0][:2] == "全局":
-        if str(event.user_id) in bot.config.superusers:
-            data: dict = json.load(open(statistics_group_file, "r", encoding="utf8"))
-            if cmd[0][2] == '日':
-                _type = 'day_statistics'
-            elif cmd[0][2] == '周':
-                _type = 'week_statistics'
-            elif cmd[0][2] == '月':
-                _type = 'month_statistics'
-            else:
-                _type = 'total_statistics'
-            tmp_dict = {}
-            data = data[_type]
-            if _type in ["day_statistics", "total_statistics"]:
-                for key in data['total']:
-                    tmp_dict[key] = data['total'][key]
-            else:
-                for group in data.keys():
-                    if group != 'total':
-                        for day in data[group].keys():
-                            for plugin_name in data[group][day].keys():
-                                if data[group][day][plugin_name] is not None:
-                                    if tmp_dict.get(plugin_name) is None:
-                                        tmp_dict[plugin_name] = 1
-                                    else:
-                                        tmp_dict[plugin_name] += data[group][day][plugin_name]
-            bar_graph = await init_bar_graph(tmp_dict, cmd[0])
-            await asyncio.get_event_loop().run_in_executor(None, bar_graph.gen_graph)
-            await statistics.finish(image(b64=bar_graph.pic2bs4()))
-        return
-    if cmd[0][:2] == "我的":
-        _type = "user"
-        key = str(event.user_id)
-        cmd = list(cmd)
-        cmd[0] = cmd[0][2:]
-        if not statistics_user_file.exists():
-            await statistics.finish("统计文件不存在...", at_sender=True)
-    else:
-        if not isinstance(event, GroupMessageEvent):
-            await statistics.finish("请在群内调用此功能...")
-        _type = "group"
-        key = str(event.group_id)
-        if not statistics_group_file.exists():
-            await statistics.finish("统计文件不存在...", at_sender=True)
-    plugin = ""
-    if cmd[0][0] == "日":
-        arg = "day_statistics"
-    elif cmd[0][0] == "周":
-        arg = "week_statistics"
-    elif cmd[0][0] == "月":
-        arg = "month_statistics"
-    else:
-        arg = "total_statistics"
-    if msg:
-        plugin = plugins2settings_manager.get_plugin_module(msg)
-        if not plugin:
-            if arg not in ["day_statistics", "total_statistics"]:
-                await statistics.finish("未找到此功能的调用...", at_sender=True)
-    if _type == "group":
-        data: dict = json.load(open(statistics_group_file, "r", encoding="utf8"))
-        if not data[arg].get(str(event.group_id)):
-            await statistics.finish("该群统计数据不存在...", at_sender=True)
-    else:
-        data: dict = json.load(open(statistics_user_file, "r", encoding="utf8"))
-        if not data[arg].get(str(event.user_id)):
-            await statistics.finish("该用户统计数据不存在...", at_sender=True)
-    day_index = data["day_index"]
-    data = data[arg][key]
-    if _type == "group":
-        name = await GroupInfo.get_group_info(event.group_id)
-        name = name.group_name if name else str(event.group_id)
-    else:
-        name = event.sender.card or event.sender.nickname
-    img = await generate_statistics_img(data, arg, name, plugin, day_index)
-    await statistics.send(image(b64=img))
-
-
-async def generate_statistics_img(
-    data: dict, arg: str, name: str, plugin: str, day_index: int
-):
-    try:
-        plugin = plugins2settings_manager.get_plugin_data(plugin)['cmd'][0]
-    except (KeyError, IndexError):
-        pass
-    bar_graph = None
-    if arg == "day_statistics":
-        bar_graph = await init_bar_graph(data, f"{name} 日功能调用统计")
-    elif arg == "week_statistics":
-        if plugin:
-            current_week = day_index % 7
-            week_lst = []
-            if current_week == 0:
-                week_lst = [1, 2, 3, 4, 5, 6, 7]
-            else:
-                for i in range(current_week + 1, 7):
-                    week_lst.append(str(i))
-                for i in range(current_week + 1):
-                    week_lst.append(str(i))
-            count = []
-            for i in range(7):
-                if int(week_lst[i]) == 7:
-                    try:
-                        count.append(data[str(0)][plugin])
-                    except KeyError:
-                        count.append(0)
-                else:
-                    try:
-                        count.append(data[str(week_lst[i])][plugin])
-                    except KeyError:
-                        count.append(0)
-            week_lst = ["7" if i == "0" else i for i in week_lst]
-            bar_graph = BuildMat(
-                y=count,
-                mat_type="line",
-                title=f"{name} 周 {plugin} 功能调用统计【为7天统计】",
-                x_index=week_lst,
-                display_num=True,
-                background=[
-                    f"{IMAGE_PATH}/background/create_mat/{x}"
-                    for x in os.listdir(f"{IMAGE_PATH}/background/create_mat")
-                ],
-                bar_color=["*"],
-            )
-        else:
-            bar_graph = await init_bar_graph(update_data(data), f"{name} 周功能调用统计【为7天统计】")
-    elif arg == "month_statistics":
-        if plugin:
-            day_index = day_index % 30
-            day_lst = []
-            for i in range(day_index + 1, 30):
-                day_lst.append(i)
-            for i in range(day_index + 1):
-                day_lst.append(i)
-            count = [data[str(day_lst[i])][plugin] for i in range(30)]
-            day_lst = [str(x + 1) for x in day_lst]
-            bar_graph = BuildMat(
-                y=count,
-                mat_type="line",
-                title=f"{name} 月 {plugin} 功能调用统计【为30天统计】",
-                x_index=day_lst,
-                display_num=True,
-                background=[
-                    f"{IMAGE_PATH}/background/create_mat/{x}"
-                    for x in os.listdir(f"{IMAGE_PATH}/background/create_mat")
-                ],
-                bar_color=["*"],
-            )
-        else:
-            bar_graph = await init_bar_graph(update_data(data), f"{name} 月功能调用统计【为30天统计】")
-    elif arg == "total_statistics":
-        bar_graph = await init_bar_graph(data, f"{name} 功能调用统计")
-    await asyncio.get_event_loop().run_in_executor(None, bar_graph.gen_graph)
-    return bar_graph.pic2bs4()
-
-
-async def init_bar_graph(data: dict, title: str) -> BuildMat:
-    return await asyncio.get_event_loop().run_in_executor(None, _init_bar_graph, data, title)
-
-
-def _init_bar_graph(data: dict, title: str) -> BuildMat:
-    bar_graph = BuildMat(
-        y=[data[x] for x in data.keys() if data[x] != 0],
-        mat_type="barh",
-        title=title,
-        x_index=[x for x in data.keys() if data[x] != 0],
-        display_num=True,
-        background=[
-            f"{IMAGE_PATH}/background/create_mat/{x}"
-            for x in os.listdir(f"{IMAGE_PATH}/background/create_mat")
-        ],
-        bar_color=["*"],
-    )
-    return bar_graph
-
-
-def update_data(data: dict):
-    tmp_dict = {}
-    for day in data.keys():
-        for plugin_name in data[day].keys():
-            # print(f'{day}：{plugin_name} = {data[day][plugin_name]}')
-            if data[day][plugin_name] is not None:
-                if tmp_dict.get(plugin_name) is None:
-                    tmp_dict[plugin_name] = 1
-                else:
-                    tmp_dict[plugin_name] += data[day][plugin_name]
-    return tmp_dict
-
+from nonebot import on_command
+from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, MessageEvent, Message
+from models.group_info import GroupInfo
+from configs.path_config import DATA_PATH, IMAGE_PATH
+from nonebot.params import CommandArg, Command
+from utils.image_utils import BuildMat
+from utils.message_builder import image
+from utils.manager import plugins2settings_manager
+from typing import Tuple
+import asyncio
+import os
+
+try:
+    import ujson as json
+except ModuleNotFoundError:
+    import json
+
+
+__zx_plugin_name__ = "功能调用统计可视化"
+__plugin_usage__ = """
+usage：
+    功能调用统计可视化
+    指令：
+        功能调用统计
+        日功能调用统计
+        周功能调用统计 ?[功能]
+        月功能调用统计 ?[功能]
+        我的功能调用统计
+        我的日功能调用统计 ?[功能]
+        我的周功能调用统计 ?[功能]
+        我的月功能调用统计 ?[功能]
+""".strip()
+__plugin_superuser_usage__ = """
+usage：
+    功能调用统计可视化
+    指令：
+        全局功能调用统计
+        全局日功能调用统计
+        全局周功能调用统计 ?[功能]
+        全局月功能调用统计 ?[功能]
+""".strip()
+__plugin_des__ = "功能调用统计可视化"
+__plugin_cmd__ = [
+    "功能调用统计",
+    "全局功能调用统计 [_superuser]",
+    "全局日功能调用统计 [_superuser]",
+    "全局周功能调用统计 ?[功能] [_superuser]",
+    "全局月功能调用统计 ?[功能] [_superuser]",
+    "周功能调用统计 ?[功能]",
+    "月功能调用统计 ?[功能]",
+    "我的功能调用统计",
+    "我的日功能调用统计 ?[功能]",
+    "我的周功能调用统计 ?[功能]",
+    "我的月功能调用统计 ?[功能]",
+]
+__plugin_type__ = ("数据统计", 1)
+__plugin_version__ = 0.1
+__plugin_author__ = "HibiKier"
+__plugin_settings__ = {
+    "level": 5,
+    "default_status": True,
+    "limit_superuser": False,
+    "cmd": ["功能调用统计"],
+}
+
+
+statistics = on_command(
+    "功能调用统计",
+    aliases={
+        "全局功能调用统计",
+        "全局日功能调用统计",
+        "全局周功能调用统计",
+        "全局月功能调用统计",
+        "日功能调用统计",
+        "周功能调用统计",
+        "月功能调用统计",
+        "我的功能调用统计",
+        "我的日功能调用统计",
+        "我的周功能调用统计",
+        "我的月功能调用统计",
+    },
+    priority=5,
+    block=True,
+)
+
+
+statistics_group_file = DATA_PATH / "statistics" / "_prefix_count.json"
+statistics_user_file = DATA_PATH / "statistics" / "_prefix_user_count.json"
+
+
+@statistics.handle()
+async def _(bot: Bot, event: MessageEvent, cmd: Tuple[str, ...] = Command(), arg: Message = CommandArg()):
+    msg = arg.extract_plain_text().strip()
+    if cmd[0][:2] == "全局":
+        if str(event.user_id) in bot.config.superusers:
+            data: dict = json.load(open(statistics_group_file, "r", encoding="utf8"))
+            if cmd[0][2] == '日':
+                _type = 'day_statistics'
+            elif cmd[0][2] == '周':
+                _type = 'week_statistics'
+            elif cmd[0][2] == '月':
+                _type = 'month_statistics'
+            else:
+                _type = 'total_statistics'
+            tmp_dict = {}
+            data = data[_type]
+            if _type in ["day_statistics", "total_statistics"]:
+                for key in data['total']:
+                    tmp_dict[key] = data['total'][key]
+            else:
+                for group in data.keys():
+                    if group != 'total':
+                        for day in data[group].keys():
+                            for plugin_name in data[group][day].keys():
+                                if data[group][day][plugin_name] is not None:
+                                    if tmp_dict.get(plugin_name) is None:
+                                        tmp_dict[plugin_name] = 1
+                                    else:
+                                        tmp_dict[plugin_name] += data[group][day][plugin_name]
+            bar_graph = await init_bar_graph(tmp_dict, cmd[0])
+            await asyncio.get_event_loop().run_in_executor(None, bar_graph.gen_graph)
+            await statistics.finish(image(b64=bar_graph.pic2bs4()))
+        return
+    if cmd[0][:2] == "我的":
+        _type = "user"
+        key = str(event.user_id)
+        cmd = list(cmd)
+        cmd[0] = cmd[0][2:]
+        if not statistics_user_file.exists():
+            await statistics.finish("统计文件不存在...", at_sender=True)
+    else:
+        if not isinstance(event, GroupMessageEvent):
+            await statistics.finish("请在群内调用此功能...")
+        _type = "group"
+        key = str(event.group_id)
+        if not statistics_group_file.exists():
+            await statistics.finish("统计文件不存在...", at_sender=True)
+    plugin = ""
+    if cmd[0][0] == "日":
+        arg = "day_statistics"
+    elif cmd[0][0] == "周":
+        arg = "week_statistics"
+    elif cmd[0][0] == "月":
+        arg = "month_statistics"
+    else:
+        arg = "total_statistics"
+    if msg:
+        plugin = plugins2settings_manager.get_plugin_module(msg)
+        if not plugin:
+            if arg not in ["day_statistics", "total_statistics"]:
+                await statistics.finish("未找到此功能的调用...", at_sender=True)
+    if _type == "group":
+        data: dict = json.load(open(statistics_group_file, "r", encoding="utf8"))
+        if not data[arg].get(str(event.group_id)):
+            await statistics.finish("该群统计数据不存在...", at_sender=True)
+    else:
+        data: dict = json.load(open(statistics_user_file, "r", encoding="utf8"))
+        if not data[arg].get(str(event.user_id)):
+            await statistics.finish("该用户统计数据不存在...", at_sender=True)
+    day_index = data["day_index"]
+    data = data[arg][key]
+    if _type == "group":
+        name = await GroupInfo.get_group_info(event.group_id)
+        name = name.group_name if name else str(event.group_id)
+    else:
+        name = event.sender.card or event.sender.nickname
+    img = await generate_statistics_img(data, arg, name, plugin, day_index)
+    await statistics.send(image(b64=img))
+
+
+async def generate_statistics_img(
+    data: dict, arg: str, name: str, plugin: str, day_index: int
+):
+    try:
+        plugin = plugins2settings_manager.get_plugin_data(plugin)['cmd'][0]
+    except (KeyError, IndexError):
+        pass
+    bar_graph = None
+    if arg == "day_statistics":
+        bar_graph = await init_bar_graph(data, f"{name} 日功能调用统计")
+    elif arg == "week_statistics":
+        if plugin:
+            current_week = day_index % 7
+            week_lst = []
+            if current_week == 0:
+                week_lst = [1, 2, 3, 4, 5, 6, 7]
+            else:
+                for i in range(current_week + 1, 7):
+                    week_lst.append(str(i))
+                for i in range(current_week + 1):
+                    week_lst.append(str(i))
+            count = []
+            for i in range(7):
+                if int(week_lst[i]) == 7:
+                    try:
+                        count.append(data[str(0)][plugin])
+                    except KeyError:
+                        count.append(0)
+                else:
+                    try:
+                        count.append(data[str(week_lst[i])][plugin])
+                    except KeyError:
+                        count.append(0)
+            week_lst = ["7" if i == "0" else i for i in week_lst]
+            bar_graph = BuildMat(
+                y=count,
+                mat_type="line",
+                title=f"{name} 周 {plugin} 功能调用统计【为7天统计】",
+                x_index=week_lst,
+                display_num=True,
+                background=[
+                    f"{IMAGE_PATH}/background/create_mat/{x}"
+                    for x in os.listdir(f"{IMAGE_PATH}/background/create_mat")
+                ],
+                bar_color=["*"],
+            )
+        else:
+            bar_graph = await init_bar_graph(update_data(data), f"{name} 周功能调用统计【为7天统计】")
+    elif arg == "month_statistics":
+        if plugin:
+            day_index = day_index % 30
+            day_lst = []
+            for i in range(day_index + 1, 30):
+                day_lst.append(i)
+            for i in range(day_index + 1):
+                day_lst.append(i)
+            count = [data[str(day_lst[i])][plugin] for i in range(30)]
+            day_lst = [str(x + 1) for x in day_lst]
+            bar_graph = BuildMat(
+                y=count,
+                mat_type="line",
+                title=f"{name} 月 {plugin} 功能调用统计【为30天统计】",
+                x_index=day_lst,
+                display_num=True,
+                background=[
+                    f"{IMAGE_PATH}/background/create_mat/{x}"
+                    for x in os.listdir(f"{IMAGE_PATH}/background/create_mat")
+                ],
+                bar_color=["*"],
+            )
+        else:
+            bar_graph = await init_bar_graph(update_data(data), f"{name} 月功能调用统计【为30天统计】")
+    elif arg == "total_statistics":
+        bar_graph = await init_bar_graph(data, f"{name} 功能调用统计")
+    await asyncio.get_event_loop().run_in_executor(None, bar_graph.gen_graph)
+    return bar_graph.pic2bs4()
+
+
+async def init_bar_graph(data: dict, title: str) -> BuildMat:
+    return await asyncio.get_event_loop().run_in_executor(None, _init_bar_graph, data, title)
+
+
+def _init_bar_graph(data: dict, title: str) -> BuildMat:
+    bar_graph = BuildMat(
+        y=[data[x] for x in data.keys() if data[x] != 0],
+        mat_type="barh",
+        title=title,
+        x_index=[x for x in data.keys() if data[x] != 0],
+        display_num=True,
+        background=[
+            f"{IMAGE_PATH}/background/create_mat/{x}"
+            for x in os.listdir(f"{IMAGE_PATH}/background/create_mat")
+        ],
+        bar_color=["*"],
+    )
+    return bar_graph
+
+
+def update_data(data: dict):
+    tmp_dict = {}
+    for day in data.keys():
+        for plugin_name in data[day].keys():
+            # print(f'{day}：{plugin_name} = {data[day][plugin_name]}')
+            if data[day][plugin_name] is not None:
+                if tmp_dict.get(plugin_name) is None:
+                    tmp_dict[plugin_name] = 1
+                else:
+                    tmp_dict[plugin_name] += data[day][plugin_name]
+    return tmp_dict

plugins/web_ui/__init__.py

@@ -0,0 +1,20 @@
+from configs.config import Config as gConfig
+from .api import *
+from .auth import *
+
+
+gConfig.add_plugin_config(
+    "web-ui",
+    "username",
+    "admin",
+    name="web-ui",
+    help_="前端管理用户名"
+)
+
+gConfig.add_plugin_config(
+    "web-ui",
+    "password",
+    None,
+    name="web-ui",
+    help_="前端管理密码"
+)

plugins/web_ui/api/__init__.py

@@ -0,0 +1,4 @@
+from .group import *
+from .plugins import *
+from .request import *
+from .system import *

plugins/web_ui/api/group.py

@@ -0,0 +1,61 @@
+from pydantic.error_wrappers import ValidationError
+from services.log import logger
+from utils.manager import group_manager
+from utils.utils import get_bot
+
+from ..auth import Depends, User, token_to_user
+from ..config import *
+
+
+@app.get("/webui/group")
+async def _(user: User = Depends(token_to_user)) -> Result:
+    """
+    获取群信息
+    """
+    group_list_result = []
+    group_info = {}
+    if bot := get_bot():
+        group_list = await bot.get_group_list()
+        for g in group_list:
+            group_info[g["group_id"]] = Group(**g)
+    group_data = group_manager.get_data()
+    for group_id in group_data["group_manager"]:
+        try:
+            task_list = []
+            data = group_data["group_manager"][group_id]
+            for tn, status in data["group_task_status"].items():
+                task_list.append(
+                    Task(
+                        **{
+                            "name": tn,
+                            "nameZh": group_manager.get_task_data().get(tn) or tn,
+                            "status": status,
+                        }
+                    )
+                )
+            data["task"] = task_list
+            if x := group_info.get(int(group_id)):
+                data["group"] = x
+            else:
+                continue
+            try:
+                group_list_result.append(GroupResult(**data))
+            except ValidationError:
+                pass
+        except Exception as e:
+            logger.error(f"WEB_UI /webui/group 发生错误 {type(e)}：{e}")
+    return Result(code=200, data=group_list_result)
+
+
+@app.post("/webui/group")
+async def _(group: GroupResult, user: User = Depends(token_to_user)) -> Result:
+    """
+    修改群信息
+    """
+    group_id = group.group.group_id
+    group_manager.set_group_level(group_id, group.level)
+    if group.status:
+        group_manager.turn_on_group_bot_status(group_id)
+    else:
+        group_manager.shutdown_group_bot_status(group_id)
+    return Result(code=200)

plugins/web_ui/api/plugins.py

@@ -0,0 +1,142 @@
+from configs.config import Config
+from services.log import logger
+from utils.manager import (plugins2block_manager, plugins2cd_manager,
+                           plugins2count_manager, plugins2settings_manager,
+                           plugins_manager)
+from utils.utils import get_matchers
+
+from ..auth import Depends, User, token_to_user
+from ..config import *
+
+plugin_name_list = None
+
+
+@app.get("/webui/plugins")
+def _(type_: Optional[str], user: User = Depends(token_to_user)) -> Result:
+    """
+    获取插件列表
+    :param type_: 类型 normal, superuser, hidden, admin
+    """
+    global plugin_name_list
+    if not plugin_name_list:
+        plugin_name_list = [x.plugin_name for x in get_matchers()]
+    plugin_list = []
+    plugin_data = plugins_manager.get_data()
+    for model in plugin_data:
+        if model in plugin_name_list:
+            try:
+                data = plugin_data.get(model)
+                data["model"] = model
+                plugin_name = data.get("plugin_name")
+                if (
+                    (type_ == "hidden" and "[hidden]" not in plugin_name.lower())
+                    or (type_ == "admin" and "[admin]" not in plugin_name.lower())
+                    or (
+                        type_ == "superuser"
+                        and "[superuser]" not in plugin_name.lower()
+                    )
+                ):
+                    continue
+                if type_ == "normal" and (
+                    "[hidden]" in plugin_name.lower()
+                    or "[admin]" in plugin_name.lower()
+                    or "[superuser]" in plugin_name.lower()
+                ):
+                    continue
+                data = {"model": model}
+                if x := plugin_data.get(model):
+                    if not x.get("status") and x.get("block_type") in [
+                        "group",
+                        "private",
+                        "all",
+                    ]:
+                        x["block_type"] = (
+                            "群聊"
+                            if x["block_type"] == "group"
+                            else "私聊"
+                            if x["block_type"] == "private"
+                            else "全部"
+                        )
+                    data["plugin_manager"] = PluginManager(**x)
+                if x := plugins2settings_manager.get(model):
+                    if x.get("cmd") and isinstance(x.get("cmd"), list):
+                        x["cmd"] = ",".join(x["cmd"])
+                    data["plugin_settings"] = PluginSettings(**x)
+                if x := plugins2cd_manager.get(model):
+                    data["cd_limit"] = CdLimit(**x)
+                if x := plugins2block_manager.get(model):
+                    data["block_limit"] = BlockLimit(**x)
+                if x := plugins2count_manager.get(model):
+                    data["count_limit"] = CountLimit(**x)
+                if x := Config.get(model):
+                    id_ = 0
+                    tmp = []
+                    for key in x.keys():
+                        tmp.append(
+                            PluginConfig(
+                                **{
+                                    "key": key,
+                                    "help_": x[key].get("help"),
+                                    "id": id_,
+                                    **x[key],
+                                }
+                            )
+                        )
+                        id_ += 1
+                    data["plugin_config"] = tmp
+                plugin_list.append(Plugin(**data))
+            except Exception as e:
+                logger.error(
+                    f"WEB_UI GET /webui/plugins model：{model} 发生错误 {type(e)}：{e}"
+                )
+                return Result(
+                    code=500,
+                    data=f"WEB_UI GET /webui/plugins model：{model} 发生错误 {type(e)}：{e}",
+                )
+    return Result(code=200, data=plugin_list)
+
+
+@app.post("/webui/plugins")
+def _(plugin: Plugin, user: User = Depends(token_to_user)) -> Result:
+    """
+    修改插件信息
+    :param plugin: 插件内容
+    """
+    try:
+        if plugin.plugin_config:
+            for c in plugin.plugin_config:
+                if str(c.value).lower() in ["true", "false"] and (
+                    c.default_value is None or isinstance(c.default_value, bool)
+                ):
+                    c.value = True if str(c.value).lower() == "true" else False
+                elif isinstance(
+                    Config.get_config(plugin.model, c.key, c.value), int
+                ) or isinstance(c.default_value, int):
+                    c.value = int(c.value)
+                elif isinstance(
+                    Config.get_config(plugin.model, c.key, c.value), float
+                ) or isinstance(c.default_value, float):
+                    c.value = float(c.value)
+                elif isinstance(c.value, str) and (
+                    isinstance(Config.get_config(plugin.model, c.key, c.value), list)
+                    or isinstance(c.default_value, list)
+                ):
+                    c.value = c.value.split(",")
+                Config.set_config(plugin.model, c.key, c.value)
+            Config.save(None, True)
+        else:
+            if plugin.plugin_settings:
+                for key, value in plugin.plugin_settings:
+                    plugins2settings_manager.set_module_data(plugin.model, key, value)
+            if plugin.plugin_manager:
+                for key, value in plugin.plugin_manager:
+                    plugins_manager.set_module_data(plugin.model, key, value)
+    except Exception as e:
+        logger.error(
+            f"WEB_UI POST /webui/plugins model：{plugin.model} 发生错误 {type(e)}：{e}"
+        )
+        return Result(
+            code=500,
+            data=f"WEB_UI POST /webui/plugins model：{plugin.model} 发生错误 {type(e)}：{e}",
+        )
+    return Result(code=200)

plugins/web_ui/api/request.py

@@ -0,0 +1,65 @@
+from utils.manager import requests_manager
+from ..auth import token_to_user, Depends, User
+from utils.utils import get_bot
+from models.group_info import GroupInfo
+from ..config import *
+
+
+@app.get("/webui/request")
+def _(type_: Optional[str], user: User = Depends(token_to_user)) -> Result:
+    req_data = requests_manager.get_data()
+    req_list = []
+    if type_ in ["group", "private"]:
+        req_data = req_data[type_]
+        for x in req_data:
+            req_data[x]["oid"] = x
+            req_list.append(RequestResult(**req_data[x]))
+        req_list.reverse()
+    return Result(code=200, data=req_list)
+
+
+@app.delete("/webui/request")
+def _(type_: Optional[str], user: User = Depends(token_to_user)) -> Result:
+    """
+    清空请求
+    :param type_: 类型
+    """
+    requests_manager.clear(type_)
+    return Result(code=200)
+
+
+@app.post("/webui/request")
+async def _(parma: RequestParma, user: User = Depends(token_to_user)) -> Result:
+    """
+    操作请求
+    :param parma: 参数
+    """
+    result = "ok"
+    flag = 3
+    if bot := get_bot():
+        if parma.handle == "approve":
+            if parma.type == "group":
+                rid = requests_manager.get_group_id(parma.id)
+                if await GroupInfo.get_group_info(rid):
+                    await GroupInfo.set_group_flag(rid, 1)
+                else:
+                    group_info = await bot.get_group_info(group_id=rid)
+                    await GroupInfo.add_group_info(
+                        rid,
+                        group_info["group_name"],
+                        group_info["max_member_count"],
+                        group_info["member_count"],
+                        1,
+                    )
+            flag = await requests_manager.approve(bot, parma.id, parma.type)
+        elif parma.handle == "refuse":
+            flag = await requests_manager.refused(bot, parma.id, parma.type)
+        elif parma.handle == "delete":
+            requests_manager.delete_request(parma.id, parma.type)
+        if parma.handle != "delete":
+            if flag == 1:
+                result = "该请求已失效"
+                requests_manager.delete_request(parma.id, parma.type)
+            elif flag == 2:
+                result = "未找到此Id"
+        return Result(code=200, data=result)

plugins/web_ui/api/system.py

@@ -0,0 +1,219 @@
+import asyncio
+import os
+from pathlib import Path
+
+import psutil
+import ujson as json
+from configs.path_config import (
+    DATA_PATH,
+    FONT_PATH,
+    IMAGE_PATH,
+    LOG_PATH,
+    RECORD_PATH,
+    TEMP_PATH,
+    TEXT_PATH,
+)
+from services.log import logger
+from utils.http_utils import AsyncHttpx
+
+from ..auth import Depends, User, token_to_user
+from ..config import *
+
+CPU_DATA_PATH = DATA_PATH / "system" / "cpu.json"
+MEMORY_DATA_PATH = DATA_PATH / "system" / "memory.json"
+DISK_DATA_PATH = DATA_PATH / "system" / "disk.json"
+CPU_DATA_PATH.parent.mkdir(exist_ok=True, parents=True)
+cpu_data = {"data": []}
+memory_data = {"data": []}
+disk_data = {"data": []}
+
+
+@app.get("/webui/system")
+async def _(user: User = Depends(token_to_user)) -> Result:
+    return await get_system_data()
+
+
+@app.get("/webui/system/status")
+async def _(user: User = Depends(token_to_user)) -> Result:
+    return Result(
+        code=200,
+        data=await asyncio.get_event_loop().run_in_executor(None, _get_system_status),
+    )
+
+
+@app.get("/webui/system/disk")
+async def _(type_: Optional[str] = None, user: User = Depends(token_to_user)) -> Result:
+    return Result(
+        code=200,
+        data=await asyncio.get_event_loop().run_in_executor(
+            None, _get_system_disk, type_
+        ),
+    )
+
+
+@app.get("/webui/system/statusList")
+async def _(user: User = Depends(token_to_user)) -> Result:
+    global cpu_data, memory_data, disk_data
+    await asyncio.get_event_loop().run_in_executor(None, _get_system_status)
+    cpu_rst = cpu_data["data"][-10:] if len(cpu_data["data"]) > 10 else cpu_data["data"]
+    memory_rst = (
+        memory_data["data"][-10:]
+        if len(memory_data["data"]) > 10
+        else memory_data["data"]
+    )
+    disk_rst = (
+        disk_data["data"][-10:] if len(disk_data["data"]) > 10 else disk_data["data"]
+    )
+    return Result(
+        code=200,
+        data=SystemStatusList(
+            cpu_data=cpu_rst,
+            memory_data=memory_rst,
+            disk_data=disk_rst,
+        ),
+    )
+
+
+async def get_system_data():
+    """
+    说明：
+        获取系统信息，资源文件大小，网络状态等
+    """
+    baidu = 200
+    google = 200
+    try:
+        await AsyncHttpx.get("https://www.baidu.com/", timeout=5)
+    except Exception as e:
+        logger.warning(f"访问BaiDu失败... {type(e)}: {e}")
+        baidu = 404
+    try:
+        await AsyncHttpx.get("https://www.google.com/", timeout=5)
+    except Exception as e:
+        logger.warning(f"访问Google失败... {type(e)}: {e}")
+        google = 404
+    network = SystemNetwork(baidu=baidu, google=google)
+    disk = await asyncio.get_event_loop().run_in_executor(None, _get_system_disk)
+    status = await asyncio.get_event_loop().run_in_executor(None, _get_system_status)
+    return Result(
+        code=200,
+        data=SystemResult(
+            status=status,
+            network=network,
+            disk=disk,
+            check_time=datetime.now().replace(microsecond=0),
+        ),
+    )
+
+
+def _get_system_status() -> SystemStatus:
+    """
+    说明：
+        获取系统信息等
+    """
+    cpu = psutil.cpu_percent()
+    memory = psutil.virtual_memory().percent
+    disk = psutil.disk_usage("/").percent
+    save_system_data(cpu, memory, disk)
+    return SystemStatus(
+        cpu=cpu,
+        memory=memory,
+        disk=disk,
+        check_time=datetime.now().replace(microsecond=0),
+    )
+
+
+def _get_system_disk(
+    type_: Optional[str],
+) -> Union[SystemFolderSize, Dict[str, Union[float, datetime]]]:
+    """
+    说明：
+        获取资源文件大小等
+    """
+    if not type_:
+        disk = SystemFolderSize(
+            font_dir_size=_get_dir_size(FONT_PATH) / 1024 / 1024,
+            image_dir_size=_get_dir_size(IMAGE_PATH) / 1024 / 1024,
+            text_dir_size=_get_dir_size(TEXT_PATH) / 1024 / 1024,
+            record_dir_size=_get_dir_size(RECORD_PATH) / 1024 / 1024,
+            temp_dir_size=_get_dir_size(TEMP_PATH) / 1024 / 102,
+            data_dir_size=_get_dir_size(DATA_PATH) / 1024 / 1024,
+            log_dir_size=_get_dir_size(LOG_PATH) / 1024 / 1024,
+            check_time=datetime.now().replace(microsecond=0),
+        )
+        return disk
+    else:
+        if type_ == "image":
+            dir_path = IMAGE_PATH
+        elif type_ == "font":
+            dir_path = FONT_PATH
+        elif type_ == "text":
+            dir_path = TEXT_PATH
+        elif type_ == "record":
+            dir_path = RECORD_PATH
+        elif type_ == "data":
+            dir_path = DATA_PATH
+        elif type_ == "temp":
+            dir_path = TEMP_PATH
+        else:
+            dir_path = LOG_PATH
+        dir_map = {}
+        other_file_size = 0
+        for file in os.listdir(dir_path):
+            file = Path(dir_path / file)
+            if file.is_dir():
+                dir_map[file.name] = _get_dir_size(file) / 1024 / 1024
+            else:
+                other_file_size += os.path.getsize(file) / 1024 / 1024
+        dir_map["其他文件"] = other_file_size
+        dir_map["check_time"] = datetime.now().replace(microsecond=0)
+        return dir_map
+
+
+def _get_dir_size(dir_path: Path) -> float:
+    """
+    说明：
+        获取文件夹大小
+    参数：
+        :param dir_path: 文件夹路径
+    """
+    size = 0
+    for root, dirs, files in os.walk(dir_path):
+        size += sum([os.path.getsize(os.path.join(root, name)) for name in files])
+    return size
+
+
+def save_system_data(cpu: float, memory: float, disk: float):
+    """
+    说明：
+        保存一些系统信息
+    参数：
+        :param cpu: cpu
+        :param memory: memory
+        :param disk: disk
+    """
+    global cpu_data, memory_data, disk_data
+    if CPU_DATA_PATH.exists() and not cpu_data["data"]:
+        with open(CPU_DATA_PATH, "r") as f:
+            cpu_data = json.load(f)
+    if MEMORY_DATA_PATH.exists() and not memory_data["data"]:
+        with open(MEMORY_DATA_PATH, "r") as f:
+            memory_data = json.load(f)
+    if DISK_DATA_PATH.exists() and not disk_data["data"]:
+        with open(DISK_DATA_PATH, "r") as f:
+            disk_data = json.load(f)
+    now = str(datetime.now().time().replace(microsecond=0))
+    cpu_data["data"].append({"time": now, "data": cpu})
+    memory_data["data"].append({"time": now, "data": memory})
+    disk_data["data"].append({"time": now, "data": disk})
+    if len(cpu_data["data"]) > 50:
+        cpu_data["data"] = cpu_data["data"][-50:]
+    if len(memory_data["data"]) > 50:
+        memory_data["data"] = memory_data["data"][-50:]
+    if len(disk_data["data"]) > 50:
+        disk_data["data"] = disk_data["data"][-50:]
+    with open(CPU_DATA_PATH, "w") as f:
+        json.dump(cpu_data, f, indent=4, ensure_ascii=False)
+    with open(MEMORY_DATA_PATH, "w") as f:
+        json.dump(memory_data, f, indent=4, ensure_ascii=False)
+    with open(DISK_DATA_PATH, "w") as f:
+        json.dump(disk_data, f, indent=4, ensure_ascii=False)

plugins/web_ui/auth/__init__.py

@@ -0,0 +1,89 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from starlette import status
+from fastapi import Depends, HTTPException
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from pydantic import BaseModel
+from configs.config import Config
+from jose import JWTError, jwt
+import nonebot
+
+app = nonebot.get_app()
+
+
+SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="webui/login")
+
+
+class User(BaseModel):
+    username: str
+    password: str
+
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+
+# USER_LIST = [
+#     User(username="admin", password="123")
+# ]
+
+
+def get_user(uname: str) -> Optional[User]:
+    username = Config.get_config("web-ui", "username")
+    password = Config.get_config("web-ui", "password")
+    if username and password and uname == username:
+        return User(username=username, password=password)
+
+
+form_exception = HTTPException(
+    status_code=status.HTTP_401_UNAUTHORIZED,
+    detail="Could not validate credentials",
+    headers={"WWW-Authenticate": "Bearer"},
+)
+
+
+def create_token(user: User, expires_delta: Optional[timedelta] = None):
+    expire = datetime.utcnow() + expires_delta or timedelta(minutes=15)
+    return jwt.encode(
+        claims={"sub": user.username, "exp": expire},
+        key=SECRET_KEY,
+        algorithm=ALGORITHM
+    )
+
+
+@app.post("/webui/login")
+async def login_get_token(form_data: OAuth2PasswordRequestForm = Depends()):
+    user: User = get_user(form_data.username)
+    if not user or user.password != form_data.password:
+        raise form_exception
+    access_token = create_token(user=user, expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES))
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+credentials_exception = HTTPException(
+    status_code=status.HTTP_401_UNAUTHORIZED,
+    detail="Could not validate credentials",
+    headers={"WWW-Authenticate": "Bearer"},
+)
+
+
+def token_to_user(token: str = Depends(oauth2_scheme)):
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username, expire = payload.get("sub"), payload.get("exp")
+        user = get_user(username)
+        if user is None:
+            raise JWTError
+    except JWTError:
+        raise credentials_exception
+    return user
+
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=8080)

plugins/web_ui/config.py

@@ -0,0 +1,212 @@
+from typing import Optional, List, Any, Union, Dict
+from pydantic import BaseModel
+from fastapi.middleware.cors import CORSMiddleware
+from datetime import datetime
+import nonebot
+
+
+app = nonebot.get_app()
+
+origins = ["http://localhost"]
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class CdLimit(BaseModel):
+    """
+    Cd 限制
+    """
+    cd: int
+    status: bool
+    check_type: str
+    limit_type: str
+    rst: Optional[str]
+
+
+class BlockLimit(BaseModel):
+    """
+    Block限制
+    """
+    status: bool
+    check_type: str
+    limit_type: str
+    rst: Optional[str]
+
+
+class CountLimit(BaseModel):
+    """
+    Count限制
+    """
+    max_count: int
+    status: bool
+    limit_type: bool
+    rst: Optional[str]
+
+
+class PluginManager(BaseModel):
+    """
+    插件信息
+    """
+    plugin_name: str  # 插件名称
+    status: Optional[bool]  # 插件状态
+    error: Optional[bool]  # 加载状态
+    version: Optional[float]  # 版本
+    author: Optional[str]  # 作者
+    block_type: Optional[str]  # 禁用类型
+
+
+class PluginSettings(BaseModel):
+    """
+    插件基本设置
+    """
+    level: Optional[int]  # 群权限等级
+    default_status: Optional[bool]  # 默认开关
+    limit_superuser: Optional[bool]  # 是否限制超级用户
+    cmd: Optional[str]  # cmd别名
+    cost_gold: Optional[int]  # 花费金币限制
+    plugin_type: Optional[List[Union[str, int]]]  # 帮助类型
+
+
+class PluginConfig(BaseModel):
+    """
+    插件配置项
+    """
+    id: int
+    key: str
+    value: Optional[Any]
+    help_: Optional[str]
+    default_value: Optional[Any]
+
+
+class Plugin(BaseModel):
+    """
+    插件
+    """
+    model: str  # 模块
+    plugin_settings: Optional[PluginSettings]
+    plugin_manager: Optional[PluginManager]
+    plugin_config: Optional[List[PluginConfig]]
+    cd_limit: Optional[CdLimit]
+    block_limit: Optional[BlockLimit]
+    count_limit: Optional[CountLimit]
+
+
+class Group(BaseModel):
+    """
+    群组信息
+    """
+    group_id: int
+    group_name: str
+    member_count: int
+    max_member_count: int
+
+
+class Task(BaseModel):
+    """
+    被动技能
+    """
+    name: str
+    nameZh: str
+    status: bool
+
+
+class GroupResult(BaseModel):
+    """
+    群组返回数据
+    """
+    group: Group
+    level: int
+    status: bool
+    close_plugins: List[str]
+    task: List[Task]
+
+
+class RequestResult(BaseModel):
+    """
+    好友/群组请求管理
+    """
+    oid: str
+    id: int
+    flag: str
+    nickname: Optional[str]
+    level: Optional[int]
+    sex: Optional[str]
+    age: Optional[int]
+    from_: Optional[str]
+    comment: Optional[str]
+    invite_group: Optional[int]
+    group_name: Optional[str]
+
+
+class RequestParma(BaseModel):
+    """
+    操作请求接收数据
+    """
+    id: int
+    handle: str
+    type: str
+
+
+class SystemStatus(BaseModel):
+    """
+    系统状态
+    """
+    cpu: int
+    memory: int
+    disk: int
+    check_time: datetime
+
+
+class SystemNetwork(BaseModel):
+    """
+    系统网络状态
+    """
+    baidu: int
+    google: int
+
+
+class SystemFolderSize(BaseModel):
+    """
+    资源文件占比
+    """
+    font_dir_size: float
+    image_dir_size: float
+    text_dir_size: float
+    record_dir_size: float
+    temp_dir_size: float
+    data_dir_size: float
+    log_dir_size: float
+    check_time: datetime
+
+
+class SystemStatusList(BaseModel):
+    """
+    状态记录
+    """
+    cpu_data: List[Dict[str, Union[float, str]]]
+    memory_data: List[Dict[str, Union[float, str]]]
+    disk_data: List[Dict[str, Union[float, str]]]
+
+
+class SystemResult(BaseModel):
+    """
+    系统api返回
+    """
+    status: SystemStatus
+    network: SystemNetwork
+    disk: SystemFolderSize
+    check_time: datetime
+
+
+class Result(BaseModel):
+    """
+    总体返回
+    """
+    code: int
+    data: Any

plugins/word_bank/__init__.py

@@ -1,7 +1,6 @@
 from configs.config import Config
 import nonebot
 
-
 Config.add_plugin_config(
     "word_bank",
     "WORD_BANK_LEVEL [LEVEL]",
@@ -11,6 +10,25 @@ Config.add_plugin_config(
     default_value=5
 )
 
-
+Config.add_plugin_config(
+    "word_bank",
+    "WORD_BANK_FUZZY",
+    False,
+    help_="模糊匹配",
+    default_value=False
+)
+Config.add_plugin_config(
+    "word_bank",
+    "WORD_BANK_KEY",
+    True,
+    help_="关键字匹配",
+    default_value=True
+)
+Config.add_plugin_config(
+    "word_bank",
+    "WORD_BANK_MIX",
+    25,
+    help_="查看词条时图片内最多显示条数",
+    default_value=25
+)
 nonebot.load_plugins("plugins/word_bank")
-

plugins/word_bank/_data_source.py

@@ -5,7 +5,6 @@ from typing import Union
 class WordBankBuilder:
 
     def __init__(self, user_id: int, group_id: int, problem: str):
-
         self._data = {
             "user_id": user_id,
             "group_id": group_id,
@@ -29,24 +28,21 @@ class WordBankBuilder:
         """
         self._data["answer"] = answer
 
-    async def save(self):
+    async def save(self,search_type):
         user_id = self._data["user_id"]
         group_id = self._data["group_id"]
         problem = self._data["problem"]
         answer = self._data["answer"]
         placeholder = self._data.get("placeholder")
-        await WordBank.add_problem_answer(user_id, group_id, problem, answer, placeholder)
+        return await WordBank.add_problem_answer(user_id, group_id, search_type,problem, answer, placeholder)
+
+    async def update(self, index):
+        user_id = self._data["user_id"]
+        group_id = self._data["group_id"]
+        problem = self._data["problem"]
+        answer = self._data["answer"]
+        placeholder = self._data.get("placeholder")
+        return await WordBank.update_problem_answer(user_id, group_id, problem, answer, index, placeholder)
 
     def __str__(self):
         return str(self._data)
-
-
-
-
-
-
-
-
-
-
-

plugins/word_bank/message_handle.py

@@ -5,36 +5,40 @@ from configs.path_config import DATA_PATH
 from nonebot.adapters.onebot.v11 import GroupMessageEvent
 from utils.utils import get_message_text
 from nonebot import on_message
-
+from models.group_member_info import GroupInfoUser
 
 __zx_plugin_name__ = "词库问答回复操作 [Hidden]"
 
-
 data_dir = DATA_PATH / "word_bank"
 data_dir.mkdir(parents=True, exist_ok=True)
 
-
-message_handle = on_message(priority=5, block=True, rule=check)
+message_handle = on_message(priority=6, block=True, rule=check)
 
 
 @message_handle.handle()
 async def _(event: GroupMessageEvent):
-    path = data_dir / f"{event.group_id}"
     q = await WordBank.check(
         event.group_id, get_message_text(event.json()), event.is_tome()
     )
+    await message_handle.send(await get_one_answer(event, q.format, q.answer))
+
+
+# 处理单条回答
+async def get_one_answer(event, format, _answer, all=1):
+    path = data_dir / f"{event.group_id}"
     placeholder_list = (
         [
             (x.split("<_s>")[0], x.split("<_s>")[1])
-            for x in q.format.split("<format>")[:-1]
+            for x in format.split("<format>")[:-1]
         ]
-        if q.format
+        if format
         else []
     )
     answer = ""
-    _a = q.answer
+    _a = _answer
     if not placeholder_list:
         answer = _a
+        return answer
     else:
         for idx, placeholder in placeholder_list:
             if placeholder.endswith("jpg"):
@@ -42,6 +46,11 @@ async def _(event: GroupMessageEvent):
                     path / placeholder
                 )
             else:
-                answer += _a[: _a.find(f"[__placeholder_{idx}]")] + at(placeholder)
-            _a = _a[_a.find(f"[__placeholder_{idx}]") + len(f"[__placeholder_{idx}]") :]
-    await message_handle.send(answer)
+                if all == 1:
+                    answer += _a[: _a.find(f"[__placeholder_{idx}]")] + at(placeholder)
+                else:
+                    q = await GroupInfoUser.get_member_info(
+                        int(placeholder), event.group_id)
+                    answer += _a[: _a.find(f"[__placeholder_{idx}]")] + "@" + q.user_name
+            _a = _a[_a.find(f"[__placeholder_{idx}]") + len(f"[__placeholder_{idx}]"):]
+    return answer + _a

plugins/word_bank/model.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from configs.path_config import DATA_PATH
 import re
 import random
+from configs.config import Config
 
 
 class WordBank(db.Model):
@@ -21,17 +22,19 @@ class WordBank(db.Model):
 
     @classmethod
     async def add_problem_answer(
-        cls,
-        user_id: int,
-        group_id: Optional[int],
-        problem: str,
-        answer: str,
-        format_: Optional[List[Tuple[int, Union[int, str]]]],
+            cls,
+            user_id: int,
+            group_id: Optional[int],
+            search_type: [int],
+            problem: str,
+            answer: str,
+            format_: Optional[List[Tuple[int, Union[int, str]]]],
     ) -> bool:
         """
         添加或新增一个问答
         :param user_id: 用户id
         :param group_id: 群号
+        :search_type: 问题类型,
         :param problem: 问题
         :param answer: 回答
         :param format_: 格式化数据
@@ -42,12 +45,12 @@ class WordBank(db.Model):
             for x, y in format_:
                 _str += f"{x}<_s>{y}<format>"
         return await cls._problem_answer_handle(
-            user_id, group_id, problem, "add", answer=answer, format_=_str
+            user_id, group_id, problem, "add", search_type=search_type, answer=answer, format_=_str
         )
 
     @classmethod
     async def delete_problem_answer(
-        cls, user_id: int, group_id: Optional[int], problem: str, index: Optional[int]
+            cls, user_id: int, group_id: Optional[int], problem: str, index: Optional[int]
     ) -> str:
         """
         删除某问题一个或全部回答
@@ -60,9 +63,35 @@ class WordBank(db.Model):
             user_id, group_id, problem, "delete", index=index
         )
 
+    @classmethod
+    async def update_problem_answer(
+            cls,
+            user_id: int,
+            group_id: Optional[int],
+            problem: str,
+            answer: str,
+            index: Optional[int],
+            format_: Optional[List[Tuple[int, Union[int, str]]]],
+    ) -> str:
+        """
+        修改某问题一个或全部回答
+        :param user_id: 用户id
+        :param group_id: 群号
+        :param problem: 问题
+        :param index: 回答下标
+        """
+        _str = None
+        if format_:
+            _str = ""
+            for x, y in format_:
+                _str += f"{x}<_s>{y}<format>"
+        return await cls._problem_answer_handle(
+            user_id, group_id, problem, "update", answer=answer, index=index, format_=_str
+        )
+
     @classmethod
     async def get_problem_answer(
-        cls, user_id: int, group_id: Optional[int], problem: str
+            cls, user_id: int, group_id: Optional[int], problem: str
     ) -> List[str]:
         """
         获取问题的所有回答
@@ -87,7 +116,8 @@ class WordBank(db.Model):
         q = await cls.query.where(
             (cls.group_id == group_id) & (cls.problem == problem)
         ).gino.all()
-        return [x.answer for x in q] if q else None
+
+        return [(x.answer, x.format) for x in q] if q else None
 
     @classmethod
     async def get_group_all_problem(cls, group_id: int) -> List[str]:
@@ -128,22 +158,45 @@ class WordBank(db.Model):
                         return x
             return None
         else:
-            q = await cls.query.where(
-                (cls.group_id == group_id) & (cls.problem == problem)
-            ).gino.all()
+            if problem:
+                FUZZY = Config.get_config("word_bank", "WORD_BANK_FUZZY")
+                KEY = Config.get_config("word_bank", "WORD_BANK_KEY")
+                q = await cls.query.where(
+                    (cls.group_id == group_id) & (cls.problem == problem)
+                ).gino.all()
+                if KEY and FUZZY:
+                    q_fuzzy = await cls.query.where(
+                        (cls.group_id == group_id) & (cls.search_type == 2) & (
+                            cls.problem.contains(f'{problem}'))).gino.all()
+                    q_key = await cls.query.where((cls.group_id == group_id) & (cls.search_type == 1)).gino.all()
+                    q_key = [x for x in q_key if str(x.problem) in (problem)]
+                    q += q_fuzzy + q_key
+                elif FUZZY:
+                    q_fuzzy = await cls.query.where(
+                        (cls.group_id == group_id) & (cls.search_type == 2) & (
+                            cls.problem.contains(f'{problem}'))).gino.all()
+                    q += q_fuzzy
+                elif KEY:
+                    q_key = await cls.query.where((cls.group_id == group_id) & (cls.search_type == 1)).gino.all()
+                    q_key = [x for x in q_key if str(x.problem) in (problem)]
+                    q += q_key
+            else:
+                return None
+
         return random.choice(q) if q else None
 
     @classmethod
     async def _problem_answer_handle(
-        cls,
-        user_id: int,
-        group_id: Optional[int],
-        problem: str,
-        type_: str,
-        *,
-        answer: Optional[str] = None,
-        index: Optional[int] = None,
-        format_: Optional[str] = None,
+            cls,
+            user_id: int,
+            group_id: Optional[int],
+            problem: str,
+            type_: str,
+            *,
+            search_type: [int] = 0,
+            answer: Optional[str] = None,
+            index: Optional[int] = None,
+            format_: Optional[str] = None,
     ) -> Union[List[Union[str, Tuple[str, str]]], bool, str]:
         """
         添加或新增一个问答
@@ -166,27 +219,27 @@ class WordBank(db.Model):
         else:
             q = cls.query.where((cls.user_qq == user_id) & (cls.problem == problem))
         if type_ == "add":
-            q = await q.where(cls.answer == answer).gino.all()
-            if not q or ".jpg" in format_:
-                await cls.create(
-                    user_qq=user_id,
-                    group_id=group_id,
-                    problem=problem,
-                    answer=answer,
-                    format=format_,
-                    create_time=datetime.now().date(),
-                    update_time=datetime.now().date(),
-                )
+            q = await q.where((cls.answer == answer) & (cls.search_type == search_type)).gino.all()
+            try:
+                if not q or ".jpg" in format_:
+                    await cls.create(
+                        user_qq=user_id,
+                        group_id=group_id,
+                        search_type=search_type,
+                        problem=problem,
+                        answer=answer,
+                        format=format_,
+                        create_time=datetime.now().replace(microsecond=0),
+                        update_time=datetime.now().replace(microsecond=0),
+                    )
+            except:
+                return False
             return True
         elif type_ == "delete":
             q = await q.with_for_update().gino.all()
             if q:
                 path = DATA_PATH / "word_bank" / f"{group_id}"
                 if index is not None:
-                    _q = [x.problem for x in q]
-                    _q.sort()
-                    prob = _q[index]
-                    index = [x.problem for x in q].index(prob)
                     q = [q[index]]
                 answer = "\n".join([x.answer for x in q])
                 for x in q:
@@ -199,14 +252,43 @@ class WordBank(db.Model):
                                 if _path.exists():
                                     _path.unlink()
                     await cls.delete.where(
-                        (cls.problem == problem)
+                        (cls.update_time == x.update_time)
+                        & (cls.problem == problem)
                         & (cls.answer == x.answer)
                         & (cls.group_id == group_id)
                     ).gino.status()
                 return answer
+        elif type_ == "update":
+            new_format = format_
+            new_answer = answer
+            q = await q.with_for_update().gino.all()
+            if q:
+                path = DATA_PATH / "word_bank" / f"{group_id}"
+                if index is not None:
+                    q = [q[index]]
+                else:
+                    q = [q[0]]
+                for x in q:
+                    format_ = x.format
+                    if format_:
+                        for sp in format_.split("<format>")[:-1]:
+                            _, image_name = sp.split("<_s>")
+                            if image_name.endswith("jpg"):
+                                _path = path / image_name
+                                if _path.exists():
+                                    _path.unlink()
+                    await cls.update.values(answer=new_answer,
+                                            format=new_format,
+                                            update_time=datetime.now().replace(microsecond=0), ).where(
+                        (cls.problem == problem)
+                        & (cls.answer == x.answer)
+                        & (cls.group_id == group_id)
+                        & (cls.group_id == group_id)
+                        & (cls.update_time == x.update_time)
+                    ).gino.status()
+                return True
         elif type_ == "get":
             q = await q.gino.all()
             if q:
                 return [(x.answer, x.format.split("<format>")[:-1]) for x in q]
         return False
-

plugins/word_bank/word_hanlde.py

@@ -4,9 +4,9 @@ from services.log import logger
 from configs.path_config import DATA_PATH
 from utils.http_utils import AsyncHttpx
 from ._data_source import WordBankBuilder
-from configs.config import Config
 from utils.message_builder import image
 from utils.image_utils import text2image
+from .message_handle import get_one_answer
 from .model import WordBank
 from nonebot.adapters.onebot.v11 import (
     Bot,
@@ -18,6 +18,7 @@ from nonebot import on_command
 import random
 import os
 import re
+from configs.config import NICKNAME, Config
 
 __zx_plugin_name__ = "词库问答 [Admin]"
 __plugin_usage__ = """
@@ -25,45 +26,51 @@ usage：
     对指定问题的随机回答，对相同问题可以设置多个不同回答
     删除词条后每个词条的id可能会变化，请查看后再删除
     指令：
-        添加词条问...答...：添加问答词条，可重复添加相同问题的不同回答
+        添加词条 ?[模糊/关键字]...答...：添加问答词条，可重复添加相同问题的不同回答
         删除词条 [问题/下标] ?[下标]：删除指定词条指定或全部回答
+        修改词条 [问题/下标] ?[下标/新回答] [新回答]：修改指定词条指定回答默认修改为第一条
         查看词条 ?[问题/下标]：查看全部词条或对应词条回答
         示例：添加词条问谁是萝莉答是我
         示例：删除词条 谁是萝莉
         示例：删除词条 谁是萝莉 0
         示例：删除词条 id:0
+        示例：修改词条 谁是萝莉 是你
+        示例：修改词条 谁是萝莉 0 是你
+        示例：修改词条 id:0 是你
         示例：查看词条
         示例：查看词条 谁是萝莉
         示例：查看词条 id:0
 """.strip()
 __plugin_des__ = "自定义词条内容随机回复"
 __plugin_cmd__ = [
-    "添加词条问...答..",
+    "添加词条 ?[模糊/关键字]问...答..",
     "删除词条 [问题/下标] ?[下标]",
+    "修改词条 [问题/下标] ?[下标/新回答] [新回答]",
     "查看词条 ?[问题/下标]",
 ]
-__plugin_version__ = 0.1
+__plugin_version__ = 0.2
 __plugin_author__ = "HibiKier"
 __plugin_settings__ = {
-    "admin_level": Config.get_config("word_bank", "WORD_BANK_LEVEL"),
-    "cmd": ["词库问答", "添加词条", "删除词条", "查看词条"],
+    "admin_level": Config.get_config("word_bank", "WORD_BANK_LEVEL [LEVEL]"),
+    "cmd": ["词库问答", "添加词条", "删除词条", "修改词条", "查看词条"],
 }
 
 data_dir = DATA_PATH / "word_bank"
 data_dir.mkdir(parents=True, exist_ok=True)
 
-
 add_word = on_command("添加词条", priority=5, block=True)
 
 delete_word = on_command("删除词条", priority=5, block=True)
 
+update_word = on_command("修改词条", priority=5, block=True)
+
 show_word = on_command("显示词条", aliases={"查看词条"}, priority=5, block=True)
 
 
 @add_word.handle()
 async def _(bot: Bot, event: GroupMessageEvent, state: T_State, arg: Message = CommandArg()):
     msg = str(arg)
-    r = re.search(r"^问(.+)\s?答([\s\S]*)", msg)
+    r = re.search(r"问(.+)\s?答([\s\S]*)", msg)
     if not r:
         await add_word.finish("未检测到词条问题...")
     problem = r.group(1).strip()
@@ -75,10 +82,177 @@ async def _(bot: Bot, event: GroupMessageEvent, state: T_State, arg: Message = C
     idx = 0
     for n in bot.config.nickname:
         if n and problem.startswith(n):
-            _problem = f"[_to_me|{n}]" + problem[len(n) :]
+            _problem = f"[_to_me|{n}]" + problem[len(n):]
             break
     else:
         _problem = problem
+    search_type = 0
+    if re.search("^关键字(.*)", msg):
+        search_type = 1
+    elif re.search("^模糊(.*)", msg):
+        search_type = 2
+    _builder = await get__builder(event, _problem, answer, idx)
+    if await _builder.save(search_type):
+        logger.info(f"已保存词条 问：{problem} 答：{msg}")
+        await add_word.send(f"已保存词条：{problem}")
+    else:
+        await delete_word.send("保存失败，可能是回答重复")
+
+
+@delete_word.handle()
+async def _(event: GroupMessageEvent, arg: Message = CommandArg()):
+    msg = arg.extract_plain_text().strip()
+    if not msg:
+        await delete_word.finish("此命令之后需要跟随指定词条，通过“显示词条“查看")
+    index = None
+    _sp_msg = msg.split()
+    if len(_sp_msg) > 1:
+        if is_number(_sp_msg[-1]):
+            index = int(_sp_msg[-1])
+            msg = " ".join(_sp_msg[:-1])
+    problem = msg
+    if problem.startswith("id:"):
+        x = problem.split(":")[-1]
+        if not is_number(x) or int(x) < 0:
+            await delete_word.finish("id必须为数字且符合规范！")
+        p = await WordBank.get_group_all_problem(event.group_id)
+        if p:
+            problem = p[int(x)]
+    try:
+        if answer := await WordBank.delete_problem_answer(
+                event.user_id, event.group_id, problem, index
+        ):
+            await delete_word.send(f"删除词条成功：{problem}\n回答：\n{answer}")
+            logger.info(
+                f"(USER {event.user_id}, GROUP "
+                f"{event.group_id if isinstance(event, GroupMessageEvent) else 'private'})"
+                f" 删除词条: {problem}"
+            )
+        else:
+            await delete_word.send(f"删除词条：{problem} 失败，可能该词条不存在")
+    except IndexError:
+        await delete_word.send("指定下标错误...请通过查看词条来确定..")
+
+
+@update_word.handle()
+async def _(bot: Bot, event: GroupMessageEvent, arg: Message = CommandArg()):
+    msg = str(arg)
+    if not msg:
+        await update_word.finish("此命令之后需要跟随指定词条，通过“显示词条“查看")
+    index = None
+    new_answer = None
+    problem = None
+    _sp_msg = msg.split()
+    len_msg = len(_sp_msg)
+    if 1 < len_msg:
+        problem = "".join(_sp_msg[0])
+        if len_msg == 3:
+            if is_number(_sp_msg[1]):
+                index = int(_sp_msg[1])
+            new_answer = "".join(_sp_msg[2:])
+        else:
+            new_answer = "".join(_sp_msg[1:])
+    else:
+        await update_word.finish("此命令之后需要跟随修改内容")
+    idx = 0
+    for n in bot.config.nickname:
+        if n and problem.startswith(n):
+            _problem = f"[_to_me|{n}]" + problem[len(n):]
+            break
+    else:
+        _problem = problem
+    _builder = await get__builder(event, _problem, new_answer, idx)
+
+    try:
+        if await _builder.update(index):
+            await update_word.send(f"修改词条成功：{problem}")
+            logger.info(
+                f"(USER {event.user_id}, GROUP "
+                f"{event.group_id if isinstance(event, GroupMessageEvent) else 'private'})"
+                f" 修改词条: {problem}"
+            )
+        else:
+            await update_word.send(f"修改词条：{problem} 失败，可能该词条不存在")
+    except IndexError:
+        await update_word.send("指定下标错误...请通过查看词条来确定..")
+
+
+@show_word.handle()
+async def _(bot: Bot, event: GroupMessageEvent, arg: Message = CommandArg()):
+    msg = arg.extract_plain_text().strip()
+    if not msg:
+        _problem_list = await WordBank.get_group_all_problem(event.group_id)
+        if not _problem_list:
+            await show_word.finish("该群未收录任何词条..")
+        _problem_list = [f"\t{i}. {x}" for i, x in enumerate(_problem_list)]
+        long_problem_list = len(_problem_list)
+        max_line = Config.get_config("word_bank", "WORD_BANK_MIX")
+        if long_problem_list > max_line:
+            pic_list = []
+            mes_list = []
+            img_nu = long_problem_list // max_line
+            one_msg = "该群已收录的词条："
+            await show_word.send(one_msg)
+            for i in range(img_nu + 1):
+                if _problem_list:
+                    one_img = image(
+                        b64=(await text2image("\n".join(_problem_list[:max_line]),
+                                              padding=10,
+                                              color="#f9f6f2",
+                                              )).pic2bs4()
+                    )
+                    if img_nu > 2:
+                        pic_list.append(one_img)
+                    else:
+                        await show_word.send(one_img)
+                del _problem_list[:max_line]
+            if pic_list:
+                for img in pic_list:
+                    data = {
+                        "type": "node",
+                        "data": {"name": f"{NICKNAME}", "uin": f"{bot.self_id}", "content": img},
+                    }
+                    mes_list.append(data)
+                await bot.send_group_forward_msg(group_id=event.group_id, messages=mes_list)
+        else:
+            await show_word.send(
+                image(
+                    b64=(await text2image(
+                        "该群已收录的词条：\n\n" + "\n".join(_problem_list),
+                        padding=10,
+                        color="#f9f6f2",
+                    )).pic2bs4()
+                )
+            )
+    else:
+        _answer_list = await WordBank.get_group_all_answer(event.group_id, msg)
+        if not _answer_list:
+            await show_word.send("未收录该词条...")
+
+        else:
+
+            # 解析图片和@
+            _answer_img_nu_list = [await get_one_answer(event, format, answer, 0) for answer, format in _answer_list]
+            word_nu = len(_answer_img_nu_list)
+            img_nu = 0
+            answer = f"词条 {msg} 回答："
+            for i, x, in enumerate(_answer_img_nu_list):
+                r = re.findall(rf"\[CQ:image,file=", str(x))
+                if r:
+                    img_nu += len(r)
+                answer += "\n" + f"{i}." + x
+            if (img_nu > 2 and word_nu > 5) or word_nu > 10 or img_nu > 4:
+                data = {
+                    "type": "node",
+                    "data": {"name": f"{NICKNAME}", "uin": f"{bot.self_id}", "content": answer},
+                }
+                await bot.send_group_forward_msg(group_id=event.group_id, messages=data)
+            else:
+                await show_word.send(answer)
+            # await show_word.send(f"词条 {msg} 回答：\n" + "\n".join(_answer_list))
+
+
+async def get__builder(event, _problem, answer, idx):
     (data_dir / f"{event.group_id}").mkdir(exist_ok=True, parents=True)
     _builder = WordBankBuilder(event.user_id, event.group_id, _problem)
     for at_ in get_message_at(event.json()):
@@ -108,67 +282,4 @@ async def _(bot: Bot, event: GroupMessageEvent, state: T_State, arg: Message = C
             _builder.set_placeholder(idx, f"__placeholder_{rand}_{idx}.jpg")
             idx += 1
     _builder.set_answer(answer)
-    await _builder.save()
-    logger.info(f"已保存词条 问：{problem} 答：{msg}")
-    await add_word.send(f"已保存词条：{problem}")
-
-
-@delete_word.handle()
-async def _(event: GroupMessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    if not msg:
-        await delete_word.finish("此命令之后需要跟随指定词条，通过“显示词条“查看")
-    index = None
-    _sp_msg = msg.split()
-    if len(_sp_msg) > 1:
-        if is_number(_sp_msg[-1]):
-            index = int(_sp_msg[-1])
-            msg = " ".join(_sp_msg[:-1])
-    problem = msg
-    if problem.startswith("id:"):
-        x = problem.split(":")[-1]
-        if not is_number(x) or int(x) < 0:
-            await delete_word.finish("id必须为数字且符合规范！")
-        p = await WordBank.get_group_all_problem(event.group_id)
-        if p:
-            problem = p[int(x)]
-    try:
-        if answer := await WordBank.delete_problem_answer(
-            event.user_id, event.group_id, problem, index
-        ):
-            await delete_word.send(f"删除词条成功：{problem}\n回答：\n{answer}")
-            logger.info(
-                f"(USER {event.user_id}, GROUP "
-                f"{event.group_id if isinstance(event, GroupMessageEvent) else 'private'})"
-                f" 删除词条: {problem}"
-            )
-        else:
-            await delete_word.send(f"删除词条：{problem} 失败，可能该词条不存在")
-    except IndexError:
-        await delete_word.send("指定下标错误...请通过查看词条来确定..")
-
-
-@show_word.handle()
-async def _(event: GroupMessageEvent, arg: Message = CommandArg()):
-    msg = arg.extract_plain_text().strip()
-    if not msg:
-        _problem_list = await WordBank.get_group_all_problem(event.group_id)
-        if not _problem_list:
-            await show_word.finish("该群未收录任何词条..")
-        _problem_list = [f"\t{i}. {x}" for i, x in enumerate(_problem_list)]
-        await show_word.send(
-            image(
-                b64=(await text2image(
-                    "该群已收录的词条：\n\n" + "\n".join(_problem_list),
-                    padding=10,
-                    color="#f9f6f2",
-                )).pic2bs4()
-            )
-        )
-    else:
-        _answer_list = await WordBank.get_group_all_answer(event.group_id, msg)
-        if not _answer_list:
-            await show_word.send("未收录该词条...")
-        else:
-            _answer_list = [f"{i}. {x}" for i, x in enumerate(_answer_list)]
-            await show_word.send(f"词条 {msg} 回答：\n" + "\n".join(_answer_list))
+    return _builder

pyproject.toml

@@ -36,6 +36,10 @@ ujson = "^5.1.0"
 matplotlib = "^3.5.1"
 black = "^22.1.0"
 pypinyin = "^0.46.0"
+dateparser = "^1.1.0"
+cn2an = "^0.5.16"
+python-jose = "^3.3.0"
+python-multipart = "^0.0.5"
 
 [tool.poetry.dev-dependencies]