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"}