deezer-python 5.11.1__tar.gz → 6.0.0__tar.gz

{deezer_python-5.11.1 → deezer_python-6.0.0}/PKG-INFO

@@ -1,20 +1,19 @@
 Metadata-Version: 2.1
 Name: deezer-python
-Version: 5.11.1
+Version: 6.0.0
 Summary: A friendly wrapper library for the Deezer API
 Home-page: https://github.com/browniebroke/deezer-python
 License: MIT
 Keywords: deezer,sdk,client,requests
 Author: Bruno Alla
 Author-email: alla.brunoo@gmail.com
-Requires-Python: >=3.7,<4.0
+Requires-Python: >=3.8,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10

{deezer_python-5.11.1 → deezer_python-6.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "deezer-python"
-version = "5.11.1"
+version = "6.0.0"
 description = "A friendly wrapper library for the Deezer API"
 authors = ["Bruno Alla <alla.brunoo@gmail.com>"]
 license = "MIT"
@@ -26,7 +26,7 @@ packages = [
 "Mastodon" = "https://fosstodon.org/@browniebroke"
 
 [tool.poetry.dependencies]
-python = "^3.7"
+python = "^3.8"
 requests = ">=2.18"
 
 [tool.poetry.group.docs]
@@ -45,8 +45,8 @@ pytest = "^7.0"
 pytest-cov = "^4.0"
 pytest-mock = "^3.6"
 pytest-vcr = "^1.0"
-vcrpy = "^4.1"
-deezer-oauth-cli = "^0.4"
+vcrpy = "^5.0.0"
+deezer-oauth-cli = "^1.0.0"
 
 [tool.semantic_release]
 version_toml = "pyproject.toml:tool.poetry.version"

{deezer_python-5.11.1 → deezer_python-6.0.0}/src/deezer/__init__.py

@@ -15,7 +15,7 @@ from deezer.resources import (
     User,
 )
 
-__version__ = "5.11.1"
+__version__ = "6.0.0"
 __all__ = [
     "Album",
     "Artist",

{deezer_python-5.11.1 → deezer_python-6.0.0}/src/deezer/client.py

@@ -565,9 +565,12 @@ class Client:
         Create a playlist on the user's account
 
         :param playlist_name: the name of the playlist.
-        :return: ID of the new playlist.
+        :return: the ID of the playlist that was created
         """
-        return self.request("POST", "user/me/playlists", title=playlist_name).id
+        result = self.request("POST", "user/me/playlists", title=playlist_name)
+        # Note: the REST API call returns a dict with just the "id" key in it,
+        # so we return that instead of the full Playlist object
+        return result.id
 
     def delete_playlist(self, playlist_id) -> bool:
         """

{deezer_python-5.11.1 → deezer_python-6.0.0}/src/deezer/resources/resource.py

@@ -71,6 +71,32 @@ class Resource:
             **kwargs,
         )
 
+    def post_relation(self, relation, **kwargs):
+        """
+        Generic method to make a POST request to a relation from any resource.
+
+        This is not meant to be used directly by a client, it's more
+        a helper method for the child objects.
+        """
+        return self.client.request(
+            "POST",
+            f"{self.type}/{self.id}/{relation}",
+            **kwargs,
+        )
+
+    def delete_relation(self, relation, **kwargs):
+        """
+        Generic method to make a DELETE request to a relation from any resource.
+
+        This is not meant to be used directly by a client, it's more
+        a helper method for the child objects.
+        """
+        return self.client.request(
+            "DELETE",
+            f"{self.type}/{self.id}/{relation}",
+            **kwargs,
+        )
+
     def get_paginated_list(
         self,
         relation: str,

deezer_python-6.0.0/src/deezer/resources/user.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import TYPE_CHECKING
+
+from ..dates import parse_date
+from ..utils import get_id
+from .resource import Resource
+
+if TYPE_CHECKING:
+    from ..pagination import PaginatedList
+    from .album import Album
+    from .artist import Artist
+    from .playlist import Playlist
+    from .track import Track
+
+
+class User(Resource):
+    """
+    To work with Deezer user objects.
+
+    Check the :deezer-api:`Deezer documentation <user>`
+    for more details about each field.
+    """
+
+    id: int
+    name: str
+    lastname: str | None
+    firstname: str | None
+    email: str | None
+    status: int | None
+    birthday: dt.date | None
+    inscription_date: dt.date
+    gender: str | None
+    link: str
+    picture: str
+    picture_small: str
+    picture_medium: str
+    picture_big: str
+    picture_xl: str
+    country: str
+    lang: str | None
+    is_kid: bool | None
+    explicit_content_level: str | None
+    explicit_content_levels_available: list[str] | None
+    tracklist: str
+
+    _parse_birthday = staticmethod(parse_date)
+    _parse_inscription_date = staticmethod(parse_date)
+
+    def get_albums(self, **kwargs) -> PaginatedList[Album]:
+        """
+        Get user's favorite albums.
+
+        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
+                  of :class:`Album <deezer.Album>` instances
+        """
+        return self.get_paginated_list("albums", **kwargs)
+
+    def add_album(self, album: Album | int):
+        """
+        Add an album to user's favorite albums.
+
+        :param album: an :class:`~deezer.Album` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.post_relation("albums", album_id=get_id(album))
+
+    def remove_album(self, album: Album | int):
+        """
+        Remove an album from user's favorite albums.
+
+        :param album: an :class:`~deezer.Album` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.delete_relation("albums", album_id=get_id(album))
+
+    def get_tracks(self, **kwargs) -> PaginatedList[Track]:
+        """
+        Get user's favorite tracks.
+
+        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
+                  of :class:`Track <deezer.Track>` instances
+        """
+        return self.get_paginated_list("tracks", **kwargs)
+
+    def add_track(self, track: Track | int):
+        """
+        Add a track to user's favorite tracks.
+
+        :param track: a :class:`~deezer.Track` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.post_relation("tracks", track_id=get_id(track))
+
+    def remove_track(self, track: Track | int):
+        """
+        Remove a track from user's favorite tracks.
+
+        :param track: a :class:`~deezer.Track` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.delete_relation("tracks", track_id=get_id(track))
+
+    def get_artists(self, **kwargs) -> PaginatedList[Artist]:
+        """
+        Get user's favorite artists.
+
+        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
+                  of :class:`Artist <deezer.Artist>` instances
+        """
+        return self.get_paginated_list("artists", **kwargs)
+
+    def add_artist(self, artist: Artist | int):
+        """
+        Add an artist to user's favorite artists.
+
+        :param artist: an :class:`~deezer.Artist` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.post_relation("artists", artist_id=get_id(artist))
+
+    def remove_artist(self, artist: Artist | int):
+        """
+        Remove an artist from user's favorite artists.
+
+        :param artist: an :class:`~deezer.Artist` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.delete_relation("artists", artist_id=get_id(artist))
+
+    def get_followers(self, **kwargs) -> PaginatedList[User]:
+        """
+        Get user's followers.
+
+        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
+                  of :class:`User <deezer.User>` instances
+        """
+        return self.get_paginated_list("followers", **kwargs)
+
+    def get_followings(self, **kwargs) -> PaginatedList[User]:
+        """
+        Get user's followings.
+
+        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
+                  of :class:`User <deezer.User>` instances
+        """
+        return self.get_paginated_list("followings", **kwargs)
+
+    def follow(self, user: User | int):
+        """
+        Follow a user.
+
+        :param user: a :class:`~deezer.User` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.post_relation("followings", user_id=get_id(user))
+
+    def unfollow(self, user: User | int):
+        """
+        Unfollow a user.
+
+        :param user: a :class:`~deezer.User` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.delete_relation("followings", user_id=get_id(user))
+
+    def get_playlists(self, **kwargs) -> PaginatedList[Playlist]:
+        """
+        Get user's public playlists.
+
+        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
+                  of :class:`Playlist <deezer.Playlist>` instances
+        """
+        return self.get_paginated_list("playlists", **kwargs)
+
+    def add_playlist(self, playlist: Playlist | int):
+        """
+        Add a playlist to user's public playlists.
+
+        :param playlist: a :class:`~deezer.Playlist` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.post_relation("playlists", playlist_id=get_id(playlist))
+
+    def remove_playlist(self, playlist: Playlist | int):
+        """
+        Remove a playlist from user's public playlists.
+
+        :param playlist: a :class:`~deezer.Playlist` instance or its ID
+        :returns: a boolean that tells if the operation was successful
+        """
+        return self.delete_relation("playlists", playlist_id=get_id(playlist))
+
+    def create_playlist(self, title: str) -> int:
+        """
+        Create a playlist.
+
+        :param title: the title of the playlist
+        :returns: the ID of the playlist that was created
+        """
+        result = self.post_relation("playlists", title=title)
+        # Note: the REST API call returns a dict with just the "id" key in it,
+        # so we return that instead of the full Playlist object
+        return result.id

{deezer_python-5.11.1 → deezer_python-6.0.0}/src/deezer/utils.py

@@ -9,9 +9,13 @@ if TYPE_CHECKING:
 def gen_ids(item_list: Iterable[int | Resource]) -> Generator[int, None, None]:
     """Get IDs for an iterable of `int` or `Resources`."""
     for item in item_list:
-        if isinstance(item, int):
-            yield item
-        elif hasattr(item, "id"):
-            yield item.id
-        else:
-            raise NotImplementedError(f"Unknown type for {item}")
+        yield get_id(item)
+
+
+def get_id(item: int | Resource) -> int:
+    """Get ID for an `int` or `Resource`."""
+    if isinstance(item, int):
+        return item
+    if hasattr(item, "id"):
+        return item.id
+    raise NotImplementedError(f"Unknown type for {item}")

deezer_python-5.11.1/src/deezer/resources/user.py

@@ -1,102 +0,0 @@
-from __future__ import annotations
-
-import datetime as dt
-from typing import TYPE_CHECKING
-
-from ..dates import parse_date
-from .resource import Resource
-
-if TYPE_CHECKING:
-    from ..pagination import PaginatedList
-    from .album import Album
-    from .artist import Artist
-    from .playlist import Playlist
-    from .track import Track
-
-
-class User(Resource):
-    """
-    To work with Deezer user objects.
-
-    Check the :deezer-api:`Deezer documentation <user>`
-    for more details about each field.
-    """
-
-    id: int
-    name: str
-    lastname: str | None
-    firstname: str | None
-    email: str | None
-    status: int | None
-    birthday: dt.date | None
-    inscription_date: dt.date
-    gender: str | None
-    link: str
-    picture: str
-    picture_small: str
-    picture_medium: str
-    picture_big: str
-    picture_xl: str
-    country: str
-    lang: str | None
-    is_kid: bool | None
-    explicit_content_level: str | None
-    explicit_content_levels_available: list[str] | None
-    tracklist: str
-
-    _parse_birthday = staticmethod(parse_date)
-    _parse_inscription_date = staticmethod(parse_date)
-
-    def get_albums(self, **kwargs) -> PaginatedList[Album]:
-        """
-        Get user's favorite albums.
-
-        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
-                  of :class:`Album <deezer.Album>` instances
-        """
-        return self.get_paginated_list("albums", **kwargs)
-
-    def get_tracks(self, **kwargs) -> PaginatedList[Track]:
-        """
-        Get user's favorite tracks.
-
-        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
-                  of :class:`Track <deezer.Track>` instances
-        """
-        return self.get_paginated_list("tracks", **kwargs)
-
-    def get_artists(self, **kwargs) -> PaginatedList[Artist]:
-        """
-        Get user's favorite artists.
-
-        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
-                  of :class:`Artist <deezer.Artist>` instances
-        """
-        return self.get_paginated_list("artists", **kwargs)
-
-    def get_followers(self, **kwargs) -> PaginatedList[User]:
-        """
-        Get user's followers.
-
-        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
-                  of :class:`User <deezer.User>` instances
-        """
-        return self.get_paginated_list("followers", **kwargs)
-
-    def get_followings(self, **kwargs) -> PaginatedList[User]:
-        """
-        Get user's followings.
-
-        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
-                  of :class:`User <deezer.User>` instances
-        """
-        return self.get_paginated_list("followings", **kwargs)
-
-    def get_playlists(self, **kwargs) -> PaginatedList[Playlist]:
-        """
-        Get user's public playlists.
-
-        :returns: a :class:`PaginatedList <deezer.PaginatedList>`
-                  of :class:`Playlist <deezer.Playlist>` instances
-        """
-        return self.get_paginated_list("playlists", **kwargs)