chore(linter): update ruff rules

app/database/beatmap.py

@@ -71,10 +71,10 @@ class Beatmap(BeatmapBase, table=True):
     failtimes: FailTime | None = Relationship(back_populates="beatmap", sa_relationship_kwargs={"lazy": "joined"})
 
     @classmethod
-    async def from_resp_no_save(cls, session: AsyncSession, resp: "BeatmapResp") -> "Beatmap":
+    async def from_resp_no_save(cls, _session: AsyncSession, resp: "BeatmapResp") -> "Beatmap":
         d = resp.model_dump()
         del d["beatmapset"]
-        beatmap = Beatmap.model_validate(
+        beatmap = cls.model_validate(
             {
                 **d,
                 "beatmapset_id": resp.beatmapset_id,
@@ -90,8 +90,7 @@ class Beatmap(BeatmapBase, table=True):
         if not (await session.exec(select(exists()).where(Beatmap.id == resp.id))).first():
             session.add(beatmap)
             await session.commit()
-        beatmap = (await session.exec(select(Beatmap).where(Beatmap.id == resp.id))).one()
-        return beatmap
+        return (await session.exec(select(Beatmap).where(Beatmap.id == resp.id))).one()
 
     @classmethod
     async def from_resp_batch(cls, session: AsyncSession, inp: list["BeatmapResp"], from_: int = 0) -> list["Beatmap"]:
@@ -250,7 +249,7 @@ async def calculate_beatmap_attributes(
     redis: Redis,
     fetcher: "Fetcher",
 ):
-    key = f"beatmap:{beatmap_id}:{ruleset}:{hashlib.md5(str(mods_).encode()).hexdigest()}:attributes"
+    key = f"beatmap:{beatmap_id}:{ruleset}:{hashlib.sha256(str(mods_).encode()).hexdigest()}:attributes"
     if await redis.exists(key):
         return BeatmapAttributes.model_validate_json(await redis.get(key))
     resp = await fetcher.get_or_fetch_beatmap_raw(redis, beatmap_id)

app/database/beatmapset.py

@@ -130,7 +130,7 @@ class Beatmapset(AsyncAttrs, BeatmapsetBase, table=True):
     favourites: list["FavouriteBeatmapset"] = Relationship(back_populates="beatmapset")
 
     @classmethod
-    async def from_resp_no_save(cls, session: AsyncSession, resp: "BeatmapsetResp", from_: int = 0) -> "Beatmapset":
+    async def from_resp_no_save(cls, resp: "BeatmapsetResp") -> "Beatmapset":
         d = resp.model_dump()
         if resp.nominations:
             d["nominations_required"] = resp.nominations.required
@@ -158,10 +158,15 @@ class Beatmapset(AsyncAttrs, BeatmapsetBase, table=True):
         return beatmapset
 
     @classmethod
-    async def from_resp(cls, session: AsyncSession, resp: "BeatmapsetResp", from_: int = 0) -> "Beatmapset":
+    async def from_resp(
+        cls,
+        session: AsyncSession,
+        resp: "BeatmapsetResp",
+        from_: int = 0,
+    ) -> "Beatmapset":
         from .beatmap import Beatmap
 
-        beatmapset = await cls.from_resp_no_save(session, resp, from_=from_)
+        beatmapset = await cls.from_resp_no_save(resp)
         if not (await session.exec(select(exists()).where(Beatmapset.id == resp.id))).first():
             session.add(beatmapset)
             await session.commit()

app/database/chat.py

@@ -105,17 +105,11 @@ class ChatChannelResp(ChatChannelBase):
             )
         ).first()
 
-        last_msg = await redis.get(f"chat:{channel.channel_id}:last_msg")
-        if last_msg and last_msg.isdigit():
-            last_msg = int(last_msg)
-        else:
-            last_msg = None
+        last_msg_raw = await redis.get(f"chat:{channel.channel_id}:last_msg")
+        last_msg = int(last_msg_raw) if last_msg_raw and last_msg_raw.isdigit() else None
 
-        last_read_id = await redis.get(f"chat:{channel.channel_id}:last_read:{user.id}")
-        if last_read_id and last_read_id.isdigit():
-            last_read_id = int(last_read_id)
-        else:
-            last_read_id = last_msg
+        last_read_id_raw = await redis.get(f"chat:{channel.channel_id}:last_read:{user.id}")
+        last_read_id = int(last_read_id_raw) if last_read_id_raw and last_read_id_raw.isdigit() else last_msg
 
         if silence is not None:
             attribute = ChatUserAttributes(

app/database/score.py

@@ -520,12 +520,11 @@ async def _score_where(
             wheres.append(col(BestScore.user).has(col(User.country_code) == user.country_code))
         else:
             return None
-    elif type == LeaderboardType.TEAM:
-        if user:
-            team_membership = await user.awaitable_attrs.team_membership
-            if team_membership:
-                team_id = team_membership.team_id
-                wheres.append(col(BestScore.user).has(col(User.team_membership).has(TeamMember.team_id == team_id)))
+    elif type == LeaderboardType.TEAM and user:
+        team_membership = await user.awaitable_attrs.team_membership
+        if team_membership:
+            team_id = team_membership.team_id
+            wheres.append(col(BestScore.user).has(col(User.team_membership).has(TeamMember.team_id == team_id)))
     if mods:
         if user and user.is_supporter:
             wheres.append(

app/database/user.py

@@ -256,8 +256,6 @@ class UserResp(UserBase):
         session: AsyncSession,
         include: list[str] = [],
         ruleset: GameMode | None = None,
-        *,
-        token_id: int | None = None,
     ) -> "UserResp":
         from app.dependencies.database import get_redis
 
@@ -310,16 +308,16 @@ class UserResp(UserBase):
                 ).all()
             ]
 
-        if "team" in include:
-            if team_membership := await obj.awaitable_attrs.team_membership:
-                u.team = team_membership.team
+        if "team" in include and (team_membership := await obj.awaitable_attrs.team_membership):
+            u.team = team_membership.team
 
         if "account_history" in include:
             u.account_history = [UserAccountHistoryResp.from_db(ah) for ah in await obj.awaitable_attrs.account_history]
 
-        if "daily_challenge_user_stats":
-            if daily_challenge_stats := await obj.awaitable_attrs.daily_challenge_stats:
-                u.daily_challenge_user_stats = DailyChallengeStatsResp.from_db(daily_challenge_stats)
+        if "daily_challenge_user_stats" in include and (
+            daily_challenge_stats := await obj.awaitable_attrs.daily_challenge_stats
+        ):
+            u.daily_challenge_user_stats = DailyChallengeStatsResp.from_db(daily_challenge_stats)
 
         if "statistics" in include:
             current_stattistics = None
@@ -443,7 +441,7 @@ class MeResp(UserResp):
         from app.dependencies.database import get_redis
         from app.service.verification_service import LoginSessionService
 
-        u = await super().from_db(obj, session, ALL_INCLUDED, ruleset, token_id=token_id)
+        u = await super().from_db(obj, session, ALL_INCLUDED, ruleset)
         u.session_verified = (
             not await LoginSessionService.check_is_need_verification(session, user_id=obj.id, token_id=token_id)
             if token_id