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

nonebot_plugin_l4d2_server/utils/api/request.py

@@ -0,0 +1,337 @@
+import asyncio
+import contextlib
+import socket
+from copy import deepcopy
+from typing import Any, Dict, List, Literal, Optional, Tuple, cast
+
+import a2s
+import ujson as js
+from bs4 import BeautifulSoup
+from httpx import AsyncClient
+
+# from nonebot.log import logger
+from ..utils import split_maohao
+from .api import AnnePlayerApi, AnneSearchApi, anne_ban
+from .models import (
+    AnnePlayer2,
+    AnnePlayerDetail,
+    AnnePlayerError,
+    AnnePlayerInf,
+    AnnePlayerInfAvg,
+    AnnePlayerInfo,
+    AnnePlayerSur,
+    AnneSearch,
+    SourceBansInfo,
+)
+
+
+class L4D2Api:
+    ssl_verify = False
+    _HEADER: Dict[str, str] = {  # noqa: RUF012
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        "(KHTML, like Gecko)"
+        "Chrome/126.0.0.0"
+        "Safari/537.36 Edg/126.0.0.0",
+        "Content-Type": "application/x-www-form-urlencoded",
+    }
+
+    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  # 处理异常情况
+
+            msg_list = await asyncio.gather(*tasks)
+            sorted_msg_list = sorted(msg_list, key=lambda x: x[0].steam_id)
+
+        return sorted_msg_list
+
+    async def process_message(
+        self,
+        ip: Tuple[str, int],
+        index: int,
+        is_server: bool,
+        is_player: bool,
+    ):
+        server: a2s.SourceInfo = a2s.SourceInfo()
+        play: List[a2s.Player] = []
+        if is_server:
+            try:
+                server = await a2s.ainfo(ip)
+                if server is not None:
+                    server.steam_id = index
+
+            except (
+                asyncio.exceptions.TimeoutError,
+                ConnectionRefusedError,
+                socket.gaierror,
+            ):
+                server.steam_id = index
+                server.player_count = 0
+                server.max_players = 0
+                server.server_name = "服务器无响应"
+                server.map_name = "无"
+                server.folder = "m"
+                server.vac_enabled = False
+
+        if is_player:
+            with contextlib.suppress(
+                asyncio.exceptions.TimeoutError,
+                ConnectionRefusedError,
+                socket.gaierror,
+            ):
+                play = await a2s.aplayers(ip)
+        return server, play
+
+    async def _server_request(
+        self,
+        url: str,
+        method: Literal["GET", "POST"] = "GET",
+        header: Dict[str, str] = _HEADER,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        is_json: bool = True,
+    ):
+        header = deepcopy(self._HEADER)
+
+        if json is not None:
+            method = "POST"
+
+        async with AsyncClient(verify=self.ssl_verify) as client:
+            resp = await client.request(
+                method,
+                url=url,
+                headers=header,
+                params=params,
+                json=json,
+                data=data,
+                timeout=300,
+            )
+
+            if is_json:
+                try:
+                    raw_data = await resp.json()
+                except:  # noqa: E722
+                    _raw_data = resp.text
+                    try:
+                        raw_data = js.loads(_raw_data)
+                    except:  # noqa: E722
+                        raw_data = {
+                            "result": {"error_code": -999, "data": _raw_data},
+                        }
+                try:
+                    if not raw_data["result"]:
+                        return raw_data
+                except Exception:
+                    return raw_data
+                if (
+                    "result" in raw_data
+                    and "error_code" in raw_data["result"]
+                    and raw_data["code"] != 0
+                ):
+                    return raw_data["result"]["error_code"]
+                return raw_data
+            html_content = resp.content
+            return BeautifulSoup(html_content, "lxml")
+
+    async def get_sourceban(self, url: str = anne_ban):
+        """从sourceban++获取服务器列表，目前未做名称处理"""
+        soup = await self._server_request(
+            url=url,
+            is_json=False,
+        )
+
+        if not isinstance(soup, BeautifulSoup):
+            return []
+        server_list = []
+        tbody = soup.select_one("tbody")
+        if tbody is None:
+            return []
+        tr_tags = tbody.select("tr")
+        for index, tr in enumerate(tr_tags):
+            td_tags = tr.select("td")
+            for num, td in enumerate(td_tags):
+                if num == 4:
+                    host, port = split_maohao(td.text)
+                    server_list.append(
+                        SourceBansInfo(index=index, host=host, port=port),
+                    )
+
+        return server_list
+
+    async def get_anne_steamid(self, name: str):
+        """从电信anne服搜索昵称获取steamid"""
+        soup = await self._server_request(
+            url=AnneSearchApi,
+            data={"search": name},
+            method="POST",
+            is_json=False,
+        )
+        if not isinstance(soup, BeautifulSoup):
+            return None
+        server_list = []
+        tbody = soup.select_one("tbody")
+        if tbody is None:
+            return None
+        tr_tags = tbody.select("tr")
+        for tr in tr_tags:
+            onclick = tr.get("onclick")
+            if onclick is None or isinstance(onclick, list):
+                continue
+            steamid = onclick.split("steamid=")[1].replace("'", "")
+            td_tags = tr.select("td")
+            server_list.append(
+                {
+                    "steamid": steamid,
+                    "rank": td_tags[0].text.strip(),
+                    "name": td_tags[1].text.strip(),
+                    "score": td_tags[2].text.strip(),
+                    "play_time": td_tags[3].text.strip(),
+                    "last_time": td_tags,
+                },
+            )
+        print(server_list)
+        return cast(List[AnneSearch], server_list)
+
+    async def get_anne_playerdetail(self, steamid: str):
+        """从电信anne服通过steamid获取战绩"""
+        soup = await self._server_request(
+            url=AnnePlayerApi,
+            method="GET",
+            params={"steamid": steamid},
+            is_json=False,
+        )
+        if not isinstance(soup, BeautifulSoup):
+            return None
+
+        tbody = soup.find(
+            "div",
+            class_="content text-center text-md-left",
+            style="background-color: #f2f2f2;",
+        )
+        if tbody is None:
+            return None
+        kill_tag = tbody.find(
+            "div",
+            class_="card-body worldmap d-flex flex-column justify-content-center text-center",
+        )
+
+        tbody_tags = tbody.find_all(
+            "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]
+        inf_avg_tag = tbody_tags[3]
+        sur_tag = tbody_tags[4]
+        inf_tag = tbody_tags[5]
+
+        info_tr = info_tag.select("tr")
+        info_dict = {
+            "name": info_tr[0].select("td")[1].text.strip(),
+            "avatar": info_tr[1].select("td")[1].text.strip(),
+            "steamid": info_tr[2].select("td")[1].text.strip(),
+            "playtime": info_tr[3].select("td")[1].text.strip(),
+            "lasttime": info_tr[4].select("td")[1].text.strip(),
+        }
+        detail_tag = {
+            "rank": detail_tag.select("tr")[0].select("td")[1].text.strip(),
+            "source": detail_tag.select("tr")[1].select("td")[1].text.strip(),
+            "avg_source": detail_tag.select("tr")[2].select("td")[1].text.strip(),
+            "kills": detail_tag.select("tr")[3].select("td")[1].text.strip(),
+            "kills_people": detail_tag.select("tr")[4].select("td")[1].text.strip(),
+            "headshots": detail_tag.select("tr")[5].select("td")[1].text.strip(),
+            "avg_headshots": detail_tag.select("tr")[6].select("td")[1].text.strip(),
+            "map_play": detail_tag.select("tr")[7].select("td")[1].text.strip(),
+        }
+        error_tag = {
+            "mistake_shout": error_tag.select("tr")[0].select("td")[1].text.strip(),
+            "kill_friend": error_tag.select("tr")[1].select("td")[1].text.strip(),
+            "down_friend": error_tag.select("tr")[2].select("td")[1].text.strip(),
+            "abandon_friend": error_tag.select("tr")[3].select("td")[1].text.strip(),
+            "put_into": error_tag.select("tr")[4].select("td")[1].text.strip(),
+            "agitate_witch": error_tag.select("tr")[5].select("td")[1].text.strip(),
+        }
+        inf_avg_dict = {
+            "avg_smoker": inf_avg_tag.select("tr")[0].select("td")[1].text.strip(),
+            "avg_boomer": inf_avg_tag.select("tr")[1].select("td")[1].text.strip(),
+            "avg_hunter": inf_avg_tag.select("tr")[2].select("td")[1].text.strip(),
+            "avg_charger": inf_avg_tag.select("tr")[3].select("td")[1].text.strip(),
+            "avg_spitter": inf_avg_tag.select("tr")[4].select("td")[1].text.strip(),
+            "avg_jockey": inf_avg_tag.select("tr")[5].select("td")[1].text.strip(),
+            "avg_tank": inf_avg_tag.select("tr")[6].select("td")[1].text.strip(),
+        }
+        sur_dict = {
+            "map_clear": sur_tag.select("tr")[0].select("td")[1].text.strip(),
+            "prefect_into": sur_tag.select("tr")[1].select("td")[1].text.strip(),
+            "get_oil": sur_tag.select("tr")[2].select("td")[1].text.strip(),
+            "ammo_arrange": sur_tag.select("tr")[3].select("td")[1].text.strip(),
+            "adrenaline_give": sur_tag.select("tr")[4].select("td")[1].text.strip(),
+            "pills_give": sur_tag.select("tr")[5].select("td")[1].text.strip(),
+            "first_aid_give": sur_tag.select("tr")[6].select("td")[1].text.strip(),
+            "friend_up": sur_tag.select("tr")[7].select("td")[1].text.strip(),
+            "diss_friend": sur_tag.select("tr")[8].select("td")[1].text.strip(),
+            "save_friend": sur_tag.select("tr")[9].select("td")[1].text.strip(),
+            "protect_friend": sur_tag.select("tr")[10].select("td")[1].text.strip(),
+            "pro_from_smoker": sur_tag.select("tr")[11].select("td")[1].text.strip(),
+            "pro_from_hunter": sur_tag.select("tr")[12].select("td")[1].text.strip(),
+            "pro_from_charger": sur_tag.select("tr")[13].select("td")[1].text.strip(),
+            "pro_from_jockey": sur_tag.select("tr")[14].select("td")[1].text.strip(),
+            "melee_charge": sur_tag.select("tr")[15].select("td")[1].text.strip(),
+            "tank_kill": sur_tag.select("tr")[16].select("td")[1].text.strip(),
+            "witch_instantly_kill": sur_tag.select("tr")[17]
+            .select("td")[1]
+            .text.strip(),
+        }
+        inf_dict = {
+            "sur_ace": inf_tag.select("tr")[0].select("td")[1].text.strip(),
+            "sur_down": inf_tag.select("tr")[1].select("td")[1].text.strip(),
+            "boommer_hit": inf_tag.select("tr")[2].select("td")[1].text.strip(),
+            "hunter_prefect": inf_tag.select("tr")[3].select("td")[1].text.strip(),
+            "hunter_success": inf_tag.select("tr")[4].select("td")[1].text.strip(),
+            "tank_damage": inf_tag.select("tr")[5].select("td")[1].text.strip(),
+            "charger_multiple": inf_tag.select("tr")[6].select("td")[1].text.strip(),
+        }
+        info_dict = cast(AnnePlayerInfo, info_dict)
+        detail_dict = cast(AnnePlayerDetail, detail_tag)
+        error_dict = cast(AnnePlayerError, error_tag)
+        inf_avg_dict = cast(AnnePlayerInfAvg, inf_avg_dict)
+        sur_dict = cast(AnnePlayerSur, sur_dict)
+        inf_dict = cast(AnnePlayerInf, inf_dict)
+
+        out_dict = {
+            "kill_msg": kill_tag.text if kill_tag is not None else "",
+            "info": info_dict,
+            "detail": detail_dict,
+            "inf_avg": inf_avg_dict,
+            "sur": sur_dict,
+            "inf": inf_dict,
+            "error": error_dict,
+        }
+
+        return cast(AnnePlayer2, out_dict)
+
+
+L4API = L4D2Api()

nonebot_plugin_l4d2_server/utils/database/models.py

@@ -0,0 +1,18 @@
+from nonebot_plugin_tortoise_orm import add_model
+from tortoise import fields
+from tortoise.models import Model
+
+add_model(__name__)
+
+
+class SteamUser(Model):
+    """个人资料"""
+
+    userid = fields.BigIntField(pk=True)
+    SteamID = fields.TextField(null=True)
+    SteamID64 = fields.TextField(null=True)
+    Name = fields.TextField(null=True)
+
+    class Meta:  # type: ignore
+        table = "steam_user"
+        table_description = "个人资料"

nonebot_plugin_l4d2_server/{l4d2_utils → utils}/utils.py

@@ -1,19 +1,13 @@
 import json
+import os
 import tempfile
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 import aiofiles
-import httpx
+import aiohttp
 from nonebot.adapters.onebot.v11 import Bot, GroupMessageEvent, MessageEvent
 from nonebot.log import logger
-from nonebot.matcher import Matcher
-
-from ..l4d2_image.steam import url_to_byte
-from .config import l4_config, systems
-
-# from .rule import
-from .txt_to_img import mode_txt_to_img
 
 
 async def get_file(url: str, down_file: Path):
@@ -21,10 +15,7 @@ async def get_file(url: str, down_file: Path):
     下载指定Url到指定位置
     """
     try:
-        if l4_config.l4_only:
-            maps = await url_to_byte(url)
-        else:
-            maps = httpx.get(url).content  # noqa: ASYNC100
+        maps = await url_to_byte(url)
         logger.info("已获取文件，尝试新建文件并写入")
         if maps:
             async with aiofiles.open(down_file, "wb") as mfile:
@@ -47,7 +38,7 @@ def get_vpk(map_path: Path, file_: str = ".vpk") -> List[str]:
 def mes_list(mes: str, name_list: List[str]) -> str:
     if name_list:
         for idx, name in enumerate(name_list):
-            mes += f"\n{idx+1}、{name}"
+            mes += f"\n{idx + 1}、{name}"
     return mes
 
 
@@ -82,16 +73,11 @@ def solve(msg: str):
     return "\n".join(lines)
 
 
-async def get_message_at(datas: str) -> List[int]:
-    data: Dict[str, Any] = json.loads(datas)
-    return [int(msg["data"]["qq"]) for msg in data["message"] if msg["type"] == "at"]
-
-
 def at_to_usrid(at: List[int]):
     return at[0] if at else None
 
 
-async def save_file(file: bytes, path_name):
+async def save_file(file: bytes, path_name: str):
     """保存文件"""
     async with aiofiles.open(path_name, "wb") as files:
         await files.write(file)
@@ -99,7 +85,7 @@ async def save_file(file: bytes, path_name):
 
 async def upload_file(bot: Bot, event: MessageEvent, file_data: bytes, filename: str):
     """上传临时文件"""
-    if systems in ["win", "other"]:
+    if os.name == "nt":
         with tempfile.TemporaryDirectory() as temp_dir:
             async with aiofiles.open(Path(temp_dir) / filename, "wb") as f:
                 await f.write(file_data)
@@ -118,23 +104,23 @@ async def upload_file(bot: Bot, event: MessageEvent, file_data: bytes, filename:
                     name=filename,
                 )
         (Path().joinpath(filename)).unlink()
-    elif systems == "linux":
+    else:
         with tempfile.NamedTemporaryFile("wb+") as f:
             f.write(file_data)
-            if isinstance(event, GroupMessageEvent):
-                await bot.call_api(
-                    "upload_group_file",
-                    group_id=event.group_id,
-                    file=f.name,
-                    name=filename,
-                )
-            else:
-                await bot.call_api(
-                    "upload_private_file",
-                    user_id=event.user_id,
-                    file=f.name,
-                    name=filename,
-                )
+        if isinstance(event, GroupMessageEvent):
+            await bot.call_api(
+                "upload_group_file",
+                group_id=event.group_id,
+                file=f.name,
+                name=filename,
+            )
+        else:
+            await bot.call_api(
+                "upload_private_file",
+                user_id=event.user_id,
+                file=f.name,
+                name=filename,
+            )
 
 
 sub_menus = []
@@ -159,7 +145,7 @@ def register_menu_func(
 
 
 def register_menu(*args, **kwargs):
-    def decorator(f):
+    def decorator(f):  # noqa: ANN001
         register_menu_func(*args, **kwargs)
         return f
 
@@ -176,32 +162,43 @@ async def extract_last_digit(msg: str) -> Tuple[str, str]:
     return msg, ""
 
 
-async def str_to_picstr(push_msg: str, matcher: Matcher, keyword: Optional[str] = None):
-    """判断图片输出还是正常输出"""
-    if l4_config.l4_image:
-        lines = push_msg.splitlines()
-        first_str = lines[0]
-        last_str = lines[-1]
-        push_msg = "\n".join(lines[1:-1])
-        if l4_config.l4_connect:
-            await mode_txt_to_img(first_str, push_msg, last_str)
-        else:
-            await mode_txt_to_img(first_str, push_msg)
-    else:
-        if l4_config.l4_connect or keyword == "connect":
-            await matcher.send(push_msg)
-        else:
-            await matcher.send("\n".join(push_msg.splitlines()[1:-2]))
-
-
-def split_maohao(msg: str) -> List[str]:
+def split_maohao(msg: str) -> Tuple[str, int]:
     """分割大小写冒号"""
     if ":" in msg:
-        msgs: List[str] = msg.split(":")
-    elif "：" in msg:
-        msgs: List[str] = msg.split("：")
-    elif msg.replace(".", "").isdigit():
-        msgs: List[str] = [msg, "20715"]
-    else:
-        msgs = []
-    return [msgs[0], msgs[-1]]
+        return msg.split(":")[0], int(msg.split(":")[-1])
+    if "：" in msg:
+        return msg.split("：")[0], int(msg.split("：")[-1])
+    if msg.replace(".", "").isdigit():
+        return msg, 20715
+    return "", -1
+
+
+headers = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0",  # noqa: E501
+}
+
+
+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:
+            if response.status == 200:
+                return await response.read()
+            return None
+
+
+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:
+            if response.status == 200:
+                return await response.text()
+            return None
+
+
+async def get_message_at(datas: str) -> Optional[int]:  # noqa: F811
+    data: Dict[str, Any] = json.loads(datas)
+    at_list = [int(msg["data"]["qq"]) for msg in data["message"] if msg["type"] == "at"]
+    return at_list[0] if at_list else None