nonebot-plugin-osubot 6.22.1__py3-none-any.whl → 6.26.4__py3-none-any.whl

nonebot_plugin_osubot/draw/score.py

@@ -3,7 +3,7 @@ from io import BytesIO
 from typing import Optional
 from datetime import datetime, timedelta
 
-from PIL import ImageDraw, ImageFilter, ImageEnhance, ImageSequence, UnidentifiedImageError
+from PIL import ImageDraw, ImageFilter, ImageEnhance
 
 from ..info import get_bg
 from ..mods import get_mods_list
@@ -14,7 +14,7 @@ from ..beatmap_stats_moder import with_mods
 from ..pp import cal_pp, get_ss_pp, get_if_pp_ss_pp
 from ..schema.score import Mod, UnifiedScore, NewStatistics
 from ..api import osu_api, get_user_scores, get_user_info_data, get_ppysb_map_scores
-from ..file import map_path, download_osu, get_projectimg, team_cache_path, user_cache_path
+from ..file import map_path, download_osu, user_cache_path
 from .utils import (
     crop_bg,
     draw_acc,
@@ -29,6 +29,9 @@ from .utils import (
     filter_scores_with_regex,
     trim_text_with_ellipsis,
     draw_text_with_outline,
+    handle_team_image,
+    process_user_avatar_with_gif,
+    get_map_difficulty_arrays,
 )
 from .static import (
     Image,
@@ -79,8 +82,6 @@ async def draw_score(
             scores = await get_user_scores(uid, mode, "recent", source=source, legacy_only=not is_lazer, limit=best)
     if not scores:
         raise NetworkError("未查询到游玩记录")
-    if not is_lazer:
-        scores = [i for i in scores if Mod(acronym="CL") in i.mods]
     if project in ("recent", "pr"):
         if len(scores) < best:
             raise NetworkError("未查询到游玩记录")
@@ -96,20 +97,18 @@ async def draw_score(
         raise Exception("Project Error")
     # 从官网获取信息
     path = map_path / str(score.beatmap.set_id)
-    if not path.exists():
-        path.mkdir(parents=True, exist_ok=True)
+    path.mkdir(parents=True, exist_ok=True)
     osu = path / f"{score.beatmap.id}.osu"
     task2 = asyncio.create_task(osu_api("map", map_id=score.beatmap.id))
     if not osu.exists():
         await download_osu(score.beatmap.set_id, score.beatmap.id)
     info = await task1
     user_path = user_cache_path / str(info.id)
-    if not user_path.exists():
-        user_path.mkdir(parents=True, exist_ok=True)
+    user_path.mkdir(parents=True, exist_ok=True)
     map_json = await task2
     # 判断是否开启lazer模式
     if source == "osu":
-        score = cal_score_info(is_lazer, score)
+        score = cal_score_info(is_lazer, score, source)
     return await draw_score_pic(score, info, map_json, "", is_lazer, source)
 
 
@@ -149,10 +148,6 @@ async def get_score_data(
         ]
     else:
         score_ls = await get_ppysb_map_scores(map_json["checksum"], uid, mode)
-    if not is_lazer:
-        score_ls = [i for i in score_ls if Mod(acronym="CL") in i.mods]
-        for i in score_ls:
-            i.mods.remove(Mod(acronym="CL"))
     if not score_ls:
         raise NetworkError("未查询到游玩记录")
     if mods:
@@ -175,18 +170,16 @@ async def get_score_data(
         score_ls.sort(key=lambda x: x.total_score, reverse=True)
         score = score_ls[0]
     path = map_path / str(map_json["beatmapset_id"])
-    if not path.exists():
-        path.mkdir(parents=True, exist_ok=True)
+    path.mkdir(parents=True, exist_ok=True)
     osu = path / f"{mapid}.osu"
     if not osu.exists():
         await download_osu(map_json["beatmapset_id"], mapid)
     info = await task
     user_path = user_cache_path / str(info.id)
-    if not user_path.exists():
-        user_path.mkdir(parents=True, exist_ok=True)
+    user_path.mkdir(parents=True, exist_ok=True)
     # 判断是否开启lazer模式
     if source == "osu":
-        score = cal_score_info(is_lazer, score)
+        score = cal_score_info(is_lazer, score, source)
     return await draw_score_pic(score, info, map_json, grank, is_lazer, source)
 
 
@@ -195,8 +188,7 @@ async def draw_score_pic(score_info: UnifiedScore, info: UnifiedUser, map_json,
     original_mapinfo = mapinfo.copy()
     mapinfo = with_mods(mapinfo, score_info, score_info.mods)
     path = map_path / str(mapinfo.beatmapset_id)
-    if not path.exists():
-        path.mkdir(parents=True, exist_ok=True)
+    path.mkdir(parents=True, exist_ok=True)
     # pp
     osu = path / f"{mapinfo.id}.osu"
     pp_info = cal_pp(score_info, str(osu.absolute()), is_lazer)
@@ -265,8 +257,9 @@ async def draw_score_pic(score_info: UnifiedScore, info: UnifiedUser, map_json,
         for mods_num, s_mods in enumerate(score_info.mods):
             mods_bg = osufile / "mods" / f"{s_mods.acronym}.png"
             try:
-                mods_img = Image.open(mods_bg).convert("RGBA")
-                im.alpha_composite(mods_img, (880 + 50 * mods_num, 100))
+                with Image.open(mods_bg) as mods_img:
+                    mods_img = mods_img.convert("RGBA")
+                    im.alpha_composite(mods_img, (880 + 50 * mods_num, 100))
             except FileNotFoundError:
                 pass
     # 成绩S-F
@@ -289,21 +282,10 @@ async def draw_score_pic(score_info: UnifiedScore, info: UnifiedUser, map_json,
     im = draw_acc(im, score_info.accuracy, score_info.ruleset_id)
     # 地区
     country = osufile / "flags" / f"{info.country_code}.png"
-    country_bg = Image.open(country).convert("RGBA").resize((66, 45))
-    im.alpha_composite(country_bg, (208, 597))
-    if info.team and info.team.flag_url:
-        team_path = team_cache_path / f"{info.team.id}.png"
-        if not team_path.exists():
-            team_img = await get_projectimg(info.team.flag_url)
-            team_img = Image.open(team_img).convert("RGBA")
-            team_img.save(team_path)
-        try:
-            team_img = Image.open(team_path).convert("RGBA").resize((80, 40))
-            im.alpha_composite(team_img, (208, 660))
-        except UnidentifiedImageError:
-            team_path.unlink()
-            raise NetworkError("team 图片下载错误，请重试！")
-        draw.text((297, 675), info.team.name, font=Torus_Regular_20, anchor="lt")
+    with Image.open(country) as country_img:
+        country_bg = country_img.convert("RGBA").resize((66, 45))
+        im.alpha_composite(country_bg, (208, 597))
+    await handle_team_image(im, draw, info, (208, 660), (80, 40), (297, 675), Torus_Regular_20)
     # supporter
     # if info.is_supporter:
     #     im.alpha_composite(SupporterBg.resize((40, 40)), (250, 640))
@@ -326,13 +308,7 @@ async def draw_score_pic(score_info: UnifiedScore, info: UnifiedUser, map_json,
             temp_accuracy += 1
             mapinfo.cs = max(4.0, min(temp_accuracy, 7.0))
     # cs, ar, od, hp
-    mapdiff = [mapinfo.cs, mapinfo.drain, mapinfo.accuracy, mapinfo.ar]
-    original_mapdiff = [
-        original_mapinfo.cs,
-        original_mapinfo.drain,
-        original_mapinfo.accuracy,
-        original_mapinfo.ar,
-    ]
+    mapdiff, original_mapdiff = get_map_difficulty_arrays(mapinfo, original_mapinfo)
 
     for num, (orig, new) in enumerate(zip(original_mapdiff, mapdiff)):
         orig_difflen = int(400 * max(0, orig) / 10) if orig <= 10 else 400
@@ -667,39 +643,7 @@ async def draw_score_pic(score_info: UnifiedScore, info: UnifiedUser, map_json,
     user_icon = await open_user_icon(info, source)
     _ = asyncio.create_task(update_map(mapinfo.beatmapset_id, mapinfo.id))
     _ = asyncio.create_task(update_icon(info))
-    gif_frames = []
-    if not getattr(user_icon, "is_animated", False):
-        icon_bg = user_icon.convert("RGBA").resize((170, 170))
-        icon_img = draw_fillet(icon_bg, 15)
-        im.alpha_composite(icon_img, (27, 532))
-        byt = BytesIO()
-        im.convert("RGB").save(byt, "jpeg")
-        im.close()
-        user_icon.close()
-        return byt
-    for gif_frame in ImageSequence.Iterator(user_icon):
-        # 将 GIF 图片中的每一帧转换为 RGBA 模式
-        gif_frame = gif_frame.convert("RGBA").resize((170, 170))
-        gif_frame = draw_fillet(gif_frame, 15)
-        # 创建一个新的 RGBA 图片，将 PNG 图片作为背景，将当前帧添加到背景上
-        rgba_frame = Image.new("RGBA", im.size, (0, 0, 0, 0))
-        rgba_frame.paste(im, (0, 0), im)
-        rgba_frame.paste(gif_frame, (27, 532), gif_frame)
-        # 将 RGBA 图片转换为 RGB 模式，并添加到 GIF 图片中
-        gif_frames.append(rgba_frame)
-    gif_bytes = BytesIO()
-    # 保存 GIF 图片
-    gif_frames[0].save(
-        gif_bytes,
-        format="gif",
-        save_all=True,
-        append_images=gif_frames[1:],
-        duration=user_icon.info["duration"],
-    )
-    # 输出
-    gif_frames[0].close()
-    user_icon.close()
-    return gif_bytes
+    return await process_user_avatar_with_gif(im, user_icon, (27, 532), (170, 170), 15)
 
 
 def cal_legacy_acc(statistics: NewStatistics) -> float:
@@ -801,12 +745,10 @@ def cal_legacy_rank(score_info: UnifiedScore, is_hidden: bool):
         return "N/A"
 
 
-def cal_score_info(is_lazer: bool, score_info: UnifiedScore) -> UnifiedScore:
+def cal_score_info(is_lazer: bool, score_info: UnifiedScore, source: str = "osu") -> UnifiedScore:
     if is_lazer:
         score_info.legacy_total_score = score_info.total_score
-    if not is_lazer and Mod(acronym="CL") in score_info.mods:
-        score_info.mods = [i for i in score_info.mods if i.acronym != "CL"]
-    if score_info.ruleset_id == 3 and not is_lazer:
+    if score_info.ruleset_id == 3 and not is_lazer and source != "ppysb":
         score_info.accuracy = cal_legacy_acc(score_info.statistics)
     if not is_lazer:
         is_hidden = any(i in score_info.mods for i in (Mod(acronym="HD"), Mod(acronym="FL"), Mod(acronym="FI")))

nonebot_plugin_osubot/draw/taiko_preview.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 from PIL import Image, ImageDraw
 
-from .static import Torus_Regular_8, Torus_Regular_15, Torus_Regular_20, Torus_Regular_25, Torus_Regular_30
+from .static import Torus_Regular_8, Torus_Regular_15
 
 HIT_DON = 0x00
 HIT_KAT = 0x01
@@ -35,20 +35,21 @@ def map_to_image(map_data) -> BytesIO:
     img = Image.new(mode="RGB", size=(3000, 30000), color=0x121212)
     draw = ImageDraw.Draw(img)
 
-    title_font = Torus_Regular_30
-    semi_font = Torus_Regular_25
-    reg_font = Torus_Regular_20
+    # title_font = Torus_Regular_30
+    # semi_font = Torus_Regular_25
+    # reg_font = Torus_Regular_20
     small_font = Torus_Regular_15
     tiny_font = Torus_Regular_8
 
-    draw.text(
-        (LEFT_MARGIN, 40),
-        map_data.artist + " - " + map_data.title + " [" + map_data.diff + "]",
-        font=title_font,
-        fill="#FFF",
-    )
-    draw.text((LEFT_MARGIN, 90), "by " + map_data.creator, font=semi_font, fill="#CCC")
-    draw.text((LEFT_MARGIN, 135), "HP = " + str(map_data.hp) + " OD = " + str(map_data.od), font=reg_font, fill="#AAA")
+    # draw.text(
+    #     (LEFT_MARGIN, 40),
+    #     map_data.artist + " - " + map_data.title + " [" + map_data.diff + "]",
+    #     font=title_font,
+    #     fill="#FFF",
+    # )
+    # draw.text((LEFT_MARGIN, 90), "by " + map_data.creator, font=semi_font, fill="#CCC")
+    # draw.text((LEFT_MARGIN, 135), "HP = " + str(map_data.hp) +
+    # " OD = " + str(map_data.od), font=reg_font, fill="#AAA")
 
     max_meter = 0
     timing_sections = []  # (start, beat_ms, meter, [list of hit_object])
@@ -67,7 +68,7 @@ def map_to_image(map_data) -> BytesIO:
             (map_data.timing_points[i][0], map_data.timing_points[i][1], map_data.timing_points[i][2], current_list)
         )
 
-    y_start = 200
+    y_start = 40
     max_x = 0
     max_y = 0
     bar_number = 1

nonebot_plugin_osubot/draw/templates/bpa_chart.html

@@ -43,7 +43,7 @@
           xAxis: [
             {
               type: 'category',
-              data: Array.from({ length: 200 }, (_, i) => i),
+              data: Array.from({ length: {{length}} }, (_, i) => i),
               axisLabel: {
                   interval: 9
               }

nonebot_plugin_osubot/draw/utils.py

@@ -8,7 +8,7 @@ from difflib import SequenceMatcher
 
 from PIL.ImageFile import ImageFile
 from matplotlib.figure import Figure
-from PIL import ImageDraw, ImageFilter, ImageEnhance, UnidentifiedImageError
+from PIL import ImageDraw, ImageFilter, ImageEnhance, UnidentifiedImageError, ImageSequence
 
 from ..schema.user import UnifiedUser
 from ..schema import SeasonalBackgrounds
@@ -130,14 +130,10 @@ async def crop_bg(size: tuple[int, int], path: Union[str, Path, BytesIO, Image.I
     if not isinstance(path, Image.Image):
         try:
             bg = Image.open(path).convert("RGBA")
-        except UnidentifiedImageError:
-            os.remove(path)
-            data = await get_seasonal_bg()
-            pic = SeasonalBackgrounds(**data)
-            url = random.choice(pic.backgrounds).url
-            res = await safe_async_get(url)
-            bg = Image.open(BytesIO(res.content)).convert("RGBA")
-        except FileNotFoundError:
+        except (UnidentifiedImageError, FileNotFoundError):
+            # Refactored: combine duplicate exception handling
+            if isinstance(path, (str, Path)) and Path(path).exists():
+                os.remove(path)
             data = await get_seasonal_bg()
             pic = SeasonalBackgrounds(**data)
             url = random.choice(pic.backgrounds).url
@@ -145,8 +141,8 @@ async def crop_bg(size: tuple[int, int], path: Union[str, Path, BytesIO, Image.I
             bg = Image.open(BytesIO(res.content)).convert("RGBA")
     else:
         bg = path
-    bg_w, bg_h = bg.size[0], bg.size[1]
-    fix_w, fix_h = size[0], size[1]
+    bg_w, bg_h = bg.size
+    fix_w, fix_h = size
     # 固定比例
     fix_scale = fix_h / fix_w
     # 图片比例
@@ -229,8 +225,7 @@ def calc_songlen(length: int) -> str:
 
 async def open_user_icon(info: UnifiedUser, source) -> Image:
     path = user_cache_path / str(info.id)
-    if not path.exists():
-        path.mkdir(parents=True, exist_ok=True)
+    path.mkdir(parents=True, exist_ok=True)
     for file_path in path.glob("icon*.*"):
         # 检查文件是否为图片格式
         if file_path.suffix.lower() in [".jpg", ".png", ".jpeg", ".gif", ".bmp"]:
@@ -249,9 +244,7 @@ async def open_user_icon(info: UnifiedUser, source) -> Image:
 
 
 def is_close(n1, n2) -> bool:
-    if abs(n1 - n2) < 0.01:
-        return True
-    return False
+    return abs(n1 - n2) < 0.01
 
 
 async def update_icon(info: UnifiedUser):
@@ -454,3 +447,156 @@ def draw_text_with_outline(draw, position, text, font, anchor, fill):
                     fill=(0, 0, 0, 255),
                 )
     draw.text(position, text, font=font, anchor=anchor, fill=fill)
+
+
+async def process_user_avatar_with_gif(
+    base_image: Image.Image,
+    user_icon: Image.Image,
+    position: tuple[int, int],
+    size: tuple[int, int],
+    corner_radius: int,
+) -> BytesIO:
+    """
+    Process user avatar (static or animated) and composite it onto the base image.
+
+    Args:
+        base_image: The base image to composite the avatar onto
+        user_icon: The user avatar image (can be animated GIF or static)
+        position: (x, y) position to place the avatar on the base image
+        size: (width, height) to resize the avatar to
+        corner_radius: Radius for rounded corners
+
+    Returns:
+        BytesIO containing the final image (JPEG for static, GIF for animated)
+    """
+    if not getattr(user_icon, "is_animated", False):
+        icon_bg = user_icon.convert("RGBA").resize(size)
+        icon_img = draw_fillet(icon_bg, corner_radius)
+        base_image.alpha_composite(icon_img, position)
+        byt = BytesIO()
+        base_image.convert("RGB").save(byt, "jpeg")
+        base_image.close()
+        user_icon.close()
+        return byt
+
+    gif_frames = []
+    for gif_frame in ImageSequence.Iterator(user_icon):
+        # 将 GIF 图片中的每一帧转换为 RGBA 模式
+        gif_frame = gif_frame.convert("RGBA").resize(size)
+        gif_frame = draw_fillet(gif_frame, corner_radius)
+        # 创建一个新的 RGBA 图片，将 PNG 图片作为背景，将当前帧添加到背景上
+        rgba_frame = Image.new("RGBA", base_image.size, (0, 0, 0, 0))
+        rgba_frame.paste(base_image, (0, 0), base_image)
+        rgba_frame.paste(gif_frame, position, gif_frame)
+        # 将 RGBA 图片转换为 RGB 模式，并添加到 GIF 图片中
+        gif_frames.append(rgba_frame)
+    gif_bytes = BytesIO()
+    # 保存 GIF 图片
+    gif_frames[0].save(
+        gif_bytes,
+        format="gif",
+        save_all=True,
+        append_images=gif_frames[1:],
+        duration=user_icon.info["duration"],
+    )
+    # 输出
+    gif_frames[0].close()
+    user_icon.close()
+    return gif_bytes
+
+
+async def handle_team_image(
+    base_image: Image.Image,
+    draw_context: Optional[ImageDraw.Draw],
+    info,
+    position: tuple[int, int],
+    size: tuple[int, int],
+    text_position: Optional[tuple[int, int]] = None,
+    text_font: Optional[object] = None,
+) -> None:
+    """
+    Download and composite team flag image onto the base image, optionally drawing team name.
+
+    Args:
+        base_image: The base image to composite the team flag onto
+        draw_context: PIL ImageDraw context for drawing text (None if no text needed)
+        info: User info object containing team information
+        position: (x, y) position to place the team flag on the base image
+        size: (width, height) to resize the team flag to
+        text_position: Optional (x, y) position to draw team name text
+        text_font: Optional font for team name text
+
+    Raises:
+        NetworkError: If team image download fails
+    """
+    from ..exceptions import NetworkError
+
+    if info.team and info.team.flag_url:
+        team_path = team_cache_path / f"{info.team.id}.png"
+        if not team_path.exists():
+            team_img = await get_projectimg(info.team.flag_url)
+            with Image.open(team_img) as team_image:
+                team_image = team_image.convert("RGBA")
+                team_image.save(team_path)
+        try:
+            with Image.open(team_path) as team_img:
+                team_img = team_img.convert("RGBA").resize(size)
+                base_image.alpha_composite(team_img, position)
+        except UnidentifiedImageError:
+            team_path.unlink()
+            raise NetworkError("team 图片下载错误，请重试！")
+
+        # Draw team name if text parameters are provided
+        if draw_context and text_position and text_font and info.team.name:
+            draw_context.text(text_position, info.team.name, font=text_font, anchor="lt")
+
+
+async def load_osu_file_and_setup_template(template_path: str, beatmap_id: int, beatmapset_id: int):
+    """
+    Load OSU file and setup Jinja2 template environment.
+
+    Args:
+        template_path: Path to template directory
+        beatmap_id: Beatmap ID
+        beatmapset_id: Beatmapset ID
+
+    Returns:
+        Tuple of (osu_file_content, template_object)
+    """
+    import jinja2
+
+    path = map_path / str(beatmapset_id)
+    path.mkdir(parents=True, exist_ok=True)
+    osu = path / f"{beatmap_id}.osu"
+    if not osu.exists():
+        await download_osu(beatmapset_id, beatmap_id)
+    with open(osu, encoding="utf-8-sig") as f:
+        osu_file = f.read()
+    template_name = "pic.html"
+    template_env = jinja2.Environment(  # noqa: S701
+        loader=jinja2.FileSystemLoader(template_path),
+        enable_async=True,
+    )
+    template = template_env.get_template(template_name)
+    return osu_file, template
+
+
+def get_map_difficulty_arrays(mapinfo, original_mapinfo):
+    """
+    Extract map difficulty arrays for comparison.
+
+    Args:
+        mapinfo: Current map info with difficulty stats
+        original_mapinfo: Original map info with difficulty stats
+
+    Returns:
+        Tuple of (mapdiff, original_mapdiff) arrays with [cs, drain, accuracy, ar]
+    """
+    mapdiff = [mapinfo.cs, mapinfo.drain, mapinfo.accuracy, mapinfo.ar]
+    original_mapdiff = [
+        original_mapinfo.cs,
+        original_mapinfo.drain,
+        original_mapinfo.accuracy,
+        original_mapinfo.ar,
+    ]
+    return mapdiff, original_mapdiff