library: remove compatibility code for model v1 (1/n) (#765)

feeluown/gui/components/menu.py

@@ -5,7 +5,7 @@
 from feeluown.excs import ProviderIOError
 from feeluown.utils.aio import run_fn, run_afn
 from feeluown.player import SongRadio
-from feeluown.library import SongProtocol, VideoModel, SupportsSongMV
+from feeluown.library import SongProtocol, VideoModel
 
 logger = logging.getLogger(__name__)
 
@@ -108,11 +108,9 @@ def mv_fetched_cb(future):
         if data['mvs'] is None and self._fetching_mv is False:
             logger.debug('fetch song.mv for actions')
             song = data['song']
-            provider = self._app.library.get(song.source)
-            if provider is not None and isinstance(provider, SupportsSongMV):
-                self._fetching_mv = True
-                task = run_fn(provider.song_get_mv, song)
-                task.add_done_callback(mv_fetched_cb)
+            self._fetching_mv = True
+            task = run_fn(self._app.library.song_get_mv, song)
+            task.add_done_callback(mv_fetched_cb)
 
     def _hover_artists(self, action, data):
         # pylint: disable=unnecessary-direct-lambda-call

feeluown/gui/page_containers/table.py

@@ -13,7 +13,7 @@
 from feeluown.utils.reader import wrap
 from feeluown.media import Media, MediaType
 from feeluown.excs import ProviderIOError
-from feeluown.library import ModelState, NotSupported, ModelFlags, ModelType
+from feeluown.library import ModelState, NotSupported, ModelType
 
 from feeluown.gui.helpers import BgTransparentMixin, \
     disconnect_slots_if_has, fetch_cover_wrapper
@@ -502,7 +502,6 @@ async def _on_songs_table_activated(self, index):
                 song = await aio.run_in_executor(
                     None, self._app.library.song_upgrade, song)
             except NotSupported as e:
-                assert ModelFlags.v2 & song.meta.flags
                 self._app.show_msg(f'资源提供方不支持该功能: {str(e)}')
                 logger.info(f'provider:{song.source} does not support song_get')
                 song.state = ModelState.cant_upgrade

feeluown/gui/pages/model.py

@@ -1,11 +1,17 @@
-from feeluown.library import V2SupportedModelTypes, AlbumModel, NotSupported
-from feeluown.utils import aio
+from feeluown.library import (
+    V2SupportedModelTypes, AlbumModel,
+    SupportsAlbumSongsReader, SupportsPlaylistRemoveSong,
+    SupportsArtistAlbumsReader, SupportsArtistContributedAlbumsReader,
+    SupportsPlaylistSongsReader, SupportsArtistSongsReader,
+)
+from feeluown.utils.aio import run_fn, run_afn
 from feeluown.utils.reader import create_reader
 from feeluown.library import ModelType, reverse
 
 from feeluown.gui.base_renderer import TabBarRendererMixin
 from feeluown.gui.page_containers.table import Renderer
 from feeluown.gui.widgets.songs import ColumnsMode
+from .template import render_error_message
 
 
 async def render(req, **kwargs):
@@ -18,17 +24,17 @@ async def render(req, **kwargs):
     # FIXME: handle ProviderIOError and RequestException.
     if ModelType(model.meta.model_type) in V2SupportedModelTypes:
         if model.meta.model_type == ModelType.album:
-            album = await aio.run_fn(app.library.album_upgrade, model)
+            album = await run_fn(app.library.album_upgrade, model)
             tab_index = int(req.query.get('tab_index', 1))
             al_renderer = AlbumRenderer(album, tab_index)
             await app.ui.table_container.set_renderer(al_renderer)
         elif model.meta.model_type == ModelType.artist:
-            artist = await aio.run_fn(app.library.artist_upgrade, model)
+            artist = await run_fn(app.library.artist_upgrade, model)
             tab_index = int(req.query.get('tab_index', 1))
             ar_renderer = ArtistRenderer(artist, tab_index)
             await app.ui.table_container.set_renderer(ar_renderer)
         elif model.meta.model_type == ModelType.playlist:
-            playlist = await aio.run_fn(app.library.playlist_upgrade, model)
+            playlist = await run_fn(app.library.playlist_upgrade, model)
             pl_renderer = PlaylistRenderer(playlist)
             await app.ui.table_container.set_renderer(pl_renderer)
         else:
@@ -60,7 +66,7 @@ async def render(self):
         tab_index = self.tab_index
 
         # fetch and render basic metadata
-        self.meta_widget.title = await aio.run_fn(lambda: artist.name)
+        self.meta_widget.title = await run_fn(lambda: artist.name)
         self.meta_widget.source = self._get_source_alias(artist.source)
         self.meta_widget.show()
 
@@ -74,8 +80,19 @@ async def render(self):
             contributed = tab_index == 3
             self.toolbar.filter_albums_needed.connect(
                 lambda types: self.albums_table.model().filter_by_types(types))
-            reader = await aio.run_fn(
-                self._app.library.artist_create_albums_rd, artist, contributed)
+
+            source = artist.source
+            provider = self._app.library.get(source)
+            if contributed is False and isinstance(provider, SupportsArtistAlbumsReader):
+                reader = await run_fn(provider.artist_create_albums_rd, artist)
+            elif isinstance(provider, SupportsArtistContributedAlbumsReader):
+                reader = await run_fn(provider.artist_create_contributed_albums_rd, artist)  # noqa
+            else:
+                if contributed:
+                    await render_error_message(self._app, '资源提供方不支持获取歌手贡献过的专辑')
+                else:
+                    await render_error_message(self._app, '资源提供方不支持获取歌手专辑')
+                return
             self.toolbar.show()
             self.show_albums(reader)
 
@@ -88,14 +105,17 @@ async def render(self):
 
     async def _show_songs(self):
         artist = self.model
-        reader = await aio.run_fn(self._app.library.artist_create_songs_rd, artist)
+        provider = self._app.library.get(artist.source)
+        if not isinstance(provider, SupportsArtistSongsReader):
+            await render_error_message(self._app, '资源提供方不支持获取歌手歌曲')
+            return
 
         async def cb():
-            reader = await aio.run_fn(self._app.library.artist_create_songs_rd, artist)
+            reader = await run_fn(provider.artist_create_songs_rd, artist)
             self.__show_songs(reader)
 
-        self.tabbar.show_songs_needed.connect(lambda: aio.run_afn(cb))
-        self.__show_songs(reader)
+        await cb()
+        self.tabbar.show_songs_needed.connect(lambda: run_afn(cb))
 
     def __show_songs(self, reader):
         self.show_songs(reader=reader,
@@ -135,19 +155,19 @@ async def render(self):
                 if album.song_count == 0:
                     reader = create_reader([])
                 else:
-                    try:
-                        reader = await aio.run_fn(
-                            self._app.library.album_create_songs_rd, album)
-                    except NotSupported as e:
-                        self._app.show_msg(str(e))
-                        reader = create_reader([])
+                    provider = self._app.library.get(album.source)
+                    if isinstance(provider, SupportsAlbumSongsReader):
+                        reader = await run_fn(provider.album_create_songs_rd, album)
+                    else:
+                        await render_error_message(self._app, '资源提供方不支持获取专辑歌曲')
+                        return
             self.meta_widget.songs_count = reader.count
             self.show_songs(reader, columns_mode=ColumnsMode.album)
 
         # fetch cover and description
         cover = album.cover
         if cover:
-            aio.run_afn(self.show_cover, cover, reverse(album, '/cover'))
+            run_afn(self.show_cover, cover, reverse(album, '/cover'))
 
 
 class PlaylistRenderer(Renderer):
@@ -166,21 +186,30 @@ async def render(self):
 
         # show playlist cover
         if playlist.cover:
-            aio.create_task(
-                self.show_cover(playlist.cover,
-                                reverse(playlist) + '/cover'))
+            run_afn(self.show_cover, playlist.cover, reverse(playlist) + '/cover')
 
-        self.songs_table.remove_song_func = self.remove_song
+        provider = self._app.library.get(self.playlist.source)
+        if isinstance(provider, SupportsPlaylistRemoveSong):
+            self.songs_table.remove_song_func = self.remove_song
 
     async def _show_songs(self):
-        reader = await aio.run_fn(self._app.library.playlist_create_songs_rd,
-                                  self.playlist)
+        provider = self._app.library.get(self.playlist.source)
+        if isinstance(provider, SupportsPlaylistSongsReader):
+            reader = await run_fn(provider.playlist_create_songs_rd, self.playlist)
+        else:
+            await render_error_message(self._app, '资源提供方不支持获取歌单歌曲')
+            return
         self.show_songs(reader=reader, show_count=True)
 
     def remove_song(self, song):
-        # FIXME: this may block the whole app.
-        if self._app.library.playlist_remove_song(self.playlist, song) is True:
-            # Re-render songs table so that user can see that the song is removed.
-            aio.run_afn(self._show_songs)
-        else:
-            self._app.show_msg('移除歌曲失败')
+
+        async def do():
+            provider = self._app.library.get(self.playlist.source)
+            if await run_fn(provider.playlist_remove_song, self.playlist, song) is True:
+                # Re-render songs table so that user can see that the song is removed.
+                run_afn(self._show_songs)
+                self._app.show_msg(f'移除歌曲 {song} 成功')
+            else:
+                self._app.show_msg(f'移除歌曲 {song} 失败')
+
+        run_afn(do)

feeluown/gui/pages/song_explore.py

@@ -333,25 +333,20 @@ async def maybe_show_song_lyric(self, song):
                 self.lyric_view.on_line_changed, weak=True)
             return
 
-        try:
-            lyric_model = self._app.library.song_get_lyric(song)
-        except NotSupported:
-            pass
-        else:
-            if lyric_model is None:
-                return
-            self.lyric_view.set_lyric(Lyric.from_content(lyric_model.content))
+        lyric_model = self._app.library.song_get_lyric(song)
+        if lyric_model is None:
+            return
+        self.lyric_view.set_lyric(Lyric.from_content(lyric_model.content))
 
     async def maybe_show_song_pic(self, song, album):
         if album:
             aio.run_afn(self.cover_label.show_cover,
                         album.cover,
                         reverse(album) + '/cover')
         else:
-            if ModelFlags.v2 in song.meta.flags:
-                aio.run_afn(self.cover_label.show_cover,
-                            song.pic_url,
-                            reverse(song) + '/pic_url')
+            aio.run_afn(self.cover_label.show_cover,
+                        song.pic_url,
+                        reverse(song) + '/pic_url')
 
     def resizeEvent(self, e: QResizeEvent) -> None:
         margins = self.layout().contentsMargins()

feeluown/gui/uimain/page_view.py

@@ -197,7 +197,10 @@ def paintEvent(self, e):
             self._draw_pixmap(painter, draw_width, draw_height, scrolled)
             self._draw_pixmap_overlay(painter, draw_width, draw_height, scrolled)
             curve = QEasingCurve(QEasingCurve.OutCubic)
-            alpha_ratio = min(scrolled / max_scroll_height, 1)
+            if max_scroll_height == 0:
+                alpha_ratio = 1
+            else:
+                alpha_ratio = min(scrolled / max_scroll_height, 1)
             alpha = int(250 * curve.valueForProgress(alpha_ratio))
             painter.save()
             color = self.palette().color(QPalette.Window)

feeluown/gui/widgets/playlists.py

@@ -9,6 +9,8 @@
     QAbstractItemView, QMenu
 )
 
+from feeluown.library import SupportsPlaylistAddSong
+from feeluown.utils.aio import run_afn, run_fn
 from .textlist import TextlistModel, TextlistView
 
 
@@ -124,16 +126,23 @@ def dropEvent(self, e):
         playlist = index.data(Qt.UserRole)
         self._results[index.row] = (index, None)
         self.viewport().update()
-        try:
-            # FIXME: this may block the app.
-            app = self.parent().parent()._app   # type: ignore[attr-defined]
-            is_success = app.library.playlist_add_song(playlist, song)
-        except:  # noqa, to avoid crash.
-            logger.exception('add song to playlist failed')
+
+        async def do():
             is_success = False
-        self._results[index.row] = (index, is_success)
-        self.viewport().update()
-        self._result_timer.start(2000)
+            app = self.parent().parent()._app   # type: ignore[attr-defined]
+            try:
+                provider = app.library.get(playlist.source)
+                if isinstance(provider, SupportsPlaylistAddSong):
+                    is_success = await run_fn(provider.playlist_add_song, playlist, song)
+            except:  # noqa, to avoid crash.
+                logger.exception('add song to playlist failed')
+                is_success = False
+            app.show_msg(f"添加歌曲 {song} 到播放列表 {'成功' if is_success is True else '失败'}")
+            self._results[index.row] = (index, is_success)
+            self.viewport().update()
+            self._result_timer.start(2000)
+
+        run_afn(do)
         e.accept()
 
     def dragMoveEvent(self, e):

feeluown/gui/widgets/songs.py

@@ -642,12 +642,13 @@ def contextMenuEvent(self, event):
         menu.addAction(add_to_playlist_action)
 
         # remove song action
-        if self.remove_song_func is not None:
-            remove_song_action = QAction('移除歌曲', menu)
-            remove_song_action.triggered.connect(
-                lambda: self._remove_by_indexes(indexes))
-            menu.addSeparator()
-            menu.addAction(remove_song_action)
+        remove_song_action = QAction('移除歌曲', menu)
+        remove_song_action.triggered.connect(
+            lambda: self._remove_by_indexes(indexes))
+        menu.addSeparator()
+        menu.addAction(remove_song_action)
+        if self.remove_song_func is None:
+            remove_song_action.setDisabled(True)
 
         model = self.model()
         models = [model.data(index, Qt.UserRole) for index in indexes]