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

nonebot_plugin_l4d2_server/{l4d2_image → l4_image}/download.py

@@ -3,15 +3,16 @@ import hashlib
 import io
 import os
 import random
+from pathlib import Path
 
 import httpx
 from nonebot.log import logger
 from PIL import Image, ImageDraw
 from PIL.Image import Image as ImageS
 
-from ..l4d2_utils.config import PLAYERSDATA, TEXT_PATH
+from ..config import DATAOUT
 
-# from .steam import web_player
+TEXT_PATH = Path(__file__).parent
 
 
 async def download_url(url: str) -> bytes:
@@ -53,7 +54,7 @@ async def get_head_by_user_id_and_save(user_id):
     """qq转头像"""
     user_id = str(user_id)
 
-    user_head_path = PLAYERSDATA / user_id / "HEAD.png"
+    user_head_path = DATAOUT / user_id / "HEAD.png"
     default_header_path = TEXT_PATH / "header"
     default_head_path = TEXT_PATH / "head"
     default_header = default_header_path / random.choice(
@@ -77,8 +78,8 @@ async def get_head_by_user_id_and_save(user_id):
                     .resize((280, 280))
                     .convert("RGBA")
                 )
-                if not (PLAYERSDATA / user_id).exists():  # 用户文件夹不存在
-                    (PLAYERSDATA / user_id).mkdir(parents=True, exist_ok=True)
+                if not (DATAOUT / user_id).exists():  # 用户文件夹不存在
+                    (DATAOUT / user_id).mkdir(parents=True, exist_ok=True)
                 im.save(user_head_path, "PNG")
             except Exception:
                 logger.error("获取失败")
@@ -91,28 +92,3 @@ async def get_head_by_user_id_and_save(user_id):
     im3.paste(im, (75, 75), mask=a1)
     im3.paste(im2, mask=a2)
     return im3
-
-
-# async def get_head_steam_and_save(user_id:str,urls):
-#     """保存steam头像"""
-#     user_head_path = PLAYERSDATA / str(user_id) / 'HEAD.png'
-#     # default_head_path = TEXT_PATH / "template/player.jpg"
-#     ## im头像 im2头像框 im3合成
-#     if os.path.exists(user_head_path):
-#         logger.info("使用本地头像")
-#         im = Image.open(user_head_path).resize((280, 280)).convert("RGBA")
-#     else:
-#         # if user_id == "1145149191810":
-#         #     logger.info("使用默认头像")
-#         #     im = Image.open(default_head_path).resize((300, 300)).convert("RGBA")
-#         # else:
-#             try:
-#                 logger.info("正在下载头像")
-#                 image_bytes = await web_player(urls)
-#                 im = Image.open(io.BytesIO(image_bytes)).resize((280, 280)).convert("RGBA")  # noqa: E501
-#                 if not os.path.exists(PLAYERSDATA / user_id):#用户文件夹不存在
-#                     os.makedirs(PLAYERSDATA / user_id)
-#                 im.save(user_head_path, "PNG")
-#             except TimeoutError:
-#                 logger.error("获取失败")
-#     return im

nonebot_plugin_l4d2_server/{l4d2_image/__init__.py → l4_image/html_img.py}

@@ -1,18 +1,20 @@
+import random
+from pathlib import Path
 from typing import List, Optional
 
 import jinja2
 from nonebot.log import logger
 from nonebot_plugin_htmlrender import html_to_pic
 
-from ..l4d2_utils.classcal import PlayerInfo, ServerGroup, ServerStatus
+from ..config import config
+from ..utils.api.models import OutServer
+from .convert import convert_img
 
 # from .htmlimg import dict_to_dict_img
 # from ..l4d2_anne.anne_telecom import ANNE_API
-from ..l4d2_utils.config import TEXT_PATH, l4_config
 from .download import get_head_by_user_id_and_save
-from .send_image_tool import convert_img
 
-template_path = TEXT_PATH / "template"
+template_path = Path(__file__).parent / "img/template"
 
 env = jinja2.Environment(
     loader=jinja2.FileSystemLoader(template_path),
@@ -66,25 +68,24 @@ async def dict_to_html(usr_id, detail_map: dict):
     return data_list
 
 
-async def server_ip_pic(msg_list: List[ServerStatus]):
+async def server_ip_pic(server_dict: List[OutServer]):
     """
     输入一个字典列表，输出图片
     msg_dict:folder/name/map_/players/max_players/Players/[Name]
     """
-    for server_info in msg_list:
-        server_info.rank_players = f"{server_info.players}/{server_info.max_players}"
-        players_list: List[PlayerInfo] = []
-        # logger.info(server_info.name)
-        max_number = l4_config.l4_img_name
-        sorted_players = sorted(server_info.Players, key=lambda x: x.Score)[:max_number]
-        for player_info in sorted_players:
-            # player_str = f"{player_info.name} | {player_info.Duration}"
-            players_list.append(player_info)
-        while len(players_list) < max_number:
-            players_list.append(PlayerInfo())
-        server_info.Players = players_list
-        # logger.info(server_info.Players)
-    pic = await get_help_img(msg_list)
+    for server_info in server_dict:
+        max_number = config.l4_players
+        if server_info.get("player"):
+            sorted_players = sorted(server_info["player"], key=lambda x: x.score)[
+                :max_number
+            ]
+            server_info["player"] = sorted_players
+        else:
+            server_info["player"] = []
+
+        # server_info["server"].server_type= f"{server_info['server'].server_type}.svg"
+
+    pic = await get_server_img(server_dict)
     if pic:
         logger.success("正在输出图片")
     else:
@@ -92,34 +93,42 @@ async def server_ip_pic(msg_list: List[ServerStatus]):
     return pic
 
 
-async def get_help_img(plugins: List[ServerStatus]) -> Optional[bytes]:
-    try:
-        if l4_config.l4_style == "black":
-            template = env.get_template("help_dack.html")
-        else:
-            template = env.get_template("help.html")
-        content = await template.render_async(plugins=plugins)
-        return await html_to_pic(
-            content,
-            wait=0,
-            viewport={"width": 100, "height": 100},
-            template_path=f"file://{template_path.absolute()}",
-        )
-    except Exception as e:
-        logger.warning(f"Error in get_help_img: {e}")
-        return None
-
+async def get_server_img(plugins: List[OutServer]) -> Optional[bytes]:
+    # try:
 
-async def server_group_ip_pic(msg_list: List[ServerGroup]):
-    """
-    输入一个群组字典列表，输出图片
-    msg_dict:folder/name/map_/players/max_players/Players/[Name]
-    """
-    template = env.get_template("group_ip.html")
-    html = await template.render_async(plugins=msg_list)
+    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:
+        template = env.get_template("normal.html")
+    content = await template.render_async(plugins=plugins, max_count=config.l4_players)
     return await html_to_pic(
-        html=html,
+        content,
         wait=0,
-        viewport={"width": 1100, "height": 800},
+        viewport={"width": 100, "height": 100},
         template_path=f"file://{template_path.absolute()}",
     )
+    # except Exception as e:
+    #     logger.warning(f"Error in get_help_img: {e}")
+    return None
+
+
+# async def server_group_ip_pic(msg_list: List[ServerGroup]) -> bytes:
+#     """
+#     输入一个群组字典列表，输出图片
+#     msg_dict:folder/name/map_/players/max_players/Players/[Name]
+#     """
+#     template = env.get_template("group_ip.html")
+#     html = await template.render_async(plugins=msg_list)
+#     return await html_to_pic(
+#         html=html,
+#         wait=0,
+#         viewport={"width": 1100, "height": 800},
+#         template_path=f"file://{template_path.absolute()}",
+#     )

nonebot_plugin_l4d2_server/l4_image/image_tools.py

@@ -0,0 +1,468 @@
+import math
+import random
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, Tuple, Union
+
+import httpx
+from httpx import get
+from PIL import Image, ImageDraw, ImageFilter, 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:
+        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:
+    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, size: Optional[Tuple[int, int]] = None) -> Image.Image:
+    """
+    从网络获取图片, 格式化为RGBA格式的指定尺寸
+    """
+    async with httpx.AsyncClient(timeout=None) as client:
+        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],
+    text: str,
+    font: ImageFont.FreeTypeFont,
+    fill: Union[Tuple[int, int, int, int], str],
+    max_length: float,
+    not_center: bool = False,
+) -> float:
+    pun = "。！？；!?…"
+    gun = "。！？；!?」』"
+    x, y = pos
+
+    if hasattr(font, "getsize"):
+        _, h = font.getsize("X")  # type: ignore
+    else:
+        bbox = font.getbbox("X")
+        _, h = 0, bbox[3] - bbox[1]
+
+    line = ""
+    lenth = 0
+    anchor = "la" if not_center else "mm"
+    for index, char in enumerate(text):
+        if hasattr(font, "getsize"):
+            # 获取当前字符的宽度
+            size, _ = font.getsize(char)  # type: ignore
+        else:
+            bbox = font.getbbox(char)
+            size, _ = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        lenth += size
+        line += char
+        if lenth < max_length and char not in pun and char != "\n":
+            pass
+        else:
+            if index + 1 < len(text) and text[index + 1] in gun:
+                pass
+            else:
+                line = line.replace("\n", "")
+                img.text((x, y), line, fill, font, anchor)
+                line, lenth = "", 0
+                y += h * 2.5
+    else:
+        img.text((x, y), line, fill, font, anchor)
+    return y
+
+
+def draw_text_by_line(
+    img: Image.Image,
+    pos: Tuple[int, int],
+    text: str,
+    font: ImageFont.FreeTypeFont,
+    fill: Union[Tuple[int, int, int, int], str],
+    max_length: float,
+    center=False,
+    line_space: Optional[float] = None,
+) -> float:
+    """
+    在图片上写长段文字, 自动换行
+    max_length单行最大长度, 单位像素
+    line_space  行间距, 单位像素, 默认是字体高度的0.3倍
+    """
+    x, y = pos
+
+    if hasattr(font, "getsize"):
+        _, h = font.getsize("X")  # type: ignore
+    else:
+        bbox = font.getbbox("X")
+        _, h = 0, bbox[3] - bbox[1]
+
+    y_add = math.ceil(1.3 * h) if line_space is None else math.ceil(h + line_space)
+    draw = ImageDraw.Draw(img)
+    row = ""  # 存储本行文字
+    length = 0  # 记录本行长度
+    for character in text:
+        # 获取当前字符的宽度
+        if hasattr(font, "getsize"):
+            w, h = font.getsize(character)  # type: ignore
+        else:
+            bbox = font.getbbox("X")
+            w, h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+
+        if length + w * 2 <= max_length:
+            row += character
+            length += w
+        else:
+            row += character
+            if center:
+                if hasattr(font, "getsize"):
+                    font_size = font.getsize(row)  # type: ignore
+                else:
+                    bbox = font.getbbox(character)
+                    font_size = bbox[2] - bbox[0], bbox[3] - bbox[1]
+                x = math.ceil((img.size[0] - font_size[0]) / 2)
+            draw.text((x, y), row, font=font, fill=fill)
+            row = ""
+            length = 0
+            y += y_add
+    if row != "":
+        if center:
+            if hasattr(font, "getsize"):
+                font_size = font.getsize(row)  # type: ignore
+            else:
+                bbox = font.getbbox(row)
+                font_size = bbox[2] - bbox[0], bbox[3] - bbox[1]
+            x = math.ceil((img.size[0] - font_size[0]) / 2)
+        draw.text((x, y), row, font=font, fill=fill)
+    return y
+
+
+def easy_paste(
+    im: Image.Image,
+    im_paste: Image.Image,
+    pos=(0, 0),
+    direction="lt",
+):
+    """
+    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),
+    direction="lt",
+) -> 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,
+) -> Image.Image:
+    if qid:
+        avatar_url = f"http://q1.qlogo.cn/g?b=qq&nk={qid}&s=640"
+    elif avatar_url is None:
+        avatar_url = "https://q1.qlogo.cn/g?b=qq&nk=3399214199&s=640"
+    return Image.open(BytesIO((await sget(avatar_url)).content)).convert(
+        "RGBA",
+    )
+
+
+async def draw_pic_with_ring(
+    pic: Image.Image,
+    size: int,
+    bg_color: Optional[Tuple[int, int, int]] = None,
+    is_ring: bool = True,
+):
+    """
+    :说明:
+      绘制一张带白色圆环的1:1比例图片。
+
+    :参数:
+      * pic: `Image.Image`: 要修改的图片。
+      * size: `int`: 最后传出图片的大小(1:1)。
+      * bg_color: `Optional[Tuple[int, int, int]]`: 是否指定圆环内背景颜色。
+
+    :返回:
+      * img: `Image.Image`: 图片对象
+    """
+    ring_pic = Image.open(TEXT_PATH / "ring.png")
+    mask_pic = Image.open(TEXT_PATH / "mask.png")
+    img = Image.new("RGBA", (size, size))
+    mask = mask_pic.resize((size, size))
+    resize_pic = crop_center_img(pic, size, size)
+    if bg_color:
+        img_color = Image.new("RGBA", (size, size), bg_color)
+        img_color.paste(resize_pic, (0, 0), resize_pic)
+        img.paste(img_color, (0, 0), mask)
+    else:
+        img.paste(resize_pic, (0, 0), mask)
+
+    if is_ring:
+        ring = ring_pic.resize((size, size))
+        img.paste(ring, (0, 0), ring)
+
+    return img
+
+
+def crop_center_img(
+    img: Image.Image,
+    based_w: int,
+    based_h: int,
+) -> Image.Image:
+    # 确定图片的长宽
+    based_scale = "%.3f" % (based_w / based_h)
+    w, h = img.size
+    scale_f = "%.3f" % (w / h)
+    new_w = math.ceil(based_h * float(scale_f))
+    new_h = math.ceil(based_w / float(scale_f))
+    if scale_f > based_scale:
+        resize_img = img.resize((new_w, based_h), Image.Resampling.LANCZOS)
+        x1 = int(new_w / 2 - based_w / 2)
+        y1 = 0
+        x2 = int(new_w / 2 + based_w / 2)
+        y2 = based_h
+    else:
+        resize_img = img.resize((based_w, new_h), Image.Resampling.LANCZOS)
+        x1 = 0
+        y1 = int(new_h / 2 - based_h / 2)
+        x2 = based_w
+        y2 = int(new_h / 2 + based_h / 2)
+    return resize_img.crop((x1, y1, x2, y2))
+
+
+async def get_color_bg(
+    based_w: int,
+    based_h: int,
+    bg_path: Optional[Path] = None,
+    without_mask: bool = False,
+    is_full: bool = False,
+    color: Optional[Tuple[int, int, int]] = None,
+    full_opacity: int = 200,
+) -> Image.Image:
+    ci_img = CustomizeImage(bg_path)  # type: ignore
+    img = ci_img.get_image(None, based_w, based_h)
+    if color is None:
+        color = ci_img.get_bg_color(img)
+    if is_full:
+        color_img = Image.new("RGBA", (based_w, based_h), color)
+        mask = Image.new(
+            "RGBA",
+            (based_w, based_h),
+            (255, 255, 255, full_opacity),
+        )
+        img.paste(color_img, (0, 0), mask)
+    elif not without_mask:
+        color_mask = Image.new("RGBA", (based_w, based_h), color)
+        enka_mask = Image.open(TEXT_PATH / "bg_mask.png").resize(
+            (based_w, based_h),
+        )
+        img.paste(color_mask, (0, 0), enka_mask)
+    return img
+
+
+class CustomizeImage:
+    def __init__(self, bg_path: Path) -> None:
+        self.bg_path = bg_path
+
+    def get_image(
+        self,
+        image: Union[str, Image.Image, None],
+        based_w: int,
+        based_h: int,
+    ) -> Image.Image:
+        # 获取背景图片
+        if isinstance(image, Image.Image):
+            edit_bg = image
+        elif image:
+            edit_bg = Image.open(BytesIO(get(image).content)).convert("RGBA")
+        else:
+            _lst = list(self.bg_path.iterdir())
+            if _lst:
+                path = random.choice(list(self.bg_path.iterdir()))
+            else:
+                path = random.choice(list(BG_PATH.iterdir()))
+            edit_bg = Image.open(path).convert("RGBA")
+
+        # 确定图片的长宽
+        return crop_center_img(edit_bg, based_w, based_h)
+
+    @staticmethod
+    def get_dominant_color(pil_img: Image.Image) -> Tuple[int, int, int]:
+        img = pil_img.copy()
+        img = img.convert("RGBA")
+        img = img.resize((1, 1), resample=0)
+        return img.getpixel((0, 0))  # type: ignore
+
+    @staticmethod
+    def get_bg_color(
+        edit_bg: Image.Image,
+        is_light: Optional[bool] = False,
+    ) -> Tuple[int, int, int]:
+        # 获取背景主色
+        color = 8
+        q = edit_bg.quantize(colors=color, method=Image.Quantize.FASTOCTREE)
+        bg_color = (0, 0, 0)
+        based_light = 195 if is_light else 120
+        temp = 9999
+        for i in range(color):
+            bg = tuple(
+                q.getpalette()[  # type:ignore
+                    i * 3 : (i * 3) + 3  # noqa:E203
+                ],
+            )
+            light_value = bg[0] * 0.3 + bg[1] * 0.6 + bg[2] * 0.1
+            if abs(light_value - based_light) < temp:  # noqa:E203
+                bg_color = bg
+                temp = abs(light_value - based_light)
+        return bg_color  # type:ignore
+
+    @staticmethod
+    def get_text_color(bg_color: Tuple[int, int, int]) -> Tuple[int, int, int]:
+        # 通过背景主色（bg_color）确定文字主色
+        r = 125
+        if max(*bg_color) > 255 - r:
+            r *= -1
+        return (
+            math.floor(bg_color[0] + r if bg_color[0] + r <= 255 else 255),
+            math.floor(bg_color[1] + r if bg_color[1] + r <= 255 else 255),
+            math.floor(bg_color[2] + r if bg_color[2] + r <= 255 else 255),
+        )
+
+    @staticmethod
+    def get_char_color(bg_color: Tuple[int, int, int]) -> Tuple[int, int, int]:
+        r = 140
+        if max(*bg_color) > 255 - r:
+            r *= -1
+        return (
+            math.floor(bg_color[0] + 5 if bg_color[0] + r <= 255 else 255),
+            math.floor(bg_color[1] + 5 if bg_color[1] + r <= 255 else 255),
+            math.floor(bg_color[2] + 5 if bg_color[2] + r <= 255 else 255),
+        )
+
+    @staticmethod
+    def get_char_high_color(
+        bg_color: Tuple[int, int, int],
+    ) -> Tuple[int, int, int]:
+        r = 140
+        d = 20
+        if max(*bg_color) > 255 - r:
+            r *= -1
+        return (
+            math.floor(bg_color[0] + d if bg_color[0] + r <= 255 else 255),
+            math.floor(bg_color[1] + d if bg_color[1] + r <= 255 else 255),
+            math.floor(bg_color[2] + d if bg_color[2] + r <= 255 else 255),
+        )
+
+    @staticmethod
+    def get_bg_detail_color(
+        bg_color: Tuple[int, int, int],
+    ) -> Tuple[int, int, int]:
+        r = 140
+        if max(*bg_color) > 255 - r:
+            r *= -1
+        return (
+            math.floor(bg_color[0] - 20 if bg_color[0] + r <= 255 else 255),
+            math.floor(bg_color[1] - 20 if bg_color[1] + r <= 255 else 255),
+            math.floor(bg_color[2] - 20 if bg_color[2] + r <= 255 else 255),
+        )
+
+    @staticmethod
+    def get_highlight_color(
+        color: Tuple[int, int, int],
+    ) -> Tuple[int, int, int]:
+        red_color = color[0]
+        green_color = color[1]
+        blue_color = color[2]
+
+        highlight_color = {
+            "red": red_color - 127 if red_color > 127 else 127,
+            "green": green_color - 127 if green_color > 127 else 127,
+            "blue": blue_color - 127 if blue_color > 127 else 127,
+        }
+
+        max_color = max(highlight_color.values())
+
+        name = ""
+        for _highlight_color in highlight_color:
+            if highlight_color[_highlight_color] == max_color:
+                name = str(_highlight_color)
+
+        if name == "red":
+            return red_color, highlight_color["green"], highlight_color["blue"]
+        if name == "green":
+            return highlight_color["red"], green_color, highlight_color["blue"]
+        if name == "blue":
+            return highlight_color["red"], highlight_color["green"], blue_color
+        return 0, 0, 0  # Error