feat: sign-server

Author: ikun0014

api/gcsp_handler.py

@@ -1,6 +1,6 @@
 import zlib
 import time
-import ujson
+from utils import orjson
 import modules
 import binascii
 
@@ -44,10 +44,10 @@ async def getKuwoOldInfo(request: Request, songId: int):
 @router.api_route("/client/cgi-bin/{method}", methods=["GET", "POST"])
 async def GcspApi(request: Request, method: str) -> Response:
     try:
-        PACKAGE = config.read("module.gcsp.package_md5")
-        SALT_1 = config.read("module.gcsp.salt_1")
-        SALT_2 = config.read("module.gcsp.salt_2")
-        NEED_VERIFY = config.read("module.gcsp.enable_verify")
+        PACKAGE = config.read("modules.gcsp.package_md5")
+        SALT_1 = config.read("modules.gcsp.salt_1")
+        SALT_2 = config.read("modules.gcsp.salt_2")
+        NEED_VERIFY = config.read("modules.gcsp.enable_verify")
 
         qm = {
             "mp3": "128k",
@@ -66,7 +66,7 @@ async def GcspApi(request: Request, method: str) -> Response:
         }
 
         def decode(indata: bytes) -> dict:
-            return ujson.loads(binascii.unhexlify(zlib.decompress(indata)))
+            return orjson.loads(binascii.unhexlify(zlib.decompress(indata)))
 
         def verify(data: dict) -> str:
             if not NEED_VERIFY:
@@ -75,8 +75,8 @@ def verify(data: dict) -> str:
             sign_1 = createMD5(PACKAGE + data["time"] + SALT_2)
             sign_2 = createMD5(
                 str(
-                    ujson.dumps(data["text_1"])
-                    + ujson.dumps(data["text_2"])
+                    orjson.dumps(data["text_1"])
+                    + orjson.dumps(data["text_2"])
                     + sign_1
                     + data["time"]
                     + SALT_1
@@ -101,38 +101,34 @@ async def handleGcspBody(body: bytes):
 
             if result != "success":
                 compressed_data = zlib.compress(
-                    ujson.dumps(
+                    orjson.dumps(
                         {
                             "code": "403",
                             "error_msg": internal_trans[result],
                             "data": None,
                         },
-                        ensure_ascii=False,
                     ).encode("utf-8")
                 )
                 return Response(
                     content=compressed_data,
                     media_type="application/octet-stream",
                 )
 
-            data["te"] = ujson.loads(data["text_1"])
+            data["te"] = orjson.loads(data["text_1"])
 
             body = await modules.getUrlForAPI(
                 pm[data["te"]["platform"]], data["te"]["t1"], qm[data["te"]["t2"]]
             )
 
             if body["code"] != 200:
-                data = ujson.dumps(
-                    {"code": "403", "error_msg": body["message"]}, ensure_ascii=False
-                )
+                data = orjson.dumps({"code": "403", "error_msg": body["message"]})
             else:
-                data = ujson.dumps(
+                data = orjson.dumps(
                     {
                         "code": "200",
                         "error_msg": "success",
                         "data": body["url"] if body["code"] == 200 else None,
                     },
-                    ensure_ascii=False,
                 )
 
             compressed_data = zlib.compress(data.encode("utf-8"))
@@ -152,14 +148,14 @@ async def handleGcspBody(body: bytes):
                 body = {
                     "code": "200",
                     "data": {
-                        "version": config.read("module.gcsp.update.ver"),
-                        "update_title": config.read("module.gcsp.update.title"),
-                        "update_log": config.read("module.gcsp.update.logs"),
-                        "down_url": config.read("module.gcsp.update.down_url"),
-                        "share_url": config.read("module.gcsp.update.pan_url"),
+                        "version": config.read("modules.gcsp.update.ver"),
+                        "update_title": config.read("modules.gcsp.update.title"),
+                        "update_log": config.read("modules.gcsp.update.logs"),
+                        "down_url": config.read("modules.gcsp.update.down_url"),
+                        "share_url": config.read("modules.gcsp.update.pan_url"),
                         "compulsory": (
                             "yes"
-                            if config.read("module.gcsp.update.required")
+                            if config.read("modules.gcsp.update.required")
                             else "no"
                         ),
                         "file_md5": PACKAGE,

api/music_handler.py

@@ -1,11 +1,7 @@
 import modules
 from fastapi import Request
 from fastapi.routing import APIRouter
-from modules.url.tx import getEncryptedUrl
-from server.exceptions import getSongInfoFailed, getUrlFailed
-from server.config import cache
 from utils.response import handleResponse
-from server.models import UrlResponse
 
 router = APIRouter()
 
@@ -35,35 +31,3 @@ async def handleLyric(request: Request, source: str, songId: str | int):
 
     result = await modules.getLyricForAPI(source, songId)
     return handleResponse(request, result)
-
-
-@router.get("/eurl")
-async def handleEncryptSongUrl(request: Request, songId: str | int, quality: str):
-    try:
-        cache_data = cache.get("eurl", f"{songId}_{quality}")
-        result = UrlResponse(**cache_data)
-        print(
-            f"获取缓存的Encrypt_QM_{songId}_{quality}成功, URL: {result.url}, Ekey: {result.ekey:10}"
-        )
-        return handleResponse(
-            request,
-            {"code": 200, "message": "成功", "url": result.url, "ekey": result.ekey},
-        )
-    except:
-        pass
-
-    try:
-        result = await getEncryptedUrl(songId, quality)
-        print(
-            f"获取Encrypt_QM_{songId}_{quality}成功, URL: {result.url}, Ekey: {result.ekey:10}"
-        )
-        cache.set("eurl", f"{songId}_{quality}", result.__dict__, 600)
-        print(f"缓存已更新: Encrypt_QM_{songId}_{quality}")
-        return handleResponse(
-            request,
-            {"code": 200, "message": "成功", "url": result.url, "ekey": result.ekey},
-        )
-    except getUrlFailed as e:
-        return handleResponse(request, {"code": 500, "message": f"获取链接失败：{e}"})
-    except getSongInfoFailed as e:
-        return handleResponse(request, {"code": 500, "message": f"获取详情失败：{e}"})

api/script_handler.py

@@ -1,5 +1,5 @@
 import re
-import ujson
+from utils import orjson
 from fastapi import APIRouter, Request, Response
 from server.config import config
 from utils.response import handleResponse
@@ -11,7 +11,7 @@
 @router.get("/script")
 async def lx_script(request: Request, key: str | None = None):
     try:
-        with open(f"./static/lx-source.js", "r", encoding="utf-8") as f:
+        with open("./static/lx-source.js", "r", encoding="utf-8") as f:
             script = f.read()
     except:
         return handleResponse(request, {"code": 404, "message": "本地无源脚本"})
@@ -26,7 +26,7 @@ async def lx_script(request: Request, key: str | None = None):
         if line.startswith("const API_URL"):
             newScriptLines.append(f'''const API_URL = "{url}"''')
         elif line.startswith("const API_KEY"):
-            newScriptLines.append(f'''const API_KEY = "{key if key else ''}"''')
+            newScriptLines.append(f'''const API_KEY = "{key if key else ""}"''')
         elif line.startswith("* @name"):
             newScriptLines.append(" * @name " + config.read("script.name"))
         elif line.startswith("* @description"):
@@ -50,7 +50,7 @@ async def lx_script(request: Request, key: str | None = None):
 
     r = re.sub(
         r"const MUSIC_QUALITY = {[^}]+}",
-        f"const MUSIC_QUALITY = JSON.parse('{ujson.dumps(config.read('script.qualitys'))}')",
+        f"const MUSIC_QUALITY = JSON.parse('{orjson.dumps(config.read('script.qualitys'))}')",
         r,
     )
 
@@ -85,10 +85,12 @@ async def lx_script(request: Request, key: str | None = None):
         content=r,
         media_type="text/javascript",
         headers={
-            "Content-Disposition": f"""attachment; filename={(
-                config.read('script.file') 
-                if config.read('script.file').endswith('.js') 
-                else config.read('script.file') + '.js'
-            )}"""
+            "Content-Disposition": f"""attachment; filename={
+                (
+                    config.read("script.file")
+                    if config.read("script.file").endswith(".js")
+                    else config.read("script.file") + ".js"
+                )
+            }"""
         },
     )

main.py

@@ -1,10 +1,5 @@
-try:
-    from fastapi import FastAPI
-    from fastapi import Request
-    from shared import Dossier, HOME
-except:
-    raise ImportError("Please run 'uv sync' to install packages.")
-
+from fastapi import FastAPI
+from fastapi import Request
 import asyncio
 from pathlib import Path
 from api import home_handler, gcsp_handler, script_handler, music_handler
@@ -24,16 +19,12 @@ async def clean():
     if variable.http_client:
         await variable.http_client.connector.close()
         await variable.http_client.close()
-
-    path = Path(HOME, "my_dossier")
-    dossier = Dossier(path)
-    dossier.set("registered", {"ok": False})
-
     logger.info("等待部分进程暂停...")
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
+    log.intercept_print()
     await scheduler.run()
 
     yield
@@ -67,13 +58,13 @@ async def lifespan(app: FastAPI):
 app.include_router(home_handler.router)
 app.include_router(script_handler.router)
 app.include_router(music_handler.router)
-if config.read("module.gcsp.enable"):
+if config.read("modules.gcsp.enable"):
     app.include_router(gcsp_handler.router)
 
 
 @app.exception_handler(Exception)
 async def globalErrorHandler(request: Request, exc: Exception):
-    logger.error(f"未处理的异常")
+    logger.error("未处理的异常")
     return {"code": 500, "message": f"未处理的异常: {exc}"}
 
 

middleware/request_logger.py

@@ -31,7 +31,7 @@ async def dispatch(self, request: Request, call_next):
             ip_info = {"local": "Unknown"}
 
         logger.info(
-            f"请求: {request.method} - {request.state.remote_addr} - "
+            f"收到请求: {request.method} - {request.state.remote_addr} - "
             f"{ip_info['local']} - {request.url.path} - "
             f"{request.headers.get('User-Agent', '')} - "
         )

modules/info/tx.py

@@ -1,33 +1,27 @@
 from modules.plat.tx.utils import signRequest
-from modules.plat.tx import build_common_params
+from modules.plat.tx import build_comm
 from server.models import SongInfo
 from server.exceptions import getSongInfoFailed
-from modules.plat import formatPlayTime, formatSinger
-from modules.lyric.tx import getLyric
+from modules.plat import formatSinger
 
 
 async def IdGetInfo(songid: int) -> SongInfo:
-    commonParams = await build_common_params()
-    infoReqBody = {
-        "comm": commonParams,
+    comm = await build_comm()
+    reqBody = {
+        "comm": comm,
         "req": {
             "module": "music.trackInfo.UniformRuleCtrl",
             "method": "CgiGetTrackInfo",
             "param": {"types": [1], "ids": [songid], "ctx": 0},
         },
     }
-    infoRequest = await signRequest(infoReqBody)
-    infoBody = infoRequest.json()
+    resp = await signRequest(reqBody)
+    respBody = resp.json()
 
-    if infoBody["code"] != 0 or infoBody["req"]["code"] != 0:
+    if respBody["code"] != 0 or respBody["req"]["code"] != 0:
         raise getSongInfoFailed("获取音乐信息失败")
 
-    info = infoBody["req"]["data"]["tracks"][0]
-
-    try:
-        lyric = await getLyric(info["id"])
-    except:
-        lyric = None
+    info = respBody["req"]["data"]["tracks"][0]
 
     return SongInfo(
         songId=info.get("id"),
@@ -40,38 +34,29 @@ async def IdGetInfo(songid: int) -> SongInfo:
         ),
         albumId=info.get("album", {}).get("id"),
         albumMid=info.get("album", {}).get("mid"),
-        duration=(
-            formatPlayTime(info.get("interval"))
-            if info.get("interval") is not None
-            else None
-        ),
+        duration=info.get("interval", 0),
         mediaMid=info.get("file", {}).get("media_mid"),
-        lyric=lyric,
     )
 
 
 async def MidGetInfo(mid: str) -> SongInfo:
-    commonParams = await build_common_params()
-    infoReqBody = {
-        "comm": commonParams,
+    comm = await build_comm()
+    reqBody = {
+        "comm": comm,
         "req": {
             "method": "get_song_detail_yqq",
             "param": {"song_type": 0, "song_mid": mid},
             "module": "music.pf_song_detail_svr",
         },
     }
-    infoRequest = await signRequest(infoReqBody)
-    infoBody = infoRequest.json()
 
-    if infoBody["code"] != 0 or infoBody["req"]["code"] != 0:
-        raise getSongInfoFailed("获取音乐信息失败")
+    resp = await signRequest(reqBody)
+    respBody = resp.json()
 
-    info = infoBody["req"]["data"]["track_info"]
+    if respBody["code"] != 0 or respBody["req"]["code"] != 0:
+        raise getSongInfoFailed("获取音乐信息失败")
 
-    try:
-        lyric = await getLyric(info["id"])
-    except:
-        lyric = None
+    info = respBody["req"]["data"]["track_info"]
 
     return SongInfo(
         songId=info.get("id"),
@@ -84,13 +69,8 @@ async def MidGetInfo(mid: str) -> SongInfo:
         ),
         albumId=info.get("album", {}).get("id"),
         albumMid=info.get("album", {}).get("mid"),
-        duration=(
-            formatPlayTime(info.get("interval"))
-            if info.get("interval") is not None
-            else None
-        ),
+        duration=info.get("interval", 0),
         mediaMid=info.get("file", {}).get("media_mid"),
-        lyric=lyric,
     )
 
 

modules/info/wy.py

@@ -1,4 +1,4 @@
-import ujson
+from utils import orjson
 from modules.lyric.wy import getLyric
 from modules.plat.wy import eEncrypt
 from server.models import SongInfo
@@ -11,7 +11,7 @@ async def getMusicInfo(songId: str):
     path = "/api/v3/song/detail"
     url = "http://interface.music.163.com/eapi/v3/song/detail"
     params = {
-        "c": [ujson.dumps({"id": songId})],
+        "c": [orjson.dumps({"id": songId})],
         "ids": [songId],
     }
     infoRequest = await HttpRequest(