feat(fetcher): add data fetcher

app/config.py

@@ -36,5 +36,13 @@ class Settings:
     SIGNALR_NEGOTIATE_TIMEOUT: int = int(os.getenv("SIGNALR_NEGOTIATE_TIMEOUT", "30"))
     SIGNALR_PING_INTERVAL: int = int(os.getenv("SIGNALR_PING_INTERVAL", "120"))
 
+    # Fetcher 设置
+    FETCHER_CLIENT_ID: str = os.getenv("FETCHER_CLIENT_ID", "")
+    FETCHER_CLIENT_SECRET: str = os.getenv("FETCHER_CLIENT_SECRET", "")
+    FETCHER_SCOPES: list[str] = os.getenv("FETCHER_SCOPES", "public").split(",")
+    FETCHER_CALLBACK_URL: str = os.getenv(
+        "FETCHER_CALLBACK_URL", "http://localhost:8000/fetcher/callback"
+    )
+
 
 settings = Settings()

app/dependencies/fetcher.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from app.config import settings
+from app.dependencies.database import get_redis
+from app.fetcher import Fetcher
+
+fetcher: Fetcher | None = None
+
+
+def get_fetcher() -> Fetcher:
+    global fetcher
+    if fetcher is None:
+        fetcher = Fetcher(
+            settings.FETCHER_CLIENT_ID,
+            settings.FETCHER_CLIENT_SECRET,
+            settings.FETCHER_SCOPES,
+            settings.FETCHER_CALLBACK_URL,
+        )
+        redis = get_redis()
+        if redis:
+            access_token = redis.get(f"fetcher:access_token:{fetcher.client_id}")
+            if access_token:
+                fetcher.access_token = str(access_token)
+            refresh_token = redis.get(f"fetcher:refresh_token:{fetcher.client_id}")
+            if refresh_token:
+                fetcher.refresh_token = str(refresh_token)
+            if not fetcher.access_token or not fetcher.refresh_token:
+                print("Login to initialize fetcher:", fetcher.authorize_url)
+    return fetcher

app/fetcher/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from .beatmap import BeatmapFetcher
+from .beatmapset import BeatmapsetFetcher
+
+
+class Fetcher(BeatmapFetcher, BeatmapsetFetcher):
+    """A class that combines all fetchers for easy access."""
+
+    pass

app/fetcher/_base.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import time
+
+from app.dependencies.database import get_redis
+
+from httpx import AsyncClient
+
+
+class BaseFetcher:
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+        scope: list[str] = ["public"],
+        callback_url: str = "",
+    ):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.access_token: str = ""
+        self.refresh_token: str = ""
+        self.token_expiry: int = 0
+        self.callback_url: str = callback_url
+        self.scope = scope
+
+    @property
+    def authorize_url(self) -> str:
+        return (
+            f"https://osu.ppy.sh/oauth/authorize?client_id={self.client_id}"
+            f"&response_type=code&scope={' '.join(self.scope)}"
+            f"&redirect_uri={self.callback_url}"
+        )
+
+    @property
+    def header(self) -> dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/json",
+        }
+
+    def is_token_expired(self) -> bool:
+        return self.token_expiry <= int(time.time())
+
+    async def grant_access_token(self, code: str) -> None:
+        async with AsyncClient() as client:
+            response = await client.post(
+                "https://osu.ppy.sh/oauth/token",
+                data={
+                    "client_id": self.client_id,
+                    "client_secret": self.client_secret,
+                    "grant_type": "authorization_code",
+                    "redirect_uri": self.callback_url,
+                    "code": code,
+                },
+            )
+            response.raise_for_status()
+            token_data = response.json()
+            self.access_token = token_data["access_token"]
+            self.refresh_token = token_data.get("refresh_token", "")
+            self.token_expiry = int(time.time()) + token_data["expires_in"]
+            redis = get_redis()
+            if redis:
+                redis.set(
+                    f"fetcher:access_token:{self.client_id}",
+                    self.access_token,
+                    ex=token_data["expires_in"],
+                )
+                redis.set(
+                    f"fetcher:refresh_token:{self.client_id}",
+                    self.refresh_token,
+                )
+
+    async def refresh_access_token(self) -> None:
+        async with AsyncClient() as client:
+            response = await client.post(
+                "https://osu.ppy.sh/oauth/token",
+                data={
+                    "client_id": self.client_id,
+                    "client_secret": self.client_secret,
+                    "grant_type": "refresh_token",
+                    "refresh_token": self.refresh_token,
+                },
+            )
+            response.raise_for_status()
+            token_data = response.json()
+            self.access_token = token_data["access_token"]
+            self.refresh_token = token_data.get("refresh_token", "")
+            self.token_expiry = int(time.time()) + token_data["expires_in"]
+            redis = get_redis()
+            if redis:
+                redis.set(
+                    f"fetcher:access_token:{self.client_id}",
+                    self.access_token,
+                    ex=token_data["expires_in"],
+                )
+                redis.set(
+                    f"fetcher:refresh_token:{self.client_id}",
+                    self.refresh_token,
+                )

app/fetcher/beatmap.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from app.database.beatmap import BeatmapResp
+
+from ._base import BaseFetcher
+
+from httpx import AsyncClient
+
+
+class BeatmapFetcher(BaseFetcher):
+    async def get_beatmap(self, beatmap_id: int) -> BeatmapResp:
+        async with AsyncClient() as client:
+            response = await client.get(
+                f"https://osu.ppy.sh/api/v2/beatmaps/{beatmap_id}",
+                headers=self.header,
+            )
+            response.raise_for_status()
+            return BeatmapResp.model_validate(response.json())

app/fetcher/beatmapset.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from app.database.beatmapset import BeatmapsetResp
+
+from ._base import BaseFetcher
+
+from httpx import AsyncClient
+
+
+class BeatmapsetFetcher(BaseFetcher):
+    async def get_beatmap_set(self, beatmap_set_id: int) -> BeatmapsetResp:
+        async with AsyncClient() as client:
+            response = await client.get(
+                f"https://osu.ppy.sh/api/v2/beatmapsets/{beatmap_set_id}",
+                headers=self.header,
+            )
+            response.raise_for_status()
+            return BeatmapsetResp.model_validate(response.json())

app/router/__init__.py

@@ -7,6 +7,7 @@ from . import (  # pyright: ignore[reportUnusedImport]  # noqa: F401
 )
 from .api_router import router as api_router
 from .auth import router as auth_router
+from .fetcher import fetcher_router as fetcher_router
 from .signalr import signalr_router as signalr_router
 
-__all__ = ["api_router", "auth_router", "signalr_router"]
+__all__ = ["api_router", "auth_router", "fetcher_router", "signalr_router"]

app/router/fetcher.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from app.dependencies.fetcher import get_fetcher
+from app.fetcher import Fetcher
+
+from fastapi import APIRouter, Depends
+
+fetcher_router = APIRouter()
+
+
+@fetcher_router.get("/callback")
+async def callback(code: str, fetcher: Fetcher = Depends(get_fetcher)):
+    await fetcher.grant_access_token(code)
+    return {"message": "Login successful"}

main.py

@@ -5,7 +5,8 @@ from datetime import datetime
 
 from app.config import settings
 from app.dependencies.database import create_tables, engine
-from app.router import api_router, auth_router, signalr_router
+from app.dependencies.fetcher import get_fetcher
+from app.router import api_router, auth_router, fetcher_router, signalr_router
 
 from fastapi import FastAPI
 
@@ -17,6 +18,7 @@ from fastapi import FastAPI
 async def lifespan(app: FastAPI):
     # on startup
     await create_tables()
+    get_fetcher()  # 初始化 fetcher
     # on shutdown
     yield
     await engine.dispose()
@@ -25,6 +27,7 @@ async def lifespan(app: FastAPI):
 app = FastAPI(title="osu! API 模拟服务器", version="1.0.0", lifespan=lifespan)
 app.include_router(api_router, prefix="/api/v2")
 app.include_router(signalr_router, prefix="/signalr")
+app.include_router(fetcher_router, prefix="/fetcher")
 app.include_router(auth_router)
 
 

pyproject.toml

@@ -10,6 +10,7 @@ dependencies = [
     "bcrypt>=4.1.2",
     "cryptography>=41.0.7",
     "fastapi>=0.104.1",
+    "httpx>=0.28.1",
     "msgpack>=1.1.1",
     "passlib[bcrypt]>=1.7.4",
     "pydantic[email]>=2.5.0",

requirements.txt

@@ -2,8 +2,8 @@ aiomysql==0.2.0
 alembic==1.16.4
 annotated-types==0.7.0
 anyio==4.9.0
-async-timeout==5.0.1
 bcrypt==4.3.0
+certifi==2025.7.14
 cffi==1.17.1
 cfgv==3.4.0
 click==8.2.1
@@ -17,7 +17,9 @@ fastapi==0.116.1
 filelock==3.18.0
 greenlet==3.2.3
 h11==0.16.0
+httpcore==1.0.9
 httptools==0.6.4
+httpx==0.28.1
 identify==2.6.12
 idna==3.10
 mako==1.3.10
@@ -48,7 +50,6 @@ starlette==0.47.2
 typing-extensions==4.14.1
 typing-inspection==0.4.1
 uvicorn==0.35.0
-uvloop==0.21.0
 virtualenv==20.32.0
 watchfiles==1.1.0
-websockets==15.0.1
+websockets==15.0.1

test_api.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 import os
 
 from dotenv import load_dotenv
-import requests
+import httpx as requests
 
 # 加载 .env 文件
 load_dotenv()
@@ -173,7 +173,7 @@ def main():
     scores_data = get_beatmap_scores(token_data["access_token"], 1)
     if scores_data:
         print(f"谱面成绩总数: {len(scores_data['scores'])}")
-        if scores_data['userScore']:
+        if scores_data["userScore"]:
             print("用户在该谱面有成绩记录")
             print(f"用户成绩 ID: {scores_data['userScore']['id']}")
             print(f"用户成绩分数: {scores_data['userScore']['total_score']}")
@@ -196,4 +196,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()