chore(deps): auto fix by pre-commit hooks

app/router/auth.py

@@ -212,7 +212,7 @@ async def oauth_token(
     geoip: GeoIPHelper = Depends(get_geoip_helper),
 ):
     scopes = scope.split(" ")
-    
+
     client = (
         await db.exec(
             select(OAuthClient).where(

app/router/lio.py

@@ -1,15 +1,11 @@
 """LIO (Legacy IO) router for osu-server-spectator compatibility."""
+
 from __future__ import annotations
 
 import json
-from typing import Any, Dict, List
-
-from fastapi import APIRouter, HTTPException, Request, status, Query, Depends
-from pydantic import BaseModel
-from sqlmodel import col, select, desc
-from sqlalchemy import update, func
-from redis.asyncio import Redis
+from typing import Any
 
+from app.database.chat import ChannelType, ChatChannel  # ChatChannel 模型 & 枚举
 from app.database.lazer_user import User
 from app.database.playlists import Playlist as DBPlaylist
 from app.database.room import Room
@@ -17,13 +13,18 @@ from app.database.room_participated_user import RoomParticipatedUser
 from app.dependencies.database import Database, get_redis
 from app.dependencies.fetcher import get_fetcher
 from app.fetcher import Fetcher
+from app.log import logger
 from app.models.multiplayer_hub import PlaylistItem as HubPlaylistItem
 from app.models.room import MatchType, QueueMode, RoomStatus
 from app.utils import utcnow
-from app.database.chat import ChatChannel, ChannelType  # ChatChannel 模型 & 枚举
-from .notification.server import server
-from app.log import logger
 
+from .notification.server import server
+
+from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
+from pydantic import BaseModel
+from redis.asyncio import Redis
+from sqlalchemy import func, update
+from sqlmodel import col, select
 
 router = APIRouter(prefix="/_lio", tags=["LIO"])
 
@@ -40,9 +41,7 @@ async def _ensure_room_chat_channel(
     # 1) 按 channel_id 查是否已存在
     try:
         # Use db.execute instead of db.exec for better async compatibility
-        result = await db.execute(
-            select(ChatChannel).where(ChatChannel.channel_id == room.channel_id)
-        )
+        result = await db.execute(select(ChatChannel).where(ChatChannel.channel_id == room.channel_id))
         ch = result.scalar_one_or_none()
     except Exception as e:
         logger.debug(f"Error querying ChatChannel: {e}")
@@ -59,8 +58,8 @@ async def _ensure_room_chat_channel(
             channel_id_value = int(room.channel_id)
 
         ch = ChatChannel(
-            channel_id=channel_id_value,           # 与房间绑定的同一 channel_id（确保为 int）
-            name=f"mp_{room.id}",                 # 频道名可自定义（注意唯一性）
+            channel_id=channel_id_value,  # 与房间绑定的同一 channel_id（确保为 int）
+            name=f"mp_{room.id}",  # 频道名可自定义（注意唯一性）
             description=f"Multiplayer room {room.id} chat",
             type=ChannelType.MULTIPLAYER,
         )
@@ -86,32 +85,34 @@ async def _alloc_channel_id(db: Database) -> int:
         logger.debug(f"Error allocating channel_id: {e}")
         # Fallback to a timestamp-based approach
         import time
+
         return int(time.time()) % 1000000 + 100
-    
-    
+
+
 class RoomCreateRequest(BaseModel):
     """Request model for creating a multiplayer room."""
+
     name: str
     user_id: int
     password: str | None = None
     match_type: str = "HeadToHead"
     queue_mode: str = "HostOnly"
-    initial_playlist: List[Dict[str, Any]] = []
-    playlist: List[Dict[str, Any]] = []
+    initial_playlist: list[dict[str, Any]] = []
+    playlist: list[dict[str, Any]] = []
 
 
 def verify_request_signature(request: Request, timestamp: str, body: bytes) -> bool:
     """
     Verify HMAC signature for shared interop requests.
-    
+
     Args:
         request: FastAPI request object
         timestamp: Request timestamp
         body: Request body bytes
-        
+
     Returns:
         bool: True if signature is valid
-        
+
     Note:
         Currently skips verification in development.
         In production, implement proper HMAC verification.
@@ -124,13 +125,10 @@ async def _validate_user_exists(db: Database, user_id: int) -> User:
     """Validate that a user exists in the database."""
     user_result = await db.execute(select(User).where(User.id == user_id))
     user = user_result.scalar_one_or_none()
-    
+
     if not user:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"User with ID {user_id} not found"
-        )
-    
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"User with ID {user_id} not found")
+
     return user
 
 
@@ -145,19 +143,19 @@ def _parse_room_enums(match_type: str, queue_mode: str) -> tuple[MatchType, Queu
         queue_mode_enum = QueueMode(queue_mode.lower())
     except ValueError:
         queue_mode_enum = QueueMode.HOST_ONLY
-    
+
     return match_type_enum, queue_mode_enum
 
 
-def _coerce_playlist_item(item_data: Dict[str, Any], default_order: int, host_user_id: int) -> Dict[str, Any]:
+def _coerce_playlist_item(item_data: dict[str, Any], default_order: int, host_user_id: int) -> dict[str, Any]:
     """
     Normalize playlist item data with default values.
-    
+
     Args:
         item_data: Raw playlist item data
         default_order: Default playlist order
         host_user_id: Host user ID for default owner
-        
+
     Returns:
         Dict with normalized playlist item data
     """
@@ -165,7 +163,7 @@ def _coerce_playlist_item(item_data: Dict[str, Any], default_order: int, host_us
     owner_id = item_data.get("owner_id", host_user_id)
     if owner_id == 0:
         owner_id = host_user_id
-    
+
     return {
         "owner_id": owner_id,
         "ruleset_id": item_data.get("ruleset_id", 0),
@@ -181,30 +179,28 @@ def _coerce_playlist_item(item_data: Dict[str, Any], default_order: int, host_us
     }
 
 
-def _validate_playlist_items(items: List[Dict[str, Any]]) -> None:
+def _validate_playlist_items(items: list[dict[str, Any]]) -> None:
     """Validate playlist items data."""
     if not items:
         raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail="At least one playlist item is required to create a room"
+            status_code=status.HTTP_400_BAD_REQUEST, detail="At least one playlist item is required to create a room"
         )
-    
+
     for idx, item in enumerate(items):
         if item["beatmap_id"] is None:
             raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Playlist item at index {idx} missing beatmap_id"
+                status_code=status.HTTP_400_BAD_REQUEST, detail=f"Playlist item at index {idx} missing beatmap_id"
             )
-        
+
         ruleset_id = item["ruleset_id"]
         if not isinstance(ruleset_id, int) or not (0 <= ruleset_id <= 3):
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Playlist item at index {idx} has invalid ruleset_id {ruleset_id}"
+                detail=f"Playlist item at index {idx} has invalid ruleset_id {ruleset_id}",
             )
 
 
-async def _create_room(db: Database, room_data: Dict[str, Any]) -> tuple[Room, int]:
+async def _create_room(db: Database, room_data: dict[str, Any]) -> tuple[Room, int]:
     host_user_id = room_data.get("user_id")
     room_name = room_data.get("name", "Unnamed Room")
     password = room_data.get("password")
@@ -232,7 +228,7 @@ async def _create_room(db: Database, room_data: Dict[str, Any]) -> tuple[Room, i
         participant_count=1,
         auto_skip=False,
         auto_start_duration=0,
-        channel_id=channel_id, 
+        channel_id=channel_id,
     )
 
     db.add(room)
@@ -242,27 +238,27 @@ async def _create_room(db: Database, room_data: Dict[str, Any]) -> tuple[Room, i
     return room, host_user_id
 
 
-async def _add_playlist_items(db: Database, room_id: int, room_data: Dict[str, Any], host_user_id: int) -> None:
+async def _add_playlist_items(db: Database, room_id: int, room_data: dict[str, Any], host_user_id: int) -> None:
     """Add playlist items to the room."""
     initial_playlist = room_data.get("initial_playlist", [])
     legacy_playlist = room_data.get("playlist", [])
-    
-    items_raw: List[Dict[str, Any]] = []
-    
+
+    items_raw: list[dict[str, Any]] = []
+
     # Process initial playlist
     for i, item in enumerate(initial_playlist):
         if hasattr(item, "dict"):
             item = item.dict()
         items_raw.append(_coerce_playlist_item(item, i, host_user_id))
-    
+
     # Process legacy playlist
     start_index = len(items_raw)
     for j, item in enumerate(legacy_playlist, start=start_index):
         items_raw.append(_coerce_playlist_item(item, j, host_user_id))
-    
+
     # Validate playlist items
     _validate_playlist_items(items_raw)
-    
+
     # Insert playlist items
     for item_data in items_raw:
         hub_item = HubPlaylistItem(
@@ -286,42 +282,31 @@ async def _add_host_as_participant(db: Database, room_id: int, host_user_id: int
     """Add the host as a room participant and update participant count."""
     participant = RoomParticipatedUser(room_id=room_id, user_id=host_user_id)
     db.add(participant)
-    
+
     await _update_room_participant_count(db, room_id)
 
 
 async def _verify_room_password(db: Database, room_id: int, provided_password: str | None) -> None:
     """Verify room password if required."""
-    room_result = await db.execute(
-        select(Room).where(col(Room.id) == room_id)
-    )
+    room_result = await db.execute(select(Room).where(col(Room.id) == room_id))
     room = room_result.scalar_one_or_none()
-    
+
     if room is None:
         logger.debug(f"Room {room_id} not found")
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Room not found"
-        )
-    
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Room not found")
+
     logger.debug(f"Room {room_id} has password: {bool(room.password)}, provided: {bool(provided_password)}")
-    
+
     # If room has password but none provided
     if room.password and not provided_password:
         logger.debug(f"Room {room_id} requires password but none provided")
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Password required"
-        )
-    
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Password required")
+
     # If room has password and provided password doesn't match
     if room.password and provided_password and provided_password != room.password:
         logger.debug(f"Room {room_id} password mismatch")
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Invalid password"
-        )
-    
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Invalid password")
+
     logger.debug(f"Room {room_id} password verification passed")
 
 
@@ -332,16 +317,16 @@ async def _add_or_update_participant(db: Database, room_id: int, user_id: int) -
         select(RoomParticipatedUser.id).where(
             RoomParticipatedUser.room_id == room_id,
             RoomParticipatedUser.user_id == user_id,
-            col(RoomParticipatedUser.left_at).is_(None)
+            col(RoomParticipatedUser.left_at).is_(None),
         )
     )
     existing_ids = existing_result.scalars().all()  # 获取所有匹配的ID
-    
+
     if existing_ids:
         # 如果存在多条记录，清理重复项，只保留最新的一条
         if len(existing_ids) > 1:
             logger.debug(f"警告：用户 {user_id} 在房间 {room_id} 中发现 {len(existing_ids)} 条活跃参与记录")
-            
+
             # 将除第一条外的所有记录标记为已离开（清理重复记录）
             for extra_id in existing_ids[1:]:
                 await db.execute(
@@ -349,7 +334,7 @@ async def _add_or_update_participant(db: Database, room_id: int, user_id: int) -
                     .where(col(RoomParticipatedUser.id) == extra_id)
                     .values(left_at=utcnow())
                 )
-        
+
         # 更新剩余的活跃参与记录（刷新加入时间）
         await db.execute(
             update(RoomParticipatedUser)
@@ -364,38 +349,36 @@ async def _add_or_update_participant(db: Database, room_id: int, user_id: int) -
 
 class BeatmapEnsureRequest(BaseModel):
     """Request model for ensuring beatmap exists."""
+
     beatmap_id: int
 
 
-async def _ensure_beatmap_exists(db: Database, fetcher, redis, beatmap_id: int) -> Dict[str, Any]:
+async def _ensure_beatmap_exists(db: Database, fetcher, redis, beatmap_id: int) -> dict[str, Any]:
     """
     确保谱面存在（包括元数据和原始文件缓存）。
-    
+
     Args:
         db: 数据库会话
         fetcher: API获取器
         redis: Redis连接
         beatmap_id: 谱面ID
-        
+
     Returns:
         Dict: 包含状态信息的响应
     """
     try:
         # 1. 确保谱面元数据存在于数据库中
         from app.database.beatmap import Beatmap
+
         beatmap = await Beatmap.get_or_fetch(db, fetcher, bid=beatmap_id)
-        
+
         if not beatmap:
-            return {
-                "success": False,
-                "error": f"Beatmap {beatmap_id} not found",
-                "beatmap_id": beatmap_id
-            }
-        
+            return {"success": False, "error": f"Beatmap {beatmap_id} not found", "beatmap_id": beatmap_id}
+
         # 2. 预缓存谱面原始文件
         cache_key = f"beatmap:{beatmap_id}:raw"
         cached = await redis.exists(cache_key)
-        
+
         if not cached:
             # 异步预加载原始文件到缓存
             try:
@@ -404,42 +387,34 @@ async def _ensure_beatmap_exists(db: Database, fetcher, redis, beatmap_id: int)
             except Exception as e:
                 logger.debug(f"Warning: Failed to cache raw beatmap {beatmap_id}: {e}")
                 # 即使原始文件缓存失败，也认为确保操作成功（因为元数据已存在）
-        
+
         return {
             "success": True,
             "beatmap_id": beatmap_id,
             "metadata_cached": True,
             "raw_file_cached": await redis.exists(cache_key),
-            "beatmap_title": f"{beatmap.beatmapset.artist} - {beatmap.beatmapset.title} [{beatmap.version}]"
+            "beatmap_title": f"{beatmap.beatmapset.artist} - {beatmap.beatmapset.title} [{beatmap.version}]",
         }
-        
+
     except Exception as e:
         logger.debug(f"Error ensuring beatmap {beatmap_id}: {e}")
-        return {
-            "success": False,
-            "error": str(e),
-            "beatmap_id": beatmap_id
-        }
+        return {"success": False, "error": str(e), "beatmap_id": beatmap_id}
+
 
 async def _update_room_participant_count(db: Database, room_id: int) -> int:
     """更新房间参与者数量并返回当前数量。"""
     # 统计活跃参与者
     active_participants_result = await db.execute(
         select(RoomParticipatedUser.user_id).where(
-            RoomParticipatedUser.room_id == room_id,
-            col(RoomParticipatedUser.left_at).is_(None)
+            RoomParticipatedUser.room_id == room_id, col(RoomParticipatedUser.left_at).is_(None)
         )
     )
     active_participants = active_participants_result.all()
     count = len(active_participants)
-    
+
     # 更新房间参与者数量
-    await db.execute(
-        update(Room)
-        .where(col(Room.id) == room_id)
-        .values(participant_count=count)
-    )
-    
+    await db.execute(update(Room).where(col(Room.id) == room_id).values(participant_count=count))
+
     return count
 
 
@@ -447,7 +422,7 @@ async def _end_room_if_empty(db: Database, room_id: int) -> bool:
     """如果房间为空，则标记房间结束。返回是否结束了房间。"""
     # 检查房间是否还有活跃参与者
     participant_count = await _update_room_participant_count(db, room_id)
-    
+
     if participant_count == 0:
         # 房间为空，标记结束
         now = utcnow()
@@ -457,12 +432,12 @@ async def _end_room_if_empty(db: Database, room_id: int) -> bool:
             .values(
                 ends_at=now,
                 status=RoomStatus.IDLE,  # 或者使用 RoomStatus.ENDED 如果有这个状态
-                participant_count=0
+                participant_count=0,
             )
         )
         logger.debug(f"Room {room_id} ended automatically (no participants remaining)")
         return True
-    
+
     return False
 
 
@@ -474,32 +449,30 @@ async def _transfer_ownership_or_end_room(db: Database, room_id: int, leaving_us
         .where(
             col(RoomParticipatedUser.room_id) == room_id,
             col(RoomParticipatedUser.user_id) != leaving_user_id,
-            col(RoomParticipatedUser.left_at).is_(None)
+            col(RoomParticipatedUser.left_at).is_(None),
         )
         .order_by(col(RoomParticipatedUser.joined_at))  # 按加入时间排序
     )
     remaining_participants = remaining_result.all()
-    
+
     if remaining_participants:
         # 将房主权限转让给最早加入的用户
         new_owner_id = remaining_participants[0][0]  # 获取 user_id
-        await db.execute(
-            update(Room)
-            .where(col(Room.id) == room_id)
-            .values(host_id=new_owner_id)
-        )
+        await db.execute(update(Room).where(col(Room.id) == room_id).values(host_id=new_owner_id))
         logger.debug(f"Room {room_id} ownership transferred from {leaving_user_id} to {new_owner_id}")
         return False  # 房间继续存在
     else:
         # 没有其他参与者，结束房间
         return await _end_room_if_empty(db, room_id)
 
+
 # ===== API ENDPOINTS =====
 
+
 @router.post("/multiplayer/rooms")
 async def create_multiplayer_room(
     request: Request,
-    room_data: Dict[str, Any],
+    room_data: dict[str, Any],
     db: Database,
     timestamp: str = "",
 ) -> int:
@@ -508,10 +481,7 @@ async def create_multiplayer_room(
         # Verify request signature
         body = await request.body()
         if not verify_request_signature(request, str(timestamp), body):
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid request signature"
-            )
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid request signature")
 
         # Parse room data if string
         if isinstance(room_data, str):
@@ -532,13 +502,13 @@ async def create_multiplayer_room(
                 await server.batch_join_channel([host_user], channel, db)
             # Add playlist items
             await _add_playlist_items(db, room_id, room_data, host_user_id)
-            
+
             # Add host as participant
-            #await _add_host_as_participant(db, room_id, host_user_id)
-            
+            # await _add_host_as_participant(db, room_id, host_user_id)
+
             await db.commit()
             return room_id
-            
+
         except HTTPException:
             # Clean up room if playlist creation fails
             await db.delete(room)
@@ -546,18 +516,11 @@ async def create_multiplayer_room(
             raise
 
     except json.JSONDecodeError as e:
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=f"Invalid JSON: {str(e)}"
-        )
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=f"Invalid JSON: {e!s}")
     except HTTPException:
         raise
     except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to create room: {str(e)}"
-        )
-
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Failed to create room: {e!s}")
 
 
 @router.delete("/multiplayer/rooms/{room_id}/users/{user_id}")
@@ -567,36 +530,28 @@ async def remove_user_from_room(
     user_id: int,
     db: Database,
     timestamp: int = Query(..., description="Unix 时间戳（秒）", ge=0),
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Remove a user from a multiplayer room."""
     try:
         # Verify request signature
         body = await request.body()
         now = utcnow()
         if not verify_request_signature(request, str(timestamp), body):
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid request signature"
-            )
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid request signature")
 
         # 检查房间是否存在
-        room_result = await db.execute(
-            select(Room).where(col(Room.id) == room_id)
-        )
+        room_result = await db.execute(select(Room).where(col(Room.id) == room_id))
         room = room_result.scalar_one_or_none()
-        
+
         if room is None:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail="Room not found"
-            )
-        
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Room not found")
+
         room_owner_id = room.host_id
         room_status = room.status
         current_participant_count = room.participant_count
         ends_at = room.ends_at
         channel_id = room.channel_id
-        
+
         # 如果房间已经结束，直接返回
         if ends_at is not None:
             logger.debug(f"Room {room_id} is already ended")
@@ -604,11 +559,10 @@ async def remove_user_from_room(
 
         # 检查用户是否在房间中
         participant_result = await db.execute(
-            select(RoomParticipatedUser.id)
-            .where(
+            select(RoomParticipatedUser.id).where(
                 col(RoomParticipatedUser.room_id) == room_id,
                 col(RoomParticipatedUser.user_id) == user_id,
-                col(RoomParticipatedUser.left_at).is_(None)
+                col(RoomParticipatedUser.left_at).is_(None),
             )
         )
         participant_query = participant_result.first()
@@ -634,13 +588,13 @@ async def remove_user_from_room(
             .where(
                 col(RoomParticipatedUser.room_id) == room_id,
                 col(RoomParticipatedUser.user_id) == user_id,
-                col(RoomParticipatedUser.left_at).is_(None)
+                col(RoomParticipatedUser.left_at).is_(None),
             )
             .values(left_at=now)
         )
 
         room_ended = False
-        
+
         # 检查是否是房主离开
         if user_id == room_owner_id:
             logger.debug(f"Host {user_id} is leaving room {room_id}")
@@ -648,10 +602,10 @@ async def remove_user_from_room(
         else:
             # 不是房主离开，只需检查房间是否为空
             room_ended = await _end_room_if_empty(db, room_id)
-        
+
         await db.commit()
         logger.debug(f"Successfully removed user {user_id} from room {room_id}, room_ended: {room_ended}")
-        
+
         # ===== 新增：提交后，把用户从聊天频道移除；若房间已结束，清理内存频道 =====
         try:
             if channel_id:
@@ -660,17 +614,16 @@ async def remove_user_from_room(
                     server.channels.pop(int(channel_id), None)
         except Exception as e:
             logger.debug(f"[warn] failed to leave user {user_id} from channel {channel_id}: {e}")
-        
+
         return {"success": True, "room_ended": room_ended}
 
     except HTTPException:
         raise
     except Exception as e:
         await db.rollback()
-        logger.debug(f"Error removing user from room: {str(e)}")
+        logger.debug(f"Error removing user from room: {e!s}")
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to remove user from room: {str(e)}"
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Failed to remove user from room: {e!s}"
         )
 
 
@@ -681,32 +634,28 @@ async def add_user_to_room(
     user_id: int,
     db: Database,
     timestamp: str = "",
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Add a user to a multiplayer room."""
     logger.debug(f"Adding user {user_id} to room {room_id}")
-    
+
     # Get request body and parse user_data
     body = await request.body()
     user_data = None
     if body:
         try:
-            user_data = json.loads(body.decode('utf-8'))
+            user_data = json.loads(body.decode("utf-8"))
             logger.debug(f"Parsed user_data: {user_data}")
         except json.JSONDecodeError:
             logger.debug("Failed to parse user_data from request body")
             user_data = None
-    
+
     # Verify request signature
     if not verify_request_signature(request, timestamp, body):
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid request signature"
-        )
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid request signature")
 
     # 检查房间是否已结束
     room_result = await db.execute(
-        select(Room.id, Room.ends_at, Room.channel_id, Room.host_id)
-        .where(col(Room.id) == room_id)
+        select(Room.id, Room.ends_at, Room.channel_id, Room.host_id).where(col(Room.id) == room_id)
     )
     room_row = room_result.first()
     if not room_row:
@@ -763,10 +712,10 @@ async def ensure_beatmap_present(
     redis: Redis = Depends(get_redis),
     fetcher: Fetcher = Depends(get_fetcher),
     timestamp: str = "",
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
     确保谱面在服务器中存在（包括元数据和原始文件缓存）。
-    
+
     这个接口用于 osu-server-spectator 确保谱面文件在服务器端可用，
     避免在需要时才获取导致的延迟。
     """
@@ -774,20 +723,17 @@ async def ensure_beatmap_present(
         # Verify request signature
         body = await request.body()
         if not verify_request_signature(request, timestamp, body):
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Invalid request signature"
-            )
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid request signature")
 
         beatmap_id = beatmap_data.beatmap_id
         logger.debug(f"Ensuring beatmap {beatmap_id} is present")
 
         # 确保谱面存在
         result = await _ensure_beatmap_exists(db, fetcher, redis, beatmap_id)
-        
+
         # 提交数据库更改
         await db.commit()
-        
+
         logger.debug(f"Ensure beatmap {beatmap_id} result: {result}")
         return result
 
@@ -795,8 +741,7 @@ async def ensure_beatmap_present(
         raise
     except Exception as e:
         await db.rollback()
-        logger.debug(f"Error ensuring beatmap: {str(e)}")
+        logger.debug(f"Error ensuring beatmap: {e!s}")
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to ensure beatmap: {str(e)}"
-        )
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Failed to ensure beatmap: {e!s}"
+        )

app/router/notification/message.py

@@ -96,6 +96,7 @@ async def send_message(
     if channel_type == ChannelType.MULTIPLAYER:
         try:
             from app.dependencies.database import get_redis
+
             redis = get_redis()
             key = f"channel:{channel_id}:messages"
             key_type = await redis.type(key)
@@ -162,13 +163,9 @@ async def get_message(
 ):
     # 1) 查频道
     if channel.isdigit():
-        db_channel = (await session.exec(
-            select(ChatChannel).where(ChatChannel.channel_id == int(channel))
-        )).first()
+        db_channel = (await session.exec(select(ChatChannel).where(ChatChannel.channel_id == int(channel)))).first()
     else:
-        db_channel = (await session.exec(
-            select(ChatChannel).where(ChatChannel.name == channel)
-        )).first()
+        db_channel = (await session.exec(select(ChatChannel).where(ChatChannel.name == channel))).first()
 
     if db_channel is None:
         raise HTTPException(status_code=404, detail="Channel not found")
@@ -176,7 +173,6 @@ async def get_message(
     channel_id = db_channel.channel_id
 
     try:
-       
         messages = await redis_message_system.get_messages(channel_id, limit, since)
         if len(messages) >= 2 and messages[0].message_id > messages[-1].message_id:
             messages.reverse()
@@ -188,11 +184,7 @@ async def get_message(
 
     if since > 0 and until is None:
         # 向前加载新消息 → 直接 ASC
-        query = (
-            base.where(col(ChatMessage.message_id) > since)
-            .order_by(col(ChatMessage.message_id).asc())
-            .limit(limit)
-        )
+        query = base.where(col(ChatMessage.message_id) > since).order_by(col(ChatMessage.message_id).asc()).limit(limit)
         rows = (await session.exec(query)).all()
         resp = [await ChatMessageResp.from_db(m, session) for m in rows]
         # 已经 ASC，无需反转
@@ -202,9 +194,7 @@ async def get_message(
     if until is not None:
         # 用 DESC 取最近的更早消息，再反转为 ASC
         query = (
-            base.where(col(ChatMessage.message_id) < until)
-            .order_by(col(ChatMessage.message_id).desc())
-            .limit(limit)
+            base.where(col(ChatMessage.message_id) < until).order_by(col(ChatMessage.message_id).desc()).limit(limit)
         )
         rows = (await session.exec(query)).all()
         rows = list(rows)
@@ -221,7 +211,6 @@ async def get_message(
     return resp
 
 
-
 @router.put(
     "/chat/channels/{channel}/mark-as-read/{message}",
     status_code=204,

app/router/notification/server.py

@@ -76,20 +76,21 @@ class ChatServer:
     async def broadcast(self, channel_id: int, event: ChatEvent):
         users_in_channel = self.channels.get(channel_id, [])
         logger.info(f"Broadcasting to channel {channel_id}, users: {users_in_channel}")
-        
+
         # 如果频道中没有用户，检查是否是多人游戏频道
         if not users_in_channel:
             try:
                 async with with_db() as session:
-                    from sqlmodel import select
                     channel = await session.get(ChatChannel, channel_id)
                     if channel and channel.type == ChannelType.MULTIPLAYER:
-                        logger.warning(f"No users in multiplayer channel {channel_id}, message will not be delivered to anyone")
+                        logger.warning(
+                            f"No users in multiplayer channel {channel_id}, message will not be delivered to anyone"
+                        )
                         # 对于多人游戏房间，这可能是正常的（用户都离开了房间）
                         # 但我们仍然记录这个情况以便调试
             except Exception as e:
                 logger.error(f"Failed to check channel type for {channel_id}: {e}")
-        
+
         for user_id in users_in_channel:
             await self.send_event(user_id, event)
             logger.debug(f"Sent event to user {user_id} in channel {channel_id}")

app/router/v2/beatmapset.py

@@ -13,8 +13,8 @@ from app.dependencies.geoip import get_client_ip, get_geoip_helper
 from app.dependencies.user import get_client_user, get_current_user
 from app.fetcher import Fetcher
 from app.models.beatmap import SearchQueryModel
-from app.service.beatmap_download_service import BeatmapDownloadService
 from app.service.asset_proxy_helper import process_response_assets
+from app.service.beatmap_download_service import BeatmapDownloadService
 
 from .router import router
 
@@ -97,7 +97,7 @@ async def search_beatmapset(
     try:
         sets = await fetcher.search_beatmapset(query, cursor, redis)
         background_tasks.add_task(_save_to_db, sets)
-        
+
         # 处理资源代理
         processed_sets = await process_response_assets(sets, request)
         return processed_sets
@@ -121,7 +121,7 @@ async def lookup_beatmapset(
 ):
     beatmap = await Beatmap.get_or_fetch(db, fetcher, bid=beatmap_id)
     resp = await BeatmapsetResp.from_db(beatmap.beatmapset, session=db, user=current_user)
-    
+
     # 处理资源代理
     processed_resp = await process_response_assets(resp, request)
     return processed_resp

app/router/v2/room.py

@@ -56,20 +56,22 @@ async def get_all_rooms(
         db_category = category
     where_clauses: list[ColumnElement[bool]] = [col(Room.category) == db_category]
     now = utcnow()
-    
+
     if status is not None:
         where_clauses.append(col(Room.status) == status)
-    #print(mode, category, status, current_user.id)    
+    # print(mode, category, status, current_user.id)
     if mode == "open":
         # 修改为新的查询逻辑：状态为 idle 或 playing，starts_at 不为空，ends_at 为空
-        where_clauses.extend([
-            col(Room.status).in_([RoomStatus.IDLE, RoomStatus.PLAYING]),
-            col(Room.starts_at).is_not(None),
-            col(Room.ends_at).is_(None)
-        ])
-        #if category == RoomCategory.REALTIME:
+        where_clauses.extend(
+            [
+                col(Room.status).in_([RoomStatus.IDLE, RoomStatus.PLAYING]),
+                col(Room.starts_at).is_not(None),
+                col(Room.ends_at).is_(None),
+            ]
+        )
+        # if category == RoomCategory.REALTIME:
         #    where_clauses.append(col(Room.id).in_(MultiplayerHubs.rooms.keys()))
-            
+
     if mode == "participated":
         where_clauses.append(
             exists().where(
@@ -77,10 +79,10 @@ async def get_all_rooms(
                 col(RoomParticipatedUser.user_id) == current_user.id,
             )
         )
-        
+
     if mode == "owned":
         where_clauses.append(col(Room.host_id) == current_user.id)
-        
+
     if mode == "ended":
         where_clauses.append((col(Room.ends_at).is_not(None)) & (col(Room.ends_at) < now.replace(tzinfo=UTC)))
 
@@ -96,7 +98,7 @@ async def get_all_rooms(
         .unique()
         .all()
     )
-    #print("Retrieved rooms:", db_rooms)
+    # print("Retrieved rooms:", db_rooms)
     for room in db_rooms:
         resp = await RoomResp.from_db(room, db)
         resp.has_password = bool((room.password or "").strip())
@@ -424,4 +426,4 @@ async def get_room_events(
         playlist_items=playlist_items_resps,
         room=room_resp,
         user=user_resps,
-    )
+    )