qqmusic-api-python 0.1.0__py3-none-any.whl

qqmusic_api/utils/common.py

@@ -0,0 +1,140 @@
+import hashlib
+import json
+import random
+import time
+from pathlib import Path
+
+# 定义全局变量
+UUID_CHARS = "0123456789ABCDEF"
+CACHE_DIR = Path(__file__).resolve().parent.parent.parent / ".cache"
+DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+API_DIR = DATA_DIR / "api"
+
+# 确保缓存目录存在
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def get_cache_file(*args) -> str:
+    return str(CACHE_DIR.joinpath(*args))
+
+
+def get_api(field: str) -> dict:
+    path = API_DIR / f"{field.lower()}.json"
+    if path.exists():
+        with path.open() as f:
+            data = json.load(f)
+            return data
+    else:
+        return {}
+
+
+def random_string(length: int, chars: str = UUID_CHARS) -> str:
+    return "".join(random.choices(chars, k=length))
+
+
+def calc_md5(*multi_string) -> str:
+    md5 = hashlib.md5()
+    for s in multi_string:
+        md5.update(s if isinstance(s, bytes) else s.encode())
+    return md5.hexdigest()
+
+
+def hash33(s: str, h: int = 0) -> int:
+    for c in s:
+        h = (h << 5) + h + ord(c)
+    return 2147483647 & h
+
+
+def random_uuid() -> str:
+    uuid_format = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
+    return "".join(random.choice(UUID_CHARS) if c in "xy" else c for c in uuid_format)
+
+
+def random_searchID() -> str:
+    e = random.randint(1, 20)
+    t = e * 18014398509481984
+    n = random.randint(0, 4194304) * 4294967296
+    a = time.time()
+    r = round(a * 1000) % (24 * 60 * 60 * 1000)
+    return str(t + n + r)
+
+
+def parse_song_info(song_info: dict) -> dict:
+    # 解析专辑信息
+    album = {
+        "id": song_info["album"]["id"],
+        "mid": song_info["album"]["mid"],
+        "name": song_info["album"]["name"],
+        "time_public": song_info["album"].get("time_public", ""),
+    }
+    # 解析MV信息
+    mv = {
+        "id": song_info["mv"]["id"],
+        "name": song_info["mv"].get("name", ""),
+        "vid": song_info["mv"]["vid"],
+    }
+    # 解析歌手信息
+    singer = [
+        {
+            "id": s["id"],
+            "mid": s["mid"],
+            "name": s["name"],
+            "type": s.get("type"),
+            "uin": s.get("uin"),
+        }
+        for s in song_info["singer"]
+    ]
+    # 解析歌曲信息
+    info = {
+        "id": song_info["id"],
+        "mid": song_info["mid"],
+        "name": song_info["name"],
+        "title": song_info["title"],
+        "subTitle": song_info.get("subtitle", ""),
+        "language": song_info["language"],
+        "time_public": song_info.get("time_public", ""),
+        "tag": song_info.get("tag", ""),
+        "type": song_info["type"],
+        "album": album,
+        "mv": mv,
+        "singer": singer,
+    }
+    # 解析文件信息
+    file = {
+        "media_mid": song_info["file"]["media_mid"],
+        "new_0": song_info["file"]["size_new"][0],
+        "new_1": song_info["file"]["size_new"][1],
+        "new_2": song_info["file"]["size_new"][2],
+        "flac": song_info["file"]["size_flac"],
+        "ogg_192": song_info["file"]["size_192ogg"],
+        "ogg_96": song_info["file"]["size_96ogg"],
+        "mp3_320": song_info["file"]["size_320mp3"],
+        "mp3_128": song_info["file"]["size_128mp3"],
+        "aac_192": song_info["file"]["size_192aac"],
+        "aac_96": song_info["file"]["size_96aac"],
+        "aac_48": song_info["file"]["size_48aac"],
+    }
+    # 组装结果
+    result = {
+        "info": info,
+        "file": file,
+        "lyric": {
+            "match": song_info.get("lyric", ""),
+            "content": song_info.get("content", ""),
+        },
+        "pay": song_info.get("pay", {}),
+        "grp": [parse_song_info(song) for song in song_info.get("grp", [])],
+        "vs": song_info.get("vs", []),
+    }
+    return result
+
+
+def filter_data(data: dict) -> dict:
+    keys = [""]
+    for key in keys:
+        data.pop(key, "")
+    return data
+
+
+def singer_to_str(data: dict) -> str:
+    return "&".join([singer["name"] for singer in data["singer"]])

qqmusic_api/utils/credential.py

@@ -0,0 +1,92 @@
+from ..exceptions import (
+    CredentialNoMusicidException,
+    CredentialNoMusickeyException,
+    CredientialCanNotRefreshException,
+)
+
+
+class Credential:
+    def __init__(
+        self, musicid: str = "", musickey: str = "", refresh_key: str = "", **kwagrs
+    ):
+        self.musicid = musicid
+        self.musickey = musickey
+        self.refresh_key = refresh_key
+        self.login_type = 1 if "W_X" in musickey else 2
+
+        for key, value in kwagrs.items():
+            setattr(self, key, value)
+
+    def get_dict(self) -> dict:
+        cookies = {}
+        for key, value in self.__dict__.items():
+            if key not in cookies and value is not None:
+                cookies[key] = value
+        return cookies
+
+    def has_musicid(self) -> bool:
+        """
+        是否提供 musicid
+        """
+        return bool(self.musicid)
+
+    def has_musickey(self) -> bool:
+        """
+        是否提供 musickey
+        """
+        return bool(self.musickey)
+
+    def can_refresh(self) -> bool:
+        """
+        是否能刷新 Credential
+        """
+        return bool(self.refresh_key)
+
+    def raise_for_cannot_refresh(self):
+        """
+        无法刷新 Credential 时则抛出异常
+        """
+        if not self.can_refresh():
+            raise CredientialCanNotRefreshException()
+
+    def raise_for_no_musicid(self):
+        """
+        没有提供 musicid 时抛出异常
+        """
+        if not self.has_musicid():
+            raise CredentialNoMusicidException()
+
+    def raise_for_no_musickey(self):
+        """
+        没有提供 musickey 时抛出异常
+        """
+        if not self.has_musickey():
+            raise CredentialNoMusickeyException()
+
+    async def refresh(self):
+        """
+        刷新 cookies
+        """
+        from ..api.login import refresh_cookies
+
+        c = await refresh_cookies(self)
+        self.musicid = c.musicid
+        self.musickey = c.musickey
+        self.refresh_key = c.refresh_key
+
+    @classmethod
+    def from_cookies(cls, cookies: dict = {}) -> "Credential":
+        """
+        从 cookies 新建 Credential
+
+        Args:
+            cookies : Cookies.
+
+        Returns:
+            Credential: 凭据类
+        """
+        c = cls()
+        c.musicid = cookies["musicid"]
+        c.musickey = cookies["musickey"]
+        c.refresh_key = cookies["refresh_key"]
+        return c

qqmusic_api/utils/network.py

@@ -0,0 +1,249 @@
+import asyncio
+import atexit
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+import aiohttp
+
+from .. import settings
+from ..exceptions import ClientException, NetworkException
+from .credential import Credential
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 11.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36 Edg/116.0.1938.54",
+    "Referer": "https://y.qq.com",
+}
+
+__session_pool: dict[asyncio.AbstractEventLoop, aiohttp.ClientSession] = {}
+
+
+def get_aiohttp_session() -> aiohttp.ClientSession:
+    """
+    获取当前模块的 aiohttp.ClientSession 对象，用于自定义请求
+
+    Returns:
+        aiohttp.ClientSession
+    """
+    loop = asyncio.get_event_loop()
+    session = __session_pool.get(loop, None)
+    if session is None:
+        session = aiohttp.ClientSession(
+            loop=loop, connector=aiohttp.TCPConnector(), trust_env=True
+        )
+        __session_pool[loop] = session
+
+    return session
+
+
+@dataclass
+class Api:
+    """
+    用于请求的 Api 类
+
+    Args:
+        url: 请求地址. Defaults to API_URL
+        method: 请求方法
+        module: 请求模块. Defaults to ""
+        comment: 注释. Defaults to ""
+        verify: 是否验证凭据. Defaults to False
+        json_body: 是否使用 json 作为载荷. Defaults to False
+        data: 请求载荷. Defaults to {}
+        params: 请求参数. Defaults to {}
+        headers: 请求头. Defaults to {}
+        credential: 凭据. Defaults to Credential()
+        extra_common: 额外参数. Defaults to {}
+    """
+
+    method: str
+    module: str = ""
+    url: str = settings.API_URL
+    comment: str = ""
+    verify: bool = False
+    json_body: bool = False
+    data: dict = field(default_factory=dict)
+    params: dict = field(default_factory=dict)
+    headers: dict = field(default_factory=dict)
+    credential: Credential = field(default_factory=Credential)
+    extra_common: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not self.module:
+            self.method = self.method.upper()
+        else:
+            self.json_body = True
+        self.original_data = self.data.copy()
+        self.original_params = self.params.copy()
+        self.data = {k: "" for k in self.data.keys()}
+        self.params = {k: "" for k in self.params.keys()}
+        self.headers = {k: "" for k in self.headers.keys()}
+        self.extra_common = {k: "" for k in self.extra_common.keys()}
+        self.__result: str | dict | None = None
+
+    def __setattr__(self, __name: str, __value: Any) -> None:
+        """
+        每次更新参数都要把 __result 清除
+        """
+        if self.initialized and __name != "_Api__result":
+            self.__result = None
+        return super().__setattr__(__name, __value)
+
+    @property
+    def initialized(self):
+        return "_Api__result" in self.__dict__
+
+    @property
+    async def result(self) -> dict | None:
+        """
+        获取请求结果
+        """
+        if self.__result is None:
+            self.__result = await self.request()
+        return self.__result
+
+    def update_params(self, **kwargs) -> "Api":
+        """
+        毫无亮点的更新 params
+        """
+        self.params = kwargs
+        self.__result = None
+        return self
+
+    def update_data(self, **kwargs) -> "Api":
+        """
+        毫无亮点的更新 data
+        """
+        self.data = kwargs
+        self.__result = None
+        return self
+
+    def update_headers(self, **kwargs) -> "Api":
+        """
+        毫无亮点的更新 headers
+        """
+        self.headers = kwargs
+        self.__result = None
+        return self
+
+    def update_extra_common(self, **kwargs) -> "Api":
+        """
+        毫无亮点的更新 extra_common
+        """
+        self.extra_common = kwargs
+        self.__result = None
+        return self
+
+    def __prepare_params_data(self) -> None:
+        """
+        准备请求参数
+        """
+        new_params, new_data = {}, {}
+        for key, value in self.params.items():
+            if isinstance(value, bool):
+                new_params[key] = int(value)
+            elif value is not None:
+                new_params[key] = value
+        for key, value in self.data.items():
+            if isinstance(value, bool):
+                new_params[key] = int(value)
+            elif value is not None:
+                new_data[key] = value
+        self.params, self.data = new_params, new_data
+
+    def __prepare_api_data(self) -> None:
+        """
+        准备API请求数据
+        """
+        common = {
+            "ct": "11",
+            "cv": settings.QQMUSIC_VERSION_CODE,
+            "v": settings.QQMUSIC_VERSION_CODE,
+            "tmeAppID": "qqmusic",
+            "QIMEI36": settings.QIMEI36,
+            "uid": settings.UID,
+            "format": "json",
+            "inCharset": "utf-8",
+            "outCharset": "utf-8",
+        }
+
+        if self.verify:
+            self.credential.raise_for_no_musickey()
+            self.credential.raise_for_no_musicid()
+
+            common["qq"] = self.credential.musicid
+            common["authst"] = self.credential.musickey
+            common["tmeLoginType"] = str(self.credential.login_type)
+
+        common.update(self.extra_common)
+
+        data = {
+            "comm": common,
+            "request": {
+                "module": self.module,
+                "method": self.method,
+                "param": self.params,
+            },
+        }
+        self.data = data
+
+    def __prepare_request(self) -> dict:
+        """
+        准备请求配置参数
+        """
+        config = {
+            "url": self.url,
+            "method": self.method,
+            "data": self.data,
+            "params": self.params,
+            "headers": HEADERS.copy() if len(self.headers) == 0 else self.headers,
+        }
+        if self.json_body:
+            config["headers"]["Content-Type"] = "application/json"
+            config["data"] = json.dumps(config["data"], ensure_ascii=False).encode()
+        if self.module:
+            config["method"] = "POST"
+            config["params"] = ""
+        return config
+
+    async def request(self) -> dict | None:
+        """
+        向接口发送请求
+        """
+        if self.module:
+            self.__prepare_api_data()
+        self.__prepare_params_data()
+        config = self.__prepare_request()
+        session = get_aiohttp_session()
+        try:
+            async with session.request(**config) as resp:
+                try:
+                    resp.raise_for_status()
+                except aiohttp.ClientResponseError as e:
+                    raise NetworkException(e.status, e.message)
+                return self.__process_response(resp, await resp.text())
+        except aiohttp.client_exceptions.ClientConnectorError:
+            raise ClientException()
+
+    def __process_response(
+        self, resp: aiohttp.ClientResponse, resp_text: str
+    ) -> dict | None:
+        content_length = resp.headers.get("content-length")
+        if content_length and int(content_length) == 0:
+            return None
+        try:
+            resp_data = json.loads(resp_text)
+            if self.module:
+                request_data = resp_data["request"]
+                return request_data["data"]
+            return resp_data
+        except Exception:
+            return None
+
+
+@atexit.register
+def __clean() -> None:
+    """
+    程序退出清理操作。
+    """
+    for session in __session_pool.values():
+        asyncio.run(session.close())