Merge branch 'dev' of https://github.com/music-assistant/server into dev

Author: marcelveldt

music_assistant/providers/plex/__init__.py

@@ -40,6 +40,7 @@
     MediaItemType,
     Playlist,
     ProviderMapping,
+    RecommendationFolder,
     SearchResults,
     Track,
     UniqueList,
@@ -91,6 +92,7 @@
 CONF_PLEX_LIKE_RATING = "plex_like_rating"
 CONF_PLEX_FAVORITE_THRESHOLD = "plex_favorite_threshold"
 CONF_PLEX_UNLIKE_RATING = "plex_unlike_rating"
+CONF_HUB_ITEMS_LIMIT = "hub_items_limit"
 
 FAKE_ARTIST_PREFIX = "_fake://"
 
@@ -108,6 +110,7 @@
     ProviderFeature.ARTIST_ALBUMS,
     ProviderFeature.ARTIST_TOPTRACKS,
     ProviderFeature.SIMILAR_TRACKS,
+    ProviderFeature.RECOMMENDATIONS,
 }
 
 
@@ -388,6 +391,19 @@ async def get_config_entries(  # noqa: PLR0915
         )
     )
 
+    # Recommendation settings (advanced)
+    entries.append(
+        ConfigEntry(
+            key=CONF_HUB_ITEMS_LIMIT,
+            type=ConfigEntryType.INTEGER,
+            label="Items per hub",
+            description="Maximum number of items to load from each hub (default: 10)",
+            default_value=10,
+            category="advanced",
+            range=(1, 100),
+        )
+    )
+
     # return all config entries
     return tuple(entries)
 
@@ -1125,6 +1141,111 @@ async def get_similar_tracks(self, prov_track_id: str, limit: int = 25) -> list[
             self.logger.warning("Error getting similar tracks for %s: %s", prov_track_id, err)
         return []
 
+    @use_cache(3600 * 3, cache_checksum="v2")  # Cache for 3 hours
+    async def recommendations(self) -> list[RecommendationFolder]:
+        """Get recommendations from Plex hubs."""
+        try:
+            # Get the configured limit for items per hub
+            limit_value = self.config.get_value(CONF_HUB_ITEMS_LIMIT)
+            limit = int(limit_value) if isinstance(limit_value, (int, float, str)) else 10
+
+            # Fetch hubs from the music library section with count parameter
+            # The section's hubs() method uses /hubs/sections/{key}?includeStations=1
+            # We need to add the count parameter manually to limit items per hub
+            key = f"/hubs/sections/{self._plex_library.key}?includeStations=1&count={limit}"
+            hubs = await self._run_async(self._plex_library.fetchItems, key)
+
+            if not hubs:
+                self.logger.debug("No hubs available from Plex")
+                return []
+
+            self.logger.debug(
+                "Fetching %d hubs (limit: %d items per hub)",
+                len(hubs),
+                limit,
+            )
+
+            folders = []
+            for hub in hubs:
+                # Create a recommendation folder for each hub
+                folder = RecommendationFolder(
+                    name=hub.title,
+                    item_id=f"{self.instance_id}_{hub.hubIdentifier}",
+                    provider=self.lookup_key,
+                    icon="mdi-music",
+                )
+
+                # Parse each item based on its type (limit to configured max)
+                # Use _partialItems to respect the count limit from the hubs() call
+                # rather than hub.items() which fetches ALL items if more is True
+                # _partialItems is a cached property that's already loaded, so no need for async
+                hub_items = hub._partialItems
+                self.logger.debug(
+                    "Processing hub '%s' (%s) with %d partial items",
+                    hub.title,
+                    hub.hubIdentifier,
+                    len(hub_items),
+                )
+                for item in hub_items:
+                    try:
+                        # Skip items without type attribute
+                        if not hasattr(item, "type"):
+                            self.logger.debug(
+                                "Skipping item in hub '%s': no type attribute",
+                                hub.title,
+                            )
+                            continue
+
+                        # Parse item based on its type
+                        if item.type == "track":
+                            folder.items.append(await self._parse_track(item))
+                        elif item.type == "album":
+                            folder.items.append(await self._parse_album(item))
+                        elif item.type == "artist":
+                            folder.items.append(await self._parse_artist(item))
+                        elif item.type == "playlist":
+                            folder.items.append(await self._parse_playlist(item))
+                        # Try to parse other types generically
+                        elif parsed_item := await self._parse(item):
+                            folder.items.append(parsed_item)  # type: ignore[arg-type]
+                        else:
+                            self.logger.debug(
+                                "Skipping unsupported item type '%s' in hub '%s'",
+                                item.type,
+                                hub.title,
+                            )
+                    except Exception as err:
+                        self.logger.debug(
+                            "Failed to parse item (type: %s) in hub '%s': %s",
+                            getattr(item, "type", "unknown"),
+                            hub.title,
+                            str(err),
+                        )
+                        continue
+
+                # Only add folder if it has items
+                if folder.items:
+                    folders.append(folder)
+                    self.logger.debug(
+                        "Added hub '%s' (%s) with %d items",
+                        hub.title,
+                        hub.hubIdentifier,
+                        len(folder.items),
+                    )
+                else:
+                    self.logger.debug(
+                        "Skipping hub '%s' (%s): no items after parsing",
+                        hub.title,
+                        hub.hubIdentifier,
+                    )
+
+            self.logger.debug("Retrieved %d recommendation folders from Plex", len(folders))
+            return folders
+
+        except Exception as err:
+            self.logger.warning("Error getting recommendations from Plex: %s", err)
+            return []
+
     async def get_stream_details(self, item_id: str, media_type: MediaType) -> StreamDetails:
         """Get streamdetails for a track."""
         plex_track = await self._get_data(item_id, PlexTrack)

music_assistant/providers/qobuz/__init__.py

@@ -16,6 +16,7 @@
     ContentType,
     ExternalID,
     ImageType,
+    MediaType,
     ProviderFeature,
     StreamType,
 )
@@ -31,7 +32,6 @@
     AudioFormat,
     MediaItemImage,
     MediaItemType,
-    MediaType,
     Playlist,
     ProviderMapping,
     SearchResults,
@@ -46,7 +46,7 @@
     VARIOUS_ARTISTS_NAME,
 )
 from music_assistant.controllers.cache import use_cache
-from music_assistant.helpers.app_vars import app_var
+from music_assistant.helpers.app_vars import app_var  # type: ignore[attr-defined]
 from music_assistant.helpers.json import json_loads
 from music_assistant.helpers.throttle_retry import ThrottlerManager, throttle_with_retries
 from music_assistant.helpers.util import (
@@ -77,6 +77,7 @@
     ProviderFeature.LIBRARY_PLAYLISTS_EDIT,
     ProviderFeature.LIBRARY_TRACKS_EDIT,
     ProviderFeature.PLAYLIST_TRACKS_EDIT,
+    ProviderFeature.PLAYLIST_CREATE,
     ProviderFeature.BROWSE,
     ProviderFeature.SEARCH,
     ProviderFeature.ARTIST_ALBUMS,
@@ -227,7 +228,7 @@ async def get_library_playlists(self) -> AsyncGenerator[Playlist, None]:
                 yield self._parse_playlist(item)
 
     @use_cache(3600 * 24 * 30)  # Cache for 30 days
-    async def get_artist(self, prov_artist_id) -> Artist:
+    async def get_artist(self, prov_artist_id: str) -> Artist:
         """Get full artist details by id."""
         params = {"artist_id": prov_artist_id}
         if (artist_obj := await self._get_data("artist/get", **params)) and artist_obj["id"]:
@@ -236,7 +237,7 @@ async def get_artist(self, prov_artist_id) -> Artist:
         raise MediaNotFoundError(msg)
 
     @use_cache(3600 * 24 * 30)  # Cache for 30 days
-    async def get_album(self, prov_album_id) -> Album:
+    async def get_album(self, prov_album_id: str) -> Album:
         """Get full album details by id."""
         params = {"album_id": prov_album_id}
         if (album_obj := await self._get_data("album/get", **params)) and album_obj["id"]:
@@ -245,7 +246,7 @@ async def get_album(self, prov_album_id) -> Album:
         raise MediaNotFoundError(msg)
 
     @use_cache(3600 * 24 * 30)  # Cache for 30 days
-    async def get_track(self, prov_track_id) -> Track:
+    async def get_track(self, prov_track_id: str) -> Track:
         """Get full track details by id."""
         params = {"track_id": prov_track_id}
         if (track_obj := await self._get_data("track/get", **params)) and track_obj["id"]:
@@ -254,16 +255,30 @@ async def get_track(self, prov_track_id) -> Track:
         raise MediaNotFoundError(msg)
 
     @use_cache(3600 * 24 * 30)  # Cache for 30 days
-    async def get_playlist(self, prov_playlist_id) -> Playlist:
+    async def get_playlist(self, prov_playlist_id: str) -> Playlist:
         """Get full playlist details by id."""
         params = {"playlist_id": prov_playlist_id}
         if (playlist_obj := await self._get_data("playlist/get", **params)) and playlist_obj["id"]:
             return self._parse_playlist(playlist_obj)
         msg = f"Item {prov_playlist_id} not found"
         raise MediaNotFoundError(msg)
 
+    async def create_playlist(self, name: str) -> Playlist:
+        """Create a new playlist on Qobuz with the given name."""
+        playlist_obj = await self._get_data(
+            "playlist/create",
+            name=name,
+            description="",
+            is_public=0,
+            is_collaborative=0,
+        )
+        if not playlist_obj or not playlist_obj.get("id"):
+            msg = f"Failed to create playlist: {name}"
+            raise InvalidDataError(msg)
+        return self._parse_playlist(playlist_obj)
+
     @use_cache(3600 * 24 * 30)  # Cache for 30 days
-    async def get_album_tracks(self, prov_album_id) -> list[Track]:
+    async def get_album_tracks(self, prov_album_id: str) -> list[Track]:
         """Get all album tracks for given album id."""
         params = {"album_id": prov_album_id}
         return [
@@ -295,7 +310,7 @@ async def get_playlist_tracks(self, prov_playlist_id: str, page: int = 0) -> lis
         return result
 
     @use_cache(3600 * 24 * 14)  # Cache for 14 days
-    async def get_artist_albums(self, prov_artist_id) -> list[Album]:
+    async def get_artist_albums(self, prov_artist_id: str) -> list[Album]:
         """Get a list of albums for the given artist."""
         result = await self._get_data(
             "artist/get",
@@ -311,7 +326,7 @@ async def get_artist_albums(self, prov_artist_id) -> list[Album]:
         ]
 
     @use_cache(3600 * 24 * 14)  # Cache for 14 days
-    async def get_artist_toptracks(self, prov_artist_id) -> list[Track]:
+    async def get_artist_toptracks(self, prov_artist_id: str) -> list[Track]:
         """Get a list of most popular tracks for the given artist."""
         result = await self._get_data(
             "artist/get",
@@ -387,7 +402,7 @@ async def add_playlist_tracks(self, prov_playlist_id: str, prov_track_ids: list[
 
     async def remove_playlist_tracks(
         self, prov_playlist_id: str, positions_to_remove: tuple[int]
-    ) -> None:
+    ) -> Any:
         """Remove track(s) from playlist."""
         playlist_track_ids = set()
         for pos in positions_to_remove:
@@ -497,7 +512,7 @@ async def on_streamed(
                 duration=try_parse_int(streamdetails.seconds_streamed),
             )
 
-    def _parse_artist(self, artist_obj: dict):
+    def _parse_artist(self, artist_obj: dict) -> Artist:
         """Parse qobuz artist object to generic layout."""
         artist = Artist(
             item_id=str(artist_obj["id"]),
@@ -686,7 +701,7 @@ async def _parse_track(self, track_obj: dict) -> Track:
 
         return track
 
-    def _parse_playlist(self, playlist_obj):
+    def _parse_playlist(self, playlist_obj: str) -> Playlist:
         """Parse qobuz playlist object to generic layout."""
         is_editable = (
             playlist_obj["owner"]["id"] == self._user_auth_info["user"]["id"]
@@ -719,7 +734,7 @@ def _parse_playlist(self, playlist_obj):
         return playlist
 
     @lock
-    async def _auth_token(self):
+    async def _auth_token(self) -> None:
         """Login to qobuz and store the token."""
         if self._user_auth_info:
             return self._user_auth_info["user_auth_token"]
@@ -738,7 +753,7 @@ async def _auth_token(self):
             return details["user_auth_token"]
         return None
 
-    async def _get_all_items(self, endpoint, key="tracks", **kwargs):
+    async def _get_all_items(self, endpoint, key="tracks", **kwargs) -> list[dict]:
         """Get all items from a paged list."""
         limit = 50
         offset = 0
@@ -759,7 +774,9 @@ async def _get_all_items(self, endpoint, key="tracks", **kwargs):
         return all_items
 
     @throttle_with_retries
-    async def _get_data(self, endpoint, sign_request=False, **kwargs):
+    async def _get_data(
+        self, endpoint: str, sign_request: bool = False, **kwargs: Any
+    ) -> dict | None:
         """Get data from api."""
         self.logger.debug("Handling GET request to %s", endpoint)
         url = f"http://www.qobuz.com/api.json/0.2/{endpoint}"
@@ -808,7 +825,12 @@ async def _get_data(self, endpoint, sign_request=False, **kwargs):
                 raise InvalidDataError(msg)
 
     @throttle_with_retries
-    async def _post_data(self, endpoint, params=None, data=None):
+    async def _post_data(
+        self,
+        endpoint: str,
+        params: dict[str, Any] | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         """Post data to api."""
         self.logger.debug("Handling POST request to %s", endpoint)
         if not params:

music_assistant/providers/squeezelite/player.py

@@ -91,7 +91,6 @@ def __init__(
             PlayerFeature.MULTI_DEVICE_DSP,
             PlayerFeature.VOLUME_SET,
             PlayerFeature.PAUSE,
-            PlayerFeature.VOLUME_MUTE,
             PlayerFeature.ENQUEUE,
             PlayerFeature.GAPLESS_PLAYBACK,
             PlayerFeature.GAPLESS_DIFFERENT_SAMPLERATE,