nonebot-plugin-l4d2-server 1.0.3__py3-none-any.whl → 1.0.4__py3-none-any.whl

nonebot_plugin_l4d2_server/__main__.py

@@ -16,7 +16,7 @@
 """
 
 from pathlib import Path
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, List, Optional, Union
 
 import aiofiles
 import ujson as json
@@ -24,10 +24,11 @@ from nonebot.adapters import Message
 from nonebot.log import logger
 from nonebot.matcher import Matcher
 from nonebot.params import CommandArg, CommandStart, RawCommand
+from nonebot.permission import SUPERUSER
 from nonebot.plugin import on_command
 from nonebot_plugin_alconna import UniMessage
 
-from .config import config
+from .config import config, config_manager
 from .l4_help import get_l4d2_core_help
 from .l4_local import *  # noqa: F403
 from .l4_request import (
@@ -45,7 +46,7 @@ if TYPE_CHECKING:
 
 reload_ip()
 
-l4_help = on_command("l4help", aliases={"l4帮助", "l4d2帮助"})
+l4_help = on_command("l4help", aliases={"l4d2帮助"})
 l4_request = on_command("anne", aliases=COMMAND, priority=10)
 l4_reload = on_command("l4reload", aliases={"l4刷新,l4重载"})
 l4_all = on_command("l4all", aliases={"l4全服"})
@@ -59,13 +60,11 @@ config_path = Path(config.l4_path) / "config.json"
 
 
 @l4_help.handle()
-async def _(matcher: Matcher):
+async def _():
     """帮助"""
     logger.info("开始执行[l4d2帮助]")
     im = await get_l4d2_core_help()
-    if isinstance(im, str):
-        await matcher.finish(im)
-    await UniMessage.image(raw=im).send()
+    await out_msg_out(im)
 
 
 @l4_request.handle()
@@ -74,11 +73,31 @@ async def _(
     command: str = RawCommand(),
     args: Message = CommandArg(),
 ):
-    """例：
-    指令：  /橘5
-    start: /(command开头指令)
-    command: /橘(响应的全部指令)
-    args: 5(响应的指令后的数字)
+    """
+    异步函数，用于处理特定的指令。
+
+    Args:
+        start (str, optional): 指令的开头部分，默认为 CommandStart() 返回的值。
+        command (str, optional): 完整的指令字符串，默认为 RawCommand() 返回的值。
+        args (Message, optional): 指令后的参数，默认为 CommandArg() 返回的值。
+
+    Returns:
+        None
+
+    Examples:
+        示例指令："/橘5"
+        - start: "/" (指令的开头部分)
+        - command: "/橘" (完整的指令字符串)
+        - args: "5" (指令后的参数)
+
+    Notes:
+        1. 如果 start 存在，会将 command 中的 start 部分替换为空字符串。
+        2. 如果 command 等于 "anne"，则将其替换为 "云"。
+        3. 提取 args 中的纯文本内容，如果内容非空且不是数字，则返回。
+        4. 如果 args 为空，则将其设置为 None。
+        5. 使用 logger 记录处理过程中的信息。
+        6. 调用 get_server_detail 函数获取服务器详情，并根据返回结果发送相应的消息。
+        7. 如果 get_server_detail 返回 None，则发送 "服务器无响应" 的文本消息。
     """
 
     if start:
@@ -93,12 +112,9 @@ async def _(
     logger.info(f"组:{command} ;数字:{_id}")
     msg = await get_server_detail(command, _id)
     if msg is not None:
-        if isinstance(msg, str):
-            await UniMessage.text(msg).finish()
-        if isinstance(msg, bytes):
-            await UniMessage.image(raw=msg).finish()
+        await out_msg_out(msg, is_connect=config.l4_image)
     else:
-        await UniMessage.text("服务器无响应").finish()
+        await out_msg_out("服务器无响应")
 
 
 @l4_find_player.handle()
@@ -120,32 +136,26 @@ async def _(
     if len(tag_list) == 2:
         group, name = tag_list
         await UniMessage.text(f"正在查询{group}组").send()
-        out: List[OutServer] = await get_server_detail(group, is_img=False)  # type: ignore
+        out: List[OutServer] = await get_server_detail(group=group, is_img=False)  # type: ignore
         out_msg = "未找到玩家"
         for one in out:
             for player in one["player"]:
                 if name in player.name:
                     out_msg = await get_ip_server(f"{one['host']}:{one['port']}")
 
-    return await UniMessage.text(out_msg).finish()
+    return await out_msg_out(out_msg)
 
 
 @l4_all.handle()
 async def _():
-    await UniMessage.text(await get_all_server_detail()).finish()
+    await out_msg_out(await get_all_server_detail())
 
 
 @l4_connect.handle()
 async def _(args: Message = CommandArg()):
     ip: Optional[str] = args.extract_plain_text()
     if ip is not None:
-        await UniMessage.text(await get_ip_server(ip)).finish()
-
-
-# anne部分
-if config.l4_anne:
-    logger.info("加载anne功能")
-    from .l4_anne import *  # noqa: F403
+        await out_msg_out(await get_ip_server(ip), is_connect=config.l4_image)
 
 
 @l4_reload.handle()
@@ -161,7 +171,7 @@ async def _(args: Message = CommandArg()):
         for tag, url in ip_json.items():
             logger.info(f"重载{tag}的ip")
             await L4API.get_sourceban(tag, url)
-        await UniMessage.text("重载ip完成").finish()
+        await out_msg_out("重载ip完成")
 
 
 l4_add_ban = on_command("l4addban", aliases={"l4添加ban"})
@@ -192,7 +202,7 @@ async def _(args: Message = CommandArg()):
         await UniMessage.text(f"文件写入失败: {e}").finish()
 
     await L4API.get_sourceban(arg[0], arg[1])
-    await UniMessage.text(f"添加成功\n组名: {arg[0]}\n网址: {arg[1]}").finish()
+    await out_msg_out(f"添加成功\n组名: {arg[0]}\n网址: {arg[1]}")
 
 
 l4_del_ban = on_command("l4delban", aliases={"l4删除ban", "l4移除ban"})
@@ -219,7 +229,7 @@ async def _(args: Message = CommandArg()):
                 del config_data[arg[0]]
             async with aiofiles.open(config_path, "w", encoding="utf-8") as f:
                 json.dump(config_data, f, ensure_ascii=False, indent=4)
-            await UniMessage.text(f"删除成功，组名:{arg[0]}").finish()
+            await out_msg_out(f"删除成功，组名:{arg[0]}")
     elif len(arg) == 2:
         if not Path(Path(config.l4_path) / "config.json").is_file():
             await UniMessage.text("没有添加过组名").finish()
@@ -236,7 +246,7 @@ async def _(args: Message = CommandArg()):
                 config_datas[arg[0]] = arg[1]
                 async with aiofiles.open(config_path, "w", encoding="utf-8") as f:
                     json.dump(config_datas, f, ensure_ascii=False, indent=4)
-                await UniMessage.text(f"修改成功，组名:{arg[0]},网址:{arg[1]}").finish()
+                await out_msg_out(f"修改成功，组名:{arg[0]},网址:{arg[1]}")
 
 
 @ld_tj.handle()
@@ -249,3 +259,39 @@ async def _(matcher: Matcher):
 async def _(matcher: Matcher):
     await matcher.send("正在寻找牢房信息")
     await matcher.finish(await tj_request("云", "zl"))
+
+
+async def out_msg_out(
+    msg: Union[str, bytes, UniMessage],
+    is_connect: bool = False,
+    host: str = "",
+    port: str = "",
+):
+    if isinstance(msg, UniMessage):
+        return await msg.finish()
+    if isinstance(msg, str):
+        await UniMessage.text(msg).finish()
+    if is_connect:
+        out = UniMessage.image(raw=msg) + UniMessage.text(
+            f"连接到服务器: {host}:{port}",
+        )
+        return await out.finish()
+    return await UniMessage.image(raw=msg).finish()
+
+
+## 以下为配置修改
+
+img_trung = on_command("l4img", aliases={"l4图片"}, permission=SUPERUSER)
+
+
+@img_trung.handle()
+async def _(args: Message = CommandArg()):
+    arg = args.extract_plain_text().strip().lower()
+    if arg == "开启":
+        config_manager.update_image_config(enabled=True)
+        await out_msg_out("[l4]已开启图片模式")
+    elif arg == "关闭":
+        config_manager.update_image_config(enabled=False)
+        await out_msg_out("[l4]已关闭图片模式")
+    else:
+        await UniMessage.text("请在参数后加上开启或关闭").finish()

nonebot_plugin_l4d2_server/config.py

@@ -20,11 +20,9 @@ map_index = 0
 
 
 class ConfigModel(BaseModel):
-    l4_anne: bool = False
-    """是否启用anne电信服相关功能"""
     l4_enable: bool = True
     """是否全局启用求生功能"""
-    l4_image: bool = False
+    l4_image: bool = True
     """是否启用图片"""
     l4_connect: bool = True
     """是否在查服命令后加入connect ip"""
@@ -43,3 +41,54 @@ class ConfigModel(BaseModel):
 
 
 config = get_plugin_config(ConfigModel)
+
+
+class ConfigManager:
+    """配置项管理类，提供类型安全的配置更新方法"""
+
+    def __init__(self):
+        self._config = config
+
+    def update_image_config(self, enabled: bool) -> None:
+        """更新图片配置
+
+        Args:
+            enabled: 是否启用图片功能
+        """
+        self._config.l4_image = enabled
+
+    def update_style_config(self, style: str) -> None:
+        """更新图片风格配置
+
+        Args:
+            style: 图片风格名称
+        """
+        if not isinstance(style, str):
+            raise TypeError("style必须是字符串")
+        self._config.l4_style = style
+
+    def update_connect_config(self, enabled: bool) -> None:
+        """更新connect ip配置
+
+        Args:
+            enabled: 是否在查服命令后加入connect ip
+        """
+        self._config.l4_connect = enabled
+
+    def update(self, **kwargs) -> None:
+        """通用配置更新方法
+
+        Args:
+            **kwargs: 要更新的配置项键值对
+
+        Raises:
+            ValueError: 当传入无效的配置项时
+        """
+        for key, value in kwargs.items():
+            if hasattr(self._config, key):
+                setattr(self._config, key, value)
+            else:
+                raise ValueError(f"无效的配置项: {key}")
+
+
+config_manager = ConfigManager()

nonebot_plugin_l4d2_server/l4_help/__init__.py

@@ -10,7 +10,7 @@ from ..l4_image.convert import core_font
 from ..l4_image.model import PluginHelp
 from .draw import get_help
 
-__version__ = "1.0.3"
+__version__ = "1.0.4"
 TEXT_PATH = Path(__file__).parent / "texture2d"
 HELP_DATA = Path(__file__).parent / "Help.json"
 

nonebot_plugin_l4d2_server/l4_request/__init__.py

@@ -1,11 +1,12 @@
 import random
-from typing import Dict, List, Optional, cast
+from typing import Dict, List, Optional, Tuple, Union, cast
 
 from nonebot.log import logger
+from nonebot_plugin_alconna import UniMessage
 
 from ..config import server_all_path
 from ..l4_image import msg_to_image
-from ..utils.api.models import AllServer, NserverOut, OutServer
+from ..utils.api.models import AllServer, NserverOut
 from ..utils.api.request import L4API
 from ..utils.utils import split_maohao
 from .draw_msg import convert_duration, draw_one_ip, get_much_server
@@ -79,48 +80,127 @@ async def get_server_detail(
         command (str): 服务器组名。
         _id (Optional[str], optional): 服务器ID。默认为None。
         is_img (bool, optional): 是否返回图片格式的信息。默认为True。
+        return_host_port (bool, optional): 是否返回host和port值。默认为False。
 
     Returns:
-        Union[bytes, List[OutServer], None]: 返回服务器详细信息。如果为图片格式，返回bytes类型；
-                                            如果不是图片格式，返回List[OutServer]类型；如果未找到服务器组，返回None。
-
+        Union[bytes, str, None, Tuple[str, int]]:
+            如果return_host_port为True且_id不为None，返回(host, port)元组；
+            否则返回服务器详细信息(图片格式返回bytes，文本格式返回str)；
+            未找到服务器组返回None。
     """
-    if command:
-        server_json = ALLHOST.get(command)
-    else:
-        server_json = []
-        for servers in ALLHOST.values():
-            server_json.extend(servers)
-
+    server_json = _get_server_json(command)
     logger.info(server_json)
     if server_json is None:
         logger.warning("未找到这个组")
         return None
 
     if _id is None:
-        # 输出组信息
-        logger.info(f"正在请求组服务器信息 {command}")
-        server_dict = await get_much_server(server_json, command)
-        if is_img:
-            out_msg = await msg_to_image(server_dict)
-        else:
-            out_msg = server_dict
-        return out_msg
+        return await _handle_group_info(server_json, command, is_img)
 
-    # 返回单个
-    logger.info("正在请求单服务器信息")
-    out_msg = ""
+    _ip = await get_single_server_info(server_json, _id)
+    if _ip is None:
+        logger.warning("未找到这个服务器")
+        return None
+
+    out_msg = await _handle_single_server(server_json, _id, is_img)
+    if isinstance(out_msg, bytes):
+        return UniMessage.image(raw=out_msg) + UniMessage.text(
+            f"connect {_ip[0]}:{_ip[1]}",
+        )
+    if isinstance(out_msg, str):
+        return UniMessage.text(out_msg)
+    return None
+
+
+def _get_server_json(command: str) -> Optional[list]:
+    """
+    根据命令获取服务器JSON列表
+
+    Args:
+        command (str): 服务器组名
+
+    Returns:
+        Optional[list]: 服务器JSON列表，未找到组时返回None
+    """
+    if command:
+        return ALLHOST.get(command)
+    server_json = []
+    for servers in ALLHOST.values():
+        server_json.extend(servers)
+    return server_json
+
+
+async def _handle_group_info(
+    server_json: list,
+    command: str,
+    is_img: bool,
+) -> Union[bytes, str, None]:
+    """
+    处理服务器组信息请求
+
+    Args:
+        server_json (list): 服务器JSON列表
+        command (str): 服务器组名
+        is_img (bool): 是否返回图片格式
+
+    Returns:
+        Union[bytes, list, None]: 图片格式返回bytes，否则返回服务器列表
+    """
+    logger.info(f"正在请求组服务器信息 {command}")
+    server_dict = await get_much_server(server_json, command)
+    if is_img:
+        return await msg_to_image(server_dict)
+    return str(server_dict)
+
+
+async def get_single_server_info(
+    server_json: list,
+    _id: str,
+) -> Optional[Tuple[str, int]]:
+    """
+    获取单个服务器的host和port信息
+
+    Args:
+        server_json (list): 服务器JSON列表
+        _id (str): 服务器ID
+
+    Returns:
+        Optional[Tuple[str, int]]: 返回(host, port)元组，未找到返回None
+    """
+    logger.info("正在获取单服务器信息")
     for i in server_json:
         if str(_id) == str(i["id"]):
-            out_msg = await draw_one_ip(i["host"], i["port"])
-            if is_img:
-                return cast(bytes, out_msg)
-            if not is_img:
-                return cast(List[OutServer], out_msg)
-    # print(out_msg)
+            return i["host"], i["port"]
     return None
 
 
+async def _handle_single_server(
+    server_json: list,
+    _id: str,
+    is_img: bool,
+) -> Union[bytes, str, None]:
+    """
+    处理单个服务器信息请求
+
+    Args:
+        server_json (list): 服务器JSON列表
+        _id (str): 服务器ID
+        is_img (bool): 是否返回图片格式
+
+    Returns:
+        Union[bytes, str, None]: 找到服务器时返回信息，否则返回None
+    """
+    server_info = await get_single_server_info(server_json, _id)
+    if server_info is None:
+        return None
+
+    host, port = server_info
+    out_msg = await draw_one_ip(host, port)
+    if is_img:
+        return cast(bytes, out_msg)
+    return out_msg
+
+
 async def get_group_detail(
     command: str,
 ):

nonebot_plugin_l4d2_server/l4_request/draw_msg.py

@@ -1,56 +1,193 @@
 import asyncio
 
 # from logging import log
+import io
+from pathlib import Path
 from typing import List, Tuple
 
+from nonebot.log import logger
+from PIL import Image, ImageDraw, ImageFont
+
 from ..config import config
 from ..utils.api.models import NserverOut, OutServer
 from ..utils.api.request import L4API
 
 
-async def draw_one_ip(host: str, port: int):
+async def draw_one_ip(host: str, port: int, is_img: bool = config.l4_image):
     """输出单个ip"""
-    # 先用文字凑合
     try:
         ser_list = await L4API.a2s_info([(host, port)], is_player=True)
     except asyncio.exceptions.TimeoutError:
         return "服务器无响应"
-    player_msg = ""
     one_server = ser_list[0][0]
     one_player = ser_list[0][1]
 
-    if len(one_player):
-        max_duration_len = max(
-            [len(str(await convert_duration(i.duration))) for i in one_player],
-        )
-        max_score_len = max(len(str(i.score)) for i in one_player)
-
-        for player in one_player:
-            soc = "[{:>{}}]".format(player.score, max_score_len)
-            chines_dur = await convert_duration(player.duration)
-            dur = "{:^{}}".format(chines_dur, max_duration_len)
-            name_leg = len(player.name)
-            if name_leg > 2:
-                xing = "*" * (name_leg - 2)
-                name = f"{player.name[0]}{xing}{player.name[-1]}"
-            else:
-                name = player.name
-            player_msg += f"{soc} | {dur} | {name} \n"
-    else:
-        player_msg = "服务器感觉很安静啊"
-
-    msg = f"""*{one_server.server_name}*
-游戏: {one_server.folder}
-地图: {one_server.map_name}
-人数: {one_server.player_count}/{one_server.max_players}"""
-    if one_server.ping is not None:
-        msg += f"""
-ping: {one_server.ping * 1000:.0f}ms
-{player_msg}"""
-    if config.l4_show_ip:
-        msg += f"""
+    async def format_player_info(players: list) -> str:
+        """格式化玩家信息
+        Args:
+            players: 玩家对象列表
+        Returns:
+            格式化后的玩家信息字符串
+        """
+        player_msg = ""
+        if len(players):
+            max_duration_len = max(
+                [len(str(await convert_duration(i.duration))) for i in players],
+            )
+            max_score_len = max(len(str(i.score)) for i in players)
+
+            for player in players:
+                soc = "[{:>{}}]".format(player.score, max_score_len)
+                chines_dur = await convert_duration(player.duration)
+                dur = "{:^{}}".format(chines_dur, max_duration_len)
+                name_leg = len(player.name)
+                if name_leg > 2:
+                    xing = ":)" * (name_leg - 2)
+                    name = f"{player.name[0]}{xing}{player.name[-1]}"
+                else:
+                    name = player.name
+                player_msg += f"{soc} | {dur} | {name} \n"
+        else:
+            player_msg = "服务器感觉很安静啊"
+        return player_msg
+
+    def build_server_message(server, player_info: str) -> str:
+        """构建服务器信息消息
+        Args:
+            server: 服务器对象
+            player_info: 格式化后的玩家信息字符串
+        Returns:
+            完整的服务器信息字符串
+        """
+        msg = f"""-{server.server_name}-
+游戏: {server.folder}
+地图: {server.map_name}
+人数: {server.player_count}/{server.max_players}"""
+        if server.ping is not None:
+            msg += f"""
+ping: {server.ping * 1000:.0f}ms
+{player_info}"""
+        if config.l4_show_ip:
+            msg += f"""
 connect {host}:{port}"""
-    return msg
+        return msg
+
+    def draw_text_on_image(
+        text: str,
+        font: ImageFont.FreeTypeFont,
+        draw: ImageDraw.ImageDraw,
+    ) -> Image.Image:
+        """在图片上绘制文本
+        Args:
+            text: 要绘制的文本
+            font: PIL字体对象
+            draw: PIL绘图对象
+        Returns:
+            包含绘制文本的PIL图片对象
+        """
+        try:
+            # 分割文本为标题行和内容行
+            lines = text.split("\n")
+            if not lines:
+                return Image.new("RGB", (600, 400), color=(73, 109, 137))
+
+            title = lines[0]
+            content = "\n".join(lines[1:]) if len(lines) > 1 else ""
+
+            # 计算各部分文字尺寸
+            title_bbox = font.getbbox(title)
+            title_width = title_bbox[2] - title_bbox[0]
+            title_height = title_bbox[3] - title_bbox[1]
+
+            content_width = 0
+            content_height = 0
+            if content:
+                content_lines = content.split("\n")
+                line_height = font.getbbox("A")[3] - font.getbbox("A")[1]
+                content_height = len(content_lines) * line_height
+                content_width = max(
+                    font.getbbox(line)[2] - font.getbbox(line)[0]
+                    for line in content_lines
+                )
+
+            # 计算图片尺寸
+            margin = 20
+            line_spacing = 5
+            img_width = max(title_width, content_width) + 2 * margin
+            content_lines_count = len(content.split("\n")) if content else 0
+            img_height = max(
+                title_height
+                + content_height
+                + (line_spacing + 1) * max(0, content_lines_count - 1)
+                + 2 * margin,
+                300,
+            )
+
+            # 加载背景图片
+            bg_path = (
+                Path(__file__).parent.parent / "l4_image" / "img" / "anne" / "back.png"
+            )
+            try:
+                img = Image.open(bg_path)
+                # 调整背景图尺寸
+                img = img.resize((int(img_width), int(img_height)))
+                logger.info(f"图片像素大小: {img.width}x{img.height}")
+                draw = ImageDraw.Draw(img)
+
+                title_x = (img_width - title_width) // 2
+                title_y = margin
+                draw.text((title_x, title_y), title, font=font, fill=(255, 255, 255))
+
+                if content:
+                    content_x = margin
+                    content_y = title_y + title_height + margin
+                    draw.text(
+                        (content_x, content_y),
+                        content,
+                        font=font,
+                        fill=(255, 255, 255),
+                        spacing=line_spacing,
+                    )
+
+                    return img
+            except Exception as e:
+                logger.error(f"加载背景图片失败: {e}")
+                img = Image.new(
+                    "RGB",
+                    (int(img_width), int(img_height)),
+                    color=(73, 109, 137),
+                )
+                draw = ImageDraw.Draw(img)
+                draw.text((title_x, title_y), title, font=font, fill=(255, 255, 255))
+                if content:
+                    draw.text(
+                        (content_x, content_y),
+                        content,
+                        font=font,
+                        fill=(255, 255, 255),
+                        spacing=line_spacing,
+                    )
+                return img
+        except Exception as e:
+            logger.error(f"绘制图片时出错: {e}")
+            error_img = Image.new("RGB", (600, 400), color=(255, 0, 0))
+            error_draw = ImageDraw.Draw(error_img)
+            error_draw.text((10, 10), "图片生成失败", fill=(255, 255, 255))
+            return error_img
+
+    player_info = await format_player_info(one_player)
+    server_message = build_server_message(one_server, player_info)
+
+    if is_img:
+        # 加载字体
+        font_path = Path(__file__).parent.parent / "data" / "font" / "loli.ttf"
+        font = ImageFont.truetype(str(font_path), 18)
+        draw = ImageDraw.Draw(Image.new("RGB", (600, 400), color=(73, 109, 137)))
+        img = draw_text_on_image(server_message, font, draw)
+        img_byte_arr = io.BytesIO()
+        img.save(img_byte_arr, format="PNG")
+        return img_byte_arr.getvalue()
+    return server_message
 
 
 async def get_much_server(server_json: List[NserverOut], command: str):
@@ -64,7 +201,7 @@ async def get_much_server(server_json: List[NserverOut], command: str):
     for index, i in enumerate(all_server):
         out_server.append(
             {
-                "server": i[0],
+                "server": i[0],  # type: ignore
                 "player": i[1],
                 "host": server_json[index]["host"],
                 "port": server_json[index]["port"],

nonebot_plugin_l4d2_server/utils/api/models.py

@@ -22,7 +22,7 @@ class NserverOut(TypedDict):
 
 
 class OutServer(TypedDict):
-    server: a2s.SourceInfo
+    server: a2s.SourceInfo[str]
     player: List[a2s.Player]
     host: str
     port: int

nonebot_plugin_l4d2_server/utils/api/request.py

@@ -3,7 +3,7 @@ import contextlib
 import socket
 from copy import deepcopy
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional, Tuple, cast
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union, cast
 
 import a2s
 import aiofiles
@@ -47,8 +47,12 @@ class L4D2Api:
         ip_list: List[Tuple[str, int]],
         is_server: bool = True,
         is_player: bool = False,
-    ) -> List[Tuple[a2s.SourceInfo, List[a2s.Player]]]:
-        msg_list: List[Tuple[a2s.SourceInfo, List[a2s.Player]]] = []
+    ) -> List[
+        Tuple[Union[a2s.SourceInfo[str], a2s.GoldSrcInfo[str]], List[a2s.Player]]
+    ]:
+        msg_list: List[
+            Tuple[Union[a2s.SourceInfo[str], a2s.GoldSrcInfo[str]], List[a2s.Player]]
+        ] = []
         sorted_msg_list = []
         tasks = []  # 用来保存异步任务
         if ip_list != []:
@@ -80,19 +84,24 @@ class L4D2Api:
         is_player: bool,
     ):
         play: List[a2s.Player] = []
+        server: Union[a2s.SourceInfo, a2s.GoldSrcInfo]
         if is_server:
             try:
-                server: a2s.SourceInfo = await a2s.ainfo(ip, timeout=3, encoding="utf8")
+                server = await a2s.ainfo(
+                    ip,
+                    timeout=3,
+                    encoding="utf8",
+                )
 
                 if server is not None:
-                    server.steam_id = index
+                    server.steam_id = index  # type: ignore
 
             except (
                 asyncio.exceptions.TimeoutError,
                 ConnectionRefusedError,
                 socket.gaierror,
             ):
-                server: a2s.SourceInfo = a2s.SourceInfo(
+                server = a2s.SourceInfo(
                     protocol=0,
                     server_name="服务器无响应",
                     map_name="无",
@@ -137,7 +146,7 @@ class L4D2Api:
         json: Optional[Dict[str, Any]] = None,
         data: Optional[Dict[str, Any]] = None,
         is_json: bool = True,
-    ):
+    ) -> Union[Dict[str, Any], BeautifulSoup]:  # type: ignore
         header = deepcopy(self._HEADER)
 
         if json is not None:
@@ -181,7 +190,17 @@ class L4D2Api:
             return BeautifulSoup(html_content, "lxml")
 
     async def get_sourceban(self, tag: str = "云", url: str = anne_ban):
-        """从sourceban++获取服务器列表，目前未做名称处理"""
+        """
+        异步函数，从sourceban++获取服务器列表，目前未做名称处理。
+
+        Args:
+            tag (str): 用于标识不同来源的标签，默认为"云"。
+            url (str): SourceBan的URL，默认为anne_ban。
+
+        Returns:
+            list: 包含服务器信息的列表。
+
+        """
         if not (url.startswith(("http://", "https://"))):
             url = "http://" + url  # 默认添加 http://
         soup = await self._server_request(
@@ -272,14 +291,14 @@ class L4D2Api:
         if not isinstance(soup, BeautifulSoup):
             return None
 
-        tbody = soup.find(
+        tbody = cast(BeautifulSoup, soup).find(
             "div",
             class_="content text-center text-md-left",
             style="background-color: #f2f2f2;",
         )
         if tbody is None:
             return None
-        kill_tag = tbody.find(
+        kill_tag = cast(BeautifulSoup, tbody).find(
             "div",
             class_="card-body worldmap d-flex flex-column justify-content-center text-center",
         )

nonebot_plugin_l4d2_server/utils/utils.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, List, Optional, Tuple
 import aiofiles
 import aiohttp
 import nonebot
+from aiohttp import ClientTimeout
 from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, MessageEvent
 from nonebot.log import logger
 from nonebot_plugin_alconna import UniMessage
@@ -184,7 +185,11 @@ async def url_to_byte(url: str):
     """获取URL数据的字节流"""
 
     async with aiohttp.ClientSession() as session:
-        async with session.get(url, headers=headers, timeout=600) as response:
+        async with session.get(
+            url,
+            headers=headers,
+            timeout=ClientTimeout(total=600),
+        ) as response:
             if response.status == 200:
                 return await response.read()
             return None
@@ -194,7 +199,11 @@ async def url_to_msg(url: str):
     """获取URL数据的字节流"""
 
     async with aiohttp.ClientSession() as session:
-        async with session.get(url, headers=headers, timeout=600) as response:
+        async with session.get(
+            url,
+            headers=headers,
+            timeout=ClientTimeout(total=600),
+        ) as response:
             if response.status == 200:
                 return await response.text()
             return None

{nonebot_plugin_l4d2_server-1.0.3.dist-info → nonebot_plugin_l4d2_server-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-l4d2-server
-Version: 1.0.3
+Version: 1.0.4
 Summary: L4D2 server related operations plugin for NoneBot2
 Keywords: steam,game,l4d2,nonebot2,plugin
 Author-Email: Agnes_Digital <Z735803792@163.com>
@@ -32,7 +32,7 @@ Requires-Dist: ujson>=5.10.0
 Requires-Dist: lxml>=5.2.2
 Requires-Dist: rcon>=2.1.0
 Requires-Dist: pillow>10
-Requires-Dist: beautifulsoup4>=4.12.3
+Requires-Dist: bs4>=0.0.2
 Requires-Dist: rarfile>=4.2
 Requires-Dist: pyunpack>=0.3
 Requires-Dist: aiofiles>=24.1.0
@@ -47,7 +47,7 @@ Description-Content-Type: text/markdown
 
 <div align="center">
 
-# nonebot_plugin_l4d2_server 1.0.0a1
+# nonebot_plugin_l4d2_server 1.0.4
 
 _✨Nonebot & Left 4 Dead 2 server操作✨_
 <div align = "center">
@@ -77,15 +77,12 @@ _✨Nonebot & Left 4 Dead 2 server操作✨_
 
 ## 顶置公告（如果以前用0.x.x版本暂时别更新）
 
-- **版本**  1.x.x进行了破坏式更新，目前处于测试阶段，使用旧插件的不要更新
+- **版本**  1.x.x进行了破坏式更新，使用旧插件的不要更新
 
-## 更改部分
+## 指令
 
-- 取消了网页控制台(没有卵用)
-- 取消了自动重启(与其他插件功能重复)
-- 取消了git拉取更新(nb规范用pypi)
-- 增加pil和浏览器渲染做选择(可以选择pil以节省性能性能)
-- 删除无用部分(依赖太多难以维护)
+- 在json文件设置的前缀指令，例如设置"云"，则指令 云 输出组服务器，云1 输出1号服务器
+- l4图片开启/关闭 超管指令 可以修改输出单图是否为图片输出
 
 ## 安装
 
@@ -142,8 +139,7 @@ conda install nonebot-plugin-l4d2-server
 ## 主要功能
 
 - [ ] 求生服务器-本地多路径操作（传地图等）
-- [ ] 批量查询指定ip服务器状态和玩家
-- [ ] [求生电信服anne](https://github.com/fantasylidong/CompetitiveWithAnne)[查询~](https://sb.trygek.com/l4d_stats/ranking/index.php)
+- [x] 批量查询指定ip服务器状态和玩家
 
 ## [数据结构](./docs/standand.md)
 
@@ -152,8 +148,6 @@ conda install nonebot-plugin-l4d2-server
 ## env设置
 
 """bash
-    l4_anne = False
-    """是否启用anne电信服相关功能"""
     l4_enable = True
     """是否全局启用求生功能"""
     l4_image = False
@@ -172,6 +166,15 @@ conda install nonebot-plugin-l4d2-server
     - 缤纷彩虹
 """
 
+## 和0.x.x更改部分
+
+- 取消了网页控制台(没有卵用)
+- 取消了自动重启(与其他插件功能重复)
+- 取消了git拉取更新(nb规范用pypi)
+- 增加pil和浏览器渲染做选择(可以选择pil以节省性能性能)
+- 删除无用部分(依赖太多难以维护)
+- 删除了anne部分，已移植到[这里](https://github.com/Agnes4m/L4D2UID),通过core插件调用
+
 ## 其他
 
 - 本人技术很差，如果您有发现BUG或者更好的建议，欢迎提Issue & Pr

{nonebot_plugin_l4d2_server-1.0.3.dist-info → nonebot_plugin_l4d2_server-1.0.4.dist-info}/RECORD

@@ -1,15 +1,13 @@
-nonebot_plugin_l4d2_server-1.0.3.dist-info/METADATA,sha256=po5LeZo-Nk7oQNuaxa5Ve_3AANnFc4RxG8fnBbcqeK0,6688
-nonebot_plugin_l4d2_server-1.0.3.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-nonebot_plugin_l4d2_server-1.0.3.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-nonebot_plugin_l4d2_server-1.0.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+nonebot_plugin_l4d2_server-1.0.4.dist-info/METADATA,sha256=kZdrFtRaRtfYjXvIapyyUJnulUxQPjtbzRAOHAVyBkA,6763
+nonebot_plugin_l4d2_server-1.0.4.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+nonebot_plugin_l4d2_server-1.0.4.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+nonebot_plugin_l4d2_server-1.0.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 nonebot_plugin_l4d2_server/__init__.py,sha256=PIufOk1bxOx-nYqdoinoB7BcntIETNFwfzqKnmu-teE,1624
-nonebot_plugin_l4d2_server/__main__.py,sha256=AGqPjt0O6dW_E3D93hcqehtsPsvzSRC1qEtx6HqEAGo,8455
-nonebot_plugin_l4d2_server/config.py,sha256=ZLYJr9lVs1Q5en1m4EA0wF7H366EVm8-6AnN8dcyy7c,1394
+nonebot_plugin_l4d2_server/__main__.py,sha256=Z8laU36rLdNq-Qfroj-1t6dbt4rfKLetvJ1cY937oGo,10232
+nonebot_plugin_l4d2_server/config.py,sha256=_UKAn1g5BbykMNc6LXRujKoGhpxIM5JAdh3z301BLHk,2665
 nonebot_plugin_l4d2_server/data/font/loli.ttf,sha256=Yrh-RPoCrn1-NG94DR0x20ASXYUt8g3Ep6BCt3CdOFk,11125812
-nonebot_plugin_l4d2_server/l4_anne/__init__.py,sha256=zX4kTu4LAsqm7_li0-GcihnbYI65SBPkfUCPTs79U8k,4124
-nonebot_plugin_l4d2_server/l4_anne/ranne.py,sha256=vtNQJ-74rJiwVI3IYS3ZgFk_LaCviKU1yxrGk3DFvQs,532
 nonebot_plugin_l4d2_server/l4_help/Help.json,sha256=hz_k-qmGmGJKwCa8wmkHTLzXu6C-G-E_g7xdK-t6fNk,2673
-nonebot_plugin_l4d2_server/l4_help/__init__.py,sha256=YNR3eob0XvRb_-4wIP9ZcSMey0RuFS4RlHMZ217Bn0E,1535
+nonebot_plugin_l4d2_server/l4_help/__init__.py,sha256=sZRp6HJE2hvEcSST7CXJk8eAyv6rj4kLIcOK_7xUTI0,1535
 nonebot_plugin_l4d2_server/l4_help/draw.py,sha256=y6yDPUnoZFvwly8cf7g9HRpT1JXTxyA9DC1TuvUinTM,6448
 nonebot_plugin_l4d2_server/l4_help/icon/介绍.png,sha256=3QC6A38QC-7gDBxmtQSQdbsz7hsefU5LL-oZmJ41zTk,3806
 nonebot_plugin_l4d2_server/l4_help/icon/任务.png,sha256=nyZ4_kM21ZO95nwanCFnUfCGX-PkmJXYQf9OrJVKomY,3782
@@ -88,12 +86,12 @@ nonebot_plugin_l4d2_server/l4_image/model.py,sha256=FGsCvf_BKbRNJUVy6I5BKnArMY-3
 nonebot_plugin_l4d2_server/l4_image/vtfs.py,sha256=He_7zzEIOip8MXP55TS7aWPbzo6ac0wPf602nN3GWZM,1461
 nonebot_plugin_l4d2_server/l4_local/__init__.py,sha256=nz9KUxmuvRrryHakQQ4B30oC9jeGWZ3sON1tCKb-lS0,3603
 nonebot_plugin_l4d2_server/l4_local/file.py,sha256=hew1Y8kV3uSZvUGplmi09EGKC89-sUJWsWV7SCEstI8,3067
-nonebot_plugin_l4d2_server/l4_request/__init__.py,sha256=ukb90pROfHtLbIRSya5pRAGSpzB9Bb5gPi3kAH2-41Y,9588
-nonebot_plugin_l4d2_server/l4_request/draw_msg.py,sha256=efmlEBqbbOozf50InPNqONGIZ0D2hI4xAGPDROIcHBY,2883
+nonebot_plugin_l4d2_server/l4_request/__init__.py,sha256=9Yo6mQ_bIBvMwQubC3Ctie6H2Qzx7ScwCQyVS9y25TE,11682
+nonebot_plugin_l4d2_server/l4_request/draw_msg.py,sha256=koAVWrsDoLCTmwXY-NJTi5yjL1y1ND3daFkDWccQjcU,8071
 nonebot_plugin_l4d2_server/l4_request/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nonebot_plugin_l4d2_server/utils/api/api.py,sha256=auvDicCEKwvnm6EJYeCxCtugFby61K-zAmmaRWWEwtM,296
-nonebot_plugin_l4d2_server/utils/api/models.py,sha256=EKAAM5RsFK-hV-a80tc4r35ToNRhnCWVuQ-7imwBjwE,2386
-nonebot_plugin_l4d2_server/utils/api/request.py,sha256=hugBaPBK-gUr5Xemyk7dSHP1JlzYrEZcXPinkNX0AuU,14987
+nonebot_plugin_l4d2_server/utils/api/models.py,sha256=p-hoxPHwadTaMRb2hqwfbaQ3pvJySrV8VbBmhA0Oi-M,2391
+nonebot_plugin_l4d2_server/utils/api/request.py,sha256=aAsXtxvm7erXLfFCbs6NmsZCRGpsg3tsMdWvSn8SkNU,15575
 nonebot_plugin_l4d2_server/utils/database/models.py,sha256=SLdcgwsn39r_ZkcBoqf4MLX1EfpCOjGBwWcR16u9Bqo,454
-nonebot_plugin_l4d2_server/utils/utils.py,sha256=C-QzwtUCbq7QXmHplpmo3OTKbRztE1W7V-IywvufDl0,5971
-nonebot_plugin_l4d2_server-1.0.3.dist-info/RECORD,,
+nonebot_plugin_l4d2_server/utils/utils.py,sha256=TD3cUCxmmj2GPmK1sQwP7NtkIXNO2FpuXjymaUqBDYo,6141
+nonebot_plugin_l4d2_server-1.0.4.dist-info/RECORD,,

nonebot_plugin_l4d2_server/l4_anne/__init__.py

@@ -1,125 +0,0 @@
-from nonebot import log as log
-from nonebot import on_command
-from nonebot.adapters import Event, Message
-from nonebot.log import logger
-from nonebot.params import CommandArg
-from nonebot_plugin_alconna import UniMessage
-
-from ..utils.api.request import L4API
-from ..utils.database.models import SteamUser
-from ..utils.utils import get_message_at
-from .ranne import get_anne_rank_out
-
-anne_bind = on_command("Banne", aliases={"l4绑定", "anne绑定"}, priority=5, block=True)
-anne_search = on_command("Sanne", aliases={"anne搜索"})
-anne_rank = on_command("Ranne", aliases={"anne成绩"}, block=True, priority=1)
-
-anne_del = on_command(
-    "Danne",
-    aliases={"l4删除", "anne删除", "l4解绑", "anne解绑"},
-    priority=5,
-    block=True,
-)
-
-
-@anne_search.handle()
-async def _(args: Message = CommandArg()):
-    name: str = args.extract_plain_text().strip()
-    print(name)
-    user_list = await L4API.get_anne_steamid(name)
-    if user_list is None:
-        await UniMessage.text("未找到玩家").finish()
-    msg = f"---有{len(user_list)}个玩家---"
-    for index, user in enumerate(user_list, start=1):
-        if index >= 10:
-            break
-        msg += f"""
-        {index}. {user["name"]} | [{user["score"]}] | {user["play_time"]}
-        {user["steamid"]}
-        """
-    if msg:
-        await UniMessage.text("\n".join(msg.splitlines())).finish()
-    else:
-        await UniMessage.text("没有找到玩家").finish()
-
-
-@anne_bind.handle()
-async def _(ev: Event, args: Message = CommandArg()):
-    arg: str = args.extract_plain_text()
-    if not arg:
-        await UniMessage.text("虚空绑定？").finish()
-
-    user = await SteamUser.get_or_none(userid=int(ev.get_user_id()))
-    if user is None:
-        user = await SteamUser.create(userid=int(ev.get_user_id()))
-
-    if len(arg) == 17:
-        # steamid64
-        logger.info(f"SteamID64:{arg}")
-        user.SteamID64 = arg
-        msg = "绑定steamid64"
-
-    elif arg.startswith("STEAM_"):
-        # steamid
-        logger.info(f"SteamID:{arg}")
-        user.SteamID = arg
-        msg = "绑定steamid"
-
-    else:
-        # name
-        logger.info(f"Name:{arg}")
-        user.Name = arg
-        msg = "绑定名字"
-    await user.save()
-
-    return await UniMessage.text(f"{msg}成功").finish()
-
-
-@anne_del.handle()
-async def _(ev: Event):
-    if record := await SteamUser.get_or_none(userid=int(ev.get_user_id())):
-        logger.info(f"删除用户:{record}")
-        await record.delete()
-        await record.save()
-        return await UniMessage.text("删除成功").finish()
-    return await UniMessage.text("没有绑定信息呢").finish()
-
-
-@anne_rank.handle()
-async def _(ev: Event, args: Message = CommandArg()):
-    uid = await get_message_at(str(ev.json()))
-    if uid is None:
-        uid = int(int(ev.get_user_id()))
-    steamid = ""
-    arg: str = args.extract_plain_text().strip()
-    logger.info(f"arg:{arg}")
-    # 优先从数据库查询
-    if not arg:
-        msg = await SteamUser.get_or_none(userid=uid)
-        if msg is not None:
-            steamid = msg.SteamID
-            if not steamid:
-                name = msg.Name
-                if not name:
-                    await UniMessage.text("未绑定名字/steamid").finish()
-                msg_dict = await L4API.get_anne_steamid(name)
-                if not msg_dict:
-                    await UniMessage.text("绑定的昵称找不到呢").finish()
-                steamid = msg_dict[0]["steamid"]
-            logger.info(f"steamid:{steamid}")
-
-    # 再从arg中查找
-    else:
-        if arg.startswith("STEAM_"):
-            steamid = arg
-        else:
-            arg_dict = await L4API.get_anne_steamid(arg)
-            if not arg_dict:
-                await UniMessage.text("未找到该昵称玩家").finish()
-            steamid = arg_dict[0]["steamid"]
-    if not steamid:
-        await UniMessage.text("未找到玩家,请使用指令`l4搜索`查找").finish()
-    out_msg = await get_anne_rank_out(steamid)
-    if out_msg is None:
-        await UniMessage.text("未找到玩家").finish()
-    await UniMessage.text(out_msg).finish()

nonebot_plugin_l4d2_server/l4_anne/ranne.py

@@ -1,18 +0,0 @@
-# coding=utf-8
-# anne战绩查询
-from ..utils.api.request import L4API
-
-
-async def get_anne_rank_out(steamid: str):
-    msg = await L4API.get_anne_playerdetail(steamid)
-    if msg is None:
-        return None
-    return f"""电信anne查询结果：
-    昵称：{msg['info']['name']}
-    排名：{msg['detail']['rank']}
-    分数：{msg['detail']["source"]}
-    击杀：{msg['detail']["kills"]}
-    爆头率：{msg['detail']["avg_source"]}
-    时间：{msg['info']['playtime']}
-    上次：{msg['info']['lasttime']}
-    """