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

qqmusic_api/api/search.py

@@ -0,0 +1,168 @@
+from enum import Enum
+
+from qqmusic_api.api.song import Song
+
+from ..utils.common import get_api, parse_song_info, random_searchID
+from ..utils.network import Api
+
+API = get_api("search")
+
+
+class SearchType(Enum):
+    """
+    搜索类型
+
+    + SONG:       歌曲
+    + SINGER:     歌手
+    + ALBUM:      专辑
+    + SONGLIST:   歌单
+    + MV:         MV
+    + LYRIC:      歌词
+    + USER:       用户
+    + AUDIO_SONG: 节目专辑
+    + AUDIO:      节目
+    """
+
+    SONG = 0
+    SINGER = 1
+    ALBUM = 2
+    SONGLIST = 3
+    MV = 4
+    LYRIC = 7
+    USER = 8
+    AUDIO_ALBUM = 15
+    AUDIO = 18
+
+
+async def hotkey() -> list[dict]:
+    """
+    获取热搜词
+
+    Returns:
+        list: 热搜词列表，k为热搜词，n为搜索量
+    """
+    params = {"search_id": random_searchID()}
+    res = await Api(**API["hotkey"]).update_params(**params).result
+    data = res.get("vec_hotkey", [])
+    return [{"k": hotkey["query"], "n": hotkey["score"]} for hotkey in data]
+
+
+async def complete(keyword: str, highlight: bool = False) -> list[str]:
+    """
+    搜索词补全
+
+    Args:
+        keyword:   关键词
+        highlight: 是否高亮关键词. Defaluts to False
+
+    Returns:
+        list: 补全结果
+    """
+    params = {
+        "search_id": random_searchID(),
+        "query": keyword,
+        "num_per_page": 0,
+        "page_idx": 0,
+    }
+    res = await Api(**API["complete"]).update_params(**params).result
+    data = res["items"]
+    if highlight:
+        return [item["hint_hilight"] for item in data]
+    else:
+        return [item["hint"] for item in data]
+
+
+async def quick_search(keyword: str) -> dict:
+    """
+    快速搜索
+
+    Args:
+        keyword: 关键词
+
+    Returns:
+        dict: 包含专辑，歌手，歌曲的简略信息
+    """
+    res = await Api(**API["quick_search"]).update_params(key=keyword).result
+    return res["data"]
+
+
+async def general_search(keyword: str, page: int = 1, highlight: bool = False) -> dict:
+    """
+    综合搜索
+
+    Args:
+        keyword:   关键词
+        page:      页码. Defaluts to 1
+        highlight: 是否高亮关键词. Defaluts to False
+
+    Returns:
+        dict: 包含直接结果，歌曲，歌手，专辑，歌单，mv等.
+    """
+    params = {
+        "search_id": random_searchID(),
+        "search_type": 100,
+        "query": keyword,
+        "page_id": page,
+        "highlight": highlight,
+        "grp": 1,
+    }
+    res = await Api(**API["general_search"]).update_params(**params).result
+    data = res["body"]
+    return {
+        "direct": data["direct_result"]["direct_group"],
+        "song": [parse_song_info(d) for d in data["item_song"]["items"]],
+        "singer": data["singer"]["items"],
+        "album": data["item_album"]["items"],
+        "songlist": data["item_songlist"]["items"],
+        "mv": data["item_mv"]["items"],
+    }
+
+
+async def search_by_type(
+    keyword: str,
+    search_type: SearchType = SearchType.SONG,
+    num: int = 10,
+    page: int = 1,
+    selectors: dict = {},
+    highlight: bool = False,
+) -> list[Song]:
+    """
+    搜索
+
+    Args:
+        keyword:     关键词
+        search_type: 搜索类型. Defaluts to SearchType.SONG
+        num:         返回数量. Defaluts to 10
+        page:        页码. Defaluts to 1
+        selectors:   选择器. Defaluts to {}
+        highlight:   是否高亮关键词. Defaluts to False
+
+    Returns:
+        list: 搜索结果.
+    """
+    params = {
+        "searchid": random_searchID(),
+        "query": keyword,
+        "search_type": search_type.value,
+        "num_per_page": num,
+        "page_num": page,
+        "highlight": highlight,
+        "page_id": page,
+        "selectors": selectors,
+    }
+    res = await Api(**API["desktop_search_by_type"]).update_params(**params).result
+    types = {
+        SearchType.SONG: "song",
+        SearchType.SINGER: "singer",
+        SearchType.ALBUM: "album",
+        SearchType.SONGLIST: "songlist",
+        SearchType.MV: "mv",
+        SearchType.LYRIC: "song",
+        SearchType.USER: "user",
+        SearchType.AUDIO_ALBUM: "album",
+        SearchType.AUDIO: "song",
+    }
+    data = res["body"][types[search_type]]["list"]
+    if search_type in [SearchType.SONG, SearchType.LYRIC, SearchType.AUDIO]:
+        return [Song.from_dict(song) for song in data]
+    return data

qqmusic_api/api/song.py

@@ -0,0 +1,389 @@
+from enum import Enum
+from typing import Optional
+
+from ..exceptions import ArgsException
+from ..utils.common import get_api, parse_song_info, random_string
+from ..utils.credential import Credential
+from ..utils.network import Api
+
+API = get_api("song")
+
+
+class SongFileType(Enum):
+    """
+    歌曲文件类型
+
+    + NEW_0:   臻品母带2.0
+    + NEW_1:   臻品全景声
+    + NEW_2:   臻品音质2.0
+    + FLAC:    无损音频压缩格式
+    + OGG_192: OGG 格式，192kbps
+    + OGG_96:  OGG 格式，96kbps
+    + MP3_320: MP3 格式，320kbps
+    + MP3_128: MP3 格式，128kbps
+    + ACC_192: AAC 格式，192kbps
+    + ACC_96:  AAC 格式，96kbps
+    + ACC_48:  AAC 格式，48kbps
+    + TRY:     试听文件
+    """
+
+    NEW_0 = ("AI00", ".flac")
+    NEW_1 = ("Q000", ".flac")
+    NEW_2 = ("Q001", ".flac")
+    FLAC = ("F000", ".flac")
+    OGG_192 = ("O600", ".ogg")
+    OGG_96 = ("O400", ".ogg")
+    MP3_320 = ("M800", ".mp3")
+    MP3_128 = ("M500", ".mp3")
+    ACC_192 = ("C600", ".m4a")
+    ACC_96 = ("C400", ".m4a")
+    ACC_48 = ("C200", ".m4a")
+    TRY = ("RS02", ".mp3")
+
+    def __init__(self, start_code: str, extension: str):
+        self.__start_code = start_code
+        self.__extension = extension
+
+    @property
+    def s(self) -> str:
+        return self.__start_code
+
+    @property
+    def e(self) -> str:
+        return self.__extension
+
+
+class UrlType(Enum):
+    """
+    歌曲文件链接类型
+    + PLAY:     播放链接
+    + DOWNLOAD: 下载链接
+    """
+
+    PLAY = "play_url"
+    DOWNLOAD = "download_url"
+
+
+class Song:
+    """
+    歌曲类
+    """
+
+    def __init__(
+        self,
+        mid: Optional[str] = None,
+        id: Optional[int] = None,
+        credential: Optional[Credential] = None,
+    ):
+        """
+        Args:
+            mid:        歌曲 mid. 歌曲 id 和歌曲 mid 必须提供其中之一
+            id:         歌曲 id. 歌曲 id 和歌曲 mid 必须提供其中之一
+            credential: Credential 类. Defaluts to None
+        """
+        # ID 检查
+        if mid is None and id is None:
+            raise ArgsException("请至少提供 mid 和 id 中的其中一个参数。")
+        self._mid = mid
+        self._id = id
+        self.credential = Credential() if credential is None else credential
+        self._info: Optional[dict] = None
+
+    @classmethod
+    def from_dict(cls, info: dict):
+        """
+        从字典新建 Song
+
+        Args:
+            info: 歌曲字典
+
+        Returns:
+            Song: 歌曲类
+        """
+        info = parse_song_info(info)
+        s = cls(id=info["info"]["id"], mid=info["info"]["mid"])
+        s._info = info
+        return s
+
+    async def __get_info(self):
+        """
+        获取歌曲必要信息
+        """
+        if not self._info:
+            if self._mid:
+                self._info = (await query_by_mid([self._mid]))[0]
+            elif self._id:
+                self._info = (await query_by_id([self._id]))[0]
+        return self._info
+
+    @property
+    async def mid(self) -> str:
+        """
+        获取歌曲 mid
+
+        Returns:
+            str: mid
+        """
+        if not self._mid:
+            self._mid = (await self.__get_info())["info"]["mid"]
+        return str(self._mid)
+
+    @property
+    async def id(self) -> int:
+        """
+        获取歌曲 id
+
+        Returns:
+            int: id
+        """
+        if not self._id:
+            self._id = (await self.__get_info())["info"]["id"]
+        return int(self._id)
+
+    async def __prepare_param(self, is_mid: bool = False, is_id: bool = False) -> dict:
+        """
+        准备请求参数
+
+        Args:
+            is_mid: 是否强制使用 mid. Defaults to False
+            is_id:  是否强制使用 id. Defaults to False
+
+        Returns:
+            dict: 请求参数
+        """
+        if is_mid and is_id:
+            raise ArgsException("参数错误")
+        if is_mid:
+            return {"songmid": await self.mid}
+        elif is_id:
+            return {"songid": await self.id}
+        elif self._mid:
+            return {"songmid": self._mid}
+        elif self._id:
+            return {"songid": self._id}
+        else:
+            return {}
+
+    async def get_info(self) -> dict:
+        """
+        获取歌曲基本信息
+
+        Returns:
+            dict: 基本信息
+        """
+        return (await self.__get_info())["info"]
+
+    async def get_detail(self) -> dict:
+        """
+        获取歌曲详细信息
+
+        Returns:
+            dict: 详细信息
+        """
+        param = await self.__prepare_param()
+        if "songmid" in param:
+            param["song_mid"] = param.pop("songmid")
+        if "songid" in param:
+            param["song_id"] = param.pop("songid")
+        return await Api(**API["detail"]).update_params(**param).result
+
+    async def get_similar_song(self) -> list[dict]:
+        """
+        获取歌曲相似歌曲
+
+        Returns:
+            list: 歌曲信息
+        """
+        param = await self.__prepare_param(is_id=True)
+        res = await Api(**API["similar"]).update_params(**param).result
+        return [parse_song_info(song["track"]) for song in res["vecSong"]]
+
+    async def get_labels(self) -> list[dict]:
+        """
+        获取歌曲标签
+
+        Returns:
+            list: 标签信息
+        """
+        param = await self.__prepare_param(is_id=True)
+        return (await Api(**API["labels"]).update_params(**param).result)["labels"]
+
+    async def get_related_playlist(self) -> list[dict]:
+        """
+        获取歌曲相关歌单
+
+        Returns:
+            list: 歌单信息
+        """
+        param = await self.__prepare_param(is_id=True)
+        return (await Api(**API["playlist"]).update_params(**param).result)[
+            "vecPlaylist"
+        ]
+
+    async def get_related_mv(self) -> list[dict]:
+        """
+        获取歌曲相关MV
+
+        Returns:
+            list: MV信息
+        """
+        param = await self.__prepare_param()
+        return (await Api(**API["mv"]).update_params(**param).result)["list"]
+
+    async def get_other_version(self) -> list[dict]:
+        """
+        获取歌曲其他版本
+
+        Returns:
+            list: 歌曲信息
+        """
+        param = await self.__prepare_param()
+        res = await Api(**API["other"]).update_params(**param).result
+        return [parse_song_info(song) for song in res["versionList"]]
+
+    async def get_sheet(self) -> list[dict]:
+        """
+        获取歌曲相关曲谱
+
+        Returns:
+            list: 曲谱信息
+        """
+        param = await self.__prepare_param(is_mid=True)
+        param["scoreType"] = -1
+        return (await Api(**API["sheet"]).update_params(**param).result)["result"]
+
+    async def get_producer(self) -> list[dict]:
+        """
+        获取歌曲制作信息
+
+        Returns:
+            list: 人员信息
+        """
+        param = await self.__prepare_param()
+        return (await Api(**API["producer"]).update_params(**param).result)["Lst"]
+
+    async def get_url(
+        self,
+        file_type: SongFileType = SongFileType.MP3_128,
+        url_type: UrlType = UrlType.PLAY,
+    ) -> dict[str, str]:
+        """
+        获取歌曲文件链接
+
+        Args:
+            file_type:  歌曲文件类型. Defaults to SongFileType.MP3_128
+            url_type:   歌曲链接类型. Defaults to UrlType.PLAY
+
+        Returns:
+            dict: 链接字典
+        """
+        return await get_song_urls([await self.mid], file_type, url_type)
+
+    async def get_file_size(self, file_type: Optional[SongFileType] = None) -> dict:
+        """
+        获取歌曲文件大小
+
+        Args:
+            file_type:  指定文件类型. Defaults to None
+
+        Return:
+            dict: 文件大小
+        """
+        size = (await self.__get_info())["file"]
+        if file_type:
+            name = file_type.name.lower()
+            size = {name: size[name]}
+        return size
+
+
+async def query_by_id(id: list[int]) -> list[dict]:
+    """
+    根据 mid 获取歌曲信息
+
+    Args:
+        mid: 歌曲 mid 列表
+
+    Returns:
+        list: 歌曲信息
+    """
+    param = {
+        "ids": id,
+        "mids": [],
+        "types": [0 for _ in range(len(id))],
+        "modify_stamp": [0 for _ in range(len(id))],
+        "ctx": 0,
+        "client": 1,
+    }
+    res = await Api(**API["query"]).update_params(**param).result
+    tracks = res["tracks"]
+    return [parse_song_info(song) for song in tracks]
+
+
+async def query_by_mid(mid: list[str]) -> list[dict]:
+    """
+    根据 mid 获取歌曲信息
+
+    Args:
+        mid: 歌曲 mid 列表
+
+    Returns:
+        list: 歌曲信息
+    """
+    param = {
+        "ids": [],
+        "mids": mid,
+        "types": [0 for _ in range(len(mid))],
+        "modify_stamp": [0 for _ in range(len(mid))],
+        "ctx": 0,
+        "client": 1,
+    }
+    res = await Api(**API["query"]).update_params(**param).result
+    tracks = res["tracks"]
+    return [parse_song_info(song) for song in tracks]
+
+
+async def get_song_urls(
+    mid: list[str],
+    file_type: SongFileType = SongFileType.MP3_128,
+    url_type: UrlType = UrlType.PLAY,
+    credential: Optional[Credential] = None,
+) -> dict[str, str]:
+    """
+    获取歌曲文件链接
+
+    Args:
+        mid:        歌曲 mid
+        file_type:  歌曲文件类型. Defaults to SongFileType.MP3_128
+        url_type:   歌曲链接类型. Defaults to UrlType.PLAY
+        credential: Credential 类. Defaluts to None
+
+    Returns:
+        dict: 链接字典
+    """
+    if credential is None:
+        credential = Credential()
+    # 分割 id,单次最大请求100
+    mid_list = [mid[i : i + 100] for i in range(0, len(mid), 100)]
+    # 选择文件域名
+    domain = (
+        "https://isure.stream.qqmusic.qq.com/"
+        if url_type == UrlType.PLAY
+        else "https://dl.stream.qqmusic.qq.com/"
+    )
+    api = Api(**API[url_type.value], credential=credential)
+    urls = {}
+    for mid in mid_list:
+        # 构造请求参数
+        file_name = [f"{file_type.s}{_}{_}{file_type.e}" for _ in mid]
+        param = {
+            "filename": file_name,
+            "guid": random_string(32, "abcdef1234567890"),
+            "songmid": mid,
+            "songtype": [1 for _ in range(len(mid))],
+        }
+        res = await api.update_params(**param).result
+        data = res["midurlinfo"]
+        for info in data:
+            song_url = domain + info["wifiurl"] if info["wifiurl"] else ""
+            urls[info["songmid"]] = song_url
+    return urls

qqmusic_api/api/songlist.py

@@ -0,0 +1,81 @@
+from typing import Optional
+
+from qqmusic_api.api.song import Song
+
+from ..utils.common import get_api
+from ..utils.network import Api
+
+API = get_api("songlist")
+
+
+class Songlist:
+    """
+    歌单类
+    """
+
+    def __init__(self, id: int):
+        """
+        Args:
+            id: 歌单 ID
+        """
+        self.id = id
+        self._info: Optional[dict] = None
+
+    async def __get_info(self):
+        if not self._info:
+            param = {
+                "disstid": self.id,
+                "dirid": 0,
+                "tag": True,
+                "song_num": 0,
+                "userinfo": True,
+                "orderlist": True,
+            }
+            result = (
+                await Api(**API["detail"])
+                .update_params(**param)
+                .update_headers(Referer="")
+                .result
+            )
+            self._info = result  # type: ignore
+        return self._info
+
+    async def get_detail(self) -> dict:
+        """
+        获取歌单详细信息
+
+        Returns:
+            dict: 歌单信息
+        """
+        result = await self.__get_info()
+        return result["dirinfo"]
+
+    async def get_song(self) -> list[Song]:
+        """
+        获取歌单歌曲
+
+        Returns:
+            list: 歌单歌曲
+        """
+        result = await self.__get_info()
+        return [Song.from_dict(song) for song in result["songlist"]]
+
+    async def get_song_tag(self) -> list[dict]:
+        """
+        获取歌单歌曲标签
+
+        Returns:
+            list: 歌单歌曲标签
+        """
+        result = await self.__get_info()
+        return result["songtag"]
+
+    async def get_song_mid(self) -> list[dict]:
+        """
+        获取歌单歌曲全部 mid
+
+        Returns:
+            list: 歌单歌曲 mid
+        """
+        result = await self.__get_info()
+        return [song["mid"] for song in result["songlist"]]