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

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:  # type: ignore # 明确返回类型
+        """在图片上绘制文本
+        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/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/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,18 +3,17 @@ 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
 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,35 +41,57 @@ 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]],
         is_server: bool = True,
         is_player: bool = False,
-    ) -> List[Tuple[a2s.SourceInfo, List[a2s.Player]]]:
-        msg_list: List[Tuple[a2s.SourceInfo, 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  # 处理异常情况
+    ) -> 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]]
+        ] = []
+
+        if ip_list:
+            tasks = [
+                asyncio.create_task(
+                    self.process_message(ip, index, is_server, is_player),
+                )
+                for index, ip in enumerate(ip_list)
+            ]
 
-            msg_list = await asyncio.gather(*tasks)
-            sorted_msg_list = sorted(msg_list, key=lambda x: x[0].steam_id)
+            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
+        # 使用稳定的排序方式，避免服务器频繁变动位置
+        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,
@@ -80,19 +101,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 +163,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 +207,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(
@@ -216,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
 
@@ -258,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):
@@ -272,14 +306,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",
         )
@@ -288,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/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/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