nonebot-plugin-l4d2-server 1.0.1__tar.gz → 1.0.3__tar.gz

{nonebot_plugin_l4d2_server-1.0.1 → nonebot_plugin_l4d2_server-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nonebot-plugin-l4d2-server
-Version: 1.0.1
+Version: 1.0.3
 Summary: L4D2 server related operations plugin for NoneBot2
 Keywords: steam,game,l4d2,nonebot2,plugin
 Author-Email: Agnes_Digital <Z735803792@163.com>
@@ -11,10 +11,12 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Project-URL: homepage, https://github.com/Agnes4m/nonebot_plugin_l4d2_server
 Requires-Python: <4.0,>=3.9
 Requires-Dist: nonebot2>=2.0.0
+Requires-Dist: nonebot2[fastapi]>=2.3.3
 Requires-Dist: nonebot-plugin-htmlrender>=0.3.0
 Requires-Dist: nonebot-adapter-onebot>=2.4.4
 Requires-Dist: nonebot-plugin-alconna>=0.50.0
@@ -25,12 +27,15 @@ Requires-Dist: jinja2>=3.0.0
 Requires-Dist: srctools>=2.3.9
 Requires-Dist: httpx<0.24.1,>=0.22.0
 Requires-Dist: msgspec>=0.18.0
-Requires-Dist: python-a2s>=1.3.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>9
+Requires-Dist: pillow>10
 Requires-Dist: beautifulsoup4>=4.12.3
+Requires-Dist: rarfile>=4.2
+Requires-Dist: pyunpack>=0.3
+Requires-Dist: aiofiles>=24.1.0
 Description-Content-Type: text/markdown
 
 <!-- markdownlint-disable MD026 MD031 MD033 MD036 MD041 MD046 MD051 -->

{nonebot_plugin_l4d2_server-1.0.1 → nonebot_plugin_l4d2_server-1.0.3}/nonebot_plugin_l4d2_server/__main__.py

@@ -18,6 +18,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, List, Optional
 
+import aiofiles
 import ujson as json
 from nonebot.adapters import Message
 from nonebot.log import logger
@@ -35,7 +36,7 @@ from .l4_request import (
     get_ip_server,
     get_server_detail,
     reload_ip,
-    tj_request
+    tj_request,
 )
 from .utils.api.request import L4API
 
@@ -54,6 +55,8 @@ l4_find_player = on_command("l4find", aliases={"l4查找"})
 ld_tj = on_command("tj", aliases={"探监"})
 ld_zl = on_command("zl")
 ld_kl = on_command("kl")
+config_path = Path(config.l4_path) / "config.json"
+
 
 @l4_help.handle()
 async def _(matcher: Matcher):
@@ -102,17 +105,27 @@ async def _(
 async def _(
     args: Message = CommandArg(),
 ):
+    # 以后有时间补img格式
     msg: str = args.extract_plain_text().strip()
     tag_list: List[str] = msg.split(" ", maxsplit=1)
-    if len(tag_list) < 2:
-        return await UniMessage.text("格式错误，正确格式：/l4find 组名 玩家名").finish()
-    group, name = tag_list
-    out: List[OutServer] = await get_server_detail(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']}")
+    if len(tag_list) == 1:
+        await UniMessage.text("未设置组，正在全服查找，时间较长").send()
+        name = tag_list[0]
+        out: List[OutServer] = await get_server_detail(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']}")
+    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_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()
 
@@ -149,18 +162,18 @@ async def _(args: Message = CommandArg()):
             logger.info(f"重载{tag}的ip")
             await L4API.get_sourceban(tag, url)
         await UniMessage.text("重载ip完成").finish()
-        
+
 
 l4_add_ban = on_command("l4addban", aliases={"l4添加ban"})
+
+
 @l4_add_ban.handle()
 async def _(args: Message = CommandArg()):
     arg = args.extract_plain_text().strip().split(" ")
-    
+
     if len(arg) != 2:
         await UniMessage.text("请在命令后增加响应指令名和网址").finish()
-    
-    config_path = Path(config.l4_path) / "config.json"
-    
+
     if not config_path.is_file():
         config_data = {}
     else:
@@ -169,61 +182,70 @@ async def _(args: Message = CommandArg()):
                 config_data = json.load(f)
         except (json.JSONDecodeError, FileNotFoundError):
             config_data = {}
-    
+
     config_data.update({arg[0]: arg[1]})
-    
+
     try:
         with config_path.open("w") as f:
             json.dump(config_data, f, ensure_ascii=False, indent=4)
     except IOError as e:
         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()
-    
+
 
 l4_del_ban = on_command("l4delban", aliases={"l4删除ban", "l4移除ban"})
+
+
 @l4_del_ban.handle()
-async def _(args: Message = CommandArg()):    
+async def _(args: Message = CommandArg()):
     arg = args.extract_plain_text().strip().split(" ")
-    if  len(arg) not in [1,2]:
+    if len(arg) not in [1, 2]:
         await UniMessage.text("请在命令后增加响应指令名或者带响应网址").finish()
     elif len(arg) == 1:
         if not Path(Path(config.l4_path) / "config.json").is_file():
             await UniMessage.text("没有添加过组名").finish()
         else:
-            with (Path(config.l4_path) / "config.json").open("r", encoding="utf-8") as f:
+            with (Path(config.l4_path) / "config.json").open(
+                "r",
+                encoding="utf-8",
+            ) as f:
                 content = f.read().strip()
-                config_data = json.loads(content)            
+                config_data = json.loads(content)
             if arg[0] not in config_data:
                 await UniMessage.text("没有添加过这个组").finish()
             else:
                 del config_data[arg[0]]
-                with Path(Path(config.l4_path) / "config.json").open("w") as f:
-                    json.dump(config_data, f,ensure_ascii=False,indent=4)
-                await UniMessage.text(f"删除成功，组名:{arg[0]}").finish()
+            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()
     elif len(arg) == 2:
         if not Path(Path(config.l4_path) / "config.json").is_file():
             await UniMessage.text("没有添加过组名").finish()
         else:
-            with (Path(config.l4_path) / "config.json").open("r", encoding="utf-8") as f:
+            with (Path(config.l4_path) / "config.json").open(
+                "r",
+                encoding="utf-8",
+            ) as f:
                 content = f.read().strip()
                 config_datas = json.loads(content)
             if arg[0] not in config_datas:
                 await UniMessage.text("没有添加过这个组").finish()
             else:
                 config_datas[arg[0]] = arg[1]
-                with Path(Path(config.l4_path) / "config.json").open("w") as f:
-                    json.dump(config_datas, f,ensure_ascii=False,indent=4)
+                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()
-                
-                
+
+
 @ld_tj.handle()
 async def _(matcher: Matcher):
     await matcher.send("正在寻找牢房信息")
-    await matcher.finish(await tj_request("云","tj"))
-    
+    await matcher.finish(await tj_request("云", "tj"))
+
+
 @ld_zl.handle()
 async def _(matcher: Matcher):
     await matcher.send("正在寻找牢房信息")
-    await matcher.finish(await tj_request("云","zl"))
+    await matcher.finish(await tj_request("云", "zl"))

{nonebot_plugin_l4d2_server-1.0.1 → nonebot_plugin_l4d2_server-1.0.3}/nonebot_plugin_l4d2_server/config.py

@@ -1,10 +1,14 @@
 from pathlib import Path
 
 from nonebot import get_plugin_config
+from nonebot.log import logger
 from pydantic import BaseModel
 
 DATAPATH = Path(__file__).parent.joinpath("data")
 DATAOUT = Path("data/L4D2")
+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.1 → nonebot_plugin_l4d2_server-1.0.3}/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.1"
+__version__ = "1.0.3"
 TEXT_PATH = Path(__file__).parent / "texture2d"
 HELP_DATA = Path(__file__).parent / "Help.json"
 

{nonebot_plugin_l4d2_server-1.0.1 → nonebot_plugin_l4d2_server-1.0.3}/nonebot_plugin_l4d2_server/l4_local/__init__.py

@@ -13,7 +13,9 @@ from .file import updown_l4d2_vpk
 try:
     vpk_path = config.l4_local[map_index]
 except IndexError:
-    logger.warning("未填写本地服务器路径,如果想要使用本地服务器功能,请填写本地服务器路径")
+    logger.warning(
+        "未填写本地服务器路径,如果想要使用本地服务器功能,请填写本地服务器路径",
+    )
     vpk_path = ""
 
 local_path_list = config.l4_local

nonebot_plugin_l4d2_server-1.0.3/nonebot_plugin_l4d2_server/l4_request/__init__.py

@@ -0,0 +1,283 @@
+import random
+from typing import Dict, List, Optional, cast
+
+from nonebot.log import logger
+
+from ..config import server_all_path
+from ..l4_image import msg_to_image
+from ..utils.api.models import AllServer, NserverOut, OutServer
+from ..utils.api.request import L4API
+from ..utils.utils import split_maohao
+from .draw_msg import convert_duration, draw_one_ip, get_much_server
+
+try:
+    import ujson as json
+except ImportError:
+    import json
+
+from ..config import config
+
+# 获取全部服务器信息
+ALLHOST: Dict[str, List[NserverOut]] = {}
+COMMAND = set()
+
+
+async def get_all_server_detail():
+    """
+    获取所有服务器的详细信息。
+
+    Args:
+        无
+
+    Returns:
+        str: 包含所有服务器详细信息的字符串。
+
+    """
+    out_list: List[AllServer] = []
+    for group in ALLHOST:
+        msg_list = await get_group_detail(group)
+        if msg_list is None:
+            continue
+        active_server = 0
+        max_server = 0
+        active_player = 0
+        max_player = 0
+        for index, msg in enumerate(msg_list):
+            max_server = index + 1
+            if msg["server"].max_players != 0:
+                active_server += 1
+                active_player += msg["server"].player_count
+                max_player += msg["server"].max_players
+        data = {
+            "command": group,
+            "active_server": active_server,
+            "max_server": max_server,
+            "active_player": active_player,
+            "max_player": max_player,
+        }
+        out_list.append(cast(AllServer, data))
+
+    # to do作图，先用文字凑合
+    out_msg = ""
+    for one in out_list:
+        if one["max_player"]:
+            out_msg += f"{one['command']} | 服务器{one['active_server']}/{one['max_server']} | 玩家{one['active_player']}/{one['max_player']}\n"
+        else:
+            continue
+    return out_msg
+
+
+async def get_server_detail(
+    command: str = "",
+    _id: Optional[str] = None,
+    is_img: bool = True,
+):
+    """
+    异步获取服务器详细信息。
+
+    Args:
+        command (str): 服务器组名。
+        _id (Optional[str], optional): 服务器ID。默认为None。
+        is_img (bool, optional): 是否返回图片格式的信息。默认为True。
+
+    Returns:
+        Union[bytes, List[OutServer], None]: 返回服务器详细信息。如果为图片格式，返回bytes类型；
+                                            如果不是图片格式，返回List[OutServer]类型；如果未找到服务器组，返回None。
+
+    """
+    if command:
+        server_json = ALLHOST.get(command)
+    else:
+        server_json = []
+        for servers in ALLHOST.values():
+            server_json.extend(servers)
+
+    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
+
+    # 返回单个
+    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)
+    return None
+
+
+async def get_group_detail(
+    command: str,
+):
+    server_json = ALLHOST.get(command)
+    logger.info(server_json)
+    if server_json is None:
+        logger.warning("未找到这个组")
+        return None
+
+    logger.info("正在请求组服务器信息")
+    return await get_much_server(server_json, command)
+
+
+async def get_ip_server(ip: str):
+    host, port = split_maohao(ip)
+    return await draw_one_ip(host, port)
+
+
+# 以下是重载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"):
+            json_data = json.loads(item.read_text(encoding="utf-8"))
+            group_server = cast(Dict[str, List[NserverOut]], json_data)
+
+            for group, group_ip in group_server.items():
+                # 处理ip,host,port关系
+                for one_ip in group_ip:
+                    if one_ip.get("ip"):
+                        if one_ip.get("host") and one_ip.get("port"):
+                            pass
+                        if one_ip.get("host") and not one_ip.get("port"):
+                            one_ip["port"] = 20715
+                        if not one_ip.get("host"):
+                            one_ip["host"], one_ip["port"] = split_maohao(
+                                one_ip.get("ip"),
+                            )
+                    else:
+                        if one_ip.get("host") and one_ip.get("port"):
+                            one_ip["ip"] = f'{one_ip["host"]}:{one_ip["port"]}'
+                        if one_ip.get("host") and not one_ip.get("port"):
+                            one_ip["ip"] = f'{one_ip["host"]}:20715'
+                        else:
+                            logger.warning(f"{one_ip} 没有ip")
+
+                ALLHOST.update({group: group_ip})
+                COMMAND.add(group)
+            logger.success(f"成功加载 {item.name.split('.')[0]} {len(group_ip)}个")
+
+
+async def tj_request(command: str = "云", tj="tj"):
+    map_type = "普通药役"
+    server_json = ALLHOST.get(command)
+    logger.info(server_json)
+    if server_json is None:
+        logger.warning("未找到这个组")
+        return None
+
+    logger.info("正在获取电信服务器信息")
+    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)
+
+        if not right_ip:
+            logger.warning("没有找到符合条件的服务器")
+            return "没有符合条件的服务器"
+
+        logger.info(
+            f"符合条件的服务器列表: {[f'{ip['host']}:{ip['port']}' for ip in right_ip]}",
+        )
+        s = random.choice(right_ip)
+        logger.info(f"最终选择的服务器: {s['host']}:{s['port']}")
+        ser_list = await L4API.a2s_info([(s["host"], s["port"])], is_player=True)
+        if not ser_list:
+            return "获取服务器信息失败"
+
+        one_server = ser_list[0][0]
+        one_player = ser_list[0][1]
+
+        if one_player:
+            player_msg = await _format_players(one_player)
+        else:
+            player_msg = "服务器感觉很安静啊"
+
+        return _build_message(one_server, player_msg, s)
+
+    except Exception as e:
+        logger.error(f"tj_request error: {e}")
+        return "获取服务器信息时出错"

{nonebot_plugin_l4d2_server-1.0.1 → nonebot_plugin_l4d2_server-1.0.3}/nonebot_plugin_l4d2_server/l4_request/draw_msg.py

@@ -32,7 +32,7 @@ async def draw_one_ip(host: str, port: int):
             name_leg = len(player.name)
             if name_leg > 2:
                 xing = "*" * (name_leg - 2)
-                name = f"{player.name[0]}xing{player.name[-1]}"
+                name = f"{player.name[0]}{xing}{player.name[-1]}"
             else:
                 name = player.name
             player_msg += f"{soc} | {dur} | {name} \n"
@@ -77,6 +77,12 @@ async def get_much_server(server_json: List[NserverOut], command: str):
 
 
 async def convert_duration(duration: float) -> str:
+    """Convert duration in seconds to human-readable string format (e.g. '1h 30m 15s')
+    Args:
+        duration: Duration in seconds
+    Returns:
+        Formatted time string
+    """
     minutes, seconds = divmod(duration, 60)
     hours, minutes = divmod(minutes, 60)
     time_str = ""

{nonebot_plugin_l4d2_server-1.0.1 → nonebot_plugin_l4d2_server-1.0.3}/nonebot_plugin_l4d2_server/utils/api/request.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional, Tuple, cast
 
 import a2s
+import aiofiles
 import ujson as js
 import ujson as json
 from bs4 import BeautifulSoup
@@ -28,6 +29,8 @@ from .models import (
     SourceBansInfo,
 )
 
+config_path = Path(config.l4_path) / "config.json"
+
 
 class L4D2Api:
     ssl_verify = False
@@ -76,11 +79,11 @@ class L4D2Api:
         is_server: bool,
         is_player: bool,
     ):
-        server: a2s.SourceInfo = a2s.SourceInfo()
         play: List[a2s.Player] = []
         if is_server:
             try:
-                server = await a2s.ainfo(ip)
+                server: a2s.SourceInfo = await a2s.ainfo(ip, timeout=3, encoding="utf8")
+
                 if server is not None:
                     server.steam_id = index
 
@@ -89,6 +92,25 @@ class L4D2Api:
                 ConnectionRefusedError,
                 socket.gaierror,
             ):
+                server: a2s.SourceInfo = a2s.SourceInfo(
+                    protocol=0,
+                    server_name="服务器无响应",
+                    map_name="无",
+                    folder="m",
+                    game="L4D2",
+                    app_id=114514,
+                    steam_id=index,
+                    player_count=0,
+                    max_players=0,
+                    bot_count=0,
+                    server_type="w",
+                    platform="w",
+                    password_protected=False,
+                    vac_enabled=False,
+                    version="1.0",
+                    edf=0,
+                    ping=0,
+                )
                 server.steam_id = index
                 server.player_count = 0
                 server.max_players = 0
@@ -103,7 +125,7 @@ class L4D2Api:
                 ConnectionRefusedError,
                 socket.gaierror,
             ):
-                play = await a2s.aplayers(ip)
+                play = await a2s.aplayers(ip, timeout=3, encoding="utf8")
         return server, play
 
     async def _server_request(
@@ -158,7 +180,7 @@ class L4D2Api:
             html_content = resp.content
             return BeautifulSoup(html_content, "lxml")
 
-    async def get_sourceban(self, tag:str = "云", url: str = anne_ban):
+    async def get_sourceban(self, tag: str = "云", url: str = anne_ban):
         """从sourceban++获取服务器列表，目前未做名称处理"""
         if not (url.startswith(("http://", "https://"))):
             url = "http://" + url  # 默认添加 http://
@@ -184,23 +206,25 @@ class L4D2Api:
                     )
 
         if not Path(Path(config.l4_path) / "config.json").is_file():
-            with Path(Path(config.l4_path) / "config.json").open("w") as f:
-                f.write("{}")
+            async with aiofiles.open(config_path, "w", encoding="utf-8") as f:
+                await f.write("{}")
         with (Path(config.l4_path) / "config.json").open("r", encoding="utf-8") as f:
             content = f.read().strip()
             ip_json = json.loads(content)
         if tag in ip_json:
             url = ip_json[tag]
-        with (Path(Path(config.l4_path) / f"l4d2/{tag}.json")).open("w") as f:
+        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["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)
+            json.dump(up_data, f, ensure_ascii=False, indent=4)
         return server_list
 
     async def get_anne_steamid(self, name: str):