✨ 迁移到新模板 (#536)

* ➕ 添加依赖 strenum

* 🐛 优化等待逻辑，修复截图爆炸

* ✨ 使用新模板

* ⚡️ 关闭自动转译

* ✨ 同步新模板 schemas

* 🌐 添加模板语言的映射

* ✨ 适配 bind

* ✨ 更新模板

* ✨ 全部适配

* 🚨 make mypy happy

* Update nonebot_plugin_tetris_stats/games/tos/query.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* ✨ 使用用户设置语言

* 🚨 auto fix by pre-commit hooks

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

nonebot_plugin_tetris_stats/games/tetrio/query/v1.py

@@ -1,17 +1,18 @@
 from asyncio import gather
-from datetime import datetime, timedelta
+from datetime import timedelta
 from hashlib import md5
-from math import ceil, floor
-from zoneinfo import ZoneInfo
 
 from yarl import URL
 
-from ....utils.exception import FallbackError, WhatTheFuckError
+from ....utils.chart import get_split, get_value_bounds, handle_history_data
+from ....utils.exception import FallbackError
 from ....utils.host import HostPage, get_self_netloc
+from ....utils.lang import get_lang
+from ....utils.metrics import get_metrics
 from ....utils.render import render
-from ....utils.render.schemas.base import Avatar, Ranking
-from ....utils.render.schemas.tetrio.user.base import TetraLeagueHistoryData
-from ....utils.render.schemas.tetrio.user.info_v1 import Info, Radar, TetraLeague, TetraLeagueHistory, User
+from ....utils.render.schemas.base import Avatar, Trending
+from ....utils.render.schemas.v1.base import History
+from ....utils.render.schemas.v1.tetrio.user.info import Info, Multiplayer, Singleplayer, User
 from ....utils.screenshot import screenshot
 from ..api import Player
 from ..api.schemas.summaries.league import RatedData
@@ -19,109 +20,6 @@ from ..constant import TR_MAX, TR_MIN
 from .tools import flow_to_history, get_league_data
 
 
-def get_value_bounds(values: list[int | float]) -> tuple[int, int]:
-    value_max = 10 * ceil(max(values) / 10)
-    value_min = 10 * floor(min(values) / 10)
-    return value_max, value_min
-
-
-def get_split(value_max: int, value_min: int) -> tuple[int, int]:
-    offset = 0
-    overflow = 0
-
-    while True:
-        if (new_max_value := value_max + offset + overflow) > TR_MAX:
-            overflow -= 1
-            continue
-        if (new_min_value := value_min - offset + overflow) < TR_MIN:
-            overflow += 1
-            continue
-        if ((new_max_value - new_min_value) / 40).is_integer():
-            split_value = int((value_max + offset - (value_min - offset)) / 4)
-            break
-        offset += 1
-    return split_value, offset + overflow
-
-
-def get_specified_point(
-    previous_point: TetraLeagueHistoryData,
-    behind_point: TetraLeagueHistoryData,
-    point_time: datetime,
-) -> TetraLeagueHistoryData:
-    """根据给出的 previous_point 和 behind_point, 推算 point_time 点处的数据
-
-    Args:
-        previous_point (Data): 前面的数据点
-        behind_point (Data): 后面的数据点
-        point_time (datetime): 要推算的点的位置
-
-    Returns:
-        Data: 要推算的点的数据
-    """
-    # 求两个点的斜率
-    slope = (behind_point.tr - previous_point.tr) / (
-        datetime.timestamp(behind_point.record_at) - datetime.timestamp(previous_point.record_at)
-    )
-    return TetraLeagueHistoryData(
-        record_at=point_time,
-        tr=previous_point.tr + slope * (datetime.timestamp(point_time) - datetime.timestamp(previous_point.record_at)),
-    )
-
-
-def handle_history_data(data: list[TetraLeagueHistoryData]) -> list[TetraLeagueHistoryData]:  # noqa: C901, PLR0912
-    # 按照 记录时间 对数据进行排序
-    data.sort(key=lambda x: x.record_at)
-
-    # 定义时间边界, 右边界为当前时间的当天零点, 左边界为右边界前推9天
-    # 返回值的[0]和[-1]分别应满足left_border和right_border
-    zero = datetime.now(ZoneInfo('Asia/Shanghai')).replace(hour=0, minute=0, second=0, microsecond=0)
-    left_border = zero - timedelta(days=9)
-    right_border = zero.replace(microsecond=1000)
-
-    lefts: list[TetraLeagueHistoryData] = []
-    in_border: list[TetraLeagueHistoryData] = []
-    rights: list[TetraLeagueHistoryData] = []
-
-    # 根据 记录时间 将数据分类到对应的列表中
-    for i in data:
-        if i.record_at < left_border:
-            lefts.append(i)
-        elif i.record_at < right_border:
-            in_border.append(i)
-        else:
-            rights.append(i)
-
-    ret: list[TetraLeagueHistoryData] = []
-
-    # 处理左边界的点
-    if lefts and in_border:  # 如果边界左侧和边界内都有值则推算
-        ret.append(get_specified_point(lefts[-1], in_border[0], left_border))
-    elif lefts and not in_border:  # 如果边界左侧有值但是边界内没有值则直接取左侧的最后一个值
-        ret.append(TetraLeagueHistoryData(tr=lefts[-1].tr, record_at=left_border))
-    elif not lefts and in_border:  # 如果边界左侧没有值但是边界内有值则直接取边界内的第一个值
-        ret.append(TetraLeagueHistoryData(tr=in_border[0].tr, record_at=left_border))
-    elif not lefts and not in_border and rights:  # 如果边界左侧和边界内都没有值但是边界右侧有值则直接取边界右侧的第一个值 # fmt: skip
-        ret.append(TetraLeagueHistoryData(tr=rights[0].tr, record_at=left_border))
-    else:  # 暂时没想到其他情况
-        raise WhatTheFuckError
-
-    # 添加边界内数据
-    ret.extend(in_border)
-
-    # 处理右边界的点
-    if in_border and rights:  # 如果边界内和边界右侧都有值则推算
-        ret.append(get_specified_point(in_border[-1], rights[0], right_border))
-    elif not in_border and rights:  # 如果边界内没有值但是边界右侧有值则直接取右侧的第一个值
-        ret.append(TetraLeagueHistoryData(tr=rights[0].tr, record_at=right_border))
-    elif in_border and not rights:  # 如果边界内有值但是边界右侧没有值则直接取边界内的最后一个值
-        ret.append(TetraLeagueHistoryData(tr=in_border[-1].tr, record_at=right_border))
-    elif not in_border and not rights and lefts:  # 如果边界内和边界右侧都没有值但是边界左侧有值则直接取边界左侧的最后一个值 # fmt: skip
-        ret.append(TetraLeagueHistoryData(tr=lefts[-1].tr, record_at=right_border))
-    else:  # 暂时没想到其他情况
-        raise WhatTheFuckError
-    return ret
-
-
 async def make_query_image_v1(player: Player) -> bytes:
     (
         (user, user_info, league, sprint, blitz, leagueflow),
@@ -134,8 +32,8 @@ async def make_query_image_v1(player: Player) -> bytes:
     if league_data.vs is None:
         raise FallbackError
     histories = flow_to_history(leagueflow, handle_history_data)
-    value_max, value_min = get_value_bounds([i.tr for i in histories])
-    split_value, offset = get_split(value_max, value_min)
+    values = get_value_bounds([i.score for i in histories])
+    split_value, offset = get_split(values, TR_MAX, TR_MIN)
     if sprint.data.record is not None:
         duration = timedelta(milliseconds=sprint.data.record.results.stats.finaltime).total_seconds()
         sprint_value = f'{duration:.3f}s' if duration < 60 else f'{duration // 60:.0f}m {duration % 60:.3f}s'  # noqa: PLR2004
@@ -143,6 +41,9 @@ async def make_query_image_v1(player: Player) -> bytes:
         sprint_value = 'N/A'
     blitz_value = f'{blitz.data.record.results.stats.score:,}' if blitz.data.record is not None else 'N/A'
     netloc = get_self_netloc()
+    dsps: float
+    dspp: float
+    # make mypy happy
     async with HostPage(
         page=await render(
             'v1/tetrio/info',
@@ -159,38 +60,40 @@ async def make_query_image_v1(player: Player) -> bytes:
                     name=user.name.upper(),
                     bio=user_info.data.bio,
                 ),
-                ranking=Ranking(
-                    rating=round(league_data.glicko, 2),
+                multiplayer=Multiplayer(
+                    glicko=f'{round(league_data.glicko, 2):,}',
                     rd=round(league_data.rd, 2),
-                ),
-                tetra_league=TetraLeague(
                     rank=league_data.rank,
-                    tr=round(league_data.tr, 2),
+                    tr=f'{round(league_data.tr, 2):,}',
                     global_rank=league_data.standing,
-                    pps=league_data.pps,
-                    lpm=round(lpm := (league_data.pps * 24), 2),
-                    apm=league_data.apm,
-                    apl=round(league_data.apm / lpm, 2),
-                    vs=league_data.vs,
-                    adpm=round(adpm := (league_data.vs * 0.6), 2),
-                    adpl=round(adpm / lpm, 2),
-                ),
-                tetra_league_history=TetraLeagueHistory(
-                    data=histories,
-                    split_interval=split_value,
-                    min_tr=value_min,
-                    max_tr=value_max,
-                    offset=offset,
-                ),
-                radar=Radar(
+                    history=History(
+                        data=histories,
+                        split_interval=split_value,
+                        min_value=values.value_min,
+                        max_value=values.value_max,
+                        offset=offset,
+                    ),
+                    lpm=(metrics := get_metrics(pps=league_data.pps, apm=league_data.apm, vs=league_data.vs)).lpm,
+                    pps=metrics.pps,
+                    lpm_trending=Trending.KEEP,
+                    apm=metrics.apm,
+                    apl=metrics.apl,
+                    apm_trending=Trending.KEEP,
+                    adpm=metrics.adpm,
+                    vs=metrics.vs,
+                    adpl=metrics.adpl,
+                    adpm_trending=Trending.KEEP,
                     app=(app := (league_data.apm / (60 * league_data.pps))),
                     dsps=(dsps := ((league_data.vs / 100) - (league_data.apm / 60))),
                     dspp=(dspp := (dsps / league_data.pps)),
                     ci=150 * dspp - 125 * app + 50 * (league_data.vs / league_data.apm) - 25,
                     ge=2 * ((app * dsps) / league_data.pps),
                 ),
-                sprint=sprint_value,
-                blitz=blitz_value,
+                singleplayer=Singleplayer(
+                    sprint=sprint_value,
+                    blitz=blitz_value,
+                ),
+                _lang=get_lang(),
             ),
         )
     ) as page_hash: