Add list of things still left and reoder (#348)

Author: joostlek

src/spotifyaio/spotify.py

@@ -147,19 +147,96 @@ async def get_album(self, album_id: str) -> Album:
         response = await self._get(f"v1/albums/{identifier}")
         return Album.from_json(response)
 
+    # Get a list of albums
+
+    # Get an album's tracks
+
+    async def get_saved_albums(self) -> list[SavedAlbum]:
+        """Get saved albums."""
+        params: dict[str, Any] = {"limit": 48}
+        response = await self._get("v1/me/albums", params=params)
+        return SavedAlbumResponse.from_json(response).items
+
+    # Save an album
+
+    # Remove an album
+
+    # Check if one or more albums is already saved
+
+    async def get_new_releases(self) -> list[SimplifiedAlbum]:
+        """Get new releases."""
+        params: dict[str, Any] = {"limit": 48}
+        response = await self._get("v1/browse/new-releases", params=params)
+        return NewReleasesResponse.from_json(response).albums.items
+
     async def get_artist(self, artist_id: str) -> Artist:
         """Get artist."""
         identifier = artist_id.split(":")[-1]
         response = await self._get(f"v1/artists/{identifier}")
         return Artist.from_json(response)
 
+    # Get several artists
+
     async def get_artist_albums(self, artist_id: str) -> list[SimplifiedAlbum]:
         """Get artist albums."""
         params: dict[str, Any] = {"limit": 48}
         identifier = artist_id.split(":")[-1]
         response = await self._get(f"v1/artists/{identifier}/albums", params=params)
         return NewReleasesResponseInner.from_json(response).items
 
+    # Get an artist's top tracks
+
+    # Get an artist's related artists
+
+    # Get audiobook
+
+    # Get several audiobooks
+
+    # Get an audiobook's episodes
+
+    # Get saved audiobooks
+
+    # Save an audiobook
+
+    # Remove an audiobook
+
+    # Check if one or more audiobooks is already saved
+
+    async def get_categories(self) -> list[Category]:
+        """Get list of categories."""
+        params: dict[str, Any] = {"limit": 48}
+        response = await self._get("v1/browse/categories", params=params)
+        return CategoriesResponse.from_json(response).categories.items
+
+    async def get_category(self, category_id: str) -> Category:
+        """Get category."""
+        response = await self._get(f"v1/browse/categories/{category_id}")
+        return Category.from_json(response)
+
+    # Get chapter
+
+    # Get several chapters
+
+    async def get_episode(self, episode_id: str) -> Episode:
+        """Get episode."""
+        identifier = episode_id.split(":")[-1]
+        response = await self._get(f"v1/episodes/{identifier}")
+        return Episode.from_json(response)
+
+    # Get several episodes
+
+    # Get saved episodes
+
+    # Save an episode
+
+    # Remove an episode
+
+    # Check if one or more episodes is already saved
+
+    # Get genre seeds
+
+    # Get available markets
+
     async def get_playback(self) -> PlaybackState | None:
         """Get playback state."""
         response = await self._get(
@@ -169,13 +246,6 @@ async def get_playback(self) -> PlaybackState | None:
             return None
         return PlaybackState.from_json(response)
 
-    async def get_current_playing(self) -> CurrentPlaying | None:
-        """Get playback state."""
-        response = await self._get("v1/me/player/currently-playing")
-        if response == "":
-            return None
-        return CurrentPlaying.from_json(response)
-
     async def transfer_playback(self, device_id: str) -> None:
         """Transfer playback."""
         await self._put("v1/me/player", {"device_ids": [device_id]})
@@ -185,6 +255,13 @@ async def get_devices(self) -> list[Device]:
         response = await self._get("v1/me/player/devices")
         return Devices.from_json(response).devices
 
+    async def get_current_playing(self) -> CurrentPlaying | None:
+        """Get playback state."""
+        response = await self._get("v1/me/player/currently-playing")
+        if response == "":
+            return None
+        return CurrentPlaying.from_json(response)
+
     async def start_playback(
         self,
         *,
@@ -261,6 +338,14 @@ async def set_shuffle(self, *, state: bool, device_id: str | None = None) -> Non
             params["device_id"] = device_id
         await self._put("v1/me/player/shuffle", params=params)
 
+    async def get_recently_played_tracks(self) -> list[PlayedTrack]:
+        """Get recently played tracks."""
+        params: dict[str, Any] = {"limit": 48}
+        response = await self._get("v1/me/player/recently-played", params=params)
+        return PlayedTrackResponse.from_json(response).items
+
+    # Get queue
+
     async def add_to_queue(self, uri: str, device_id: str | None = None) -> None:
         """Add to queue."""
         data: dict[str, str] = {"uri": uri}
@@ -274,52 +359,52 @@ async def get_playlist(self, playlist_id: str) -> Playlist:
         response = await self._get(f"v1/playlists/{identifier}")
         return Playlist.from_json(response)
 
+    # Update playlist details
+
+    # Get a playlist items
+
+    # Update a playlist items
+
+    # Remove a playlist items
+
     async def get_playlists_for_current_user(self) -> list[BasePlaylist]:
         """Get playlists."""
         params: dict[str, Any] = {"limit": 48}
         response = await self._get("v1/me/playlists", params=params)
         return PlaylistResponse.from_json(response).items
 
-    async def get_followed_artists(self) -> list[Artist]:
-        """Get followed artists."""
-        params: dict[str, Any] = {"limit": 48, "type": "artist"}
-        response = await self._get("v1/me/following", params=params)
-        return ArtistResponse.from_json(response).artists.items
+    # Get users playlists
+
+    # Create a playlist
 
     async def get_featured_playlists(self) -> list[BasePlaylist]:
         """Get featured playlists."""
         params: dict[str, Any] = {"limit": 48}
         response = await self._get("v1/browse/featured-playlists", params=params)
         return FeaturedPlaylistResponse.from_json(response).playlists.items
 
-    async def get_category(self, category_id: str) -> Category:
-        """Get category."""
-        response = await self._get(f"v1/browse/categories/{category_id}")
-        return Category.from_json(response)
-
-    async def get_categories(self) -> list[Category]:
-        """Get category."""
+    async def get_category_playlists(self, category_id: str) -> list[BasePlaylist]:
+        """Get category playlists."""
         params: dict[str, Any] = {"limit": 48}
-        response = await self._get("v1/browse/categories", params=params)
-        return CategoriesResponse.from_json(response).categories.items
+        response = await self._get(
+            f"v1/browse/categories/{category_id}/playlists",
+            params=params,
+        )
+        return CategoryPlaylistResponse.from_json(response).playlists.items
 
-    async def get_saved_albums(self) -> list[SavedAlbum]:
-        """Get saved albums."""
-        params: dict[str, Any] = {"limit": 48}
-        response = await self._get("v1/me/albums", params=params)
-        return SavedAlbumResponse.from_json(response).items
+    # Get playlist cover image
 
-    async def get_saved_tracks(self) -> list[SavedTrack]:
-        """Get saved tracks."""
-        params: dict[str, Any] = {"limit": 48}
-        response = await self._get("v1/me/tracks", params=params)
-        return SavedTrackResponse.from_json(response).items
+    # Upload a custom playlist cover image
 
-    async def get_saved_shows(self) -> list[SavedShow]:
-        """Get saved shows."""
-        params: dict[str, Any] = {"limit": 48}
-        response = await self._get("v1/me/shows", params=params)
-        return SavedShowResponse.from_json(response).items
+    # Search for an item
+
+    async def get_show(self, show_id: str) -> Show:
+        """Get show."""
+        identifier = show_id.split(":")[-1]
+        response = await self._get(f"v1/shows/{identifier}")
+        return Show.from_json(response)
+
+    # Get several shows
 
     async def get_show_episodes(self, show_id: str) -> list[SimplifiedEpisode]:
         """Get show episodes."""
@@ -328,26 +413,46 @@ async def get_show_episodes(self, show_id: str) -> list[SimplifiedEpisode]:
         response = await self._get(f"v1/shows/{identifier}/episodes", params=params)
         return ShowEpisodesResponse.from_json(response).items
 
-    async def get_recently_played_tracks(self) -> list[PlayedTrack]:
-        """Get recently played tracks."""
+    async def get_saved_shows(self) -> list[SavedShow]:
+        """Get saved shows."""
         params: dict[str, Any] = {"limit": 48}
-        response = await self._get("v1/me/player/recently-played", params=params)
-        return PlayedTrackResponse.from_json(response).items
+        response = await self._get("v1/me/shows", params=params)
+        return SavedShowResponse.from_json(response).items
 
-    async def get_category_playlists(self, category_id: str) -> list[BasePlaylist]:
-        """Get category playlists."""
-        params: dict[str, Any] = {"limit": 48}
-        response = await self._get(
-            f"v1/browse/categories/{category_id}/playlists",
-            params=params,
-        )
-        return CategoryPlaylistResponse.from_json(response).playlists.items
+    # Save a show
 
-    async def get_new_releases(self) -> list[SimplifiedAlbum]:
-        """Get new releases."""
+    # Remove a show
+
+    # Check if one or more shows is already saved
+
+    # Get a track
+
+    # Get several tracks
+
+    async def get_saved_tracks(self) -> list[SavedTrack]:
+        """Get saved tracks."""
         params: dict[str, Any] = {"limit": 48}
-        response = await self._get("v1/browse/new-releases", params=params)
-        return NewReleasesResponse.from_json(response).albums.items
+        response = await self._get("v1/me/tracks", params=params)
+        return SavedTrackResponse.from_json(response).items
+
+    # Save a track
+
+    # Remove a track
+
+    # Check if one or more tracks is already saved
+
+    # Get audio features for several tracks
+
+    # Get audio features for a track
+
+    # Get audio analysis for a track
+
+    # Get recommendations
+
+    async def get_current_user(self) -> UserProfile:
+        """Get current user."""
+        response = await self._get("v1/me")
+        return UserProfile.from_json(response)
 
     async def get_top_artists(self) -> list[Artist]:
         """Get top artists."""
@@ -361,28 +466,29 @@ async def get_top_tracks(self) -> list[Track]:
         response = await self._get("v1/me/top/tracks", params=params)
         return TopTracksResponse.from_json(response).items
 
-    async def get_episode(self, episode_id: str) -> Episode:
-        """Get episode."""
-        identifier = episode_id.split(":")[-1]
-        response = await self._get(f"v1/episodes/{identifier}")
-        return Episode.from_json(response)
-
-    async def get_show(self, show_id: str) -> Show:
-        """Get show."""
-        identifier = show_id.split(":")[-1]
-        response = await self._get(f"v1/shows/{identifier}")
-        return Show.from_json(response)
-
-    async def get_current_user(self) -> UserProfile:
-        """Get current user."""
-        response = await self._get("v1/me")
-        return UserProfile.from_json(response)
-
     async def get_user(self, user_id: str) -> BaseUserProfile:
         """Get user."""
         response = await self._get(f"v1/users/{user_id}")
         return BaseUserProfile.from_json(response)
 
+    # Follow a playlist
+
+    # Unfollow a playlist
+
+    async def get_followed_artists(self) -> list[Artist]:
+        """Get followed artists."""
+        params: dict[str, Any] = {"limit": 48, "type": "artist"}
+        response = await self._get("v1/me/following", params=params)
+        return ArtistResponse.from_json(response).artists.items
+
+    # Follow an artist or user
+
+    # Unfollow an artist or user
+
+    # Check if a user is following an artist or user
+
+    # Check if a user is following a playlist
+
     async def close(self) -> None:
         """Close open client session."""
         if self.session and self._close_session: