def setUp(self):
super().setUp()
self.client = deezer.Client( # nosec
app_id="foo", app_secret="bar", do_not_compress_reponse=True
)
self.unsec_client = deezer.Client(use_ssl=False, do_not_compress_reponse=True)
self.client_fr = deezer.Client(headers={"Accept-Language": "fr"}) # French
self.client_ja = deezer.Client(headers={"Accept-Language": "ja"}) # Japanese
def get_spotify_pics(self):
self.spotify_exists = True
text = self.get_spotify_text()
if len(text) != 0:
try:
client = deezer.Client()
data = client.search(self.get_spotify_text())[0].asdict()
self.spotify_artist_pic_download = data["artist"][
"picture_big"]
self.spotify_album_pic_download = data["album"]["cover_big"]
self.spotify_pic_number = data["album"]["md5_image"]
self.root.spotify_artist_pic.source = data["artist"]["picture"]
self.root.spotify_album_pic.source = data["album"]["cover"]
self.root.spotify_artist_pic.pos_hint = {
"x": 0.25,
"top": 0.75
}
self.root.spotify_album_pic.pos_hint = {
"x": 0.25,
"top": 0.419
}
self.root.download_manager.pos_hint = {"x": 0.76, "top": 0.12}
artist_name = data["artist"]["name"]
album_name = data["album"]["title"]
self.root.artist_name.text = f"Artista: {artist_name}"
self.root.album_name.text = f"Album: {album_name}"
except IndexError:
self.spotify_exists = False
self.spotify_error()
self.spotify_pics_clean()
def client():
return deezer.Client( # nosec
app_id="foo",
app_secret="bar",
# This is to get human readable response output in VCR cassettes
headers={"Accept-Encoding": "identity"},
)
def client(self):
if not hasattr(self, '_client'):
settings = models.DeezerSettings.objects.get() # pylint: disable=no-member
self._client = deezer.Client(app_id=settings.app_id,
app_secred=settings.app_secret,
access_token=settings.access_token,
follow_next_links=True)
return self._client
def test_resource_relation(self):
"""
Test passing parent object when using get_relation
"""
client = deezer.Client()
album = client.get_album(302127)
tracks = album.get_tracks()
self.assertTrue(tracks[0].album is album)
def get_artist(artist_id_or_name):
client = deezer.Client()
try:
artist = client.get_artist(int(artist_id_or_name))
except:
artist = client.search(artist_id_or_name, relation='artist')[0]
artist.albums = get_albums(artist)
return artist
def __init__(self, soco, username, service_type):
super(DeezerSocoPlugin, self).__init__(soco)
account = Account()
account.username = username
account.service_type = service_type
self.__ms = MusicService('Deezer', account=account)
self.__dz = deezer.Client()
def test_genre_attributes(self):
"""
Test genre resource
"""
client = deezer.Client()
genre = client.get_genre(106)
self.assertTrue(hasattr(genre, 'name'))
self.assertIsInstance(genre, deezer.resources.Genre)
self.assertEqual(repr(genre), '<Genre: Electro>')
def test_radio_attributes(self):
"""
Test radio resource
"""
client = deezer.Client()
radio = client.get_radio(23261)
self.assertTrue(hasattr(radio, 'title'))
self.assertIsInstance(radio, deezer.resources.Radio)
self.assertEqual(repr(radio), '<Radio: Telegraph Classical>')
def test_artist_attributes(self):
"""
Test artist resource
"""
client = deezer.Client()
artist = client.get_artist(27)
self.assertTrue(hasattr(artist, 'name'))
self.assertIsInstance(artist, deezer.resources.Artist)
self.assertEqual(repr(artist), '<Artist: Daft Punk>')
def test_artist_top(self):
"""
Test top method of artist resource
"""
client = deezer.Client()
artist = client.get_artist(27)
tracks = artist.get_top()
self.assertIsInstance(tracks, list)
track = tracks[0]
self.assertIsInstance(track, deezer.resources.Track)
self.assertEqual(repr(track), '<Track: Get Lucky (Radio Edit)>')
def test_album_attributes(self):
"""
Test album resource
"""
client = deezer.Client()
album = client.get_album(302127)
self.assertTrue(hasattr(album, 'title'))
self.assertEqual(repr(album), '<Album: Discovery>')
artist = album.get_artist()
self.assertIsInstance(artist, deezer.resources.Artist)
self.assertEqual(repr(artist), '<Artist: Daft Punk>')
def test_radio_tracks(self):
"""
Test tracks method of radio resource
"""
client = deezer.Client()
radio = client.get_radio(23261)
tracks = radio.get_tracks()
self.assertIsInstance(tracks, list)
track = tracks[2]
self.assertIsInstance(track, deezer.resources.Track)
self.assertEqual(type(radio.iter_tracks()), GeneratorType)
def test_resource_dict(self):
"""
Test that resource can be converted to dict
"""
client = deezer.Client()
response = fake_urlopen(client.object_url('track', 3135556))
resp_str = response.read().decode('utf-8')
response.close()
data = json.loads(resp_str)
resource = deezer.resources.Resource(client, data)
self.assertEqual(resource.asdict(), data)
def test_artist_radio(self):
"""
Test radio method of artist resource
"""
client = deezer.Client()
artist = client.get_artist(27)
tracks = artist.get_radio()
self.assertIsInstance(tracks, list)
track = tracks[0]
self.assertIsInstance(track, deezer.resources.Track)
self.assertEqual(repr(track), '<Track: Lose Yourself to Dance>')
def test_with_deezer_python_objects(self):
client = deezer.Client()
artist = client.search(query="Beirut", relation="artist")[0]
album = artist.get_albums()[0]
self.dzs.add_album_to_queue(album)
track = client.advanced_search({'artist': "Lou Doillon", 'album': "Soliloquy",
'track': "Widows"}, relation="track")[0]
self.dzs.add_track_to_queue(track)
playlist = client.get_playlist('6036493264')
self.dzs.add_playlist_to_queue(playlist)
def test_chart_artists(self):
"""
Test artists method of chart resource
"""
client = deezer.Client()
chart = client.get_chart()
artists = chart.get_artists()
self.assertIsInstance(artists, list)
artist = artists[0]
self.assertIsInstance(artist, deezer.resources.Artist)
self.assertEqual(repr(artist), '<Artist: Pnl>')
self.assertEqual(type(chart.iter_artists()), GeneratorType)
def test_chart_albums(self):
"""
Test albums method of chart resource
"""
client = deezer.Client()
chart = client.get_chart()
albums = chart.get_albums()
self.assertIsInstance(albums, list)
album = albums[0]
self.assertIsInstance(album, deezer.resources.Album)
self.assertEqual(repr(album), "<Album: Where Is l'album de Gradur>")
self.assertEqual(type(chart.iter_albums()), GeneratorType)
def test_genre_radios(self):
"""
Test radios method of genre resource
"""
client = deezer.Client()
genre = client.get_genre(106)
radios = genre.get_radios()
self.assertIsInstance(radios, list)
radio = radios[0]
self.assertIsInstance(radio, deezer.resources.Radio)
self.assertEqual(repr(radio), '<Radio: Techno/House>')
self.assertEqual(type(genre.iter_radios()), GeneratorType)
def test_genre_artists(self):
"""
Test artists method of genre resource
"""
client = deezer.Client()
genre = client.get_genre(106)
artists = genre.get_artists()
self.assertIsInstance(artists, list)
artist = artists[0]
self.assertIsInstance(artist, deezer.resources.Artist)
self.assertEqual(repr(artist), '<Artist: Calvin Harris>')
self.assertEqual(type(genre.iter_artists()), GeneratorType)
def test_chart_playlists(self):
"""
Test playlists method of chart resource
"""
client = deezer.Client()
chart = client.get_chart()
playlists = chart.get_playlists()
self.assertIsInstance(playlists, list)
playlist = playlists[0]
self.assertIsInstance(playlist, deezer.resources.Playlist)
self.assertEqual(repr(playlist), "<Playlist: Top France>")
self.assertEqual(type(chart.iter_playlists()), GeneratorType)
def test_radio_tracks(self):
"""
Test tracks method of radio resource
"""
client = deezer.Client()
radio = client.get_radio(23261)
tracks = radio.get_tracks()
self.assertIsInstance(tracks, list)
track = tracks[2]
self.assertIsInstance(track, deezer.resources.Track)
self.assertEqual(repr(track), '<Track: Schumann: Kinderszenen, Op.15 - 11. Fürchtenmachen>')
self.assertEqual(type(radio.iter_tracks()), GeneratorType)
def test_artist_related(self):
"""
Test related method of artist resource
"""
client = deezer.Client()
artist = client.get_artist(27)
artists = artist.get_related()
self.assertIsInstance(artists, list)
artist = artists[0]
self.assertIsInstance(artist, deezer.resources.Artist)
self.assertEqual(repr(artist), '<Artist: Justice>')
self.assertEqual(type(artist.iter_related()), GeneratorType)
def __init__(self, bot):
self.bot = bot
self.yt_rx = re.compile(
r"(https?\:\/\/)?(www\.youtube\.com|youtu\.be)\/.+")
# check if both spotify id and secret are not none
if not None in (Config.SPOTIFY_ID, Config.SPOTIFY_SECRET):
self.sp = spotipy.Spotify(
client_credentials_manager=SpotifyClientCredentials(
Config.SPOTIFY_ID, Config.SPOTIFY_SECRET))
else:
self.sp = None
self.deezer = deezer.Client()
def test_chart_tracks(self):
"""
Test tracks method of chart resource
"""
client = deezer.Client()
chart = client.get_chart()
tracks = chart.get_tracks()
self.assertIsInstance(tracks, list)
track = tracks[0]
self.assertIsInstance(track, deezer.resources.Track)
self.assertEqual(repr(track), '<Track: Starboy>')
self.assertEqual(type(chart.iter_tracks()), GeneratorType)
def test_artist_albums(self):
"""
Test albums method of artist resource
"""
client = deezer.Client()
artist = client.get_artist(27)
albums = artist.get_albums()
self.assertIsInstance(albums, list)
album = albums[0]
self.assertIsInstance(album, deezer.resources.Album)
self.assertEqual(repr(album),
'<Album: Human After All (Remixes) (Remixes)>')
self.assertEqual(type(artist.iter_albums()), GeneratorType)
def main():
authenticator = DeezerAuthenticator(APP_ID, APP_SECRET)
authenticator.authenticate()
print(authenticator.access_token)
client = deezer.Client(app_id=APP_ID, app_secret=APP_SECRET)
client.access_token = authenticator.access_token
client.follow_next_links = True
u: deezer.User = client.get_user('me')
for i in u.get_playlists():
print(i.title)
for t in i.get_tracks():
print(' ',
f'{t.artist.name} - {t.title} (from {t.album.title})')
def hydrate_tracks(tracks):
client = deezer.Client()
result = []
for track_id in tracks:
track = client.get_track(track_id)
try:
row = [track.id, track.rank, track.bpm, track.explicit_lyrics]
result.append(row)
except AttributeError:
continue
return result
def hydrate_albums(albums):
client = deezer.Client()
result = []
for album_id in albums:
album = client.get_album(album_id)
try:
row = [album.id, album.fans, album.rating]
result.append(row)
except AttributeError:
continue
return result
def hydrate_artists(artists):
client = deezer.Client()
result = []
for artist_id in artists:
artist = client.get_artist(artist_id)
try:
row = [artist.id, artist.name, artist.nb_album, artist.nb_fan]
result.append(row)
except AttributeError:
continue
return result
