nonebot-plugin-l4d2-server 0.6.6__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

nonebot_plugin_l4d2_server/l4d2_queries/qqgroup.py

@@ -1,370 +0,0 @@
-import asyncio
-import random
-from pathlib import Path
-from typing import Dict, List, Tuple
-
-import a2s
-import aiofiles
-from nonebot.log import logger
-
-from ..l4d2_data.serverip import L4D2Server
-from ..l4d2_image import server_ip_pic
-from ..l4d2_utils.classcal import ServerStatus
-from ..l4d2_utils.message import KAILAO, PRISON, QUEREN
-from ..l4d2_utils.utils import split_maohao
-from .local_ip import ALL_HOST
-from .utils import (
-    msg_ip_to_list,
-    player_queries,
-    player_queries_anne_dict,
-    queries,
-    queries_dict,
-)
-
-try:
-    import ujson as json
-except ImportError:
-    import json
-si = L4D2Server()
-errors = (
-    ConnectionRefusedError,
-    ConnectionResetError,
-    asyncio.exceptions.TimeoutError,
-    OSError,
-)
-# errors = (TypeError,KeyError,ValueError,ConnectionResetError,TimeoutError)
-
-
-async def get_qqgroup_ip_msg(qqgroup):
-    """首先，获取qq群订阅数据，再依次queries返回ip原标"""
-    return await si.query_server_ip(qqgroup)
-
-
-async def bind_group_ip(group: int, host: str, port: int):
-    ip_list = await si.query_server_ip(group)
-    if (host, port) in ip_list:
-        return "本群已添加过该ip辣"
-    await si.bind_server_ip(group, host, port)
-    return "绑定成功喵，新增ip" + host
-
-
-async def del_group_ip(group: int, number: int):
-    number = int(number)
-    logger.info(number)
-    try:
-        groups, host, port = await si.query_number(number)
-    except TypeError:
-        return "没有这个序号哦"
-    if groups != group:
-        return "本群可没有订阅过这个ip"
-    await si.del_server_ip(number)
-    return "取消成功喵，已删除序号" + str(number)
-
-
-async def qq_ip_queries(msg: List[tuple]):
-    """输入一个ip的二元元组组成的列表，返回一个输出消息的列表
-    未来作图这里重置"""
-    messsage = ""
-    for i in msg:
-        number, qqgroup, host, port = i
-        msg2 = await player_queries(host, port)
-        msg1 = await queries(host, port)
-        messsage += f"序号、{number!s} \n{msg1}{msg2}--------------------\n"
-    return messsage
-
-
-async def qq_ip_querie(msg: List[Tuple[str, str, int]], igr: bool = True):
-    msg_list: List[ServerStatus] = []
-    tasks = []  # 用来保存异步任务
-    if msg != []:
-        for i in msg:
-            try:
-                number: str
-                host: str
-                port: int
-                qqgroup: str = ""  # 初始化为""
-                if len(i) == 3:
-                    number, host, port = i
-                else:
-                    number, qqgroup, host, port = i  # type: ignore
-                # 将异步任务添加到任务列表中
-                tasks.append(
-                    asyncio.create_task(
-                        process_message(
-                            number,
-                            host,
-                            port,
-                            msg_list,
-                            igr,
-                            qqgroup,
-                        ),
-                    ),
-                )
-            except ValueError:
-                continue  # 处理异常情况
-        # 等待所有异步任务完成
-        await asyncio.gather(*tasks)
-        # 对msg_list按照number顺序排序
-        # msg_list.sort(key=lambda x: x["number"])
-        send_list = sorted(msg_list, key=lambda x: int(x.number))
-        result = {"msg_list": send_list}
-
-    else:
-        result: Dict[str, List[ServerStatus]] = {}
-    return result
-
-
-async def qq_ip_queries_pic(msg: list, igr=False):
-    result = await qq_ip_querie(msg, igr)
-    if "msg_list" in result:
-        pic = await server_ip_pic(result["msg_list"])
-    else:
-        pic = None
-    return pic
-
-
-async def process_message(
-    number: str,
-    host: str,
-    port: int,
-    msg_list: List[ServerStatus],
-    igr: bool,
-    qqgroup: str = "",
-):
-    try:
-        msg2 = await player_queries_anne_dict(host, port)
-        msg1 = await queries_dict(host, port)
-        msg3 = await server_rule_dict(host, port)
-        msg1.update(
-            {
-                "Players": msg2,
-                "number": number,
-            },
-        )
-        msg1.update(msg3)
-        if qqgroup:
-            msg1.update({"tag": qqgroup})
-        msg_list.append(ServerStatus(**msg1))
-    except errors:
-        if igr:
-            pass
-        else:
-            # 空白字典
-            null_dict = ServerStatus(number=number)
-            msg_list.append(null_dict)
-
-
-async def get_tan_jian(msg: List[tuple], mode: int):
-    """获取anne列表抽一个"""
-    msg_list = []
-    random.shuffle(msg)
-    for i in msg:
-        number, host, port = i
-        try:
-            if mode == 1:
-                # 探监
-                msg2 = await player_queries_anne_dict(host, port)
-                point = 0
-                for i in msg2:
-                    point += int(i["Score"])
-                logger.info(point)
-                msg1 = await queries_dict(host, port)
-                sp: str = msg1["name"]
-                if "特" not in sp:
-                    continue
-                sps = int(sp.split("特")[0].split("[")[-1])
-                points = point / 4
-                if points / sps < 10:
-                    continue
-                if "HT" in msg1["name"]:
-                    continue
-                msg1.update({"Players": msg2})
-                msg1.update({"ranks": point})
-                ips = f"{host}:{port!s}"
-                msg1.update({"ips": ips})
-                # msg1是一行数据完整的字典
-                msg_list.append(msg1)
-            if mode == 2:
-                # 坐牢
-                # try:
-                msg1 = await queries_dict(host, port)
-                if "普通药役" in msg1["name"]:
-                    if "缺人" in msg1["name"]:
-                        msg2 = await player_queries_anne_dict(host, port)
-                        msg1.update({"Players": msg2})
-                        ips = f"{host}:{port!s}"
-                        msg1.update({"ips": ips})
-                        # msg1是一行数据完整的字典
-                    else:
-                        continue
-                else:
-                    continue
-                msg_list.append(msg1)
-            if mode == 3:
-                # 开牢
-                msg1 = await queries_dict(host, port)
-                if "[" not in msg1["name"]:
-                    msg2 = await player_queries_anne_dict(host, port)
-                    msg1.update({"Players": msg2})
-                    ips = f"{host}:{port!s}"
-                    msg1.update({"ips": ips})
-                    # msg1是一行数据完整的字典
-                    msg_list.append(msg1)
-        except errors:
-            continue
-        if msg_list != []:
-            break
-    # 随机选一个牢房
-    logger.info(msg_list)
-    if len(msg_list) == 0:
-        return "暂时没有这种牢房捏"
-    logger.info(len(msg_list))
-    mse = msg_list[0]
-    message: str = ""
-    if mode == 1:
-        ranks = mse["ranks"]
-        if ranks <= 300:
-            message = random.choice(PRISON[1])
-        if 300 < ranks <= 450:
-            message = random.choice(PRISON[2])
-        if ranks > 450:
-            message = random.choice(PRISON[3])
-    if mode == 2:
-        player_point = mse["players"]
-        if player_point == "1":
-            message = random.choice(QUEREN[1])
-        elif player_point == "2":
-            message = random.choice(QUEREN[2])
-        elif player_point == "3":
-            message = random.choice(QUEREN[3])
-        else:
-            message = random.choice(QUEREN[4])
-    if mode == 3:
-        message = random.choice(KAILAO)
-    message += f"\n名称：{mse['name']}\n"
-    message += f"地图：{mse['map_']} \n"
-    message += f"玩家：{mse['players']} / {mse['max_players']}\n"
-    try:
-        message += await msg_ip_to_list(mse["Players"])
-    except KeyError:
-        message += "服务器里，是空空的呢\n"
-    return message
-
-
-async def get_server_ip(number):
-    group, host, port = await si.query_number(number)
-    try:
-        return str(host) + ":" + str(port)
-    except TypeError:
-        return None
-
-
-async def write_json(data_str: str):
-    """
-    添加数据或者删除数据
-     - 【求生更新 添加 腐竹 ip 模式 序号】
-     - 【求生更新 添加 腐竹 ip 模式】
-     - 【求生更新 删除 腐竹 序号】
-    """
-    data_list = data_str.split()
-    logger.info(data_list)
-    if data_list[0] == "添加":
-        add_server = {}
-        server_dict = ALL_HOST.get(data_list[1], {})
-        if not server_dict:
-            logger.info("新建分支")
-            ALL_HOST[data_list[1]] = []
-        for key, value in ALL_HOST.items():
-            if data_list[1] == key:
-                ids = [server["id"] for server in value]
-                # 序号
-                if len(data_list) == 4:
-                    data_num = int(max(ids, default=0)) + 1
-                    add_server.update({"id": data_num})
-                elif len(data_list) == 5:
-                    if not data_list[4].isdigit():
-                        return "请输入【求生更新 添加 腐竹 ip 模式 序号】"
-                    data_num = int(data_list[4])
-                    if data_num in ids:
-                        return "该序号已存在，请删除原序号【求生更新 删除 腐竹 序号】"
-                    add_server.update({"id": data_num})
-                else:
-                    return "请输入【求生更新 添加 腐竹 ip 模式 序号】"
-                # 模式，ip
-                try:
-                    host, port = split_maohao(data_list[2])
-                    add_server.update({"host": host, "port": port})
-                except KeyError:
-                    return "ip格式不正确【114.11.4.514:9191】"
-                add_server.update({"version": data_list[3]})
-                value.append(add_server)
-                ALL_HOST[key] = value
-                with Path("data/L4D2/l4d2.json").open("w", encoding="utf8") as f_new:
-                    json.dump(ALL_HOST, f_new, ensure_ascii=False, indent=4)
-                return f"添加成功，指令为{key}{data_num}"
-        return None
-
-    if data_list[0] == "删除":
-        for key, value in ALL_HOST.items():
-            if data_list[1] == key:
-                try:
-                    data_num = int(data_list[2])
-                except ValueError:
-                    return "序号应该为大于0的正整数，请输入【求生更新 删除 腐竹 序号】"
-                for i, server in enumerate(value):
-                    if data_num == server["id"]:
-                        value.pop(i)
-                        if not value:
-                            ALL_HOST.pop(key)
-                        async with aiofiles.open(
-                            "data/L4D2/l4d2.json",
-                            "w",
-                            encoding="utf8",
-                        ) as f_new:
-                            await f_new.write(
-                                json.dumps(ALL_HOST, ensure_ascii=False, indent=4),
-                            )
-                            await f_new.flush()
-                        return "删除成功喵"
-                return "序号不正确，请输入【求生更新 删除 腐竹 序号】"
-        return "腐竹名不存在，请输入【求生更新 删除 腐竹 序号】"
-    return None
-
-
-async def add_ip(group_id, host, port):
-    """先查找是否存在，如果不存在则创建"""
-    return await bind_group_ip(group_id, host, port)
-
-
-async def del_ip(group_id, number):
-    """删除群ip"""
-    return await del_group_ip(group_id, number)
-
-
-async def show_ip(group_id):
-    """先查找群ip，再根据群ip返回"""
-    data_list = await get_qqgroup_ip_msg(group_id)
-    logger.info(data_list)
-    if len(data_list) == 0:
-        return "本群没有订阅"
-    return await qq_ip_queries_pic(data_list)
-
-
-async def get_number_url(number):
-    ip = await get_server_ip(number)
-    if not ip:
-        return "该序号不存在"
-    return f"connect {ip}"
-
-
-async def server_rule_dict(ip: str, port: int):
-    port = int(port)
-    ip = str(ip)
-    msg_dict = {}
-    # message_dict = await l4d(ip,port)
-    try:
-        msg: dict = await a2s.arules((ip, port))  # type: ignore
-        msg_dict["tick"] = msg["l4d2_tickrate_enabler"] + "tick"
-    except Exception:
-        msg_dict["tick"] = ""
-    return msg_dict

nonebot_plugin_l4d2_server/l4d2_queries/send_msg.py

@@ -1,131 +0,0 @@
-import asyncio
-from typing import Dict, List, Optional, Tuple
-
-from nonebot.log import logger
-from nonebot_plugin_saa import Image, Text
-
-from ..l4d2_queries.local_ip import ALL_HOST
-from ..l4d2_queries.qqgroup import qq_ip_queries_pic
-from ..l4d2_queries.utils import get_anne_server_ip, json_server_to_tag_dict
-from ..l4d2_utils.classcal import ServerGroup, ServerStatus
-from ..l4d2_utils.utils import split_maohao
-from .local_ip import Group_All_HOST
-from .qqgroup import qq_ip_querie
-
-
-async def get_ip_to_mes(msg: str, command: str = ""):
-    if not msg:
-        # 以图片输出全部当前
-        igr = False
-        # if command in gamemode_list:
-        #     this_ips = [
-        #         d for l in ALL_HOST.values() for d in l if d.get("version") == command
-        #     ]
-        #     igr = True
-        # else:
-        this_ips = ALL_HOST[command]
-        ip_list: List[Tuple[str, str, str]] = []
-        for one_ip in this_ips:
-            host, port = split_maohao(one_ip["ip"])
-            msg_tuple = (one_ip["id"], host, port)
-            ip_list.append(msg_tuple)
-        img = await qq_ip_queries_pic(ip_list, igr)
-        return [Image(img)] if img else None
-
-    if not msg[0].isdigit():
-        # if any(mode in msg for mode in gamemode_list):
-        #     pass
-        # else:
-        return None
-    message = await json_server_to_tag_dict(command, msg)
-    if len(message) == 0:
-        # 关键词不匹配，忽略
-        return None
-    ip = str(message["ip"])
-    logger.info(ip)
-
-    try:
-        msg_send: Optional[str] = await get_anne_server_ip(ip)
-        if msg_send is not None:
-            return [Text(msg_send)]
-
-    except (OSError, asyncio.exceptions.TimeoutError):
-        return [Text("服务器无响应")]
-
-
-# async def get_read_group_ip():
-#     """输出群组服务器"""
-#     get_grou_ip = on_command("anne", aliases=group_key(), priority=80, block=True)
-
-#     @get_grou_ip.handle()
-#     async def _(
-#         matcher: Matcher,
-#         start: str = CommandStart(),
-#         command: str = RawCommand(),
-#         args: Message = CommandArg(),
-#     ):
-#         if start:
-#             command = command.replace(start, "")
-#         msg: str = args.extract_plain_text()
-#         push_msg = await get_group_ip_to_msg(msg, command)
-#         msg_img = await server_group_ip_pic(push_msg)
-#         if isinstance(push_msg, bytes):
-#             await MessageFactory([Image(push_msg)]).finish()
-#         elif msg and type(push_msg) == list:
-#             await MessageFactory([Image(push_msg[0]), Text(push_msg[-1])]).finish()
-#         elif msg and isinstance(push_msg, str):
-#             await str_to_picstr(push_msg, matcher)
-#         await matcher.finish()
-
-
-async def get_group_ip_to_msg(command: str):
-    """输出群组ip的dict信息"""
-    if command in Group_All_HOST:
-        group_tag_list: List[str] = Group_All_HOST[command]
-    elif command in ALL_HOST:
-        group_tag_list = [command]
-    else:
-        return None
-    logger.info(f"组内关键词{group_tag_list}")
-    group_ip_dict: Dict[str, List[Dict[str, str]]] = {}
-    tag = len(group_tag_list) == 0
-    return_list: List[ServerGroup] = []
-    id_number = 0
-    for tag, one_group in ALL_HOST.items():
-        id_number += 1
-        if tag in group_tag_list and tag:
-            group_ip_dict.update({tag: one_group})
-            ip_tuple_list: List[Tuple[str, str, int]] = []
-            for one_server in one_group:
-                number = one_server["id"]
-                host, port = split_maohao(one_server["ip"])
-                ip_tuple_list.append((number, host, int(port)))
-            msg_group_server = await qq_ip_querie(ip_tuple_list)
-            return_list.append(
-                await check_group_msg(msg_group_server, id_number, command),
-            )
-
-    return return_list
-    # 还没写完
-    #     host, port = split_maohao(one_ip["ip"])
-    #     msg_tuple = (one_ip["id"], host, port)
-    #     ip_list.append(msg_tuple)
-    # img = await qq_ip_queries_pic(ip_list, igr)
-
-
-async def check_group_msg(msg: Dict[str, List[ServerStatus]], number: int, command: str):
-    server_info = ServerGroup()
-    server_info.server_id = number
-
-    for server_group in msg["msg_list"]:
-        # 服务器，服务器玩家数量
-        # 当前/总数
-        server_info.server_tag = command
-        if server_group.name == "null":
-            server_info.server_all_number += 1
-            continue
-        server_info.server_all_number += 1
-        server_info.server_number += 1
-        server_info.server_people += server_group.players
-        server_info.server_all_people += server_group.max_players
-    return server_info