Another subset of review comments from @snejus:

- Renamed _extract_* methods to _parse_*
- Renamed release to date_parts
- Using .get instead of .request("GET"...)

Author: semohr

beetsplug/tidal/__init__.py

@@ -372,37 +372,37 @@ def _get_album_info(
                 track_info.index = i
                 track_infos.append(track_info)
 
-        artist_names, artist_ids = self._extract_artists(
+        artist_names, artist_ids = self._parse_artists(
             album["relationships"]["artists"]["data"],
             artist_lookup,
         )
-        release = self._extract_release_date(album["attributes"])
+        date_parts = self._parse_release_date(album["attributes"])
         return AlbumInfo(
             # Identifier
             data_source=self.data_source,
             album_id=album["id"],
             artists_ids=artist_ids,
-            data_url=self._extract_data_url(album["attributes"]),
+            data_url=self._parse_data_url(album["attributes"]),
             barcode=album["attributes"]["barcodeId"],
             # Meta
-            album=self._extract_title(album["attributes"]),
+            album=self._parse_title(album["attributes"]),
             tracks=track_infos,
             artist=", ".join(artist_names),
             artists=artist_names,
             duration=self._duration_to_seconds(album["attributes"]["duration"]),
             albumtype=album["attributes"]["albumType"],
-            label=self._extract_label(album["attributes"]),
-            year=release[0] if release else None,
-            month=release[1] if release else None,
-            day=release[2] if release else None,
+            label=self._parse_label(album["attributes"]),
+            year=date_parts[0] if date_parts else None,
+            month=date_parts[1] if date_parts else None,
+            day=date_parts[2] if date_parts else None,
         )
 
     def _get_track_info(
         self,
         track: TidalTrack,
         artist_lookup: dict[str, TidalArtist],
     ) -> TrackInfo:
-        artist_names, artist_ids = self._extract_artists(
+        artist_names, artist_ids = self._parse_artists(
             track["relationships"]["artists"]["data"],
             artist_lookup,
         )
@@ -412,18 +412,18 @@ def _get_track_info(
             data_source=self.data_source,
             track_id=track["id"],
             artists_ids=artist_ids,
-            data_url=self._extract_data_url(track["attributes"]),
+            data_url=self._parse_data_url(track["attributes"]),
             # Meta
-            title=self._extract_title(track["attributes"]),
+            title=self._parse_title(track["attributes"]),
             isrc=track["attributes"]["isrc"],
             artist=", ".join(artist_names),
             artists=artist_names,
             duration=self._duration_to_seconds(track["attributes"]["duration"]),
-            label=self._extract_label(track["attributes"]),
+            label=self._parse_label(track["attributes"]),
         )
 
     @staticmethod
-    def _extract_artists(
+    def _parse_artists(
         artist_relationships: list[ResourceIdentifier],
         artist_lookup: dict[str, TidalArtist],
     ) -> tuple[list[str], list[str]]:
@@ -447,7 +447,7 @@ def _extract_artists(
         return artist_names, artist_ids
 
     @staticmethod
-    def _extract_title(attributes: AlbumAttributes | TrackAttributes):
+    def _parse_title(attributes: AlbumAttributes | TrackAttributes):
         """
         Tidal UIs append the version string at the end of the title. We do the same here
         by formatting it as ``"{title} ({version})"`` to stay consistent.
@@ -458,7 +458,7 @@ def _extract_title(attributes: AlbumAttributes | TrackAttributes):
             return attributes["title"]
 
     @staticmethod
-    def _extract_data_url(
+    def _parse_data_url(
         attributes: AlbumAttributes | TrackAttributes,
     ) -> str | None:
         if external_links := attributes.get("externalLinks"):
@@ -483,15 +483,15 @@ def _duration_to_seconds(duration: str) -> int:
         )
 
     @staticmethod
-    def _extract_label(
+    def _parse_label(
         attributes: AlbumAttributes | TrackAttributes,
     ) -> str | None:
         if copyright := attributes.get("copyright"):
             return copyright["text"]
         return None
 
     @staticmethod
-    def _extract_release_date(
+    def _parse_release_date(
         attributes: AlbumAttributes,
     ) -> tuple[int, int, int] | None:
         """Returns year, month, day from iso YYYY-MM-DD"""

beetsplug/tidal/api.py

@@ -121,8 +121,6 @@ def get_paginated(
     ) -> Document[list[Any]]:
         """
         Perform a GET request to the Tidal API with pagination resolution.
-
-        This handles both top-level pagination and nested relationship pagination.
         """
         include = include or []
         params = params or {}
@@ -134,8 +132,7 @@ def get_paginated(
         }
 
         while next := doc.get("links", {}).get("next"):
-            res = self.request(
-                method="GET",
+            res = self.get(
                 url=next,
                 params={**params, "include": include},
                 **kwargs,

test/plugins/test_tidal.py

@@ -535,8 +535,8 @@ class TestStaticHelpers:
             ({}, None),
         ],
     )
-    def test_extract_data_url(self, attrs, expected):
-        assert TidalPlugin._extract_data_url(attrs) == expected
+    def test_parse_data_url(self, attrs, expected):
+        assert TidalPlugin._parse_data_url(attrs) == expected
 
     @pytest.mark.parametrize(
         "attrs, expected",
@@ -545,8 +545,8 @@ def test_extract_data_url(self, attrs, expected):
             ({}, None),
         ],
     )
-    def test_extract_label(self, attrs, expected):
-        assert TidalPlugin._extract_label(attrs) == expected
+    def test_parse_label(self, attrs, expected):
+        assert TidalPlugin._parse_label(attrs) == expected
 
     @pytest.mark.parametrize(
         "attrs, expected",
@@ -556,8 +556,8 @@ def test_extract_label(self, attrs, expected):
             ({"releaseDate": "2024"}, None),
         ],
     )
-    def test_extract_release_date(self, attrs, expected):
-        assert TidalPlugin._extract_release_date(attrs) == expected
+    def test_parse_release_date(self, attrs, expected):
+        assert TidalPlugin._parse_release_date(attrs) == expected
 
     @pytest.mark.parametrize(
         "duration,expected",