fuo-qqmusic 0.5.0__tar.gz → 1.0__tar.gz

{fuo_qqmusic-0.5.0 → fuo_qqmusic-1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fuo_qqmusic
-Version: 0.5.0
+Version: 1.0
 Summary: feeluown qqmusic plugin
 Home-page: https://github.com/feeluown/feeluown-qqmusic
 Author: Cosven

{fuo_qqmusic-0.5.0 → fuo_qqmusic-1.0}/README.md

@@ -21,41 +21,41 @@ pip3 install fuo-qqmusic
 
 ## changelog
 
-### 0.5.0 (2023-07-14)
+### 1.0 (2024-01-1)
+- 使用 FeelUOwn 新接口
+- 支持发现，推荐等接口
+
+### 0.5.1 (2023-08-14)
+- 恢复部分接口（0.5.0 移除了一些实际上可用的接口）
 
+### 0.5.0 (2023-07-14)
 - 修复搜索接口
 - 让部分不可用接口直接报错
 
 ### 0.4.1 (2022-03-21)
-
 - 修复加载歌单时，应用可能会 crash 的问题
 
 ### 0.4.0 (???)
-
 - 修复若干问题
 
 ### 0.3.4 (2022-01-31)
-
 感谢 [@cyliuu](https://github.com/cyliuu)
 
 - 修复若干问题
 
 ### 0.3.3 (2021-06-10)
-
 感谢 [@cyliuu](https://github.com/cyliuu)
 
 - 支持展示收藏的歌曲、专辑和歌手
 - 支持获取相似歌曲
 
 ### 0.3.2 (2021-04-23)
-
 感谢 [@cyliuu](https://github.com/cyliuu)
 
 - 提供更准确的音乐的比特率
 - 绿钻用户使用合适的 cookie 可以获取到高品质音乐
 
 ### 0.3 (2020-08-10)
-
 感谢 [@csy19960309](https://github.com/csy19960309)
 
 - 支持登陆功能，加载用户歌单

{fuo_qqmusic-0.5.0 → fuo_qqmusic-1.0}/fuo_qqmusic/__init__.py

@@ -8,15 +8,15 @@ __version__ = '0.3a0'
 __desc__ = 'QQ 音乐'
 
 logger = logging.getLogger(__name__)
-ui_mgr = None
 
 
 def enable(app):
-    global ui_mgr
     app.library.register(provider)
     if app.mode & app.GuiMode:
-        from .ui import UiManager
-        ui_mgr = ui_mgr or UiManager(app)
+        from .provider_ui import ProviderUI
+
+        provider_ui = ProviderUI(app)
+        app.pvd_ui_mgr.register(provider_ui)
 
 
 def disable(app):

{fuo_qqmusic-0.5.0 → fuo_qqmusic-1.0}/fuo_qqmusic/api.py

@@ -2,7 +2,6 @@
 # encoding: UTF-8
 
 import base64
-import re
 import hashlib
 import logging
 import math
@@ -15,6 +14,8 @@ from .excs import QQIOError
 
 logger = logging.getLogger(__name__)
 
+api_base_url = 'http://c.y.qq.com'
+
 
 def djb2(string):
     ''' Hash a word using the djb2 algorithm with the specified base. '''
@@ -240,16 +241,62 @@ class API(object):
         return js['req_0']['data']
 
     def artist_albums(self, artist_id, page=1, page_size=20):
-        raise QQIOError('artist_albums api is not available')
+        url = api_base_url + '/v8/fcg-bin/fcg_v8_singer_album.fcg'
+        params = {
+            'singerid': artist_id,
+            'order': 'time',
+            'begin': (page - 1) * page_size,  # TODO: 这里应该代表偏移量
+            'num': page_size
+        }
+        response = requests.get(url, params=params)
+        js = response.json()
+        return js['data']
 
     def album_detail(self, album_id):
-        raise QQIOError('album_detail api is not available')
+        url = api_base_url + '/v8/fcg-bin/fcg_v8_album_detail_cp.fcg'
+        params = {
+            'albumid': album_id,
+            'format': 'json',
+            'newsong': 1
+        }
+        resp = requests.get(url, params=params)
+        return resp.json()['data']
 
     def playlist_detail(self, pid, offset=0, limit=50):
-        raise QQIOError('playlist_detail api is not available')
+        url = api_base_url + '/qzone/fcg-bin/fcg_ucc_getcdinfo_byids_cp.fcg'
+        params = {
+            'type': '1',
+            'utf8': '1',
+            'disstid': pid,
+            'format': 'json',
+            'new_format': '1',  # 需要这个字段来获取file等信息
+            'song_begin': offset,
+            'song_num': limit,
+        }
+        resp = requests.get(url, params=params, headers=self._headers,
+                            cookies=self._cookies, timeout=self._timeout)
+        js = resp.json()
+        if js['code'] != 0:
+            raise CodeShouldBe0(js)
+        return js['cdlist'][0]
 
     def user_detail(self, uid):
-        raise QQIOError('user_detail api is not available')
+        """
+        this API can be called only when user has logged in
+        """
+        url = api_base_url + '/rsc/fcgi-bin/fcg_get_profile_homepage.fcg'
+        params = {
+            # 这两个字段意义不明，不过至少固定为此值时可正常使用
+            'cid': 205360838,
+            'reqfrom': 1,
+            'userid': uid
+        }
+        resp = requests.get(url, params=params, headers=self._headers,
+                            cookies=self._cookies, timeout=self._timeout)
+        js = resp.json()
+        if js['code'] != 0:
+            raise CodeShouldBe0(js)
+        return js['data']
 
     def user_favorite_artists(self, uid, mid, page=1, page_size=30):
         # FIXME: page/page_size is just a guess
@@ -263,37 +310,57 @@ class API(object):
                     'HostUin': mid
                 }},
             'comm': {
-                'g_tk': self.get_token_from_cookies(),
+                "cv": 4747474,
+                "ct": 24,
+                'g_tk': int(self.get_token_from_cookies()),
+                'g_tk_new_20200303': int(self.get_token_from_cookies()),
                 'uin': uid,
                 'format': 'json',
+                'notice': 0,
+                'platform': 'yqq.json',
+                'needNewCode': 1,
             }
         }
         js = self.rpc(payload)
-        return js['req_0']['data']['List']
+        return js['req_1']['data']['List']
 
     def user_favorite_albums(self, uid, start=0, end=100):
-        raise QQIOError('user_detail api is not available')
+        url = api_base_url + '/fav/fcgi-bin/fcg_get_profile_order_asset.fcg'
+        params = {
+            'ct': 20,  # 不知道此字段什么含义
+            'reqtype': 2,
+            'sin': start,  # 每一页的开始
+            'ein': end,  # 每一页的结尾，目前假设最多收藏 30 个专辑
+            'cid': 205360956,
+            'reqfrom': 1,
+            'userid': uid
+        }
+        resp = requests.get(url, params=params, headers=self._headers,
+                            cookies=self._cookies, timeout=self._timeout)
+        js = resp.json()
+        if js['code'] != 0:
+            raise CodeShouldBe0(js)
+        return js['data']['albumlist']
 
     def user_favorite_playlists(self, uid, mid, start=0, end=100):
-        raise QQIOError('api is not available')
+        url = api_base_url + '/fav/fcgi-bin/fcg_get_profile_order_asset.fcg'
 
-    def get_recommend_songs_pid(self):
-        data = {
-            'req_0': {
-                'module': 'recommend.RecommendFeedServer',
-                'method': 'get_recommend_feed',
-                'param': {
-                    'direction': 0,
-                    'page': 1,
-                    'v_cache': [],
-                    'v_uniq': [],
-                    's_num': 0
-                }
-            },
+        params = {
+            'loginUin': uid,
+            'userid': mid,
+            'cid': 205360956,
+            'sin': start,
+            'ein': end,
+            'reqtype': 3,
+            'ct': 20,  # 没有该字段 返回中文字符是乱码
         }
-        js = self.rpc(data)
-        disstid = js['req_0']['data']['v_shelf'][0]['v_niche'][0]['v_card'][1]['id']
-        return disstid
+
+        resp = requests.get(url, params=params, headers=self._headers,
+                            cookies=self._cookies, timeout=self._timeout)
+        js = resp.json()
+        if js['code'] != 0:
+            raise CodeShouldBe0(js)
+        return js['data']['cdlist']
 
     def recommend_playlists(self):
         data = {
@@ -330,7 +397,18 @@ class API(object):
         return ids
 
     def get_lyric_by_songmid(self, songmid):
-        raise QQIOError('get_lyric_by_songmid is not available')
+        url = api_base_url + '/lyric/fcgi-bin/fcg_query_lyric_new.fcg'
+        params = {
+            'songmid': songmid,
+            'pcachetime': int(round(time.time() * 1000)),
+            'format': 'json',
+        }
+        response = requests.get(url, params=params, headers=self._headers,
+                                timeout=self._timeout)
+        js = response.json()
+        CodeShouldBe0.check(js)
+        lyric = js['lyric'] or ''
+        return base64.b64decode(lyric).decode()
 
     def rpc(self, payload):
         if 'comm' not in payload:
@@ -343,7 +421,7 @@ class API(object):
         }
         url = 'https://u.y.qq.com/cgi-bin/musicu.fcg'
         resp = requests.get(url, params=params, headers=self._headers,
-                            timeout=self._timeout)
+                            cookies=self._cookies, timeout=self._timeout)
         js = resp.json()
         CodeShouldBe0.check(js)
         return js

fuo_qqmusic-1.0/fuo_qqmusic/provider.py

@@ -0,0 +1,371 @@
+import logging
+from typing import List, Optional, Protocol
+from feeluown.excs import ModelNotFound
+from feeluown.library import (
+    AbstractProvider,
+    ProviderV2,
+    ProviderFlags as PF,
+    SupportsSongGet,
+    SupportsSongMultiQuality,
+    SupportsSongMV,
+    VideoModel,
+    LyricModel,
+    SupportsCurrentUser,
+    SupportsVideoGet,
+    SupportsSongLyric,
+    SupportsAlbumGet,
+    SupportsArtistGet,
+    SupportsPlaylistGet,
+    SupportsPlaylistSongsReader,
+    SimpleSearchResult,
+    SearchType,
+    ModelType,
+)
+from feeluown.media import Media, Quality
+from feeluown.utils.reader import create_reader, SequentialReader
+from .api import API
+
+
+logger = logging.getLogger(__name__)
+UNFETCHED_MEDIA = object()
+SOURCE = "qqmusic"
+
+
+class Supports(
+    SupportsSongGet,
+    SupportsSongMultiQuality,
+    SupportsSongMV,
+    SupportsCurrentUser,
+    SupportsVideoGet,
+    SupportsSongLyric,
+    SupportsAlbumGet,
+    SupportsArtistGet,
+    SupportsPlaylistGet,
+    SupportsPlaylistSongsReader,
+    Protocol,
+):
+    pass
+
+
+class QQProvider(AbstractProvider, ProviderV2):
+    class meta:
+        identifier = "qqmusic"
+        name = "QQ 音乐"
+        flags = {
+            ModelType.song: PF.similar,
+            ModelType.none: PF.current_user,
+        }
+
+    def __init__(self):
+        super().__init__()
+        self.api = API()
+
+    def _(self) -> Supports:
+        return self
+
+    @property
+    def identifier(self):
+        return "qqmusic"
+
+    @property
+    def name(self):
+        return "QQ 音乐"
+
+    def use_model_v2(self, mtype):
+        return mtype in (
+            ModelType.song,
+            ModelType.album,
+            ModelType.artist,
+            ModelType.playlist,
+        )
+
+    def song_get(self, identifier):
+        data = self.api.song_detail(identifier)
+        return _deserialize(data, QQSongSchema)
+
+    def song_get_mv(self, song):
+        mv_id = self._model_cache_get_or_fetch(song, "mv_id")
+        if mv_id == 0:
+            return None
+        video = self.video_get(mv_id)
+        # mv 的名字是空的
+        video.title = song.title
+        return video
+
+    def song_get_lyric(self, song):
+        mid = self._model_cache_get_or_fetch(song, "mid")
+        content = self.api.get_lyric_by_songmid(mid)
+        return LyricModel(identifier=mid, source=SOURCE, content=content)
+
+    def video_get(self, identifier):
+        data = self.api.get_mv(identifier)
+        if not data:
+            raise ModelNotFound(f"mv:{identifier} not found")
+        fhd = hd = sd = ld = None
+        for file in data["mp4"]:
+            if not file["url"]:
+                continue
+            file_type = file["filetype"]
+            url = file["freeflow_url"][0]
+            if file_type == 40:
+                fhd = url
+            elif file_type == 30:
+                hd = url
+            elif file_type == 20:
+                sd = url
+            elif file_type == 10:
+                ld = url
+            elif file_type == 0:
+                pass
+            else:
+                logger.warning("There exists another quality:%s mv.", str(file_type))
+        q_url_mapping = dict(fhd=fhd, hd=hd, sd=sd, ld=ld)
+        video = VideoModel(
+            identifier=identifier,
+            source=SOURCE,
+            title="未知名字",
+            artists=[],
+            duration=1,
+            cover="",
+        )
+        video.cache_set("q_url_mapping", q_url_mapping)
+        return video
+
+    def video_get_media(self, video, quality):
+        q_media_mapping = self._model_cache_get_or_fetch(video, "q_url_mapping")
+        return Media(q_media_mapping[quality.value])
+
+    def video_list_quality(self, video):
+        q_media_mapping = self._model_cache_get_or_fetch(video, "q_url_mapping")
+        return [Quality.Video(k) for k, v in q_media_mapping.items() if v]
+
+    def song_list_quality(self, song) -> List[Quality.Audio]:
+        """List all possible qualities
+
+        Please ensure all the qualities are valid. `song_get_media(song, quality)`
+        must not return None with a valid quality.
+        """
+        return list(self._song_get_q_media_mapping(song))
+
+    def song_get_media(self, song, quality: Quality.Audio) -> Optional[Media]:
+        """Get song's media by a specified quality
+
+        :return: when quality is invalid, return None
+        """
+        q_media_mapping = self._song_get_q_media_mapping(song)
+        quality_suffix = song.cache_get("quality_suffix")
+        mid = song.cache_get("mid")
+        media_id = song.cache_get("media_id")
+        media = q_media_mapping.get(quality)
+        if media is UNFETCHED_MEDIA:
+            for q, t, b, s in quality_suffix:
+                if quality == q:
+                    url = self.api.get_song_url_v2(mid, media_id, t)
+                    if url:
+                        media = Media(url, bitrate=b, format=s)
+                        q_media_mapping[quality] = media
+                    else:
+                        media = None
+                        q_media_mapping[quality] = None
+                    break
+            else:
+                media = None
+        return media
+
+    def _song_get_q_media_mapping(self, song):
+        q_media_mapping, exists = song.cache_get("q_media_mapping")
+        if exists is True:
+            return q_media_mapping
+        quality_suffix = self._model_cache_get_or_fetch(song, "quality_suffix")
+        mid = self._model_cache_get_or_fetch(song, "mid")
+        media_id = self._model_cache_get_or_fetch(song, "media_id")
+        q_media_mapping = {}
+        # 注：self.quality_suffix 这里可能会触发一次网络请求
+        for idx, (q, t, b, s) in enumerate(quality_suffix):
+            url = self.api.get_song_url_v2(mid, media_id, t)
+            if url:
+                q_media_mapping[Quality.Audio(q)] = Media(url, bitrate=b, format=s)
+                # 一般来说，高品质有权限 低品质也会有权限，减少网络请求。
+                # 这里把值设置为 UNFETCHED_MEDIA，作为一个标记。
+                for i in range(idx + 1, len(quality_suffix)):
+                    q_media_mapping[
+                        Quality.Audio(quality_suffix[i][0])
+                    ] = UNFETCHED_MEDIA
+                break
+        song.cache_set("q_media_mapping", q_media_mapping)
+        return q_media_mapping
+
+    def artist_get(self, identifier):
+        data_mid = self.api.artist_songs(int(identifier), 1, 0)["singerMid"]
+        data_artist = self.api.artist_detail(data_mid)
+        artist = _deserialize(data_artist, QQArtistSchema)
+        return artist
+
+    def artist_create_songs_rd(self, artist):
+        return create_g(
+            self.api.artist_songs, int(artist.identifier), _ArtistSongSchema
+        )
+
+    def artist_create_albums_rd(self, artist):
+        return create_g(
+            self.api.artist_albums, int(artist.identifier), _BriefAlbumSchema
+        )
+
+    def album_get(self, identifier):
+        data_album = self.api.album_detail(int(identifier))
+        if data_album is None:
+            raise ModelNotFound
+        album = _deserialize(data_album, QQAlbumSchema)
+        return album
+
+    def user_get(self, identifier):
+        data = self.api.user_detail(identifier)
+        data["creator"]["fav_pid"] = data["mymusic"][0]["id"]
+        # 假设使用微信登陆，从网页拿到 cookie，cookie 里面的 uin 是正确的，
+        # 而这个接口返回的 uin 则可能是 0，因此手动重置一下。
+        data["creator"]["uin"] = identifier
+        return _deserialize(data, QQUserSchema)
+
+    def playlist_get(self, identifier):
+        data = self.api.playlist_detail(int(identifier), limit=1000)
+        return _deserialize(data, QQPlaylistSchema)
+
+    def playlist_create_songs_rd(self, playlist):
+        songs = self._model_cache_get_or_fetch(playlist, "songs")
+        return create_reader(songs)
+
+    def rec_list_daily_playlists(self):
+        user = self.get_current_user()
+        if user is None:
+            return []
+        # pids = self.api.get_recommend_playlists_ids()
+        # rec_playlists = [QQPlaylistModel.get(pid) for pid in pids]
+        playlists = self.api.recommend_playlists()
+        for pl in playlists:
+            pl["dissid"] = pl["content_id"]
+            pl["dissname"] = pl["title"]
+            pl["logo"] = pl["cover"]
+        return [_deserialize(playlist, QQPlaylistSchema) for playlist in playlists]
+
+    def current_user_list_playlists(self):
+        user = self.get_current_user()
+        if user is None:
+            return []
+        playlists = self._model_cache_get_or_fetch(user, "playlists")
+        return playlists
+
+    def current_user_fav_create_songs_rd(self):
+        user = self.get_current_user()
+        if user is None:
+            return create_reader([])
+        fav_pid = self._model_cache_get_or_fetch(user, "fav_pid")
+        playlist = self.playlist_get(fav_pid)
+        reader = create_reader(self.playlist_create_songs_rd(playlist))
+        return reader.readall()
+
+    def current_user_fav_create_albums_rd(self):
+        user = self.get_current_user()
+        if user is None:
+            return create_reader([])
+        # TODO: fetch more if total count > 100
+        albums = self.api.user_favorite_albums(user.identifier)
+        return [_deserialize(album, _UserAlbumSchema) for album in albums]
+
+    def current_user_fav_create_artists_rd(self):
+        user = self.get_current_user()
+        if user is None:
+            return create_reader([])
+        # TODO: fetch more if total count > 100
+        mid = self._model_cache_get_or_fetch(user, "mid")
+        artists = self.api.user_favorite_artists(user.identifier, mid)
+        return [_deserialize(artist, _UserArtistSchema) for artist in artists]
+
+    def current_user_fav_create_playlists_rd(self):
+        user = self.get_current_user()
+        if user is None:
+            return create_reader([])
+        mid = self._model_cache_get_or_fetch(user, "mid")
+        playlists = self.api.user_favorite_playlists(user.identifier, mid)
+        return [_deserialize(playlist, QQPlaylistSchema) for playlist in playlists]
+
+    def has_current_user(self):
+        return self._user is not None
+
+    def get_current_user(self):
+        return self._user
+
+    def song_list_similar(self, song):
+        data_songs = self.api.song_similar(int(song.identifier))
+        return [_deserialize(data_song, QQSongSchema) for data_song in data_songs]
+
+
+def _deserialize(data, schema_cls):
+    schema = schema_cls()
+    obj = schema.load(data)
+    return obj
+
+
+def create_g(func, identifier, schema):
+    data = func(identifier, page=1)
+    total = int(data["totalNum"] if schema == _ArtistSongSchema else data["total"])
+
+    def g():
+        nonlocal data
+        if data is None:
+            yield from ()
+        else:
+            page = 1
+            while data["songList"] if schema == _ArtistSongSchema else data["list"]:
+                obj_data_list = (
+                    data["songList"] if schema == _ArtistSongSchema else data["list"]
+                )
+                for obj_data in obj_data_list:
+                    obj = _deserialize(obj_data, schema)
+                    yield obj
+                page += 1
+                data = func(identifier, page)
+
+    return SequentialReader(g(), total)
+
+
+def search(keyword, **kwargs):
+    type_ = SearchType.parse(kwargs["type_"])
+    if type_ == SearchType.pl:
+        data = provider.api.search_playlists(keyword)
+        playlists = [_deserialize(playlist, _BriefPlaylistSchema) for playlist in data]
+        return SimpleSearchResult(q=keyword, playlists=playlists)
+    else:
+        type_type_map = {
+            SearchType.so: 0,
+            SearchType.al: 8,
+            SearchType.ar: 9,
+        }
+        data = provider.api.search(keyword, type_=type_type_map[type_])
+        if type_ == SearchType.so:
+            songs = [_deserialize(song, QQSongSchema) for song in data]
+            return SimpleSearchResult(q=keyword, songs=songs)
+        elif type_ == SearchType.al:
+            albums = [_deserialize(album, _BriefAlbumSchema) for album in data]
+            return SimpleSearchResult(q=keyword, albums=albums)
+        else:
+            artists = [_deserialize(artist, _BriefArtistSchema) for artist in data]
+            return SimpleSearchResult(q=keyword, artists=artists)
+
+
+provider = QQProvider()
+provider.search = search
+
+
+from .schemas import (  # noqa
+    QQSongSchema,
+    QQArtistSchema,
+    _ArtistSongSchema,
+    _BriefAlbumSchema,
+    _UserArtistSchema,
+    _BriefArtistSchema,
+    _BriefPlaylistSchema,
+    QQAlbumSchema,
+    QQPlaylistSchema,
+    QQUserSchema,
+    _UserAlbumSchema,
+)  # noqa