def del_tracks(self, tracks, own, max_elements_per_request=50):
"""Delete tracks from the playlist.
In order to limit the length of the resulting URL for a very large
number of tracks, split the request into multiple.
Parameters
----------
tracks: list: Track or int (playlist track id)
Tracks to be deleted. Note that the id used here, is Track.playlist_track_id, returned via Playlist.get_tracks
own: User
Deleting tracks requires a logged in User
max_elements_per_request: int
Split the request into multiple. Each with at most this many tracks
"""
if isinstance(tracks[0], int):
track_ids = tracks
else:
track_ids = [t.playlist_track_id for t in tracks]
for c in self._split_into_chunks(track_ids, max_elements_per_request):
api.request(
"playlist/deleteTracks",
playlist_id=self.id,
comma_encoding=False,
playlist_track_ids=",".join(map(str, c)),
user_auth_token=own.auth_token,
)
def favorites_add(self, obj):
"""Add artist/album/track to user's favorites.
Parameters
----------
obj: Artist/Album/Track
Object to be added to the favorites
Returns
-------
bool
Successfully added to favorites
"""
if isinstance(obj, Artist):
status = api.request(
"favorite/create",
artist_ids=obj.id,
user_auth_token=self.auth_token,
)
elif isinstance(obj, Album):
status = api.request(
"favorite/create",
album_ids=obj.id,
user_auth_token=self.auth_token,
)
elif isinstance(obj, Track):
status = api.request(
"favorite/create",
track_ids=obj.id,
user_auth_token=self.auth_token,
)
else:
raise TypeError("obj must be Artist, Album or Track")
return status.get("status") == "success"
def add_tracks(self, tracks, own, max_elements_per_request=50):
"""Add tracks to the playlist.
In order to limit the length of the resulting URL for a very large
number of tracks, split the request into multiple.
Parameters
----------
tracks: list: Track
Tracks to be added
own: User
Adding tracks requires a logged in User
max_elements_per_request: int
Split the request into multiple. Each with at most this many tracks
"""
track_ids = [t.id for t in tracks]
for c in self._split_into_chunks(track_ids, max_elements_per_request):
api.request(
"playlist/addTracks",
playlist_id=self.id,
comma_encoding=False,
track_ids=",".join(map(str, c)),
user_auth_token=own.auth_token,
)
def playlist_create(self,
name,
description=None,
is_public=0,
is_collaborative=0):
"""Create a new playlist.
Parameters
----------
name: str
Name for the new playlist
description: str
Description for the playlist
is_public: bool
Flag to make the playlist public.
is_collaborative: bool
Flag to make the playlist collaborative.
"""
playlist = api.request(
"playlist/create",
name=name,
description=description,
is_public=is_public,
is_collaborative=is_collaborative,
user_auth_token=self.auth_token,
)
return Playlist(playlist)
def search(cls, query, limit=50, offset=0, raw=False):
"""Search for a track.
Parameters
----------
query: str
Search query
limit: int
Number of elements returned per request
offset: int
Offset from which to obtain limit elements
raw: bool
results will be returned as json if True
Returns
-------
list of Track
Resulting tracks for the search query
"""
tracks = api.request("track/search",
query=query,
offset=offset,
limit=limit)
if raw:
return tracks
return [cls(t) for t in tracks["tracks"]["items"]]
def get_tracks(self, limit=50, offset=0):
"""Tracks of the playlist.
Parameters
---------
limit: int
Number of elements returned per request
offset: int
Offset from which to obtain limit elements
Returns
-------
lst
List of Tracks
"""
token = self._user.auth_token if self._user else None
playlist = api.request(
"playlist/get",
playlist_id=self.id,
extra="tracks",
limit=limit,
user_auth_token=token,
offset=offset,
)
return [Track(t) for t in playlist["tracks"]["items"]]
def get_file_url(self, track_id, format_id=None, intent=None):
"""Get the file url for a track.
Parameters
----------
track_id: int
Track-ID to get the url for
format_id: int
Format ID following qobuz specifications:
5: MP3 320
6: FLAC Lossless
7: FLAC Hi-Res 24 bit =< 96kHz,
27: FLAC Hi-Res 24 bit >96 kHz & =< 192 kHz
intent: str
How the application will use the file URL
Either 'stream', 'import', or 'download'.
Returns
-------
str
URL to the appropriate file
"""
resp = api.request(
"track/getFileUrl",
signed=True,
track_id=track_id,
format_id=format_id,
intent=intent,
user_auth_token=self.auth_token,
)
return resp.get("url")
def from_id(cls, playlist_id, user=None):
token = user.auth_token if user is not None else None
playlist = api.request("playlist/get",
playlist_id=playlist_id,
user_auth_token=token)
return cls(playlist, user=user)
def playlists_get(self, filter="owner", limit=50, offset=0):
result = api.request(
"playlist/getUserPlaylists",
filter=filter,
limit=limit,
offset=offset,
user_auth_token=self.auth_token,
)
return [Playlist(p, user=self) for p in result["playlists"]["items"]]
def reset_password(username):
"""Request the resetting of the current password.
Parameters
----------
username: str
Username to be sent a email with instructions.
Returns
-------
bool
Successfully requested
"""
resp = api.request("user/resetPassword", username=username)
return resp.get("status") == "success"
def __init__(self, username, password, device_manufacturer_id=None):
self.username = username
if device_manufacturer_id is None:
device_manufacturer_id = uuid.uuid4()
login_resp = api.request(
"user/login",
username=username,
password=self._hash_password(password),
device_manufacturer_id=device_manufacturer_id,
)
self.auth_token = login_resp["user_auth_token"]
self.id = login_resp["user"]["id"]
self.credential_id = login_resp["user"]["credential"]["id"]
self.device_id = login_resp["user"]["device"]["id"]
def favorites_get(self, fav_type=None, limit=50, offset=0, raw=False):
"""Get all favorites for the user.
Parameters
----------
fav_type: str
Favorite type: 'artists', 'albums' or 'tracks'
limit: int
Number of elements returned per request
offset: int
Offset from which to obtain limit elements
raw: bool
results will be returned as json if True
Returns
-------
list
List containing Artist/Album/Track objects
"""
favorites = api.request(
"favorite/getUserFavorites",
type=fav_type,
limit=limit,
offset=offset,
user_auth_token=self.auth_token,
)
if raw:
return favorites
if fav_type == "artists":
return [Artist(f) for f in favorites["artists"]["items"]]
if fav_type == "albums":
return [Album(f) for f in favorites["albums"]["items"]]
if fav_type == "tracks":
return [Track(f) for f in favorites["tracks"]["items"]]
else:
all_favorites = [Artist(f) for f in favorites["artists"]["items"]]
all_favorites.append(
Album(f) for f in favorites["albums"]["items"])
all_favorites.append(
Track(f) for f in favorites["tracks"]["items"])
return all_favorites
def playlist_delete(self, playlist):
"""Delete a playlist.
Parameters
----------
playlist: Playlist
Playlist to be deleted
Returns
-------
bool
Successfully deleted playlist
"""
status = api.request(
"playlist/delete",
playlist_id=playlist.id,
user_auth_token=self.auth_token,
)
return status.get("status") == "success"
def favorites_add(self, **kwargs):
"""Add artists/albums/tracks to user's favorites.
kwargs
----------
artists : Artist, int, str or list of these
albums : Album, int or str or list of these
tracks : Track, int, str or list of these
Returns
-------
bool
Successfully added to favorites
"""
for params in self._get_params_splitted(kwargs):
status = api.request("favorite/create", **params)
if status.get("status") != "success":
return False
return True
def favorites_status(self, obj):
"""Get status whether obj is in the favorites.
Parameters
----------
obj: Artist/Album/Track
Object to be added to the favorites
Returns
-------
bool
Successfully deleted from favorites
"""
status = api.request(
"favorite/status",
item=obj.id,
type=obj.type,
user_auth_token=self.auth_token,
)
return status.get("status") == "true"
def search(cls, query, limit=50, offset=0):
"""Search for a playlist.
Parameters
----------
query: str
Search query
limit: int
Number of elements returned per request
offset: int
Offset from which to obtain limit elements
Returns
-------
list of Playlist
Resulting playlists for the search query
"""
playlists = api.request("playlist/search",
query=query,
limit=limit,
offset=offset)
return [cls(p) for p in playlists["playlists"]["items"]]
def favorites_del(self, **kwargs):
"""Delete artists/albums/tracks from favorites.
Parameters
----------
artists : Artist, int, str or list of these
albums : Album, int or str or list of these
tracks : Track, int, str or list of these
Returns
-------
bool
Successfully deleted from favorites
"""
for params in self._get_params_splitted(kwargs):
status = api.request(
"favorite/delete",
**params,
)
if status.get("status") != "success":
return False
return True
def search(cls, query, limit=50, offset=0):
"""Search for a track.
Parameters
----------
query: str
Search query
limit: int
Number of elements returned per request
offset: int
Offset from which to obtain limit elements
Returns
-------
list of Track
Resulting tracks for the search query
"""
tracks = api.request("track/search",
query=query,
offset=offset,
limit=limit)
return [cls(t) for t in tracks["tracks"]["items"]]
def playlist_delete(self, playlist):
"""Delete a playlist.
Parameters
----------
playlist: Playlist or int (playlist id)
Playlist to be deleted
Returns
-------
bool
Successfully deleted playlist
"""
if isinstance(playlist, int):
id = playlist
else:
id = playlist.id
status = api.request(
"playlist/delete",
playlist_id=id,
user_auth_token=self.auth_token,
)
return status.get("status") == "success"
def from_id(cls, id):
return cls(api.request("track/get", track_id=id))
