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

nonebot_plugin_osubot/api.py

@@ -11,19 +11,19 @@ from nonebot import get_plugin_config
 from httpx import Response
 
 from .network.manager import network_manager
+from .schema.beatmapsets import BeatmapSets
 from .utils import FGM
 from .config import Config
 from .mods import get_mods
 from .network import auto_retry
 from .exceptions import NetworkError
 from .network.first_response import get_first_response
-from .schema import User, NewScore, SayoBeatmap, RecommendData
+from .schema import User, NewScore, RecommendData
 from .schema.score import UnifiedScore, NewStatistics, UnifiedBeatmap
 from .schema.ppysb import InfoResponse, ScoresResponse, V2ScoresResponse
 from .schema.user import Level, GradeCounts, UnifiedUser, UserStatistics
 
 api = "https://osu.ppy.sh/api/v2"
-sayoapi = "https://api.sayobot.cn"
 cache = ExpiringDict(max_len=1, max_age_seconds=86400)
 plugin_config = get_plugin_config(Config)
 
@@ -122,6 +122,7 @@ async def fetch_score_batch(
                 hp=i.beatmap.drain,
                 od=i.beatmap.accuracy,
                 stars=i.beatmap.difficulty_rating,
+                convert=i.beatmap.convert,
             ),
             beatmapset=i.beatmapset,
         )
@@ -189,6 +190,7 @@ async def get_user_scores(
                 ended_at=datetime.strptime(i.play_time, "%Y-%m-%dT%H:%M:%S") + timedelta(hours=8),
                 max_combo=i.max_combo,
                 passed=True,
+                pp=i.pp,
                 statistics=NewStatistics(
                     miss=i.nmiss,
                     perfect=i.ngeki,
@@ -412,12 +414,13 @@ async def get_random_bg() -> Optional[bytes]:
     return res.content
 
 
-async def get_sayo_map_info(sid, t=0) -> SayoBeatmap:
-    res = await safe_async_get(f"https://api.sayobot.cn/v2/beatmapinfo?K={sid}&T={t}")
-    return SayoBeatmap(**res.json())
+async def get_beatmapsets_info(sid) -> BeatmapSets:
+    url = f"https://osu.ppy.sh/api/v2/beatmapsets/{sid}"
+    res = await make_request(url, await get_headers(), "未查询到该谱面集(Setid)信息")
+    return BeatmapSets(**res)
 
 
-async def get_map_bg(mapid, sid, bg_name) -> BytesIO:
+async def get_map_bg(mapid, sid, bg_name) -> BytesIO | None:
     res = await get_first_response(
         [
             f"https://catboy.best/preview/background/{mapid}",
@@ -425,7 +428,9 @@ async def get_map_bg(mapid, sid, bg_name) -> BytesIO:
             f"https://dl.sayobot.cn/beatmaps/files/{sid}/{bg_name}",
         ]
     )
-    return BytesIO(res)
+    if res:
+        return BytesIO(res.content)
+    return None
 
 
 async def get_seasonal_bg() -> Optional[dict]:

nonebot_plugin_osubot/config.py

@@ -1,10 +1,10 @@
-from typing import Union, Optional
-
-from pydantic import BaseModel
-
-
-class Config(BaseModel):
-    osu_client: Optional[int] = None
-    osu_key: Optional[str] = None
-    info_bg: Optional[list[str]] = ["https://t.alcy.cc/mp", "https://t.alcy.cc/moemp"]
-    osu_proxy: Optional[Union[str, dict]] = None
+from typing import Union, Optional
+
+from pydantic import BaseModel
+
+
+class Config(BaseModel):
+    osu_client: Optional[int] = None
+    osu_key: Optional[str] = None
+    info_bg: Optional[list[str]] = ["https://t.alcy.cc/mp", "https://t.alcy.cc/moemp"]
+    osu_proxy: Optional[Union[str, dict]] = None

nonebot_plugin_osubot/draw/bmap.py

@@ -4,25 +4,20 @@ from datetime import datetime, timedelta
 from PIL import ImageDraw, ImageFilter, ImageEnhance
 
 from ..file import get_projectimg
-from ..api import get_sayo_map_info
-from ..exceptions import NetworkError
+from ..api import get_beatmapsets_info
 from .utils import crop_bg, stars_diff, calc_songlen
-from .static import Image, BarImg, IconLs, Torus_SemiBold_20, Torus_SemiBold_40, Torus_SemiBold_50, extra_30
+from .static import Image, BarImg, IconLs, Torus_SemiBold_20, Torus_SemiBold_40, Torus_SemiBold_50, extra_30, Stars
 
 
 async def draw_bmap_info(mapid) -> BytesIO:
-    sayo_info = await get_sayo_map_info(mapid)
-    if sayo_info.status == -1:
-        raise NetworkError("在sayobot未查询到该地图")
-    data = sayo_info.data
-
+    data = await get_beatmapsets_info(mapid)
     coverurl = f"https://assets.ppy.sh/beatmaps/{mapid}/covers/cover@2x.jpg"
     cover = await get_projectimg(coverurl)
     # 新建
-    if len(data.bid_data) > 20:
+    if len(data.beatmaps) > 20:
         im_h = 400 + 102 * 20
     else:
-        im_h = 400 + 102 * (len(data.bid_data) - 1)
+        im_h = 400 + 102 * (len(data.beatmaps) - 1)
     im = Image.new("RGBA", (1200, im_h), (31, 41, 46, 255))
     draw = ImageDraw.Draw(im)
     # 背景
@@ -37,35 +32,36 @@ async def draw_bmap_info(mapid) -> BytesIO:
     # mapper
     draw.text((25, 105), f"谱面作者: {data.creator}", font=Torus_SemiBold_20, anchor="lt")
     # rank时间
-    if data.approved_date == -1:
+    if not data.ranked_date:
         approved_date = "谱面状态可能非ranked"
     else:
-        datearray = datetime.utcfromtimestamp(data.approved_date)
+        datearray = datetime.fromisoformat(data.ranked_date.replace("Z", ""))
         approved_date = (datearray + timedelta(hours=8)).strftime("%Y-%m-%d %H:%M:%S")
     draw.text((25, 140), f"上架时间: {approved_date}", font=Torus_SemiBold_20, anchor="lt")
     # 来源
-    draw.text((25, 175), f"Source: {data.source}", font=Torus_SemiBold_20, anchor="lt")
+    if data.source:
+        draw.text((25, 175), f"Source: {data.source}", font=Torus_SemiBold_20, anchor="lt")
     # bpm
     draw.text((1150, 105), f"BPM: {data.bpm}", font=Torus_SemiBold_20, anchor="rt")
     # 曲长
-    music_len = calc_songlen(data.bid_data[0].length)
+    music_len = calc_songlen(data.beatmaps[0].total_length)
     draw.text((1150, 140), f"length: {music_len}", font=Torus_SemiBold_20, anchor="rt")
     # Setid
     draw.text((1150, 35), f"Setid: {mapid}", font=Torus_SemiBold_20, anchor="rt")
-    gmap = sorted(data.bid_data, key=lambda k: k.star, reverse=False)
+    gmap = sorted(data.beatmaps, key=lambda k: k.difficulty_rating, reverse=False)
     for num, cmap in enumerate(gmap):
         if num < 20:
             h_num = 102 * num
             # 难度
-            draw.text((20, 320 + h_num), IconLs[cmap.mode], font=extra_30, anchor="lt")
+            draw.text((20, 320 + h_num), IconLs[cmap.mode_int], font=extra_30, anchor="lt")
             # 星星
-            stars_bg = stars_diff(cmap.star)
+            stars_bg = stars_diff(cmap.difficulty_rating, Stars)
             stars_img = stars_bg.resize((80, 30))
             im.alpha_composite(stars_img, (60, 320 + h_num))
             # diff
             im.alpha_composite(BarImg, (10, 365 + h_num))
             gc = ["CS", "HP", "OD", "AR"]
-            for index, i in enumerate((cmap.CS, cmap.HP, cmap.OD, cmap.AR)):
+            for index, i in enumerate((cmap.cs, cmap.drain, cmap.accuracy, cmap.ar)):
                 diff_len = int(200 * i / 10) if i <= 10 else 200
                 diff_bg = Image.new("RGBA", (diff_len, 12), (255, 255, 255, 255))
                 im.alpha_composite(diff_bg, (50 + 300 * index, 365 + h_num))
@@ -90,11 +86,13 @@ async def draw_bmap_info(mapid) -> BytesIO:
                         anchor="lm",
                     )
             # 难度
-            if cmap.star < 6.5:
+            if cmap.difficulty_rating < 6.5:
                 color = (0, 0, 0, 255)
             else:
                 color = (255, 217, 102, 255)
-            draw.text((65, 335 + h_num), f"★{cmap.star:.2f}", font=Torus_SemiBold_20, anchor="lm", fill=color)
+            draw.text(
+                (65, 335 + h_num), f"★{cmap.difficulty_rating:.2f}", font=Torus_SemiBold_20, anchor="lm", fill=color
+            )
             # version
             draw.text(
                 (150, 335 + h_num),
@@ -105,14 +103,14 @@ async def draw_bmap_info(mapid) -> BytesIO:
             # mapid
             draw.text(
                 (1150, 328 + h_num),
-                f"Mapid: {cmap.bid}",
+                f"Mapid: {cmap.id}",
                 font=Torus_SemiBold_20,
                 anchor="rm",
             )
             # maxcb
             draw.text(
                 (700, 328 + h_num),
-                f"Max Combo: {cmap.maxcombo}",
+                f"Max Combo: {cmap.max_combo or 0}",
                 font=Torus_SemiBold_20,
                 anchor="lm",
             )

nonebot_plugin_osubot/draw/bp.py

@@ -9,7 +9,7 @@ from ..pp import cal_pp
 from ..mods import get_mods_list
 from ..exceptions import NetworkError
 from ..schema.score import Mod, UnifiedScore
-from .score import cal_legacy_acc, cal_legacy_rank
+from .score import cal_score_info
 from ..api import get_user_scores, get_user_info_data
 from ..file import map_path, get_pfm_img, download_osu
 from .utils import draw_fillet, draw_fillet2, open_user_icon, filter_scores_with_regex
@@ -29,8 +29,6 @@ async def draw_bp(
     source: str,
 ) -> BytesIO:
     scores = await get_user_scores(uid, mode, "best", source=source, legacy_only=not is_lazer)
-    if not is_lazer:
-        scores = [i for i in scores if any(mod.acronym == "CL" for mod in i.mods)]
     if mods:
         mods_ls = get_mods_list(scores, mods)
         if low_bound > len(mods_ls):
@@ -46,17 +44,9 @@ async def draw_bp(
         score_ls_filtered = [score for score in scores if score.ended_at > datetime.now() - timedelta(days=day + 1)]
         if not score_ls_filtered:
             raise NetworkError("未查询到游玩记录")
-    for score_info in score_ls_filtered:
+    for i, score_info in enumerate(score_ls_filtered):
         # 判断是否开启lazer模式
-        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.remove(Mod(acronym="CL"))
-        if score_info.ruleset_id == 3 and not is_lazer:
-            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")))
-            score_info.rank = cal_legacy_rank(score_info, is_hidden)
+        score_ls_filtered[i] = cal_score_info(is_lazer, score_info, source)
     if search_condition:
         score_ls_filtered = filter_scores_with_regex(score_ls_filtered, search_condition)
     if not score_ls_filtered:

nonebot_plugin_osubot/draw/catch_preview.py

@@ -1,28 +1,14 @@
 from pathlib import Path
 
-import jinja2
 from nonebot_plugin_htmlrender import get_new_page
 
-from ..file import map_path, download_osu
+from .utils import load_osu_file_and_setup_template
 
 template_path = str(Path(__file__).parent / "catch_preview_templates")
 
 
 async def draw_cath_preview(beatmap_id, beatmapset_id, mods) -> bytes:
-    path = map_path / str(beatmapset_id)
-    if not path.exists():
-        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)
+    osu_file, template = await load_osu_file_and_setup_template(template_path, beatmap_id, beatmapset_id)
     is_hr = 1 if "HR" in mods else 0
     is_ez = 1 if "EZ" in mods else 0
     is_dt = 1 if "DT" in mods else 0

nonebot_plugin_osubot/draw/echarts.py

@@ -20,7 +20,14 @@ async def draw_bpa_plot(name, pp_ls, length_ls, mod_pp_ls, mapper_pp_ls) -> byte
     pic = await template_to_pic(
         template_path,
         template_name,
-        {"name": name, "pp_ls": pp_ls, "length_ls": length_ls, "mod_pp_ls": mod_pp_ls, "mapper_pp_ls": mapper_pp_ls},
+        {
+            "name": name,
+            "pp_ls": pp_ls,
+            "length_ls": length_ls,
+            "mod_pp_ls": mod_pp_ls,
+            "mapper_pp_ls": mapper_pp_ls,
+            "length": len(pp_ls),
+        },
     )
     return pic
 

nonebot_plugin_osubot/draw/info.py

@@ -1,34 +1,22 @@
-import asyncio
-from io import BytesIO
+import base64
+import jinja2
+from pathlib import Path
 from typing import Union
 from datetime import date, datetime, timedelta
 
-from PIL import ImageDraw, ImageSequence, UnidentifiedImageError
+from PIL import UnidentifiedImageError
+from nonebot_plugin_htmlrender import get_new_page
 
+from .utils import info_calc
 from ..utils import FGM, GMN
+from ..file import user_cache_path
 from ..exceptions import NetworkError
 from ..database.models import InfoData
+from ..schema.draw_info import DrawUser, Badge
 from ..api import get_random_bg, get_user_info_data
-from .utils import info_calc, draw_fillet, update_icon, open_user_icon
-from ..file import get_projectimg, team_cache_path, user_cache_path, badge_cache_path, make_badge_cache_file
-from .static import (
-    Image,
-    InfoImg,
-    ExpLeftBg,
-    ExpRightBg,
-    ExpCenterBg,
-    Torus_Regular_20,
-    Torus_Regular_25,
-    Torus_Regular_30,
-    Torus_Regular_35,
-    Torus_Regular_40,
-    Torus_Regular_45,
-    Torus_Regular_50,
-    osufile,
-)
 
 
-async def draw_info(uid: Union[int, str], mode: str, day: int, source: str) -> BytesIO:
+async def draw_info(uid: Union[int, str], mode: str, day: int, source: str) -> bytes:
     info = await get_user_info_data(uid, mode, source)
     statistics = info.statistics
     if statistics.play_count == 0:
@@ -69,208 +57,72 @@ async def draw_info(uid: Union[int, str], mode: str, day: int, source: str) -> B
             statistics.play_count,
             statistics.total_hits,
         )
-    # 新建
-    im = Image.new("RGBA", (1000, 1350))
-    draw = ImageDraw.Draw(im)
     # 获取背景
     bg_path = user_cache_path / str(info.id) / "info.png"
     if bg_path.exists():
         try:
-            bg = Image.open(bg_path)
+            with open(bg_path, "rb") as image_file:
+                encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
+
+            # 格式化为 CSS 接受的 data URI 格式
+            bg = f"data:image/png;base64,{encoded_string}"
         except UnidentifiedImageError:
             bg_path.unlink()
             raise NetworkError("自定义背景图片读取错误，请重新上传！")
     else:
         bg = await get_random_bg()
-        if bg:
-            bg = Image.open(BytesIO(bg))
-    if bg:
-        bg = bg.convert("RGBA")
-        width, height = bg.size
-        bg_ratio = height / width
-        ratio = 1350 / 1000
-        if bg_ratio > ratio:
-            height = ratio * width
-        else:
-            width = height / ratio
-        x, y = bg.size
-        x, y = (x - width) // 2, (y - height) // 2
-        bg = bg.crop((x, y, x + width, y + height)).resize((1000, 1350))
-        im.alpha_composite(bg, (0, 0))
-    # 获取头图，头像，地区，状态，supporter
-    path = user_cache_path / str(info.id)
-    if not path.exists():
-        path.mkdir()
-    country = osufile / "flags" / f"{info.country_code}.png"
-    # 底图
-    im.alpha_composite(InfoImg)
-    # 4/7K排名
-    if FGM[mode] == 3 and statistics.variants:
-        for variant in statistics.variants:
-            if variant.variant == "4k" and variant.pp != 0:
-                draw.text(
-                    (935, 85),
-                    f"4K: {variant.pp} // #{variant.global_rank} // {info.country_code} #{variant.country_rank}",
-                    font=Torus_Regular_25,
-                    anchor="rt",
-                )
-            if variant.variant == "7k" and variant.pp != 0:
-                draw.text(
-                    (935, 120),
-                    f"7K: {variant.pp} // #{variant.global_rank} // {info.country_code} #{variant.country_rank}",
-                    font=Torus_Regular_25,
-                    anchor="rt",
-                )
-    # 奖牌
-    if info.badges:
-        badges_num = len(info.badges)
-        for num, badge in enumerate(info.badges):
-            if badges_num <= 9:
-                length = 50 + 100 * num
-                height = 510
-            elif num < 9:
-                length = 50 + 100 * num
-                height = 486
-            else:
-                length = 50 + 100 * (num - 9)
-                height = 534
-            badges_path = badge_cache_path / f"{hash(badge.description)}.png"
-            if not badges_path.exists():
-                await make_badge_cache_file(badge)
-            try:
-                badges_img = Image.open(badges_path).convert("RGBA").resize((86, 40))
-            except UnidentifiedImageError:
-                badges_path.unlink()
-                raise NetworkError("badges 图片下载错误，请重试！")
-            im.alpha_composite(badges_img, (length, height))
-    # 地区
-    country_bg = Image.open(country).convert("RGBA").resize((80, 54))
-    im.alpha_composite(country_bg, (400, 394))
-    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((108, 54))
-            im.alpha_composite(team_img, (400, 280))
-        except UnidentifiedImageError:
-            team_path.unlink()
-            raise NetworkError("team 图片下载错误，请重试！")
-        draw.text((515, 300), info.team.name, font=Torus_Regular_30, anchor="lt")
-    # supporter
-    # if info.is_supporter:
-    # im.alpha_composite(SupporterBg.resize((54, 54)), (400, 280))
-    # 经验
-    if statistics.level.progress != 0:
-        im.alpha_composite(ExpLeftBg, (50, 646))
-        exp_width = statistics.level.progress * 7 - 3
-        im.alpha_composite(ExpCenterBg.resize((exp_width, 10)), (54, 646))
-        im.alpha_composite(ExpRightBg, (int(54 + exp_width), 646))
-    # 模式
-    draw.text((935, 50), GMN[mode], font=Torus_Regular_45, anchor="rm")
-    # 玩家名
-    draw.text((400, 205), info.username, font=Torus_Regular_50, anchor="lm")
-    # 地区排名
-    op, value = info_calc(statistics.country_rank, n_crank, rank=True)
-    if not statistics.country_rank:
-        t_crank = "#0"
-    else:
-        t_crank = f"#{statistics.country_rank:,}({op}{value:,})" if value != 0 else f"#{statistics.country_rank:,}"
-    draw.text((495, 448), t_crank, font=Torus_Regular_30, anchor="lb")
-    # 等级
-    draw.text((900, 650), str(statistics.level.current), font=Torus_Regular_25, anchor="mm")
-    # 经验百分比
-    draw.text((750, 660), f"{statistics.level.progress}%", font=Torus_Regular_20, anchor="rt")
-    # 全球排名
-    if not statistics.global_rank:
-        draw.text((55, 785), "#0", font=Torus_Regular_35, anchor="lt")
+    if day != 0 and user:
+        day_delta = date.today() - user.date
+        time = day_delta.days
+        footer = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
+        footer += f" | 数据对比于 {time} 天前"
     else:
-        draw.text(
-            (55, 785),
-            f"#{statistics.global_rank:,}",
-            font=Torus_Regular_35,
-            anchor="lt",
-        )
-    op, value = info_calc(statistics.global_rank, n_grank, rank=True)
-    if value != 0:
-        draw.text((65, 820), f"{op}{value:,}", font=Torus_Regular_20, anchor="lt")
-    # pp
-    draw.text((295, 785), f"{statistics.pp:,}", font=Torus_Regular_35, anchor="lt")
+        footer = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
     op, value = info_calc(statistics.pp, n_pp, pp=True)
-    if value != 0:
-        draw.text((305, 820), f"{op}{int(value)}", font=Torus_Regular_20)
-    # SS - A
-    # gc_x = 493
-    for gc_num, (_, num) in enumerate(statistics.grade_counts):
-        draw.text((493 + 100 * gc_num, 788), f"{num}", font=Torus_Regular_30, anchor="mt")
-        # gc_x+=100
-    # rank分
-    draw.text((935, 895), f"{statistics.ranked_score:,}", font=Torus_Regular_40, anchor="rt")
+    pp_change = f"{op}{value:,.2f}" if value != 0 else None
+    op, value = info_calc(statistics.global_rank, n_grank, rank=True)
+    rank_change = f"{op}{value:,}" if value != 0 else None
+    op, value = info_calc(statistics.country_rank, n_crank, rank=True)
+    country_rank_change = f"({op}{value:,})" if value != 0 else None
     # acc
     op, value = info_calc(statistics.hit_accuracy, n_acc)
-    t_acc = f"{statistics.hit_accuracy:.2f}%({op}{value:.2f}%)" if value != 0 else f"{statistics.hit_accuracy:.2f}%"
-    draw.text((935, 965), t_acc, font=Torus_Regular_40, anchor="rt")
+    acc_change = f"({op}{value:.2f}%)" if value != 0 else None
     # 游玩次数
     op, value = info_calc(statistics.play_count, n_pc)
-    t_pc = f"{statistics.play_count:,}({op}{value:,})" if value != 0 else f"{statistics.play_count:,}"
-    draw.text((935, 1035), t_pc, font=Torus_Regular_40, anchor="rt")
+    pc_change = f"({op}{value:,})" if value != 0 else None
     # 总分
-    draw.text((935, 1105), f"{statistics.total_score:,}", font=Torus_Regular_40, anchor="rt")
     # 总命中
     op, value = info_calc(statistics.total_hits, n_count)
-    t_count = f"{statistics.total_hits:,}({op}{value:,})" if value != 0 else f"{statistics.total_hits:,}"
-    draw.text((935, 1175), t_count, font=Torus_Regular_40, anchor="rt")
-    # 游玩时间
-    sec = timedelta(seconds=statistics.play_time)
-    d_time = datetime(1, 1, 1) + sec
-    t_time = f"{sec.days}d {d_time.hour}h {d_time.minute}m {d_time.second}s"
-    draw.text((935, 1245), t_time, font=Torus_Regular_40, anchor="rt")
-    # 底部时间对比
-    if day != 0 and user:
-        day_delta = date.today() - user.date
-        time = day_delta.days
-        current_time = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
-        draw.text((260, 1305), current_time, font=Torus_Regular_25, anchor="la")
-        text = f"| 数据对比于 {time} 天前"
-        draw.text((515, 1305), text, font=Torus_Regular_25, anchor="la")
-    else:
-        current_time = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
-        draw.text((380, 1305), current_time, font=Torus_Regular_25, anchor="la")
-    # 头像
-    gif_frames = []
-    user_icon = await open_user_icon(info, source)
-    _ = asyncio.create_task(update_icon(info))
-    if not getattr(user_icon, "is_animated", False):
-        icon_bg = user_icon.convert("RGBA").resize((300, 300))
-        icon_img = draw_fillet(icon_bg, 25)
-        im.alpha_composite(icon_img, (50, 148))
-        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((300, 300))
-        gif_frame = draw_fillet(gif_frame, 25)
-        # 创建一个新的 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, (50, 148), 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"],
+    hits_change = f"({op}{value:,})" if value != 0 else None
+    badges = [Badge(**i.model_dump()) for i in info.badges]
+    draw_user = DrawUser(
+        id=info.id,
+        username=info.username,
+        country_code=info.country_code,
+        mode=mode.upper(),
+        badges=badges,
+        team=info.team.model_dump() if info.team else None,
+        statistics=info.statistics.model_dump() if info.statistics else None,
+        footer=footer,
+        rank_change=rank_change,
+        country_rank_change=country_rank_change,
+        pp_change=pp_change,
+        acc_change=acc_change,
+        pc_change=pc_change,
+        hits_change=hits_change,
     )
-    # 输出
-    gif_frames[0].close()
-    user_icon.close()
-    return gif_bytes
+    template_path = str(Path(__file__).parent / "info_templates")
+    template_name = "index.html"
+    template_env = jinja2.Environment(  # noqa: S701
+        loader=jinja2.FileSystemLoader(template_path),
+        enable_async=True,
+    )
+    template = template_env.get_template(template_name)
+    async with get_new_page(2) as page:
+        await page.goto(f"file://{template_path}")
+        await page.set_content(
+            await template.render_async(user_json=draw_user.model_dump_json(), bg=bg), wait_until="networkidle"
+        )
+        elem = await page.query_selector("#display")
+        assert elem
+        return await elem.screenshot(type="jpeg")