polish album_songs_rd, song_lyric

feeluown/gui/pages/model.py

@@ -1,6 +1,7 @@
-from feeluown.library import V2SupportedModelTypes, AlbumModel, NotSupported
-from feeluown.library.provider_protocol import SupportsPlaylistRemoveSong
-from feeluown.utils import aio
+from feeluown.library import (
+    V2SupportedModelTypes, AlbumModel,
+    SupportsAlbumSongsReader, SupportsPlaylistRemoveSong,
+)
 from feeluown.utils.aio import run_fn, run_afn
 from feeluown.utils.reader import create_reader
 from feeluown.library import ModelType, reverse
@@ -20,17 +21,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:
@@ -62,7 +63,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()
 
@@ -76,7 +77,7 @@ 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(
+            reader = await run_fn(
                 self._app.library.artist_create_albums_rd, artist, contributed)
             self.toolbar.show()
             self.show_albums(reader)
@@ -90,13 +91,13 @@ 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)
+        reader = await run_fn(self._app.library.artist_create_songs_rd, artist)
 
         async def cb():
-            reader = await aio.run_fn(self._app.library.artist_create_songs_rd, artist)
+            reader = await run_fn(self._app.library.artist_create_songs_rd, artist)
             self.__show_songs(reader)
 
-        self.tabbar.show_songs_needed.connect(lambda: aio.run_afn(cb))
+        self.tabbar.show_songs_needed.connect(lambda: run_afn(cb))
         self.__show_songs(reader)
 
     def __show_songs(self, reader):
@@ -137,19 +138,18 @@ 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))
+                    provider = self._app.library.get(album.source)
+                    if isinstance(provider, SupportsAlbumSongsReader):
+                        reader = await run_fn(provider.album_create_songs_rd, album)
+                    else:
                         reader = create_reader([])
             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):
@@ -168,17 +168,15 @@ 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')
 
         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)
+        reader = await run_fn(self._app.library.playlist_create_songs_rd,
+                              self.playlist)
         self.show_songs(reader=reader, show_count=True)
 
     def remove_song(self, song):
@@ -187,7 +185,7 @@ 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.
-                aio.run_afn(self._show_songs)
+                run_afn(self._show_songs)
                 self._app.show_msg(f'移除歌曲 {song} 成功')
             else:
                 self._app.show_msg(f'移除歌曲 {song} 失败')

feeluown/gui/pages/song_explore.py

@@ -333,14 +333,10 @@ 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:

feeluown/library/library.py

@@ -27,7 +27,7 @@
 from .model_state import ModelState
 from .provider_protocol import (
     check_flag as check_flag_impl,
-    SupportsCurrentUser, SupportsAlbumSongsReader,
+    SupportsCurrentUser,
     SupportsSongLyric, SupportsSongMV, SupportsSongMultiQuality,
     SupportsPlaylistSongsReader,
     SupportsArtistSongsReader, SupportsArtistAlbumsReader,
@@ -46,11 +46,6 @@ def raise_(e):
     raise e
 
 
-def support_or_raise(provider, protocol_cls):
-    if not isinstance(provider, protocol_cls):
-        raise NotSupported(f'{provider} not support {protocol_cls}') from None
-
-
 def default_score_fn(origin, standby):
 
     # TODO: move this function to utils module
@@ -381,30 +376,20 @@ def song_prepare_mv_media(self, song: BriefSongProtocol, policy) -> Media:
         raise MediaNotFound('provider returns empty media')
 
     def song_get_mv(self, song: BriefSongProtocol) -> Optional[VideoProtocol]:
-        """Get the MV model of a song.
-
-        :raises NotSupported:
-        """
+        """Get the MV model of a song."""
         provider = self.get(song.source)
         if isinstance(provider, SupportsSongMV):
-            mv = provider.song_get_mv(song)
-        else:
-            mv = None
-        return mv
+            return provider.song_get_mv(song)
 
     def song_get_lyric(self, song: BriefSongModel) -> Optional[LyricProtocol]:
         """Get the lyric model of a song.
 
         Return None when lyric does not exist instead of raising exceptions,
         because it is predictable.
-
-        :raises NotSupported:
-        :raises ProviderNotFound:
         """
-        provider = self.get_or_raise(song.source)
+        provider = self.get(song.source)
         if isinstance(provider, SupportsSongLyric):
             return provider.song_get_lyric(song)
-        raise NotSupported
 
     def song_get_web_url(self, song: BriefSongProtocol) -> str:
         provider = self.getv2_or_raise(song.source)
@@ -416,15 +401,6 @@ def song_get_web_url(self, song: BriefSongProtocol) -> str:
     def album_upgrade(self, album: BriefAlbumProtocol):
         return self._model_upgrade(album)
 
-    def album_create_songs_rd(self, album: BriefAlbumProtocol):
-        """Create songs reader for album model."""
-        return self._handle_protocol_with_model(
-            SupportsAlbumSongsReader,
-            lambda p, m: p.album_create_songs_rd(m),
-            lambda v1_m: create_reader(v1_m.songs),  # type: ignore
-            album,
-        )
-
     def _handle_protocol_with_model(self,
                                     protocol_cls: Type[T_p],
                                     v2_handler: Callable[[T_p, Any], Any],

feeluown/player/lyric.py

@@ -4,8 +4,8 @@
 from typing import Dict, Optional, TYPE_CHECKING
 from collections import namedtuple, OrderedDict
 
-from feeluown.library import LyricModel, NotSupported
-from feeluown.utils import aio
+from feeluown.library import LyricModel
+from feeluown.utils.aio import run_fn
 from feeluown.utils.dispatch import Signal
 
 if TYPE_CHECKING:
@@ -207,17 +207,15 @@ def on_song_changed(self, song):
         def cb(future):
             try:
                 lyric = future.result()
-            except NotSupported:
-                lyric = None
             except:  # noqa
                 logger.exception('get lyric failed')
                 lyric = None
             self.set_lyric(lyric)
 
-        future = aio.run_fn(self._app.library.song_get_lyric, song)
+        future = run_fn(self._app.library.song_get_lyric, song)
         future.add_done_callback(cb)
 
-    def set_lyric(self, model: LyricModel):
+    def set_lyric(self, model: Optional[LyricModel]):
         if model is None:
             self._lyric = self._trans_lyric = None
         elif model.content: