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

nonebot_plugin_l4d2_server/__main__.py

@@ -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 (
@@ -39,13 +40,14 @@ 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
 
 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 +61,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 +74,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:
@@ -92,13 +112,15 @@ async def _(
         _id = None
     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()
-    else:
-        await UniMessage.text("服务器无响应").finish()
+    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()
@@ -120,48 +142,41 @@ 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()
 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():
             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 +207,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 +234,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 +251,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 +264,21 @@ async def _(matcher: Matcher):
 async def _(matcher: Matcher):
     await matcher.send("正在寻找牢房信息")
     await matcher.finish(await tj_request("云", "zl"))
+
+
+## 以下为配置修改
+
+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

@@ -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)
 
@@ -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/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/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.3"
+__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/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/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/l4_request/__init__.py

@@ -2,20 +2,28 @@ import random
 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 ..utils.api.models import AllServer, NserverOut, OutServer
+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]] = {}
@@ -79,52 +87,43 @@ 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, ALLHOST)
     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 = ""
-    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)
+    _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
 
 
 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("未找到这个组")
@@ -142,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"):
@@ -186,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("没有找到符合条件的服务器")
@@ -276,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}")