refactor(router): restructure

app/router/v2/beatmap.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+
+from app.calculator import calculate_beatmap_attribute
+from app.database import Beatmap, BeatmapResp, User
+from app.dependencies.database import get_db, get_redis
+from app.dependencies.fetcher import get_fetcher
+from app.dependencies.user import get_current_user
+from app.fetcher import Fetcher
+from app.models.beatmap import BeatmapAttributes
+from app.models.mods import APIMod, int_to_mods
+from app.models.score import (
+    INT_TO_MODE,
+    GameMode,
+)
+
+from .router import router
+
+from fastapi import Depends, HTTPException, Query, Security
+from httpx import HTTPError, HTTPStatusError
+from pydantic import BaseModel
+from redis.asyncio import Redis
+import rosu_pp_py as rosu
+from sqlmodel import col, select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+
+@router.get("/beatmaps/lookup", tags=["beatmap"], response_model=BeatmapResp)
+async def lookup_beatmap(
+    id: int | None = Query(default=None, alias="id"),
+    md5: str | None = Query(default=None, alias="checksum"),
+    filename: str | None = Query(default=None, alias="filename"),
+    current_user: User = Security(get_current_user, scopes=["public"]),
+    db: AsyncSession = Depends(get_db),
+    fetcher: Fetcher = Depends(get_fetcher),
+):
+    if id is None and md5 is None and filename is None:
+        raise HTTPException(
+            status_code=400,
+            detail="At least one of 'id', 'checksum', or 'filename' must be provided.",
+        )
+    try:
+        beatmap = await Beatmap.get_or_fetch(db, fetcher, bid=id, md5=md5)
+    except HTTPError:
+        raise HTTPException(status_code=404, detail="Beatmap not found")
+
+    if beatmap is None:
+        raise HTTPException(status_code=404, detail="Beatmap not found")
+
+    return await BeatmapResp.from_db(beatmap, session=db, user=current_user)
+
+
+@router.get("/beatmaps/{bid}", tags=["beatmap"], response_model=BeatmapResp)
+async def get_beatmap(
+    bid: int,
+    current_user: User = Security(get_current_user, scopes=["public"]),
+    db: AsyncSession = Depends(get_db),
+    fetcher: Fetcher = Depends(get_fetcher),
+):
+    try:
+        beatmap = await Beatmap.get_or_fetch(db, fetcher, bid)
+        return await BeatmapResp.from_db(beatmap, session=db, user=current_user)
+    except HTTPError:
+        raise HTTPException(status_code=404, detail="Beatmap not found")
+
+
+class BatchGetResp(BaseModel):
+    beatmaps: list[BeatmapResp]
+
+
+@router.get("/beatmaps", tags=["beatmap"], response_model=BatchGetResp)
+@router.get("/beatmaps/", tags=["beatmap"], response_model=BatchGetResp)
+async def batch_get_beatmaps(
+    b_ids: list[int] = Query(alias="ids[]", default_factory=list),
+    current_user: User = Security(get_current_user, scopes=["public"]),
+    db: AsyncSession = Depends(get_db),
+    fetcher: Fetcher = Depends(get_fetcher),
+):
+    if not b_ids:
+        # select 50 beatmaps by last_updated
+        beatmaps = (
+            await db.exec(
+                select(Beatmap).order_by(col(Beatmap.last_updated).desc()).limit(50)
+            )
+        ).all()
+    else:
+        beatmaps = list(
+            (
+                await db.exec(
+                    select(Beatmap).where(col(Beatmap.id).in_(b_ids)).limit(50)
+                )
+            ).all()
+        )
+        not_found_beatmaps = [
+            bid for bid in b_ids if bid not in [bm.id for bm in beatmaps]
+        ]
+        beatmaps.extend(
+            beatmap
+            for beatmap in await asyncio.gather(
+                *[
+                    Beatmap.get_or_fetch(db, fetcher, bid=bid)
+                    for bid in not_found_beatmaps
+                ],
+                return_exceptions=True,
+            )
+            if isinstance(beatmap, Beatmap)
+        )
+        for beatmap in beatmaps:
+            await db.refresh(beatmap)
+
+    return BatchGetResp(
+        beatmaps=[
+            await BeatmapResp.from_db(bm, session=db, user=current_user)
+            for bm in beatmaps
+        ]
+    )
+
+
+@router.post(
+    "/beatmaps/{beatmap}/attributes",
+    tags=["beatmap"],
+    response_model=BeatmapAttributes,
+)
+async def get_beatmap_attributes(
+    beatmap: int,
+    current_user: User = Security(get_current_user, scopes=["public"]),
+    mods: list[str] = Query(default_factory=list),
+    ruleset: GameMode | None = Query(default=None),
+    ruleset_id: int | None = Query(default=None),
+    redis: Redis = Depends(get_redis),
+    db: AsyncSession = Depends(get_db),
+    fetcher: Fetcher = Depends(get_fetcher),
+):
+    mods_ = []
+    if mods and mods[0].isdigit():
+        mods_ = int_to_mods(int(mods[0]))
+    else:
+        for i in mods:
+            try:
+                mods_.append(json.loads(i))
+            except json.JSONDecodeError:
+                mods_.append(APIMod(acronym=i, settings={}))
+    mods_.sort(key=lambda x: x["acronym"])
+    if ruleset_id is not None and ruleset is None:
+        ruleset = INT_TO_MODE[ruleset_id]
+    if ruleset is None:
+        beatmap_db = await Beatmap.get_or_fetch(db, fetcher, beatmap)
+        ruleset = beatmap_db.mode
+    key = (
+        f"beatmap:{beatmap}:{ruleset}:"
+        f"{hashlib.md5(str(mods_).encode()).hexdigest()}:attributes"
+    )
+    if await redis.exists(key):
+        return BeatmapAttributes.model_validate_json(await redis.get(key))  # pyright: ignore[reportArgumentType]
+
+    try:
+        resp = await fetcher.get_or_fetch_beatmap_raw(redis, beatmap)
+        try:
+            attr = await asyncio.get_event_loop().run_in_executor(
+                None, calculate_beatmap_attribute, resp, ruleset, mods_
+            )
+        except rosu.ConvertError as e:  # pyright: ignore[reportAttributeAccessIssue]
+            raise HTTPException(status_code=400, detail=str(e))
+        await redis.set(key, attr.model_dump_json())
+        return attr
+    except HTTPStatusError:
+        raise HTTPException(status_code=404, detail="Beatmap not found")