FUCK(LevelRecordInfo): 移除不必要的初始化

- 移除惰性加载机制，改为使用build()方法进行数据构建
- 添加NEW评级类型到Rating枚举中
- 使用default_factory替代default设置date字段
- 新增_raw_rank私有字段用于存储原始难度索引
- 优化init方法为build方法，统一处理数据构建逻辑
- 移除多余的Any类型导入

Author: molanp

phi-plugin/apps/user.py

@@ -270,6 +270,7 @@ async def _(session: Uninfo, _input: Match):
     totsongs = 0
     totRating: dict[
         Literal[
+            "NEW",
             "phi",
             "FC",
             "V",

phi-plugin/model/cls/LevelRecordInfo.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Literal
+from typing import Literal
 
 from pydantic import BaseModel, Field
 
@@ -22,6 +22,7 @@ class LevelRecordInfo(BaseModel):
     rank: LevelItem | str = ""
     """Level"""
     Rating: Literal[
+        "NEW",
         "phi",
         "FC",
         "V",
@@ -45,139 +46,55 @@ class LevelRecordInfo(BaseModel):
     """推分建议"""
     num: int = Field(default=0, exclude=True)
     """是 Best 几"""
-    date: datetime = Field(default=datetime.now(), exclude=True)
+    date: datetime = Field(default_factory=datetime.now, exclude=True)
     """更新时间(iso)"""
+    _raw_rank: str | int = Field(default="", exclude=True)
 
-    # 私有字段
-    lazy_song_id: str = Field(default="", exclude=True)
-    lazy_index: int = Field(default=0, exclude=True)
-    lazy_raw_data: dict[str, Any] | None = Field(default=None, exclude=True)
-    is_lazy: bool = Field(default=False, exclude=True)
-    initialized: bool = Field(default=True, exclude=True)  # 默认为已初始化
-
-    @classmethod
-    def lazy_init(cls, data: dict, id: str, index: int) -> "LevelRecordInfo":
+    def build(self,) -> None:  # type: ignore[override]
         """
-        惰性初始化方法，只设置基本字段
+        构建所需的完整数据
         """
-        # 检查数据是否包含完整字段，如果包含则直接初始化
-        if cls._is_data_complete(data):
-            # 数据已经完整，直接创建实例而不调用 init
-            instance = cls(**data)
-            # 标记为已初始化
-            instance.initialized = True
-            instance.is_lazy = False
-            return instance
-        # 数据不完整，使用惰性加载
-        instance = cls(
-            fc=data.get("fc", False),
-            score=data.get("score", 0),
-            acc=data.get("acc", 0.0),
-        )
-        instance.lazy_raw_data = data
-        instance.lazy_song_id = id
-        instance.lazy_index = index
-        instance.is_lazy = True
-        instance.initialized = False
-        return instance
 
-    @classmethod
-    def _is_data_complete(cls, data: dict) -> bool:
-        """
-        检查传入数据是否包含完整字段
-        """
-        # 定义完整字段列表
-        complete_fields = [
-            "song",
-            "rank",
-            "difficulty",
-            "rks",
-            "Rating",
-            "illustration",
-        ]
+        # rank 可能传的是 int / str，这里统一一下
+        if isinstance(self._raw_rank, int):
+            rank_key: LevelItem | str = getInfo.Level[self._raw_rank]
+            self.rank = rank_key
+        else:
+            rank_key = self.rank
 
-        # 检查是否包含完整字段
-        return all(field in data for field in complete_fields)
+        # rating
+        self.Rating = Rating(self.score, self.fc)
 
-    def _ensure_initialized(self):
-        """
-        确保完全初始化
-        """
-        if not self.initialized and self.is_lazy and self.lazy_raw_data is not None:
-            # 完整初始化
-            full_instance = LevelRecordInfo.init(
-                self.lazy_raw_data, self.lazy_song_id, self.lazy_index
-            )
-            # 复制所有字段
-            for field_name in LevelRecordInfo.model_fields:
-                setattr(self, field_name, getattr(full_instance, field_name))
-            self.initialized = True
-            self.is_lazy = False
+        if song := getInfo.idgetsong(self.id):
+            info = getInfo.info(song)
+        else:
+            info = None
+        if not info:
+            self.song = self.id
+            self.difficulty = 0.0
+            self.rks = 0.0
+            return
 
-    # 重写 __getattribute__ 实现惰性加载
-    def __getattribute__(self, name: str):
-        # 避免无限递归，对特殊属性直接返回
-        if name in {
-            "initialized",
-            "is_lazy",
-            "lazy_raw_data",
-            "lazy_song_id",
-            "lazy_index",
-        }:
-            return object.__getattribute__(self, name)
+        self.song = info.song
 
-        # 检查是否是模型字段且需要初始化
-        if name in {
-            "song",
-            "rank",
-            "difficulty",
-            "rks",
-            "Rating",
-            "illustration",
-        } and not object.__getattribute__(self, "initialized"):
-            object.__getattribute__(self, "_ensure_initialized")()
-        return object.__getattribute__(self, name)
+        # illustration
+        ill = getInfo.getill(self.song)
+        self.illustration = ill
 
-    @classmethod
-    def init(cls, data: dict, id: str, rank: int | str) -> "LevelRecordInfo":
-        """
-        :param data: 原始数据
-        :param id: 曲目id
-        :param rank: 难度
-        """
-        data_ = {"fc": data["fc"], "score": data["score"], "acc": data["acc"], "id": id}
-        song = getInfo.idgetsong(id)
-        info = getInfo.info(song) if song else None
-        data_["rank"] = (
-            getInfo.Level[rank] if isinstance(rank, int) else rank
-        )  # EZ HD IN AT LEGACY
-        data_["Rating"] = Rating(data_["score"], data_["fc"])  # V S A
-        if not info:
-            data_["song"] = id
-            data_["difficulty"] = 0
-            data_["rks"] = 0
-            return cls(**data_)
-        data_["song"] = info.song  # 曲名
-        data_["illustration"] = getInfo.getill(data_["song"])  # 曲绘链接
-        difficulty = (
-            info.chart[data_["rank"]].difficulty
-            if data_["rank"] in info.chart
-            else None
-        )
-        if info.chart and difficulty:
-            assert isinstance(difficulty, float)
-            data_["difficulty"] = difficulty  # 难度
-            data_["rks"] = fCompute.rks(data_["acc"], data_["difficulty"])  # 等效rks
+        chart = info.chart
+        if chart and rank_key in chart and chart[rank_key].difficulty:
+            diff_val = chart[rank_key].difficulty
+            assert isinstance(diff_val, float)
+            self.difficulty = diff_val
+            self.rks = fCompute.rks(self.acc, self.difficulty)
         else:
-            data_["difficulty"] = 0
-            data_["rks"] = 0
-        return cls(**data_)
+            self.difficulty = 0.0
+            self.rks = 0.0
 
-    @classmethod
-    def to_tuple(cls) -> tuple[float, int, datetime, bool]:
+    def to_tuple(self) -> tuple[float, int, datetime, bool]:
         return (
-            cls.acc,
-            cls.score,
-            cls.date,
-            cls.fc,
+            self.acc,
+            self.score,
+            self.date,
+            self.fc,
         )

phi-plugin/model/cls/common.py

@@ -238,14 +238,21 @@ class Save(BaseModel):
 
     @field_validator("gameRecord", mode="before")
     @classmethod
-    def parse_game_record(cls, v):
-        return {
-            song_id: [
-                LevelRecordInfo.lazy_init(record, song_id, index)
-                for index, record in enumerate(records)
-            ]
-            for song_id, records in v.items()
-        }
+    def parse_game_record(cls, v: dict[str, list[dict[str, Any]]]):
+        """
+        只做轻量加工：把原始记录补上 id 和 rank，
+        不在这里构造 LevelRecordInfo，交给 Pydantic + model_post_init。
+        """
+        result: dict[str, list[dict[str, Any]]] = {}
+        for song_id, records in v.items():
+            new_list: list[dict[str, Any]] = []
+            for idx, record in enumerate(records):
+                # 你要求的三个参数：data(dict) + id + rank
+                record["id"] = song_id
+                record["_raw_rank"] = idx  # 0/1/2/3 -> EZ/HD/IN/AT，在 model_post_init 里转换
+                new_list.append(record)
+            result[song_id] = new_list
+        return result
 
     @field_validator("saveInfo", mode="before")
     @classmethod