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

nonebot_plugin_l4d2_server/l4_help/draw.py

@@ -0,0 +1,206 @@
+from copy import deepcopy
+from pathlib import Path
+from typing import Callable, Dict, List, Optional, Tuple
+
+from nonebot_plugin_datastore import get_plugin_data
+from PIL import Image, ImageDraw, ImageFilter, ImageFont
+
+from ..l4_image.convert import convert_img, pic_quality
+from ..l4_image.image_tools import crop_center_img
+from ..l4_image.model import PluginHelp
+
+cache: Dict[str, int] = {}
+Micon_path = Path(__file__).parent / "icon"
+DEFAULT_ICON = Micon_path / "拼图.png"
+plugin_data = get_plugin_data()
+
+
+def cx(w: int, x: int) -> int:
+    return int((w - x) / 2)
+
+
+def _get_icon(name: str, icon_path: Path) -> Optional[Image.Image]:
+    path = icon_path / f"{name}.png"
+    icon = None
+    if path.exists():
+        icon = Image.open(path)
+    else:
+        for i in icon_path.glob("*.png"):
+            if i.stem in name:
+                icon = Image.open(i)
+                break
+
+    return icon
+
+
+def get_icon(name: str, icon_path: Optional[Path]) -> Image.Image:
+    if icon_path is not None:
+        icon = _get_icon(name, icon_path)
+        if icon is None:
+            icon = _get_icon(name, Micon_path)
+    else:
+        icon = _get_icon(name, Micon_path)
+
+    if icon is None:
+        icon = Image.open(DEFAULT_ICON)
+
+    return icon.resize((36, 36))
+
+
+async def get_help(
+    name: str,
+    sub_text: str,
+    help_data: Dict[str, PluginHelp],
+    bg: Image.Image,
+    icon: Image.Image,
+    badge: Image.Image,
+    banner: Image.Image,
+    button: Image.Image,
+    font: Callable[[int], ImageFont.FreeTypeFont],
+    is_dark: bool = True,
+    text_color: Tuple[int, int, int] = (250, 250, 250),
+    sub_c: Optional[Tuple[int, int, int]] = None,
+    op_color: Optional[Tuple[int, int, int]] = None,
+    title_color: Tuple[int, int, int] = (250, 250, 250),
+    sub_title_color: Tuple[int, int, int] = (235, 235, 235),
+    sv_color: Tuple[int, int, int] = (250, 250, 250),
+    sv_desc_color: Tuple[int, int, int] = (235, 235, 235),
+    column: int = 5,
+    is_gaussian: bool = False,
+    gaussian_blur: int = 20,
+    is_icon: bool = True,
+    icon_path: Optional[Path] = None,
+    extra_message: Optional[List[str]] = None,
+    enable_cache: bool = True,
+) -> bytes:
+    if sub_c is None and is_dark:
+        sub_c = tuple(x - 50 if x > 50 else x for x in text_color)  # type: ignore
+    elif sub_c is None and not is_dark:
+        sub_c = tuple(x + 50 if x < 205 else x for x in text_color)  # type: ignore
+
+    if op_color is None and is_dark:
+        op_color = tuple(x - 90 if x > 90 else x for x in text_color)  # type: ignore
+    elif op_color is None and not is_dark:
+        op_color = tuple(x + 90 if x < 160 else x for x in text_color)  # type: ignore
+
+    _h = 600
+
+    if extra_message:
+        _h += 100
+
+    w, h = 50 + 260 * column, _h + 30
+    button_x = 260
+    button_y = 103  # 80
+
+    title = Image.new("RGBA", (w, _h))
+    icon = icon.resize((300, 300))
+
+    title.paste(icon, (cx(w, 300), 89), icon)
+    title.paste(badge, (cx(w, 900), 390), badge)
+    badge_s = badge.resize((720, 80))
+    title.paste(badge_s, (cx(w, 720), 480), badge_s)
+
+    title_draw = ImageDraw.Draw(title)
+
+    if extra_message:
+        all_lenth = 300 * (len(extra_message) - 1) + 720
+        first_x = (w - all_lenth) / 2
+        for _i, message in enumerate(extra_message):
+            _x = int(first_x + _i * 300)
+            title.paste(badge_s, (_x, 556), badge_s)
+            title_draw.text((_x + 360, 596), message, sub_c, font(26), "mm")
+
+    title_draw.text(
+        (cx(w, 0), 440),
+        f"{name} 帮助",
+        title_color,
+        font(36),
+        "mm",
+    )
+    title_draw.text((cx(w, 0), 520), sub_text, sub_title_color, font(26), "mm")
+
+    if is_dark:
+        icon_mask = Image.new("RGBA", (36, 36), (255, 255, 255))
+    else:
+        icon_mask = Image.new("RGBA", (36, 36), (10, 10, 10))
+
+    sv_img_list: List[Image.Image] = []
+    for sv_name in help_data:
+        tr_size = len(help_data[sv_name]["data"])
+        y = 100 + ((tr_size + column - 1) // column) * button_y
+        h += y
+
+        # 生成单个服务的背景， 依据默认column
+        sv_img = Image.new("RGBA", (w, y))
+        sv_data = help_data[sv_name]["data"]
+        sv_desc = help_data[sv_name]["desc"]
+
+        bc = deepcopy(banner)
+        bc_draw = ImageDraw.Draw(bc)
+        bc_draw.text((30, 25), sv_name, sv_color, font(35), "lm")
+
+        if hasattr(font, "getsize"):
+            size, _ = font(35).getsize(sv_name)  # type: ignore
+        else:
+            bbox = font(35).getbbox(sv_name)
+            size, _ = bbox[2] - bbox[0], bbox[3] - bbox[1]
+
+        bc_draw.text((42 + size, 30), sv_desc, sv_desc_color, font(20), "lm")
+        sv_img.paste(bc, (0, 10), bc)
+        # sv_img = easy_alpha_composite(sv_img, bc, (0, 10))
+
+        # 开始绘制各个按钮
+        for index, tr in enumerate(sv_data):
+            bt = deepcopy(button)
+            bt_draw = ImageDraw.Draw(bt)
+
+            # 限制长度
+            tr_name = tr["name"]
+
+            if is_icon:
+                f = 38
+                icon = get_icon(tr["name"], icon_path)
+                bt.paste(icon_mask, (14, 20), icon)
+            else:
+                f = 0
+
+            # 标题
+            bt_draw.text((20 + f, 28), tr_name, text_color, font(26), "lm")
+            # 使用范例
+            bt_draw.text((20 + f, 50), tr["eg"], sub_c, font(17), "lm")
+            # 简单介绍
+            bt_draw.text((20, 78), tr["desc"], op_color, font(16), "lm")
+
+            offset_x = button_x * (index % column)
+            offset_y = button_y * (index // column)
+            sv_img.paste(bt, (25 + offset_x, 83 + offset_y), bt)
+
+        sv_img_list.append(sv_img)
+
+    img = crop_center_img(bg, w, h)
+    if is_gaussian:
+        img = img.filter(ImageFilter.GaussianBlur(gaussian_blur))
+
+    img.paste(title, (0, 0), title)
+    temp = 0
+    for _sm in sv_img_list:
+        img.paste(_sm, (0, _h + temp), _sm)
+        temp += _sm.size[1]
+
+    img = img.convert("RGBA")
+    all_white = Image.new("RGBA", img.size, (255, 255, 255))
+    img = Image.alpha_composite(all_white, img)
+
+    img = img.convert("RGB")
+    help_path = plugin_data.data_dir.joinpath("help") / f"{name}.jpg"
+    help_path.parent.mkdir(parents=True, exist_ok=True)
+    if enable_cache:
+        img.save(
+            help_path,
+            "JPEG",
+            quality=pic_quality,
+            subsampling=0,
+        )
+        cache[name] = 1
+
+    return await convert_img(img)

nonebot_plugin_l4d2_server/l4_image/__init__.py

@@ -0,0 +1,16 @@
+from typing import List  # noqa:
+
+from ..utils.api.models import OutServer
+from .html_img import server_ip_pic
+
+
+async def msg_to_image(server_dict: List[OutServer], mode_: str = "html"):
+    """信息构造图片"""
+    if mode_ == "html":
+        """用浏览器作图"""
+        return await server_ip_pic(server_dict)
+    if mode_ == "pil":
+        """用pil作图"""
+        return None
+    """返回文字"""
+    return None

nonebot_plugin_l4d2_server/l4_image/anne_pil.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+
+from nonebot_plugin_l4d2_server.utils.api.models import AnnePlayer2
+from PIL import Image, ImageFont
+
+from ..config import config
+
+font = ImageFont.truetype(config.l4_font)
+
+anne_path = Path(__file__).parent / "img" / "anne"
+
+
+async def anne_player_info(msg: AnnePlayer2):
+    back_img = Image.open(anne_path / "back1.jpg")
+    base_img = Image.new("RGBA", (back_img.size), (255, 255, 255, 50))
+    back_img.paste(base_img, (0, 0), base_img)
+    return msg

nonebot_plugin_l4d2_server/l4_image/convert.py

@@ -0,0 +1,175 @@
+from base64 import b64encode
+from io import BytesIO
+from pathlib import Path
+from typing import Union, overload
+
+import aiofiles
+from nonebot.log import logger
+from PIL import Image, ImageDraw, ImageFont
+
+from .image_tools import draw_center_text_by_line
+
+FONT_PATH = Path(__file__).parent.parent / "data/font/loli.ttf"
+pic_quality: int = 95
+
+
+def core_font(size: int) -> ImageFont.FreeTypeFont:
+    return ImageFont.truetype(str(FONT_PATH), size=size)
+
+
+@overload
+async def convert_img(
+    img: Image.Image,
+    is_base64: bool = False,
+) -> bytes:
+    ...
+
+
+@overload
+async def convert_img(
+    img: Image.Image,
+    is_base64: bool = True,
+) -> str:
+    ...
+
+
+@overload
+async def convert_img(
+    img: bytes,
+    is_base64: bool = False,
+) -> str:
+    ...
+
+
+@overload
+async def convert_img(
+    img: Path,
+    is_base64: bool = False,
+) -> str:
+    ...
+
+
+async def convert_img(
+    img: Union[Image.Image, str, Path, bytes],
+    is_base64: bool = False,
+):
+    """
+    :说明:
+      将PIL.Image对象转换为bytes或者base64格式。
+    :参数:
+      * img (Image): 图片。
+      * is_base64 (bool): 是否转换为base64格式, 不填默认转为bytes。
+    :返回:
+      * res: bytes对象或base64编码图片。
+    """
+    logger.info("处理图片中....")
+
+    if isinstance(img, Image.Image):
+        img = img.convert("RGB")
+        result_buffer = BytesIO()
+        img.save(result_buffer, format="JPEG", quality=95)
+        res = result_buffer.getvalue()
+        if is_base64:
+            res = "base64://" + b64encode(res).decode()
+        return res
+    if isinstance(img, bytes):
+        pass
+    else:
+        async with aiofiles.open(img, "rb") as fp:
+            img = await fp.read()
+
+    logger.success("图片处理完成！")
+
+    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:
+    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]
+
+    img = Image.new(
+        "RGB",
+        (max_size, len(text) * font_size // 3),
+        (255, 255, 255),
+    )
+    img_draw = ImageDraw.ImageDraw(img)
+    y = draw_center_text_by_line(
+        img_draw,
+        (50, 50),
+        text,
+        core_font(font_size),
+        "black",
+        max_size - 80,
+        True,  # noqa: FBT003
+    )
+    img = img.crop((0, 0, max_size, int(y + 80)))
+    return await convert_img(img)

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:
@@ -32,7 +33,7 @@ async def download_url(url: str) -> bytes:
 async def download_head(user_id: str) -> bytes:
     url = f"http://q1.qlogo.cn/g?b=qq&nk={user_id}&s=640"
     data = await download_url(url)
-    if hashlib.md5(data).hexdigest() == "acef72340ac0e914090bd35799f5594e":
+    if hashlib.md5(data).hexdigest() == "acef72340ac0e914090bd35799f5594e":  # noqa: S324
         url = f"http://q1.qlogo.cn/g?b=qq&nk={user_id}&s=100"
         data = await download_url(url)
     return data
@@ -49,18 +50,18 @@ def square_to_circle(im: ImageS):
     return im
 
 
-async def get_head_by_user_id_and_save(user_id):
+async def get_head_by_user_id_and_save(user_id: str):
     """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(
         os.listdir(default_header_path),
     )
     default_head = default_head_path / random.choice(os.listdir(default_head_path))
-    ## im头像 im2头像框 im3合成
+    # im头像 im2头像框 im3合成
     if user_head_path.exists():
         logger.info("使用本地头像")
         im = Image.open(user_head_path).resize((280, 280)).convert("RGBA")
@@ -77,42 +78,17 @@ 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("获取失败")
                 return None
     im2 = Image.open(default_head).resize((450, 450)).convert("RGBA")
     im3 = Image.new("RGBA", im2.size, (255, 255, 255, 0))
-    r, g, b, a1 = im.split()
-    r, g, b, a2 = im2.split()
+    _, _, _, a1 = im.split()
+    _, _, _, a2 = im2.split()
     im = square_to_circle(im)
     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