nonebot-plugin-l4d2-server 1.0.4__tar.gz → 1.0.5__tar.gz

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-l4d2-server
-Version: 1.0.4
+Version: 1.0.5
 Summary: L4D2 server related operations plugin for NoneBot2
 Keywords: steam,game,l4d2,nonebot2,plugin
 Author-Email: Agnes_Digital <Z735803792@163.com>
@@ -25,13 +25,13 @@ Requires-Dist: nonebot-plugin-tortoise-orm>=0.1.4
 Requires-Dist: aiohttp>=3.8.4
 Requires-Dist: jinja2>=3.0.0
 Requires-Dist: srctools>=2.3.9
-Requires-Dist: httpx<0.24.1,>=0.22.0
+Requires-Dist: httpx>=0.22.0
 Requires-Dist: msgspec>=0.18.0
 Requires-Dist: python-a2s>=1.4.1
 Requires-Dist: ujson>=5.10.0
 Requires-Dist: lxml>=5.2.2
 Requires-Dist: rcon>=2.1.0
-Requires-Dist: pillow>10
+Requires-Dist: pillow>10.0.0
 Requires-Dist: bs4>=0.0.2
 Requires-Dist: rarfile>=4.2
 Requires-Dist: pyunpack>=0.3

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/nonebot_plugin_l4d2_server/__main__.py

@@ -16,7 +16,7 @@
 """
 
 from pathlib import Path
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, List, Optional
 
 import aiofiles
 import ujson as json
@@ -40,6 +40,7 @@ from .l4_request import (
     tj_request,
 )
 from .utils.api.request import L4API
+from .utils.api.utils import out_msg_out
 
 if TYPE_CHECKING:
     from .utils.api.models import OutServer
@@ -111,10 +112,15 @@ async def _(
         _id = None
     logger.info(f"组:{command} ;数字:{_id}")
     msg = await get_server_detail(command, _id)
-    if msg is not None:
-        await out_msg_out(msg, is_connect=config.l4_image)
-    else:
+    if msg is None:
         await out_msg_out("服务器无响应")
+        return
+    if _id is None:
+        logger.info(f"正在输出组:{command}")
+        await out_msg_out(msg)
+    if _id:
+        logger.info(f"正在输出单服务器:{command} {_id}", is_connect=config.l4_image)
+        await out_msg_out(msg)
 
 
 @l4_find_player.handle()
@@ -161,11 +167,10 @@ async def _(args: Message = CommandArg()):
 @l4_reload.handle()
 async def _(args: Message = CommandArg()):
     arg = args.extract_plain_text().strip()
-    print(arg)
     if not arg:
         reload_ip()
         logger.success("重载ip完成")
-        with (Path(config.l4_path) / "config.json").open("r", encoding="utf-8") as f:
+        with (Path(config.l4_path) / "l4d2.json").open("r", encoding="utf-8") as f:
             content = f.read().strip()
             ip_json = json.loads(content)
         for tag, url in ip_json.items():
@@ -261,24 +266,6 @@ async def _(matcher: Matcher):
     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)

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/nonebot_plugin_l4d2_server/config.py

@@ -6,10 +6,10 @@ from pydantic import BaseModel
 
 DATAPATH = Path(__file__).parent.joinpath("data")
 DATAOUT = Path("data/L4D2")
+DATAOUT.mkdir(parents=True, exist_ok=True)
 if not Path(DATAOUT / "l4d2.json").exists():
     logger.info("文件 l4d2.json 不存在，已创建并初始化为 {}")
     Path(DATAOUT / "l4d2.json").write_text("{}", encoding="utf-8")
-print(DATAOUT.absolute())
 server_all_path = DATAOUT / "l4d2"
 server_all_path.mkdir(parents=True, exist_ok=True)
 

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/nonebot_plugin_l4d2_server/l4_help/Help.json

@@ -28,7 +28,7 @@
       },
       {
         "name": "l4全服",
-        "desc": "返回可以查询的所有服务器组(未完成)",
+        "desc": "返回可以查询的所有服务器组",
         "eg": "/l4全服",
         "need_ck": false,
         "need_sk": false,
@@ -36,43 +36,6 @@
       }
     ]
   },
-  "电信服anne服务": {
-    "desc": "电信anne服相关服务",
-    "data": [
-      {
-        "name": "Banne xx",
-        "desc": "绑定昵称/steamid",
-        "eg": "/Banne 爱丽数码",
-        "need_ck": false,
-        "need_sk": false,
-        "need_admin": false
-      },
-      {
-        "name": "Ranne(玩家)",
-        "desc": "查询anne个人信息,没有参数查自己",
-        "eg": "/Ranne 爱丽数码",
-        "need_ck": false,
-        "need_sk": false,
-        "need_admin": false
-      },
-      {
-        "name": "Sanne(玩家)",
-        "desc": "按昵称查询anne玩家信息",
-        "eg": "/Sanne 爱丽数码",
-        "need_ck": false,
-        "need_sk": false,
-        "need_admin": false
-      },
-      {
-        "name": "Danne(玩家)",
-        "desc": "删除anne玩家信息",
-        "eg": "/Danne 爱丽数码",
-        "need_ck": false,
-        "need_sk": false,
-        "need_admin": false
-      }
-    ]
-  },
   "管理员服务": {
     "desc": "管理可以使用的指令",
     "data": [
@@ -83,7 +46,7 @@
         "need_ck": false,
         "need_sk": false,
         "need_admin": true
-      },      
+      },
       {
         "name": "l4地图上传",
         "desc": "进入交互上传地图文件",

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/nonebot_plugin_l4d2_server/l4_help/__init__.py

@@ -1,8 +1,8 @@
+import json
 from pathlib import Path
 from typing import Dict, Union
 
 import aiofiles
-from msgspec import json as msgjson
 from PIL import Image
 
 from ..config import ICONPATH
@@ -10,18 +10,16 @@ from ..l4_image.convert import core_font
 from ..l4_image.model import PluginHelp
 from .draw import get_help
 
-__version__ = "1.0.4"
+__version__ = "1.0.5"
 TEXT_PATH = Path(__file__).parent / "texture2d"
 HELP_DATA = Path(__file__).parent / "Help.json"
 
 
 async def get_help_data() -> Union[Dict[str, PluginHelp], None]:
     if HELP_DATA.exists():
-        async with aiofiles.open(HELP_DATA, "rb") as file:
-            return msgjson.decode(
-                await file.read(),
-                type=Dict[str, PluginHelp],
-            )
+        async with aiofiles.open(HELP_DATA, "r", encoding="utf-8") as file:
+            content = await file.read()
+            return json.loads(content)
     return None
 
 

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/nonebot_plugin_l4d2_server/l4_image/html_img.py

@@ -45,7 +45,7 @@ async def server_ip_pic(server_dict: List[OutServer]):
                 key=lambda x: x.score,
                 reverse=True,
             )[:max_number]
-            print(sorted_players)
+            logger.debug(sorted_players)
             server_info["player"] = sorted_players
         else:
             server_info["player"] = []

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/nonebot_plugin_l4d2_server/l4_local/__init__.py

@@ -47,7 +47,6 @@ else:
     async def _():
         supath = local_path[map_index] / "addons"
         vpk_list: list[str] = []
-        print(supath)
         if supath.is_dir():
             for sudir in supath.iterdir():
                 logger.info(f"找到文件:{sudir}")

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/nonebot_plugin_l4d2_server/l4_request/__init__.py

@@ -1,22 +1,29 @@
 import random
-from typing import Dict, List, Optional, Tuple, Union, cast
+from typing import Dict, List, Optional, 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 ..config import config, server_all_path
 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
+from .draw_msg import draw_one_ip, get_much_server
+from .utils import (
+    _build_message,
+    _filter_servers,
+    _format_players,
+    _get_server_json,
+    _handle_group_info,
+    _handle_single_server,
+    get_single_server_info,
+)
 
 try:
     import ujson as json
 except ImportError:
     import json
 
-from ..config import config
 
 # 获取全部服务器信息
 ALLHOST: Dict[str, List[NserverOut]] = {}
@@ -88,12 +95,13 @@ async def get_server_detail(
             否则返回服务器详细信息(图片格式返回bytes，文本格式返回str)；
             未找到服务器组返回None。
     """
-    server_json = _get_server_json(command)
+    server_json = _get_server_json(command, ALLHOST)
     logger.info(server_json)
     if server_json is None:
         logger.warning("未找到这个组")
         return None
 
+    # 输出组服务器
     if _id is None:
         return await _handle_group_info(server_json, command, is_img)
 
@@ -112,99 +120,10 @@ async def get_server_detail(
     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"]):
-            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,
 ):
-    server_json = ALLHOST.get(command)
+    server_json = _get_server_json(command, ALLHOST)
     logger.info(server_json)
     if server_json is None:
         logger.warning("未找到这个组")
@@ -222,7 +141,6 @@ async def get_ip_server(ip: str):
 # 以下是重载ip
 def reload_ip():
     global COMMAND
-    # print("正在读取json文件")
     group_ip = []
     for item in server_all_path.iterdir():
         if item.is_file() and item.name.endswith("json"):
@@ -266,74 +184,8 @@ async def tj_request(command: str = "云", tj="tj"):
     player_msg = ""
     right_ip = []
 
-    async def _filter_servers(servers: list, tj_mode: str) -> list:
-        """筛选符合条件的服务器
-        Args:
-            servers: 服务器列表
-            tj_mode: 筛选模式（'tj'或'zl'）
-        Returns:
-            符合条件的服务器列表
-        """
-        filtered = []
-        for i in servers:
-            ser_list = await L4API.a2s_info([(i["host"], i["port"])], is_player=True)
-            if not ser_list:
-                continue
-
-            srv = ser_list[0][0]
-            players = ser_list[0][1]
-
-            if tj_mode == "tj" and map_type in srv.map_name:
-                score = sum(p.score for p in players[:4])
-                t = srv.map_name.split("[")[-1].split("特")[0]
-                if t.isdigit() and int(t) * 50 < score:
-                    logger.info(
-                        f"符合TJ条件的服务器: {i['host']}:{i['port']}, 地图: {srv.map_name}, 分数: {score}",
-                    )
-                    filtered.append(i)
-            elif tj_mode == "zl" and map_type in srv.map_name and len(players) <= 4:
-                logger.info(
-                    f"符合ZL条件的服务器: {i['host']}:{i['port']}, 地图: {srv.map_name}, 玩家数: {len(players)}",
-                )
-                filtered.append(i)
-        return filtered
-
-    async def _format_players(player_list: list) -> str:
-        """格式化玩家信息
-        Args:
-            player_list: 玩家对象列表
-        Returns:
-            格式化后的玩家信息字符串
-        """
-        durations = [await convert_duration(p.duration) for p in player_list]
-        max_duration_len = max(len(str(d)) for d in durations)
-        max_score_len = max(len(str(p.score)) for p in player_list)
-        return "\n".join(
-            f"[{p.score:>{max_score_len}}] | {durations[i]:^{max_duration_len}} | {p.name[0]}***{p.name[-1]}"
-            for i, p in enumerate(player_list)
-        )
-
-    def _build_message(srv_info, players_msg: str, selected_srv: dict) -> str:
-        """构建服务器信息消息
-        Args:
-            srv_info: 服务器信息对象
-            players_msg: 格式化后的玩家信息
-            selected_srv: 选中的服务器信息
-        Returns:
-            完整的消息字符串
-        """
-        msg = f"""*{srv_info.server_name}*
-游戏: {srv_info.folder}
-地图: {srv_info.map_name}
-人数: {srv_info.player_count}/{srv_info.max_players}"""
-        if srv_info.ping is not None:
-            msg += f"\nping: {srv_info.ping * 1000:.0f}ms\n{players_msg}"
-        if config.l4_show_ip:
-            msg += f"\nconnect {selected_srv['host']}:{selected_srv['port']}"
-        return msg
-
     try:
-        right_ip = await _filter_servers(server_json, tj)
+        right_ip = await _filter_servers(server_json, tj, map_type)
 
         if not right_ip:
             logger.warning("没有找到符合条件的服务器")
@@ -356,7 +208,7 @@ async def tj_request(command: str = "云", tj="tj"):
         else:
             player_msg = "服务器感觉很安静啊"
 
-        return _build_message(one_server, player_msg, s)
+        return _build_message(one_server, player_msg, s, config)
 
     except Exception as e:
         logger.error(f"tj_request error: {e}")

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/nonebot_plugin_l4d2_server/l4_request/draw_msg.py

@@ -76,7 +76,7 @@ connect {host}:{port}"""
         text: str,
         font: ImageFont.FreeTypeFont,
         draw: ImageDraw.ImageDraw,
-    ) -> Image.Image:
+    ) -> Image.Image:  # type: ignore # 明确返回类型
         """在图片上绘制文本
         Args:
             text: 要绘制的文本

nonebot_plugin_l4d2_server-1.0.5/nonebot_plugin_l4d2_server/l4_request/utils.py

@@ -0,0 +1,176 @@
+from typing import Dict, List, Optional, Tuple, Union, cast
+
+from nonebot.log import logger
+
+from ..l4_image import msg_to_image
+from ..utils.api.models import NserverOut
+from ..utils.api.request import L4API
+from .draw_msg import convert_duration, draw_one_ip, get_much_server
+
+
+def _get_server_json(
+    command: str,
+    allhost: Dict[str, List[NserverOut]],
+) -> Optional[list]:
+    """
+    根据命令获取服务器JSON列表
+
+    Args:
+        command (str): 服务器组名
+        ALLHOST (Dict): 全局服务器字典
+
+    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, str, 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"]):
+            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 _filter_servers(
+    servers: list,
+    tj_mode: str,
+    map_type: str = "普通药役",
+) -> list:
+    """筛选符合条件的服务器
+    Args:
+        servers: 服务器列表
+        tj_mode: 筛选模式（'tj'或'zl'）
+        map_type: 地图类型筛选条件
+    Returns:
+        符合条件的服务器列表
+    """
+    filtered = []
+    for i in servers:
+        ser_list = await L4API.a2s_info([(i["host"], i["port"])], is_player=True)
+        if not ser_list:
+            continue
+
+        srv = ser_list[0][0]
+        players = ser_list[0][1]
+
+        if tj_mode == "tj" and map_type in srv.map_name:
+            score = sum(p.score for p in players[:4])
+            t = srv.map_name.split("[")[-1].split("特")[0]
+            if t.isdigit() and int(t) * 50 < score:
+                logger.info(
+                    f"符合TJ条件的服务器: {i['host']}:{i['port']}, 地图: {srv.map_name}, 分数: {score}",
+                )
+                filtered.append(i)
+        elif tj_mode == "zl" and map_type in srv.map_name and len(players) <= 4:
+            logger.info(
+                f"符合ZL条件的服务器: {i['host']}:{i['port']}, 地图: {srv.map_name}, 玩家数: {len(players)}",
+            )
+            filtered.append(i)
+    return filtered
+
+
+async def _format_players(player_list: list) -> str:
+    """格式化玩家信息
+    Args:
+        player_list: 玩家对象列表
+    Returns:
+        格式化后的玩家信息字符串
+    """
+    durations = [await convert_duration(p.duration) for p in player_list]
+    max_duration_len = max(len(str(d)) for d in durations)
+    max_score_len = max(len(str(p.score)) for p in player_list)
+    return "\n".join(
+        f"[{p.score:>{max_score_len}}] | {durations[i]:^{max_duration_len}} | {p.name[0]}***{p.name[-1]}"
+        for i, p in enumerate(player_list)
+    )
+
+
+def _build_message(srv_info, players_msg: str, selected_srv: dict, config) -> str:
+    """构建服务器信息消息
+    Args:
+        srv_info: 服务器信息对象
+        players_msg: 格式化后的玩家信息
+        selected_srv: 选中的服务器信息
+        config: 配置对象
+    Returns:
+        完整的消息字符串
+    """
+    msg = f"""*{srv_info.server_name}*
+游戏: {srv_info.folder}
+地图: {srv_info.map_name}
+人数: {srv_info.player_count}/{srv_info.max_players}"""
+    if srv_info.ping is not None:
+        msg += f"\nping: {srv_info.ping * 1000:.0f}ms\n{players_msg}"
+    if config.l4_show_ip:
+        msg += f"\nconnect {selected_srv['host']}:{selected_srv['port']}"
+    return msg

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/nonebot_plugin_l4d2_server/utils/api/request.py

@@ -9,12 +9,11 @@ import a2s
 import aiofiles
 import ujson as js
 import ujson as json
-from bs4 import BeautifulSoup
+from bs4 import BeautifulSoup, Tag
 from httpx import AsyncClient
+from nonebot.log import logger
 
 from ...config import config
-
-# from nonebot.log import logger
 from ..utils import split_maohao
 from .api import AnnePlayerApi, AnneSearchApi, anne_ban
 from .models import (
@@ -42,6 +41,23 @@ class L4D2Api:
         "Content-Type": "application/x-www-form-urlencoded",
     }
 
+    def safe_select(self, element: Optional[Tag], selector: str) -> List[Any]:
+        """安全地调用 select 方法"""
+        if isinstance(element, Tag):
+            return element.select(selector)
+        return []
+
+    def safe_find_all(
+        self,
+        element: Optional[Tag],
+        tag: str,
+        class_: str = "",
+    ) -> List[Any]:
+        """安全地调用 find_all 方法"""
+        if isinstance(element, Tag):
+            return element.find_all(tag, class_=class_)
+        return []
+
     async def a2s_info(
         self,
         ip_list: List[Tuple[str, int]],
@@ -53,28 +69,29 @@ class L4D2Api:
         msg_list: List[
             Tuple[Union[a2s.SourceInfo[str], a2s.GoldSrcInfo[str]], List[a2s.Player]]
         ] = []
-        sorted_msg_list = []
-        tasks = []  # 用来保存异步任务
-        if ip_list != []:
-            for index, i in enumerate(ip_list):
-                try:
-                    tasks.append(
-                        asyncio.create_task(
-                            self.process_message(
-                                i,
-                                index,
-                                is_server,
-                                is_player,
-                            ),
-                        ),
-                    )
-                except ValueError:
-                    continue  # 处理异常情况
 
-            msg_list = await asyncio.gather(*tasks)
-            sorted_msg_list = sorted(msg_list, key=lambda x: x[0].steam_id)
+        if ip_list:
+            tasks = [
+                asyncio.create_task(
+                    self.process_message(ip, index, is_server, is_player),
+                )
+                for index, ip in enumerate(ip_list)
+            ]
 
-        return sorted_msg_list
+            try:
+                results = await asyncio.gather(*tasks)
+                msg_list = [r for r in results if r is not None]
+            except Exception as e:
+                logger.error(f"获取服务器信息时发生错误: {e}")
+
+        # 使用稳定的排序方式，避免服务器频繁变动位置
+        return sorted(
+            msg_list,
+            key=lambda x: (
+                getattr(x[0], "steam_id", float("inf")) is None,
+                getattr(x[0], "steam_id", float("inf")),
+            ),
+        )
 
     async def process_message(
         self,
@@ -235,14 +252,12 @@ class L4D2Api:
         tag_path = Path(Path(config.l4_path) / f"l4d2/{tag}.json")
 
         async with aiofiles.open(tag_path, "w", encoding="utf-8") as f:
-            print(Path(Path(config.l4_path) / f"l4d2/{tag}.json"))
             up_data = {}
             for server in server_list:
                 new_dict = {}
                 new_dict["id"] = int(server.index) + 1
                 new_dict["ip"] = server.host + ":" + str(server.port)
                 up_data.update(new_dict)
-            print(up_data)
             json.dump(up_data, f, ensure_ascii=False, indent=4)
         return server_list
 
@@ -277,7 +292,7 @@ class L4D2Api:
                     "last_time": td_tags,
                 },
             )
-        print(server_list)
+        logger.debug(server_list)
         return cast(List[AnneSearch], server_list)
 
     async def get_anne_playerdetail(self, steamid: str):
@@ -307,7 +322,7 @@ class L4D2Api:
             "table",
             class_="table content-table-noborder text-left",
         )
-        print(len(tbody_tags))
+
         info_tag = tbody_tags[0]
         detail_tag = tbody_tags[1]
         error_tag = tbody_tags[2]

nonebot_plugin_l4d2_server-1.0.5/nonebot_plugin_l4d2_server/utils/api/utils.py

@@ -0,0 +1,30 @@
+from typing import Union
+
+from nonebot_plugin_alconna import UniMessage
+
+
+async def out_msg_out(
+    msg: Union[str, bytes, UniMessage],
+    is_connect: bool = False,
+    host: str = "",
+    port: str = "",
+):
+    """
+    统一消息输出函数
+
+    Args:
+        msg: 要输出的消息内容
+        is_connect: 是否为连接消息
+        host: 服务器地址
+        port: 服务器端口
+    """
+    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()

{nonebot_plugin_l4d2_server-1.0.4 → nonebot_plugin_l4d2_server-1.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nonebot-plugin-l4d2-server"
-version = "1.0.4"
+version = "1.0.5"
 description = "L4D2 server related operations plugin for NoneBot2"
 authors = [
     { name = "Agnes_Digital", email = "Z735803792@163.com" },
@@ -24,13 +24,13 @@ dependencies = [
     "aiohttp>=3.8.4",
     "jinja2>=3.0.0",
     "srctools>=2.3.9",
-    "httpx>=0.22.0,<0.24.1",
+    "httpx>=0.22.0",
     "msgspec>=0.18.0",
     "python-a2s>=1.4.1",
     "ujson>=5.10.0",
     "lxml>=5.2.2",
     "rcon>=2.1.0",
-    "pillow>10",
+    "pillow>10.0.0",
     "bs4>=0.0.2",
     "rarfile>=4.2",
     "pyunpack>=0.3",