fuo-qqmusic 1.0.5__py3-none-any.whl

fuo_qqmusic/assets/icon.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="-147 -173.29999999999998 470 492.29999999999995" width="256.0px" height="256.0px">
+  <linearGradient id="a" gradientTransform="rotate(-90 1397 232)" gradientUnits="userSpaceOnUse" x1="1310" x2="1780" y1="-1077" y2="-1077">
+    <stop offset="0" stop-color="#fbbe0a" />
+    <stop offset="1" stop-color="#feda24" />
+  </linearGradient>
+  <circle cx="88" cy="84" fill="url(#a)" r="235" />
+  <path d="M123.8 104c-5.9-8.3-11.5-16.1-17.1-23.8C85.2 50.4 63.6 20.6 42-9.1 28.3-28 14.7-46.9.8-65.6-3.4-71.2-3.9-77.1-2-83.5c3.9-13.3 13.2-22.5 24.2-30.1 20.1-13.9 42.8-21 66.6-25.2 20.7-3.6 41.2-8 59.3-19.4 4.9-3.1 9-7.3 13.5-11 1.2-1 2.3-2.1 4.6-4.1 1.5 7.3 3 13.4 4 19.5 3 18 1.9 35.5-6.2 52.1-11 22.4-29 36.4-52.6 43.6C97-53.5 82.1-52.4 67-52.5c-1.1 0-2.2.3-4.1.5 3.7 6.5 7 12.6 10.6 18.5 14.5 23.7 29 47.4 43.4 71.2l47.4 78.6c4.1 6.8 8.4 13.6 12.4 20.5 9.3 16 16.1 32.7 14.8 51.9-1.3 18.8-8.1 35.2-19.8 49.6-19.1 23.5-43.9 37.1-73.5 42.4-27.9 4.9-54.5 1.8-79.2-12.3-27.8-15.8-45.6-44.5-41.4-78.7 2.7-22.5 13.9-41.1 30.4-56.4 17.6-16.2 38.5-26.1 61.8-30.6 17.2-3.4 34.4-3.2 51.4 1.4.5.1 1.1-.1 2.6-.1z"
+        fill="#0daf52" />
+</svg>

fuo_qqmusic/consts.py

@@ -0,0 +1,6 @@
+from feeluown.consts import DATA_DIR
+
+
+COOKIES_FILE = DATA_DIR + '/qqmusic_cookies.json'
+USER_PW_FILE = DATA_DIR + '/qm_user_pw.json'
+USERS_INFO_FILE = DATA_DIR + '/qm_users_info.json'

fuo_qqmusic/excs.py

@@ -0,0 +1,6 @@
+from feeluown.excs import ProviderIOError
+
+
+class QQIOError(ProviderIOError):
+    def __init__(self, message):
+        super().__init__(message, provider='qq')

fuo_qqmusic/provider.py

@@ -0,0 +1,447 @@
+import logging
+from typing import List, Optional, Protocol
+from feeluown.excs import ModelNotFound
+from feeluown.library import (
+    AbstractProvider,
+    BriefSongModel,
+    PlaylistModel,
+    Collection,
+    CollectionType,
+    ProviderV2,
+    ProviderFlags as PF,
+    SupportsSongGet,
+    SupportsSongMultiQuality,
+    SupportsSongMV,
+    VideoModel,
+    LyricModel,
+    SupportsCurrentUser,
+    SupportsVideoGet,
+    SupportsSongLyric,
+    SupportsAlbumGet,
+    SupportsAlbumSongsReader,
+    SupportsArtistGet,
+    SupportsPlaylistGet,
+    SupportsPlaylistSongsReader,
+    SupportsRecACollectionOfSongs,
+    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,
+    SupportsRecACollectionOfSongs,
+    SupportsAlbumSongsReader,
+    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 = 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")
+        media = q_media_mapping.get(quality)
+        if media is UNFETCHED_MEDIA:
+            for q, t, b, s in quality_suffix:
+                if quality == Quality.Audio(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 album_create_songs_rd(self, album):
+        album = self.album_get(album.identifier)
+        return create_reader(album.songs)
+
+    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_hot_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 rec_list_daily_playlists(self):
+        # TODO: cache API result
+        feed = self.api.get_recommend_feed()
+        shelf = None
+        for shelf_ in feed['v_shelf']:
+            # I guess 10046 means 'song'.
+            if shelf_['extra_info'].get('moduleID', '').startswith('playlist'):
+                shelf = shelf_
+                break
+        if shelf is None:
+            return []
+        playlists = []
+        for batch in shelf['v_niche']:
+            for card in batch['v_card']:
+                if card['jumptype'] == 10014:  # 10014->playlist
+                    playlists.append(
+                        PlaylistModel(identifier=str(card['id']),
+                                      source=SOURCE,
+                                      name=card['title'],
+                                      cover=card['cover'],
+                                      description=card['miscellany']['rcmdtemplate'],
+                                      play_count=card['cnt'])
+                    )
+        return playlists
+
+    def rec_a_collection_of_songs(self):
+        # TODO: cache API result
+        feed = self.api.get_recommend_feed()
+        shelf = None
+        for shelf_ in feed['v_shelf']:
+            # I guess 10046 means 'song'.
+            if int(shelf_['miscellany'].get('jumptype', 0)) == 10046:
+                shelf = shelf_
+                break
+        if shelf is None:
+            return Collection(name='',
+                              type_=CollectionType.only_songs,
+                              models=[],
+                              description='')
+        title = shelf['title_content'] or shelf['title_template']
+        song_ids = []
+        for batch in shelf['v_niche']:
+            for card in batch['v_card']:
+                if card['jumptype'] == 10046:
+                    song_id = int(card['id'])
+                    if song_id not in song_ids:
+                        song_ids.append(song_id)
+
+        tracks = self.api.batch_song_details(song_ids)
+        return Collection(name=title,
+                          type_=CollectionType.only_songs,
+                          models=[_deserialize(track, QQSongSchema) for track in tracks],
+                          description='')
+
+    def current_user_get_radio_songs(self):
+        songs_data = self.api.get_radio_music()
+        return [_deserialize(s, QQSongSchema) for s in songs_data]
+
+    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_"])
+    type_type_map = {
+        SearchType.so: 0,
+        SearchType.ar: 1,
+        SearchType.al: 2,
+        SearchType.pl: 3,
+        SearchType.vi: 4,
+    }
+    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)
+    if type_ == SearchType.ar:
+        artists = [_deserialize(artist, SearchArtistSchema) for artist in data]
+        return SimpleSearchResult(q=keyword, artists=artists)
+    elif type_ == SearchType.al:
+        albums = [_deserialize(album, SearchAlbumSchema) for album in data]
+        return SimpleSearchResult(q=keyword, albums=albums)
+    elif type_ == SearchType.pl:
+        playlists = [_deserialize(playlist, SearchPlaylistSchema) for playlist in data]
+        return SimpleSearchResult(q=keyword, playlists=playlists)
+    elif type_ == SearchType.vi:
+        models = [_deserialize(model, SearchMVSchema) for model in data]
+        return SimpleSearchResult(q=keyword, videos=models)
+
+
+provider = QQProvider()
+provider.search = search
+
+
+from .schemas import (  # noqa
+    QQSongSchema,
+    QQArtistSchema,
+    _ArtistSongSchema,
+    _BriefAlbumSchema,
+    _UserArtistSchema,
+    _BriefArtistSchema,
+    QQAlbumSchema,
+    QQPlaylistSchema,
+    QQUserSchema,
+    _UserAlbumSchema,
+    SearchAlbumSchema,
+    SearchArtistSchema,
+    SearchPlaylistSchema,
+    SearchMVSchema,
+)  # noqa

fuo_qqmusic/provider_ui.py

@@ -0,0 +1,102 @@
+import json
+import logging
+import os
+
+from feeluown.utils.dispatch import Signal
+from feeluown.utils.aio import run_fn
+from feeluown.consts import DATA_DIR
+from feeluown.gui.widgets.login import CookiesLoginDialog, InvalidCookies
+from feeluown.gui.provider_ui import AbstractProviderUi
+from feeluown.app.gui_app import GuiApp
+
+from .provider import provider
+from .excs import QQIOError
+
+logger = logging.getLogger(__name__)
+
+
+USER_INFO_FILE = DATA_DIR + '/qqmusic_user_info.json'
+
+
+def read_cookies():
+    if os.path.exists(USER_INFO_FILE):
+        # if the file is broken, just raise error
+        with open(USER_INFO_FILE) as f:
+            return json.load(f).get('cookies', None)
+
+
+class ProviderUI(AbstractProviderUi):
+    def __init__(self, app: GuiApp):
+        self._app = app
+        self._login_event = Signal()
+
+    @property
+    def provider(self):
+        return provider
+
+    def get_colorful_svg(self) -> str:
+        return os.path.join(os.path.dirname(__file__), 'assets', 'icon.svg')
+
+    def login_or_go_home(self):
+        if provider._user is None:
+            # According to #14, we have two ways to login:
+            # 1. the default way, as the code shows
+            # 2. a way for VIP user(maybe):
+            #    - url: https://xui.ptlogin2.qq.com/cgi-bin/xlogin?appid=1006102
+            #           &daid=384&low_login=1&pt_no_auth=1
+            #           &s_url=https://y.qq.com/vip/daren_recruit/apply.html&style=40
+            #
+            #    - keys: ['skey']
+            url = os.getenv('FUO_QQMUSIC_LOGIN_URL', 'https://y.qq.com')
+            keys = os.getenv('FUO_QQMUSIC_LOGIN_COOKIE_KEYS', 'qqmusic_key').split(',')
+            self._dialog = LoginDialog(url, keys)
+            self._dialog.login_succeed.connect(self.on_login_succeed)
+            self._dialog.show()
+            self._dialog.autologin()
+        else:
+            logger.info('already logged in')
+            self.login_event.emit(self, 2)
+
+    @property
+    def login_event(self):
+        return self._login_event
+
+    def on_login_succeed(self):
+        del self._dialog
+        self.login_event.emit(self, 1)
+
+
+class LoginDialog(CookiesLoginDialog):
+
+    def setup_user(self, user):
+        provider._user = user
+
+    async def user_from_cookies(self, cookies):
+        if not cookies:  # is None or empty
+            raise InvalidCookies('empty cookies')
+
+        uin = provider.api.get_uin_from_cookies(cookies)
+        if uin is None:
+            raise InvalidCookies("can't extract user info from cookies")
+
+        provider.api.set_cookies(cookies)
+        # try to extract current user
+        try:
+            user = await run_fn(provider.user_get, uin)
+        except QQIOError:
+            provider.api.set_cookies(None)
+            raise InvalidCookies('get user info with cookies failed, expired cookies?')
+        else:
+            return user
+
+    def load_user_cookies(self):
+        return read_cookies()
+
+    def dump_user_cookies(self, user, cookies):
+        js = {
+            'identifier': user.identifier,
+            'name': user.name,
+            'cookies': cookies
+        }
+        with open(USER_INFO_FILE, 'w') as f:
+            json.dump(js, f, indent=2)