nonebot-plugin-l4d2-server 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

nonebot_plugin_l4d2_server/config.py

@@ -1,43 +1,73 @@
 from pathlib import Path
+from typing import List
 
 from nonebot import get_plugin_config
 from nonebot.log import logger
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
+# 常量定义
 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")
+DEFAULT_DATA_DIR = "data/L4D2"
+DEFAULT_FONT = str(Path(__file__).parent.joinpath("data/font/loli.ttf"))
+
+
+# 初始化数据目录
+def init_data_directory(data_dir: Path) -> None:
+    """初始化数据目录和必要文件"""
+    data_dir.mkdir(parents=True, exist_ok=True)
+    json_file = data_dir / "l4d2.json"
+
+    if not json_file.exists():
+        logger.info(f"文件 {json_file.name} 不存在，已创建并初始化为 {{}}")
+        json_file.write_text("{}", encoding="utf-8")
+
+
+# 初始化目录结构
+DATAOUT = Path(DEFAULT_DATA_DIR)
+init_data_directory(DATAOUT)
+init_data_directory(DATAOUT / "l4d2")
 server_all_path = DATAOUT / "l4d2"
 server_all_path.mkdir(parents=True, exist_ok=True)
 
 ICONPATH = DATAPATH / "icon"
-
 global map_index
 map_index = 0
 
 
 class ConfigModel(BaseModel):
-    l4_enable: bool = True
-    """是否全局启用求生功能"""
-    l4_image: bool = True
-    """是否启用图片"""
-    l4_connect: bool = True
-    """是否在查服命令后加入connect ip"""
-    l4_path: str = "data/L4D2"
-    """插件数据路径"""
-    l4_players: int = 4
-    """查询总图的时候展示的用户数量"""
-    l4_style: str = "default"
-    """图片风格"""
-    l4_font: str = str(Path(__file__).parent.joinpath("data/font/loli.ttf"))
-    """字体"""
-    l4_show_ip: bool = True
-    """单服务器查询时候是否展示ip直连地址"""
-    l4_local: list[str] = []
-    """本地服务器路径,填写路径下有`steam_appid.txt`文件"""
+    """插件配置模型"""
+
+    l4_enable: bool = Field(default=True, description="是否全局启用求生功能")
+    l4_image: bool = Field(default=True, description="是否启用图片")
+    l4_connect: bool = Field(default=True, description="是否在查服命令后加入connect ip")
+    l4_path: str = Field(default=DEFAULT_DATA_DIR, description="插件数据路径")
+    l4_players: int = Field(default=4, ge=1, description="查询总图时展示的用户数量")
+    l4_style: str = Field(default="default", description="图片风格")
+    l4_font: str = Field(default=DEFAULT_FONT, description="字体文件路径")
+    l4_show_ip: bool = Field(
+        default=True,
+        description="单服务器查询时是否展示ip直连地址",
+    )
+    l4_local: List[str] = Field(default_factory=list, description="本地服务器路径列表")
+
+    @classmethod
+    def validate_players(cls, v):
+        if v < 1:
+            raise ValueError("玩家数量必须大于0")
+        return v
+
+    @classmethod
+    def validate_font(cls, v):
+        if not Path(v).exists():
+            logger.warning(f"字体文件 {v} 不存在")
+        return v
+
+    @classmethod
+    def validate_local_paths(cls, v):
+        path = Path(v)
+        if not (path / "steam_appid.txt").exists():
+            raise ValueError(f"路径 {v} 下缺少 steam_appid.txt 文件")
+        return str(path.resolve())
 
 
 config = get_plugin_config(ConfigModel)
@@ -49,46 +79,53 @@ class ConfigManager:
     def __init__(self):
         self._config = config
 
-    def update_image_config(self, enabled: bool) -> None:
-        """更新图片配置
+    @property
+    def current_config(self) -> ConfigModel:
+        """获取当前配置"""
+        return self._config
 
-        Args:
-            enabled: 是否启用图片功能
-        """
+    def update_image_config(self, enabled: bool) -> None:
+        """更新图片配置"""
         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
-        """
+        """更新connect ip配置"""
         self._config.l4_connect = enabled
 
     def update(self, **kwargs) -> None:
-        """通用配置更新方法
+        """
+        通用配置更新方法
 
         Args:
             **kwargs: 要更新的配置项键值对
 
         Raises:
-            ValueError: 当传入无效的配置项时
+            ValueError: 当传入无效的配置项或值不合法时
+            TypeError: 当传入值的类型不正确时
         """
+        valid_keys = ConfigModel.model_fields.keys()
+
         for key, value in kwargs.items():
-            if hasattr(self._config, key):
-                setattr(self._config, key, value)
-            else:
+            if key not in valid_keys:
                 raise ValueError(f"无效的配置项: {key}")
 
+            field_type = ConfigModel[key].type_
+            if not isinstance(value, field_type):
+                raise TypeError(f"{key} 必须是 {field_type.__name__} 类型")
+
+            setattr(self._config, key, value)
+
+        # 验证更新后的配置
+        try:
+            self._config = ConfigModel(**self._config.dict())
+        except ValueError as e:
+            logger.error(f"配置更新失败: {e!s}")
+
 
 config_manager = ConfigManager()

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.1.1"
+__version__ = "1.1.3"
 TEXT_PATH = Path(__file__).parent / "texture2d"
 HELP_DATA = Path(__file__).parent / "Help.json"
 

nonebot_plugin_l4d2_server/l4_image/convert.py

@@ -79,75 +79,6 @@ async def convert_img(
     return f"base64://{b64encode(img).decode()}"
 
 
-def convert_img_sync(img_path: Path):
-    with img_path.open("rb") as fp:
-        img = fp.read()
-
-    return f"base64://{b64encode(img).decode()}"
-
-
-async def str_lenth(r: str, size: int, limit: int = 540) -> str:  # noqa: RUF029
-    result = ""
-    temp = 0
-    for i in r:
-        if i == "\n":
-            temp = 0
-            result += i
-            continue
-
-        if temp >= limit:
-            result += "\n" + i
-            temp = 0
-        else:
-            result += i
-
-        if i.isdigit():
-            temp += round(size / 10 * 6)
-        elif i == "/":
-            temp += round(size / 10 * 2.2)
-        elif i == ".":
-            temp += round(size / 10 * 3)
-        elif i == "%":
-            temp += round(size / 10 * 9.4)
-        else:
-            temp += size
-    return result
-
-
-def get_str_size(
-    r: str,
-    font: ImageFont.FreeTypeFont,
-    limit: int = 540,
-) -> str:
-    result = ""
-    line = ""
-    for i in r:
-        if i == "\n":
-            result += f"{line}\n"
-            line = ""
-            continue
-
-        line += i
-
-        if hasattr(font, "getsize"):
-            size, _ = font.getsize(line)  # type: ignore
-        else:
-            bbox = font.getbbox(line)
-            size, _ = bbox[2] - bbox[0], bbox[3] - bbox[1]
-
-        if size >= limit:
-            result += f"{line}\n"
-            line = ""
-    else:
-        result += line
-    return result
-
-
-def get_height(content: str, size: int) -> int:
-    line_count = content.count("\n")
-    return (line_count + 1) * size
-
-
 async def text2pic(text: str, max_size: int = 800, font_size: int = 24):
     if text.endswith("\n"):
         text = text[:-1]

nonebot_plugin_l4d2_server/l4_image/html_img.py

@@ -1,10 +1,10 @@
-import random
 from pathlib import Path
+import re
 from typing import List, Optional
 
 import jinja2
 from nonebot.log import logger
-from nonebot_plugin_htmlrender import html_to_pic
+from nonebot_plugin_htmlrender import html_to_pic, template_to_html, template_to_pic
 
 from ..config import config
 from ..utils.api.models import OutServer
@@ -46,12 +46,20 @@ async def server_ip_pic(server_dict: List[OutServer]):
                 reverse=True,
             )[:max_number]
             logger.debug(sorted_players)
+
+            # 时间转换
+            max_duration_len = max(
+                [len(str(await convert_duration(i.duration))) for i in sorted_players],
+            )
+            for player in sorted_players:
+                chines_dur = await convert_duration(player.duration)
+                dur = "{:^{}}".format(chines_dur, max_duration_len)
+                player.name = str(player.name) + " | " + dur
+
             server_info["player"] = sorted_players
         else:
             server_info["player"] = []
 
-        # server_info["server"].server_type= f"{server_info['server'].server_type}.svg"
-    print(server_dict)
     pic = await get_server_img(server_dict)
     if pic:
         logger.success("正在输出图片")
@@ -62,23 +70,18 @@ async def server_ip_pic(server_dict: List[OutServer]):
 
 async def get_server_img(plugins: List[OutServer]) -> Optional[bytes]:
     try:
-        if config.l4_style == "孤独摇滚":
-            template = env.get_template("Bocchi_The_Rock.html")
-        elif config.l4_style == "电玩像素":
-            template = env.get_template("Pixel.html")
-        elif config.l4_style == "缤纷彩虹":
-            template = env.get_template("Rainbow.html")
-        elif config.l4_style == "随机":
-            html_files = [
-                str(f.name) for f in template_path.rglob("*.html") if f.is_file()
-            ]
-            template = env.get_template(random.choice(html_files))
-        else:
+        if config.l4_style == "default":
+
+
             template = env.get_template("normal.html")
+        else:
+            template = env.get_template("normal_old.html")
         content = await template.render_async(
             servers=plugins,
             max_count=config.l4_players,
         )
+        # with open("test.html", "w", encoding="utf-8") as f:
+        #     f.write(content)
         return await html_to_pic(
             content,
             wait=0,
@@ -87,4 +90,25 @@ async def get_server_img(plugins: List[OutServer]) -> Optional[bytes]:
         )
     except Exception as e:
         logger.warning(f"Error in get_server_img: {e}")
-    return None
+        return None
+
+
+async def convert_duration(duration: float) -> str:
+    """将秒数转换为易读的时间字符串格式（例如 '1h 30m 15s'）
+
+    参数:
+        duration: 秒数
+
+    返回:
+        格式化的时间字符串
+    """
+    total_seconds = int(duration)
+    minutes, seconds = divmod(total_seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    time_str = ""
+    if hours > 0:
+        time_str += f"{hours}h "
+    if minutes > 0:
+        time_str += f"{minutes}m "
+    time_str += f"{seconds}s"
+    return time_str

nonebot_plugin_l4d2_server/l4_image/image_tools.py

@@ -6,83 +6,17 @@ from typing import Optional, Tuple, Union
 
 import httpx
 from httpx import get
-from PIL import Image, ImageDraw, ImageFilter, ImageFont
+from PIL import Image, ImageDraw, ImageFont
 
 TEXT_PATH = Path(__file__).parent / "texture2d"
 BG_PATH = Path(__file__).parents[1] / "default_bg"
 
 
-def get_div():
-    return Image.open(TEXT_PATH / "div.png")
-
-
 async def sget(url: str):
     async with httpx.AsyncClient(timeout=None) as client:  # noqa: S113
         return await client.get(url=url)
 
 
-def get_status_icon(status: Union[int, bool]) -> Image.Image:
-    if status:
-        img = Image.open(TEXT_PATH / "yes.png")
-    else:
-        img = Image.open(TEXT_PATH / "no.png")
-    return img
-
-
-def get_v4_footer():
-    return Image.open(TEXT_PATH / "footer.png")
-
-
-def get_v4_bg(w: int, h: int, is_dark: bool = False, is_blur: bool = False):
-    ci_img = CustomizeImage(BG_PATH)
-    img = ci_img.get_image(None, w, h)
-    if is_blur:
-        img = img.filter(ImageFilter.GaussianBlur(radius=20))
-    if is_dark:
-        black_img = Image.new("RGBA", (w, h), (0, 0, 0, 180))
-        img.paste(black_img, (0, 0), black_img)
-    return img.convert("RGBA")
-
-
-async def shift_image_hue(
-    img: Image.Image,
-    angle: float = 30,
-) -> Image.Image:  # noqa: RUF029
-    alpha = img.getchannel("A")
-    img = img.convert("HSV")
-
-    pixels = img.load()
-    assert pixels is not None
-    hue_shift = angle
-
-    for y in range(img.height):
-        for x in range(img.width):
-            h, s, v = pixels[x, y]  # type: ignore
-            h = (h + hue_shift) % 360
-            pixels[x, y] = (h, s, v)  # type: ignore
-
-    img = img.convert("RGBA")
-    img.putalpha(alpha)
-    return img
-
-
-async def get_pic(url: str, size: Optional[Tuple[int, int]] = None) -> Image.Image:
-    """
-    从网络获取图片, 格式化为RGBA格式的指定尺寸
-    """
-    async with httpx.AsyncClient(timeout=None) as client:  # noqa: S113
-        resp = await client.get(url=url)
-        if resp.status_code != 200:
-            if size is None:
-                size = (960, 600)
-            return Image.new("RGBA", size)
-        pic = Image.open(BytesIO(resp.read()))
-        pic = pic.convert("RGBA")
-        if size is not None:
-            pic = pic.resize(size)
-        return pic
-
-
 def draw_center_text_by_line(
     img: ImageDraw.ImageDraw,
     pos: Tuple[int, int],
@@ -191,43 +125,6 @@ def draw_text_by_line(
     return y
 
 
-def easy_paste(
-    im: Image.Image,
-    im_paste: Image.Image,
-    pos=(0, 0),  # noqa: ANN001
-    direction="lt",  # noqa: ANN001
-):
-    """
-    inplace method
-    快速粘贴, 自动获取被粘贴图像的坐标。
-    pos应当是粘贴点坐标,direction指定粘贴点方位,例如lt为左上
-    """
-    x, y = pos
-    size_x, size_y = im_paste.size
-    if "d" in direction:
-        y = y - size_y
-    if "r" in direction:
-        x = x - size_x
-    if "c" in direction:
-        x = x - int(0.5 * size_x)
-        y = y - int(0.5 * size_y)
-    im.paste(im_paste, (x, y, x + size_x, y + size_y), im_paste)
-
-
-def easy_alpha_composite(
-    im: Image.Image,
-    im_paste: Image.Image,
-    pos=(0, 0),  # noqa: ANN001
-    direction="lt",  # noqa: ANN001
-) -> Image.Image:
-    """
-    透明图像快速粘贴
-    """
-    base = Image.new("RGBA", im.size)
-    easy_paste(base, im_paste, pos, direction)
-    return Image.alpha_composite(im, base)
-
-
 async def get_qq_avatar(
     qid: Optional[Union[int, str]] = None,
     avatar_url: Optional[str] = None,