def __init__(self):
self.__youtube = Youtube()
self.__spotify = Spotify()
self.__editor = TagEditor()
self.__last = LastFM()
self.__apple = AppleMusic()
self.__deezer = Deezer()
def get_playlist(query: int):
try:
api_result = Deezer().api.get_playlist(query)
except deezer.errors.PermissionException:
logger.warning(f" [!] Playlist ID {query} is private")
return
except deezer.errors.DataException:
logger.warning(f" [!] Playlist ID {query} was not found")
return
except json.decoder.JSONDecodeError:
logger.error(f" [!] Empty response from API while getting data for playlist ID {query}, retrying...")
try:
api_result = Deezer().api.get_playlist(query)
except json.decoder.JSONDecodeError:
logger.error(f" [!] API still sending empty response while getting data for playlist ID {query}")
return
return {'id': query, 'title': api_result['title'],
'link': f"https://deezer.com/playlist/{str(api_result['id'])}"}
def __init__(self):
deezer_app_id = getenv("DEEZER_application_id")
deezer_secret_key = getenv("DEEZER_secret_key")
scope = "basic_access,manage_library"
# login
logging.info("Starting Deezer client")
self.deezer_client = Deezer(access_token=deezer_authorize(
deezer_app_id, deezer_secret_key, scope))
def __init__(self):
self.max_threads = 2
self.dz = Deezer()
# Make our session threadsafe
PlatformAPI.TOKEN = self.dz.gw.get_user_data()['checkForm']
self.dz.gw._get_token = self._get_token
self.platform = self.get_platform()
self.account_type = self.get_account_type()
self.api = self.set_platform()
def get_account_type(self):
temp_dz = Deezer()
temp_dz.login_via_arl(config.arl())
if temp_dz.get_session()['current_user'].get('can_stream_lossless'):
logger.debug(f"Deezer account type is \"Hi-Fi\"")
return "hifi"
elif temp_dz.get_session()['current_user'].get('can_stream_hq'):
logger.debug(f"Deezer account type is \"Premium\"")
return "premium"
else:
logger.debug(f"Deezer account type is \"Free\"")
return "free"
def getConfigArl(self):
tempDz = Deezer()
arl = None
if (self.configFolder / '.arl').is_file():
with open(self.configFolder / '.arl', 'r') as f:
arl = f.readline().rstrip("\n")
if not tempDz.login_via_arl(arl):
print("Saved ARL mistyped or expired, please enter a new one")
return self.getArl(tempDz)
else:
return self.getArl(tempDz)
return arl
def get_playlist_tracks(query: dict):
track_list = []
try:
api_result = Deezer().api.get_playlist(query['id'])
except deezer.errors.PermissionException:
logger.warning(f" [!] Playlist ID {query} is private")
return
except deezer.errors.DataException:
logger.warning(f" [!] Playlist ID {query} was not found")
return
except json.decoder.JSONDecodeError:
logger.error(f" [!] Empty response from API while getting data for playlist ID {query['id']}")
try:
api_result = Deezer().api.get_playlist(query['id'])
except json.decoder.JSONDecodeError:
logger.error(f" [!] API still sending empty response while getting data for playlist ID {query['id']}")
return
for track in api_result['tracks']['data']:
track_list.append({'id': track['id'], 'title': track['title'],
'artist_id': track['artist']['id'],
'artist_name': track['artist']['name']})
query['tracks'] = track_list
return query
def __init__(self):
logger.debug("Initializing deemix library")
self.db = Database()
self.dz = Deezer()
if config.deemix_path() == "":
self.config_dir = localpaths.getConfigFolder()
else:
self.config_dir = Path(config.deemix_path())
self.dx_settings = LoadSettings(self.config_dir)
logger.debug("deemix " + deemix.__version__)
logger.debug(f"deemix config path: {self.config_dir}")
def __init__(self):
self.api = api.PlatformAPI()
self.artist_id: int = None
self.artist: str = None
self.choices: list = []
self.status_message: str = None
self.queue_list = []
self.select_mode = False
self.explicit_only = False
self.search_results: str = None
self.sort: str = "release_date"
self.filter: str = None
self.desc: bool = True
self.db = db.Database()
self.dz = Deezer()
def main():
print('\nThis script will print out every album and song of a specific artist.')
# initialize the main class
deezer = Deezer()
# taking the user input
user_input = input('What artist do you want to see? > ').lower()
# creating a generator object with all the artists found
artists = deezer.search(user_input, 'artist')
album_count = 1
track_count = 1
for artist in artists:
# if the specific artis is found
if artist.name.lower() == user_input:
# print artist name
print('\nArtist: %s\n' % (artist.name))
# for every album of the artist
for album in artist.albums():
# print current count and album name
print('Album: %s - %s\n' % (album_count, album.title))
# every new album increment this counter
album_count += 1
# for every track of every album
for track in album.tracks():
# print current track count and track title
print('\tTrack: %s - %s' % (track_count, track.title))
# every new track increment this counter
track_count +=1
# reset the track count every new album and print new line
track_count = 1
print()
def login(arl, force=False, child=0):
global first_connection
if not app.isDeezerAvailable:
emit('logged_in', {'status': LoginStatus.NOT_AVAILABLE, 'arl': arl, 'user': session['dz'].current_user})
return
if child == None: child = 0
arl = arl.strip()
emit('logging_in')
if force: session['dz'] = Deezer()
result = app.login(session['dz'], arl, int(child))
if force and result == LoginStatus.SUCCESS: result = LoginStatus.FORCED_SUCCESS
emit('logged_in', {'status': result, 'arl': arl, 'user': session['dz'].current_user})
if first_connection and result in [LoginStatus.SUCCESS, LoginStatus.FORCED_SUCCESS]:
first_connection = False
app.restoreDownloadQueue(session['dz'], socket_interface)
if result != 0:
emit('familyAccounts', session['dz'].childs)
emit('init_favorites', app.getUserFavorites(session['dz']))
def on_connect():
session['dz'] = Deezer()
(settings, spotifyCredentials, defaultSettings) = app.getAllSettings()
session['dz'].set_accept_language(settings.get('tagsLanguage'))
emit('init_settings', (settings, spotifyCredentials, defaultSettings))
if first_connection:
app.checkForUpdates()
app.checkDeezerAvailability()
emit('init_update',{
'currentCommit': app.currentVersion,
'latestCommit': app.latestVersion,
'updateAvailable': app.updateAvailable,
'deemixVersion': deemix_version
}
)
if arl:
login(arl)
else:
emit('init_autologin')
queue, queueComplete, queueList, currentItem = app.initDownloadQueue()
if len(queueList.keys()):
emit('init_downloadQueue',{
'queue': queue,
'queueComplete': queueComplete,
'queueList': queueList,
'currentItem': currentItem
})
#emit('init_home', app.get_home(session['dz']))
#emit('init_charts', app.get_charts(session['dz']))
if app.updateAvailable: emit('updateAvailable')
if not app.isDeezerAvailable: emit('deezerNotAvailable')
#!/usr/bin/env python3
from deezer import Deezer
import sys
if __name__ == '__main__':
if len(sys.argv) > 1:
dz = Deezer()
releases = dz.gw.get_artist_discography_tabs(sys.argv[1], 100)
for type in releases:
for release in releases[type]:
print(release['id'])
def logout():
if session['dz'].logged_in:
session['dz'] = Deezer()
emit('logged_out')
"Compare iTunes and cached versions of playlists to re-sync (fixes problems from program crash, also reverts user modifications)? [y/n] "
) == "y"
else:
fix_itunes = False
make_m3u = input(
"Make m3u files (stored in the playlists folder)? [y/n] ") == "y"
verify_path_lengths = input(
"Rename files too long to copy to Android? [y/n] ") == "y"
copy_to_android = input(
"Copy music and playlists to Android Music folder? (Won't waste time overwriting, make sure to enable USB debugging) [y/n] "
) == "y"
account_manager = AccountManager(logger)
account_manager.login_spotify()
deezer_object = Deezer()
account_manager.login_deezer(deezer_object)
music_directory = str(Path.cwd().parents[0] / "music")
youtube_tag_dict = collections.OrderedDict()
youtube_manager = YoutubeManager(log_manager, logger, account_manager.spotipy,
music_directory, youtube_tag_dict)
playlist_manager = PlaylistManager(logger=logger,
account_manager=account_manager)
if get_user_playlists:
playlist_manager.retrieve_spotify_playlists()
if get_custom_playlists:
playlist_manager.retrieve_custom_playlists()