Manually fix ruff lints

pyproject.toml

@@ -91,6 +91,7 @@ ignore = [
 	"ANN401", # any-type
 	"D",      # pydocstyle
 	"ISC001", # single-line-implicit-string-concatenation
+	"SLF001", # private-member-access
 	"TRY003", # raise-vanilla-args
 ]
 
@@ -103,7 +104,6 @@ ignore = [
 	"PLR0913", # too-many-arguments
 	"PLR2004", # magic-value-comparison
 	"PT027",   # pytest-unittest-raises-assertion
-	"SLF001",  # private-member-access
 	"TRY002",  # raise-vanilla-class
 ]
 

src/mopidy_spotify/browse.py

@@ -47,14 +47,20 @@
 }
 
 
-def browse(*, config, session, web_client, uri):
+def browse(  # noqa: C901, PLR0911, PLR0912
+    *,
+    config,  # noqa: ARG001
+    session,  # noqa: ARG001
+    web_client,
+    uri,
+):
     if uri == ROOT_DIR.uri:
         return _ROOT_DIR_CONTENTS
-    elif uri == _TOP_LIST_DIR.uri:
+    if uri == _TOP_LIST_DIR.uri:
         return _TOP_LIST_DIR_CONTENTS
-    elif uri == _YOUR_MUSIC_DIR.uri:
+    if uri == _YOUR_MUSIC_DIR.uri:
         return _YOUR_MUSIC_DIR_CONTENTS
-    elif uri == _PLAYLISTS_DIR.uri:
+    if uri == _PLAYLISTS_DIR.uri:
         return _PLAYLISTS_DIR_CONTENTS
 
     if web_client is None or not web_client.logged_in:
@@ -63,22 +69,21 @@ def browse(*, config, session, web_client, uri):
     # TODO: Support for category browsing.
     if uri.startswith(("spotify:user:", "spotify:playlist:")):
         return _browse_playlist(web_client, uri)
-    elif uri.startswith("spotify:album:"):
+    if uri.startswith("spotify:album:"):
         return _browse_album(web_client, uri)
-    elif uri.startswith("spotify:artist:"):
+    if uri.startswith("spotify:artist:"):
         return _browse_artist(web_client, uri)
-    elif uri.startswith("spotify:top:"):
+    if uri.startswith("spotify:top:"):
         parts = uri.replace("spotify:top:", "").split(":")
-        if len(parts) == 1:
-            return _browse_toplist_user(web_client, variant=parts[0])
-        else:
+        if len(parts) != 1:
             logger.info(f"Failed to browse {uri!r}: Toplist URI parsing failed")
             return []
-    elif uri.startswith("spotify:your:"):
+        return _browse_toplist_user(web_client, variant=parts[0])
+    if uri.startswith("spotify:your:"):
         parts = uri.replace("spotify:your:", "").split(":")
         if len(parts) == 1:
             return _browse_your_music(web_client, variant=parts[0])
-    elif uri.startswith("spotify:playlists:"):
+    if uri.startswith("spotify:playlists:"):
         parts = uri.replace("spotify:playlists:", "").split(":")
         if len(parts) == 1:
             return _browse_playlists(web_client, variant=parts[0])
@@ -88,7 +93,12 @@ def browse(*, config, session, web_client, uri):
 
 
 def _browse_playlist(web_client, uri):
-    return playlists.playlist_lookup(web_client, uri, None, as_items=True)
+    return playlists.playlist_lookup(
+        web_client,
+        uri,
+        bitrate=None,
+        as_items=True,
+    )
 
 
 def _browse_album(web_client, uri):
@@ -134,10 +144,11 @@ def _browse_toplist_user(web_client, variant):
                 if page
             ]
         )
-        if variant == "tracks":
-            return list(translator.web_to_track_refs(items, check_playable=False))
-        else:
-            return list(translator.web_to_artist_refs(items))
+        match variant:
+            case "tracks":
+                return list(translator.web_to_track_refs(items, check_playable=False))
+            case "artists":
+                return list(translator.web_to_artist_refs(items))
     else:
         return []
 
@@ -162,29 +173,30 @@ def _load_your_music(web_client, variant):
 
 def _browse_your_music(web_client, variant):
     items = _load_your_music(web_client, variant)
-    if variant == "tracks":
-        return list(translator.web_to_track_refs(items))
-    elif variant == "albums":
-        return list(translator.web_to_album_refs(items))
-    else:
-        return []
+    match variant:
+        case "tracks":
+            return list(translator.web_to_track_refs(items))
+        case "albums":
+            return list(translator.web_to_album_refs(items))
+        case _:
+            return []
 
 
 def _browse_playlists(web_client, variant):
     if not web_client.logged_in:
         return []
 
-    if variant == "featured":
-        items = flatten(
-            [
-                page.get("playlists", {}).get("items", [])
-                for page in web_client.get_all(
-                    "browse/featured-playlists",
-                    params={"limit": 50},
-                )
-                if page
-            ]
-        )
-        return list(translator.to_playlist_refs(items))
-    else:
+    if variant != "featured":
         return []
+
+    items = flatten(
+        [
+            page.get("playlists", {}).get("items", [])
+            for page in web_client.get_all(
+                "browse/featured-playlists",
+                params={"limit": 50},
+            )
+            if page
+        ]
+    )
+    return list(translator.to_playlist_refs(items))

src/mopidy_spotify/distinct.py

@@ -13,35 +13,38 @@ def get_distinct(config, playlists, web_client, field, query=None):
     if web_client is None or not web_client.logged_in:
         return set()
 
-    if field == "artist":
-        result = _get_distinct_artists(config, playlists, web_client, query)
-    elif field == "albumartist":
-        result = _get_distinct_albumartists(config, playlists, web_client, query)
-    elif field == "album":
-        result = _get_distinct_albums(config, playlists, web_client, query)
-    elif field == "date":
-        result = _get_distinct_dates(config, playlists, web_client, query)
-    else:
-        result = set()
+    match field:
+        case "artist":
+            result = _get_distinct_artists(config, playlists, web_client, query)
+        case "albumartist":
+            result = _get_distinct_albumartists(config, playlists, web_client, query)
+        case "album":
+            result = _get_distinct_albums(config, playlists, web_client, query)
+        case "date":
+            result = _get_distinct_dates(config, playlists, web_client, query)
+        case _:
+            result = set()
 
     return result - {None}
 
 
 def _get_distinct_artists(config, playlists, web_client, query):
     logger.debug(f"Getting distinct artists: {query}")
+
     if query:
         search_result = _get_search(config, web_client, query, artist=True)
         return {artist.name for artist in search_result.artists}
-    else:
-        return {
-            artist.name
-            for track in _get_playlist_tracks(config, playlists, web_client)
-            for artist in track.artists
-        }
+
+    return {
+        artist.name
+        for track in _get_playlist_tracks(config, playlists, web_client)
+        for artist in track.artists
+    }
 
 
 def _get_distinct_albumartists(config, playlists, web_client, query):
     logger.debug(f"Getting distinct albumartists: {query}")
+
     if query:
         search_result = _get_search(config, web_client, query, album=True)
         return {
@@ -50,46 +53,56 @@ def _get_distinct_albumartists(config, playlists, web_client, query):
             for artist in album.artists
             if album.artists
         }
-    else:
-        return {
-            artists.name
-            for track in _get_playlist_tracks(config, playlists, web_client)
-            for artists in track.album.artists
-            if track.album and track.album.artists
-        }
+
+    return {
+        artists.name
+        for track in _get_playlist_tracks(config, playlists, web_client)
+        for artists in track.album.artists
+        if track.album and track.album.artists
+    }
 
 
 def _get_distinct_albums(config, playlists, web_client, query):
     logger.debug(f"Getting distinct albums: {query}")
+
     if query:
         search_result = _get_search(config, web_client, query, album=True)
         return {album.name for album in search_result.albums}
-    else:
-        return {
-            track.album.name
-            for track in _get_playlist_tracks(config, playlists, web_client)
-            if track.album
-        }
+
+    return {
+        track.album.name
+        for track in _get_playlist_tracks(config, playlists, web_client)
+        if track.album
+    }
 
 
 def _get_distinct_dates(config, playlists, web_client, query):
     logger.debug(f"Getting distinct album years: {query}")
+
     if query:
         search_result = _get_search(config, web_client, query, album=True)
         return {
             album.date
             for album in search_result.albums
             if album.date not in (None, "0")
         }
-    else:
-        return {
-            f"{track.album.date}"
-            for track in _get_playlist_tracks(config, playlists, web_client)
-            if track.album and track.album.date not in (None, 0)
-        }
-
 
-def _get_search(config, web_client, query, album=False, artist=False, track=False):
+    return {
+        f"{track.album.date}"
+        for track in _get_playlist_tracks(config, playlists, web_client)
+        if track.album and track.album.date not in (None, 0)
+    }
+
+
+def _get_search(  # noqa: PLR0913
+    config,
+    web_client,
+    query,
+    *,
+    album=False,
+    artist=False,
+    track=False,
+):
     types = []
     if album:
         types.append("album")
@@ -98,10 +111,19 @@ def _get_search(config, web_client, query, album=False, artist=False, track=Fals
     if track:
         types.append("track")
 
-    return search.search(config, web_client, query, types=types)
+    return search.search(
+        config,
+        web_client,
+        query=query,
+        types=types,
+    )
 
 
-def _get_playlist_tracks(config, playlists, web_client):
+def _get_playlist_tracks(
+    config,
+    playlists,
+    web_client,  # noqa: ARG001
+):
     if not playlists or not config["allow_playlists"]:
         return
 

src/mopidy_spotify/images.py

@@ -41,30 +41,32 @@ def _parse_uri(uri):
         parsed_uri = urllib.parse.urlparse(uri)
         uri_type, uri_id = None, None
 
-        if parsed_uri.scheme == "spotify":
-            fragments = parsed_uri.path.split(":")
-            if len(fragments) < 2:
-                raise ValueError("Too few fragments")
-            uri_type, uri_id = parsed_uri.path.split(":")[:2]
-        elif parsed_uri.scheme in ("http", "https"):
-            if parsed_uri.netloc in ("open.spotify.com", "play.spotify.com"):
-                uri_type, uri_id = parsed_uri.path.split("/")[1:3]
+        match parsed_uri.scheme:
+            case "spotify":
+                match parsed_uri.path.split(":"):
+                    case uri_type, uri_id, *_:
+                        pass
+                    case _:
+                        raise ValueError("Too few arguments")  # noqa: TRY301
+            case "http" | "https":
+                if parsed_uri.netloc in ("open.spotify.com", "play.spotify.com"):
+                    uri_type, uri_id = parsed_uri.path.split("/")[1:3]
 
         supported_types = ("track", "album", "artist", "playlist")
         if uri_type:
             if uri_type not in supported_types:
                 logger.warning(f"Unsupported image type '{uri_type}' in {uri!r}")
                 return None
-            elif uri_id:
+            if uri_id:
                 return {
                     "uri": uri,
                     "type": uri_type,
                     "id": uri_id,
                     "key": (uri_type, uri_id),
                 }
-        raise ValueError("Unknown error")
+        raise ValueError("Unknown error")  # noqa: TRY301
     except Exception as e:
-        logger.exception(f"Could not parse {uri!r} as a Spotify URI ({e})")
+        logger.exception(f"Could not parse {uri!r} as a Spotify URI ({e!s})")  # noqa: TRY401
 
 
 def _process_uri(web_client, uri):
@@ -73,7 +75,11 @@ def _process_uri(web_client, uri):
     return {uri["uri"]: _cache[uri["key"]]}
 
 
-def _process_uris(web_client, uri_type, uris):
+def _process_uris(  # noqa: C901
+    web_client,
+    uri_type,
+    uris,
+):
     result = {}
     ids = [u["id"] for u in uris]
     ids_to_uris = {u["id"]: u for u in uris}

src/mopidy_spotify/library.py

@@ -37,11 +37,16 @@ def get_images(self, uris):
     def lookup(self, uri):
         return lookup.lookup(self._config, self._backend._web_client, uri)
 
-    def search(self, query=None, uris=None, exact=False):
+    def search(
+        self,
+        query=None,
+        uris=None,
+        exact=False,  # noqa: FBT002
+    ):
         return search.search(
             self._config,
             self._backend._web_client,
-            query,
-            uris,
-            exact,
+            query=query,
+            uris=uris,
+            exact=exact,
         )