Removed saveDownloadQueue and tagsLanguage from lib settings

.gitignore

@@ -26,13 +26,11 @@ yarn-error.log*
 *.sw?
 
 # Private configs
-config.py
-test.py
-config
+/config.py
+/test.py
 
 #build files
-build
-*egg-info
+/build
+/*egg-info
 updatePyPi.sh
-deezer
-.cache
+/deezer

deemix/__init__.py

@@ -7,10 +7,11 @@ from deemix.itemgen import generateTrackItem, \
     generatePlaylistItem, \
     generateArtistItem, \
     generateArtistDiscographyItem, \
-    generateArtistTopItem
-from deemix.errors import LinkNotRecognized, LinkNotSupported
+    generateArtistTopItem, \
+    LinkNotRecognized, \
+    LinkNotSupported
 
-__version__ = "3.6.6"
+__version__ = "3.0.0"
 
 # Returns the Resolved URL, the Type and the ID
 def parseLink(link):

deemix/__main__.py

@@ -7,21 +7,9 @@ from deezer import TrackFormats
 
 from deemix import generateDownloadObject
 from deemix.settings import load as loadSettings
-from deemix.utils import getBitrateNumberFromText, formatListener
+from deemix.utils import getBitrateNumberFromText
 import deemix.utils.localpaths as localpaths
 from deemix.downloader import Downloader
-from deemix.itemgen import GenerationError
-try:
-    from deemix.plugins.spotify import Spotify
-except ImportError:
-    Spotify = None
-
-class LogListener:
-    @classmethod
-    def send(cls, key, value=None):
-        logString = formatListener(key, value)
-        if logString: print(logString)
-
 
 @click.command()
 @click.option('--portable', is_flag=True, help='Creates the config folder in the same directory where the script is launched')
@@ -34,8 +22,7 @@ def download(url, bitrate, portable, path):
     configFolder = localpath / 'config' if portable else localpaths.getConfigFolder()
 
     settings = loadSettings(configFolder)
-    dz = Deezer()
-    listener = LogListener()
+    dz = Deezer(settings.get('tagsLanguage', ""))
 
     def requestValidArl():
         while True:
@@ -44,22 +31,12 @@ def download(url, bitrate, portable, path):
         return arl
 
     if (configFolder / '.arl').is_file():
-        with open(configFolder / '.arl', 'r', encoding="utf-8") as f:
+        with open(configFolder / '.arl', 'r') as f:
             arl = f.readline().rstrip("\n").strip()
         if not dz.login_via_arl(arl): arl = requestValidArl()
     else: arl = requestValidArl()
-    try:
-        with open(configFolder / '.arl', 'w', encoding="utf-8") as f:
+    with open(configFolder / '.arl', 'w') as f:
         f.write(arl)
-    except:
-        print(f"Error opening {configFolder / '.arl'}, continuing anyway.")
-
-    plugins = {}
-    if Spotify:
-        plugins = {
-            "spotify": Spotify(configFolder=configFolder)
-        }
-        plugins["spotify"].setup()
 
     def downloadLinks(url, bitrate=None):
         if not bitrate: bitrate = settings.get("maxBitrate", TrackFormats.MP3_320)
@@ -71,24 +48,9 @@ def download(url, bitrate, portable, path):
             else:
                 links.append(link)
 
-        downloadObjects = []
-
         for link in links:
-            try:
-                downloadObject = generateDownloadObject(dz, link, bitrate, plugins, listener)
-            except GenerationError as e:
-                print(f"{e.link}: {e.message}")
-                continue
-            if isinstance(downloadObject, list):
-                downloadObjects += downloadObject
-            else:
-                downloadObjects.append(downloadObject)
-
-        for obj in downloadObjects:
-            if obj.__type__ == "Convertable":
-                obj = plugins[obj.plugin].convert(dz, obj, settings, listener)
-            Downloader(dz, obj, settings, listener).start()
-
+            downloadObject = generateDownloadObject(dz, link, bitrate)
+            Downloader(dz, downloadObject, settings).start()
 
     if path is not None:
         if path == '': path = '.'
@@ -104,7 +66,7 @@ def download(url, bitrate, portable, path):
         isfile = False
     if isfile:
         filename = url[0]
-        with open(filename, encoding="utf-8") as f:
+        with open(filename) as f:
             url = f.readlines()
 
     downloadLinks(url, bitrate)

deemix/decryption.py

@@ -10,7 +10,6 @@ from deemix.utils.crypto import _md5, _ecbCrypt, _ecbDecrypt, generateBlowfishKe
 
 from deemix.utils import USER_AGENT_HEADER
 from deemix.types.DownloadObjects import Single
-from deemix.errors import DownloadCanceled, DownloadEmpty
 
 logger = logging.getLogger('deemix')
 
@@ -41,22 +40,15 @@ def reverseStreamURL(url):
     return reverseStreamPath(urlPart)
 
 def streamTrack(outputStream, track, start=0, downloadObject=None, listener=None):
-    if downloadObject and downloadObject.isCanceled: raise DownloadCanceled
+    if downloadObject.isCanceled: raise DownloadCanceled
     headers= {'User-Agent': USER_AGENT_HEADER}
     chunkLength = start
-    isCryptedStream = "/mobile/" in track.downloadURL or "/media/" in track.downloadURL
 
-    itemData = {
-        'id': track.id,
-        'title': track.title,
-        'artist': track.mainArtist.name
-    }
+    itemName = f"[{track.mainArtist.name} - {track.title}]"
 
     try:
-        with get(track.downloadURL, headers=headers, stream=True, timeout=10) as request:
+        with get(track.downloadUrl, headers=headers, stream=True, timeout=10) as request:
             request.raise_for_status()
-            if isCryptedStream:
-                blowfish_key = generateBlowfishKey(str(track.id))
 
             complete = int(request.headers["Content-Length"])
             if complete == 0: raise DownloadEmpty
@@ -65,7 +57,7 @@ def streamTrack(outputStream, track, start=0, downloadObject=None, listener=None
                 if listener:
                     listener.send('downloadInfo', {
                         'uuid': downloadObject.uuid,
-                        'data': itemData,
+                        'itemName': itemName,
                         'state': "downloading",
                         'alreadyStarted': True,
                         'value': responseRange
@@ -74,24 +66,70 @@ def streamTrack(outputStream, track, start=0, downloadObject=None, listener=None
                 if listener:
                     listener.send('downloadInfo', {
                         'uuid': downloadObject.uuid,
-                        'data': itemData,
+                        'itemName': itemName,
+                        'state': "downloading",
+                        'alreadyStarted': False,
+                        'value': complete
+                    })
+
+            for chunk in request.iter_content(2048 * 3):
+                outputStream.write(chunk)
+                chunkLength += len(chunk)
+
+                if downloadObject:
+                    if isinstance(downloadObject, Single):
+                        chunkProgres = (chunkLength / (complete + start)) * 100
+                        downloadObject.progressNext = chunkProgres
+                    else:
+                        chunkProgres = (len(chunk) / (complete + start)) / downloadObject.size * 100
+                        downloadObject.progressNext += chunkProgres
+                    downloadObject.updateProgress(listener)
+
+    except (SSLError, u3SSLError):
+        logger.info('%s retrying from byte %s', itemName, chunkLength)
+        streamTrack(outputStream, track, chunkLength, downloadObject, listener)
+    except (RequestsConnectionError, ReadTimeout, ChunkedEncodingError):
+        sleep(2)
+        streamTrack(outputStream, track, start, downloadObject, listener)
+
+def streamCryptedTrack(outputStream, track, start=0, downloadObject=None, listener=None):
+    if downloadObject.isCanceled: raise DownloadCanceled
+    headers= {'User-Agent': USER_AGENT_HEADER}
+    chunkLength = start
+
+    itemName = f"[{track.mainArtist.name} - {track.title}]"
+
+    try:
+        with get(track.downloadUrl, headers=headers, stream=True, timeout=10) as request:
+            request.raise_for_status()
+            blowfish_key = str.encode(generateBlowfishKey(str(track.id)))
+
+            complete = int(request.headers["Content-Length"])
+            if complete == 0: raise DownloadEmpty
+            if start != 0:
+                responseRange = request.headers["Content-Range"]
+                if listener:
+                    listener.send('downloadInfo', {
+                        'uuid': downloadObject.uuid,
+                        'itemName': itemName,
+                        'state': "downloading",
+                        'alreadyStarted': True,
+                        'value': responseRange
+                    })
+            else:
+                if listener:
+                    listener.send('downloadInfo', {
+                        'uuid': downloadObject.uuid,
+                        'itemName': itemName,
                         'state': "downloading",
                         'alreadyStarted': False,
                         'value': complete
                     })
 
-            isStart = True
             for chunk in request.iter_content(2048 * 3):
-                if isCryptedStream:
                 if len(chunk) >= 2048:
                     chunk = decryptChunk(blowfish_key, chunk[0:2048]) + chunk[2048:]
 
-                if isStart and chunk[0] == 0 and chunk[4:8].decode('utf-8') != "ftyp":
-                    for i, byte in enumerate(chunk):
-                        if byte != 0: break
-                    chunk = chunk[i:]
-                isStart = False
-
                 outputStream.write(chunk)
                 chunkLength += len(chunk)
 
@@ -105,7 +143,14 @@ def streamTrack(outputStream, track, start=0, downloadObject=None, listener=None
                     downloadObject.updateProgress(listener)
 
     except (SSLError, u3SSLError):
-        streamTrack(outputStream, track, chunkLength, downloadObject, listener)
+        logger.info('%s retrying from byte %s', itemName, chunkLength)
+        streamCryptedTrack(outputStream, track, chunkLength, downloadObject, listener)
     except (RequestsConnectionError, ReadTimeout, ChunkedEncodingError):
         sleep(2)
-        streamTrack(outputStream, track, start, downloadObject, listener)
+        streamCryptedTrack(outputStream, track, start, downloadObject, listener)
+
+class DownloadCanceled(Exception):
+    pass
+
+class DownloadEmpty(Exception):
+    pass

deemix/downloader.py

@@ -1,6 +1,5 @@
 from concurrent.futures import ThreadPoolExecutor
 from time import sleep
-import traceback
 
 from os.path import sep as pathSep
 from os import makedirs, system as execute
@@ -19,17 +18,14 @@ from urllib3.exceptions import SSLError as u3SSLError
 from mutagen.flac import FLACNoHeaderError, error as FLACError
 
 from deezer import TrackFormats
-from deezer.errors import WrongLicense, WrongGeolocation
-from deezer.utils import map_track
 from deemix.types.DownloadObjects import Single, Collection
-from deemix.types.Track import Track
+from deemix.types.Track import Track, AlbumDoesntExists, MD5NotFound
 from deemix.types.Picture import StaticPicture
 from deemix.utils import USER_AGENT_HEADER
 from deemix.utils.pathtemplates import generatePath, generateAlbumName, generateArtistName, generateDownloadObjectName
 from deemix.tagger import tagID3, tagFLAC
-from deemix.decryption import generateCryptedStreamURL, streamTrack
+from deemix.decryption import generateStreamURL, streamTrack, DownloadCanceled
 from deemix.settings import OverwriteOption
-from deemix.errors import DownloadFailed, MD5NotFound, DownloadCanceled, PreferredBitrateNotFound, TrackNot360, AlbumDoesntExists, DownloadError, ErrorMessages
 
 logger = logging.getLogger('deemix')
 
@@ -44,17 +40,6 @@ extensions = {
     TrackFormats.MP4_RA1: '.mp4'
 }
 
-formatsName = {
-    TrackFormats.FLAC:    'FLAC',
-    TrackFormats.LOCAL:   'MP3_MISC',
-    TrackFormats.MP3_320: 'MP3_320',
-    TrackFormats.MP3_128: 'MP3_128',
-    TrackFormats.DEFAULT: 'MP3_MISC',
-    TrackFormats.MP4_RA3: 'MP4_RA3',
-    TrackFormats.MP4_RA2: 'MP4_RA2',
-    TrackFormats.MP4_RA1: 'MP4_RA1'
-}
-
 TEMPDIR = Path(gettempdir()) / 'deemix-imgs'
 if not TEMPDIR.is_dir(): makedirs(TEMPDIR)
 
@@ -75,7 +60,7 @@ def downloadImage(url, path, overwrite=OverwriteOption.DONT_OVERWRITE):
             pictureSize = int(pictureUrl[:pictureUrl.find("x")])
             if pictureSize > 1200:
                 return downloadImage(urlBase+pictureUrl.replace(f"{pictureSize}x{pictureSize}", '1200x1200'), path, overwrite)
-    except (requests.exceptions.ConnectionError, requests.exceptions.ChunkedEncodingError, u3SSLError):
+    except (requests.exceptions.ConnectionError, requests.exceptions.ChunkedEncodingError, u3SSLError) as e:
         if path.is_file(): path.unlink()
         sleep(5)
         return downloadImage(url, path, overwrite)
@@ -85,54 +70,11 @@ def downloadImage(url, path, overwrite=OverwriteOption.DONT_OVERWRITE):
         logger.exception("Error while downloading an image, you should report this to the developers: %s", e)
     return None
 
-def getPreferredBitrate(dz, track, preferredBitrate, shouldFallback, feelingLucky, uuid=None, listener=None):
-    preferredBitrate = int(preferredBitrate)
+def getPreferredBitrate(track, bitrate, shouldFallback, uuid=None, listener=None):
+    bitrate = int(bitrate)
+    if track.local: return TrackFormats.LOCAL
 
     falledBack = False
-    hasAlternative = track.fallbackID != "0"
-    isGeolocked = False
-    wrongLicense = False
-
-    def testURL(track, url, formatName):
-        if not url: return False
-        request = requests.head(
-            url,
-            headers={'User-Agent': USER_AGENT_HEADER},
-            timeout=30
-        )
-        try:
-            request.raise_for_status()
-            track.filesizes[f"{formatName.lower()}"] = int(request.headers["Content-Length"])
-            track.filesizes[f"{formatName.lower()}_TESTED"] = True
-            return track.filesizes[f"{formatName.lower()}"] != 0
-        except requests.exceptions.HTTPError: # if the format is not available, Deezer returns a 403 error
-            return False
-
-    def getCorrectURL(track, formatName, formatNumber, feelingLucky):
-        nonlocal wrongLicense, isGeolocked
-        url = None
-        # Check the track with the legit method
-        wrongLicense = (
-            (formatName == "FLAC" or formatName.startswith("MP4_RA")) and not dz.current_user.get('can_stream_lossless') or \
-            formatName == "MP3_320" and not dz.current_user.get('can_stream_hq')
-        )
-        if track.filesizes.get(formatName.lower()) and track.filesizes[formatName.lower()] != "0":
-            try:
-                url = dz.get_track_url(track.trackToken, formatName)
-            except (WrongLicense, WrongGeolocation) as e:
-                wrongLicense = isinstance(e, WrongLicense)
-                isGeolocked = isinstance(e, WrongGeolocation)
-        # Fallback to old method
-        if not url and feelingLucky:
-            url = generateCryptedStreamURL(track.id, track.MD5, track.mediaVersion, formatNumber)
-            if testURL(track, url, formatName): return url
-            url = None
-        return url
-
-    if track.local:
-        url = getCorrectURL(track, "MP3_MISC", TrackFormats.LOCAL, feelingLucky)
-        track.urls["MP3_MISC"] = url
-        return TrackFormats.LOCAL
 
     formats_non_360 = {
         TrackFormats.FLAC: "FLAC",
@@ -145,7 +87,8 @@ def getPreferredBitrate(dz, track, preferredBitrate, shouldFallback, feelingLuck
         TrackFormats.MP4_RA1: "MP4_RA1",
     }
 
-    is360format = preferredBitrate in formats_360.keys()
+    is360format = bitrate in formats_360.keys()
+
     if not shouldFallback:
         formats = formats_360
         formats.update(formats_non_360)
@@ -154,41 +97,38 @@ def getPreferredBitrate(dz, track, preferredBitrate, shouldFallback, feelingLuck
     else:
         formats = formats_non_360
 
-    # check and renew trackToken before starting the check
-    track.checkAndRenewTrackToken(dz)
-    for formatNumber, formatName in formats.items():
-        # Current bitrate is higher than preferred bitrate; skip
-        if formatNumber > preferredBitrate: continue
-
-        currentTrack = track
-        url = getCorrectURL(currentTrack, formatName, formatNumber, feelingLucky)
-        newTrack = None
-        while True:
-            if not url and hasAlternative:
-                newTrack = dz.gw.get_track_with_fallback(currentTrack.fallbackID)
-                newTrack = map_track(newTrack)
-                currentTrack = Track()
-                currentTrack.parseEssentialData(newTrack)
-                hasAlternative = currentTrack.fallbackID != "0"
-            if not url: getCorrectURL(currentTrack, formatName, formatNumber, feelingLucky)
-            if (url or not hasAlternative): break
-
-        if url:
-            if newTrack: track.parseEssentialData(newTrack)
-            track.urls[formatName] = url
+    def testBitrate(track, formatNumber, formatName):
+        request = requests.head(
+            generateStreamURL(track.id, track.MD5, track.mediaVersion, formatNumber),
+            headers={'User-Agent': USER_AGENT_HEADER},
+            timeout=30
+        )
+        try:
+            request.raise_for_status()
+            track.filesizes[f"FILESIZE_{formatName}"] = int(request.headers["Content-Length"])
+            track.filesizes[f"FILESIZE_{formatName}_TESTED"] = True
+            if track.filesizes[f"FILESIZE_{formatName}"] == 0: return None
             return formatNumber
+        except requests.exceptions.HTTPError: # if the format is not available, Deezer returns a 403 error
+            return None
+
+    for formatNumber, formatName in formats.items():
+        if formatNumber > bitrate: continue
+        if f"FILESIZE_{formatName}" in track.filesizes:
+            if int(track.filesizes[f"FILESIZE_{formatName}"]) != 0: return formatNumber
+            if not track.filesizes[f"FILESIZE_{formatName}_TESTED"]:
+                testedBitrate = testBitrate(track, formatNumber, formatName)
+                if testedBitrate: return testedBitrate
 
         if not shouldFallback:
-            if wrongLicense: raise WrongLicense(formatName)
-            if isGeolocked: raise WrongGeolocation(dz.current_user['country'])
             raise PreferredBitrateNotFound
         if not falledBack:
             falledBack = True
             logger.info("%s Fallback to lower bitrate", f"[{track.mainArtist.name} - {track.title}]")
             if listener and uuid:
-                listener.send('downloadInfo', {
+                listener.send('queueUpdate', {
                     'uuid': uuid,
-                    'state': 'bitrateFallback',
+                    'bitrateFallback': True,
                     'data': {
                         'id': track.id,
                         'title': track.title,
@@ -196,8 +136,6 @@ def getPreferredBitrate(dz, track, preferredBitrate, shouldFallback, feelingLuck
                     },
                 })
     if is360format: raise TrackNot360
-    url = getCorrectURL(track, "MP3_MISC", TrackFormats.DEFAULT, feelingLucky)
-    track.urls["MP3_MISC"] = url
     return TrackFormats.DEFAULT
 
 class Downloader:
@@ -208,6 +146,7 @@ class Downloader:
         self.bitrate = downloadObject.bitrate
         self.listener = listener
 
+        self.extrasPath = None
         self.playlistCoverName = None
         self.playlistURLs = []
 
@@ -215,58 +154,47 @@ class Downloader:
         if not self.downloadObject.isCanceled:
             if isinstance(self.downloadObject, Single):
                 track = self.downloadWrapper({
+                    'trackAPI_gw': self.downloadObject.single['trackAPI_gw'],
                     'trackAPI': self.downloadObject.single.get('trackAPI'),
                     'albumAPI': self.downloadObject.single.get('albumAPI')
                 })
                 if track: self.afterDownloadSingle(track)
             elif isinstance(self.downloadObject, Collection):
-                tracks = [None] * len(self.downloadObject.collection['tracks'])
+                tracks = [None] * len(self.downloadObject.collection['tracks_gw'])
                 with ThreadPoolExecutor(self.settings['queueConcurrency']) as executor:
-                    for pos, track in enumerate(self.downloadObject.collection['tracks'], start=0):
+                    for pos, track in enumerate(self.downloadObject.collection['tracks_gw'], start=0):
                         tracks[pos] = executor.submit(self.downloadWrapper, {
-                            'trackAPI': track,
+                            'trackAPI_gw': track,
                             'albumAPI': self.downloadObject.collection.get('albumAPI'),
                             'playlistAPI': self.downloadObject.collection.get('playlistAPI')
                         })
                 self.afterDownloadCollection(tracks)
 
         if self.listener:
-            if self.downloadObject.isCanceled:
+            if self.listener:
                 self.listener.send('currentItemCancelled', self.downloadObject.uuid)
                 self.listener.send("removedFromQueue", self.downloadObject.uuid)
             else:
                 self.listener.send("finishDownload", self.downloadObject.uuid)
 
-    def log(self, data, state):
-        if self.listener:
-            self.listener.send('downloadInfo', {'uuid': self.downloadObject.uuid, 'data': data, 'state': state})
-
-    def warn(self, data, state, solution):
-        if self.listener:
-            self.listener.send('downloadWarn', {'uuid': self.downloadObject.uuid, 'data': data, 'state': state, 'solution': solution})
-
     def download(self, extraData, track=None):
         returnData = {}
+        trackAPI_gw = extraData['trackAPI_gw']
         trackAPI = extraData.get('trackAPI')
         albumAPI = extraData.get('albumAPI')
         playlistAPI = extraData.get('playlistAPI')
-        trackAPI['size'] = self.downloadObject.size
         if self.downloadObject.isCanceled: raise DownloadCanceled
-        if int(trackAPI['id']) == 0: raise DownloadFailed("notOnDeezer")
+        if trackAPI_gw['SNG_ID'] == "0": raise DownloadFailed("notOnDeezer")
 
-        itemData = {
-            'id': trackAPI['id'],
-            'title': trackAPI['title'],
-            'artist': trackAPI['artist']['name']
-        }
+        itemName = f"[{trackAPI_gw['ART_NAME']} - {trackAPI_gw['SNG_TITLE']}]"
 
         # Create Track object
         if not track:
-            self.log(itemData, "getTags")
+            logger.info("%s Getting the tags", itemName)
             try:
                 track = Track().parseData(
                     dz=self.dz,
-                    track_id=trackAPI['id'],
+                    trackAPI_gw=trackAPI_gw,
                     trackAPI=trackAPI,
                     albumAPI=albumAPI,
                     playlistAPI=playlistAPI
@@ -275,38 +203,26 @@ class Downloader:
                 raise DownloadError('albumDoesntExists') from e
             except MD5NotFound as e:
                 raise DownloadError('notLoggedIn') from e
-            self.log(itemData, "gotTags")
 
-        itemData = {
-            'id': track.id,
-            'title': track.title,
-            'artist': track.mainArtist.name
-        }
+        itemName = f"[{track.mainArtist.name} - {track.title}]"
 
         # Check if track not yet encoded
         if track.MD5 == '': raise DownloadFailed("notEncoded", track)
 
         # Choose the target bitrate
-        self.log(itemData, "getBitrate")
         try:
             selectedFormat = getPreferredBitrate(
-                self.dz,
                 track,
                 self.bitrate,
-                self.settings['fallbackBitrate'], self.settings['feelingLucky'],
+                self.settings['fallbackBitrate'],
                 self.downloadObject.uuid, self.listener
             )
-        except WrongLicense as e:
-            raise DownloadFailed("wrongLicense") from e
-        except WrongGeolocation as e:
-            raise DownloadFailed("wrongGeolocation", track) from e
         except PreferredBitrateNotFound as e:
             raise DownloadFailed("wrongBitrate", track) from e
         except TrackNot360 as e:
             raise DownloadFailed("no360RA") from e
         track.bitrate = selectedFormat
         track.album.bitrate = selectedFormat
-        self.log(itemData, "gotBitrate")
 
         # Apply settings
         track.applySettings(self.settings)
@@ -320,7 +236,7 @@ class Downloader:
         writepath = filepath / f"{filename}{extension}"
 
         # Save extrasPath
-        if extrasPath and not self.downloadObject.extrasPath: self.downloadObject.extrasPath = extrasPath
+        if extrasPath and not self.extrasPath: self.extrasPath = extrasPath
 
         # Generate covers URLs
         embeddedImageFormat = f'jpg-{self.settings["jpegImageQuality"]}'
@@ -332,9 +248,8 @@ class Downloader:
         track.album.embeddedCoverPath = TEMPDIR / ((f"pl{track.playlist.id}" if track.album.isPlaylist else f"alb{track.album.id}") + f"_{self.settings['embeddedArtworkSize']}{ext}")
 
         # Download and cache coverart
-        self.log(itemData, "getAlbumArt")
+        logger.info("%s Getting the album cover", itemName)
         track.album.embeddedCoverPath = downloadImage(track.album.embeddedCoverURL, track.album.embeddedCoverPath)
-        self.log(itemData, "gotAlbumArt")
 
         # Save local album art
         if coverPath:
@@ -382,8 +297,8 @@ class Downloader:
         # Save lyrics in lrc file
         if self.settings['syncedLyrics'] and track.lyrics.sync:
             if not (filepath / f"{filename}.lrc").is_file() or self.settings['overwriteFile'] in [OverwriteOption.OVERWRITE, OverwriteOption.ONLY_TAGS]:
-                with open(filepath / f"{filename}.lrc", 'w', encoding="utf-8") as f:
-                    f.write(track.lyrics.sync)
+                with open(filepath / f"{filename}.lrc", 'wb') as f:
+                    f.write(track.lyrics.sync.encode('utf-8'))
 
         # Check for overwrite settings
         trackAlreadyDownloaded = writepath.is_file()
@@ -407,26 +322,26 @@ class Downloader:
             writepath = Path(currentFilename)
 
         if not trackAlreadyDownloaded or self.settings['overwriteFile'] == OverwriteOption.OVERWRITE:
-            track.downloadURL = track.urls[formatsName[track.bitrate]]
-            if not track.downloadURL: raise DownloadFailed('notAvailable', track)
+            logger.info("%s Downloading the track", itemName)
+            track.downloadUrl = generateStreamURL(track.id, track.MD5, track.mediaVersion, track.bitrate)
+
             try:
                 with open(writepath, 'wb') as stream:
                     streamTrack(stream, track, downloadObject=self.downloadObject, listener=self.listener)
             except requests.exceptions.HTTPError as e:
-                if writepath.is_file(): writepath.unlink()
                 raise DownloadFailed('notAvailable', track) from e
             except OSError as e:
                 if writepath.is_file(): writepath.unlink()
                 if e.errno == errno.ENOSPC: raise DownloadFailed("noSpaceLeft") from e
                 raise e
-            self.log(itemData, "downloaded")
+
         else:
-            self.log(itemData, "alreadyDownloaded")
+            logger.info("%s Skipping track as it's already downloaded", itemName)
             self.downloadObject.completeTrackProgress(self.listener)
 
         # Adding tags
         if (not trackAlreadyDownloaded or self.settings['overwriteFile'] in [OverwriteOption.ONLY_TAGS, OverwriteOption.OVERWRITE]) and not track.local:
-            self.log(itemData, "tagging")
+            logger.info("%s Applying tags to the track", itemName)
             if extension == '.mp3':
                 tagID3(writepath, track, self.settings['tags'])
             elif extension == '.flac':
@@ -434,35 +349,47 @@ class Downloader:
                     tagFLAC(writepath, track, self.settings['tags'])
                 except (FLACNoHeaderError, FLACError):
                     writepath.unlink()
-                    logger.warning("%s Track not available in FLAC, falling back if necessary", f"{itemData['artist']} - {itemData['title']}")
+                    logger.warning("%s Track not available in FLAC, falling back if necessary", itemName)
                     self.downloadObject.removeTrackProgress(self.listener)
                     track.filesizes['FILESIZE_FLAC'] = "0"
                     track.filesizes['FILESIZE_FLAC_TESTED'] = True
-                    return self.download(extraData, track=track)
-            self.log(itemData, "tagged")
+                    return self.download(trackAPI_gw, track=track)
 
         if track.searched: returnData['searched'] = True
         self.downloadObject.downloaded += 1
+        self.downloadObject.files.append(str(writepath))
+        self.downloadObject.extrasPath = str(self.extrasPath)
+        logger.info("%s Track download completed\n%s", itemName, writepath)
         if self.listener: self.listener.send("updateQueue", {
             'uuid': self.downloadObject.uuid,
             'downloaded': True,
             'downloadPath': str(writepath),
-            'extrasPath': str(self.downloadObject.extrasPath)
+            'extrasPath': str(self.extrasPath)
         })
         returnData['filename'] = str(writepath)[len(str(extrasPath))+ len(pathSep):]
-        returnData['data'] = itemData
-        returnData['path'] = str(writepath)
-        self.downloadObject.files.append(returnData)
+        returnData['data'] = {
+            'id': track.id,
+            'title': track.title,
+            'artist': track.mainArtist.name
+        }
         return returnData
 
     def downloadWrapper(self, extraData, track=None):
-        trackAPI = extraData['trackAPI']
+        trackAPI_gw = extraData['trackAPI_gw']
+        if ('_EXTRA_TRACK' in trackAPI_gw):
+            extraData['trackAPI'] = trackAPI_gw['_EXTRA_TRACK'].copy()
+            del extraData['trackAPI_gw']['_EXTRA_TRACK']
+            del trackAPI_gw['_EXTRA_TRACK']
         # Temp metadata to generate logs
-        itemData = {
-            'id': trackAPI['id'],
-            'title': trackAPI['title'],
-            'artist': trackAPI['artist']['name']
+        tempTrack = {
+            'id': trackAPI_gw['SNG_ID'],
+            'title': trackAPI_gw['SNG_TITLE'].strip(),
+            'artist': trackAPI_gw['ART_NAME']
         }
+        if trackAPI_gw.get('VERSION') and trackAPI_gw['VERSION'] not in trackAPI_gw['SNG_TITLE']:
+            tempTrack['title'] += f" {trackAPI_gw['VERSION']}".strip()
+
+        itemName = f"[{tempTrack['artist']} - {tempTrack['title']}]"
 
         try:
             result = self.download(extraData, track)
@@ -470,50 +397,42 @@ class Downloader:
             if error.track:
                 track = error.track
                 if track.fallbackID != "0":
-                    self.warn(itemData, error.errid, 'fallback')
+                    logger.warning("%s %s Using fallback id", itemName, error.message)
                     newTrack = self.dz.gw.get_track_with_fallback(track.fallbackID)
-                    newTrack = map_track(newTrack)
-                    track.parseEssentialData(newTrack)
-                    return self.downloadWrapper(extraData, track)
-                if len(track.albumsFallback) != 0 and self.settings['fallbackISRC']:
-                    newAlbumID = track.albumsFallback.pop()
-                    newAlbum = self.dz.gw.get_album_page(newAlbumID)
-                    fallbackID = 0
-                    for newTrack in newAlbum['SONGS']['data']:
-                        if newTrack['ISRC'] == track.ISRC:
-                            fallbackID = newTrack['SNG_ID']
-                            break
-                    if fallbackID != 0:
-                        self.warn(itemData, error.errid, 'fallback')
-                        newTrack = self.dz.gw.get_track_with_fallback(fallbackID)
-                        newTrack = map_track(newTrack)
                     track.parseEssentialData(newTrack)
+                    track.retriveFilesizes(self.dz)
                     return self.downloadWrapper(extraData, track)
                 if not track.searched and self.settings['fallbackSearch']:
-                    self.warn(itemData, error.errid, 'search')
+                    logger.warning("%s %s Searching for alternative", itemName, error.message)
                     searchedId = self.dz.api.get_track_id_from_metadata(track.mainArtist.name, track.title, track.album.title)
                     if searchedId != "0":
                         newTrack = self.dz.gw.get_track_with_fallback(searchedId)
-                        newTrack = map_track(newTrack)
                         track.parseEssentialData(newTrack)
+                        track.retriveFilesizes(self.dz)
                         track.searched = True
-                        self.log(itemData, "searchFallback")
+                        if self.listener: self.listener.send('queueUpdate', {
+                            'uuid': self.downloadObject.uuid,
+                            'searchFallback': True,
+                            'data': {
+                                'id': track.id,
+                                'title': track.title,
+                                'artist': track.mainArtist.name
+                            },
+                        })
                         return self.downloadWrapper(extraData, track)
                 error.errid += "NoAlternative"
-                error.message = ErrorMessages[error.errid]
+                error.message = errorMessages[error.errid]
+            logger.error("%s %s", itemName, error.message)
             result = {'error': {
                 'message': error.message,
                 'errid': error.errid,
-                'data': itemData,
-                'type': "track"
+                'data': tempTrack
             }}
         except Exception as e:
-            logger.exception("%s %s", f"{itemData['artist']} - {itemData['title']}", e)
+            logger.exception("%s %s", itemName, e)
             result = {'error': {
                 'message': str(e),
-                'data': itemData,
-                'stack': traceback.format_exc(),
-                'type': "track"
+                'data': tempTrack
             }}
 
         if 'error' in result:
@@ -527,74 +446,39 @@ class Downloader:
                     'failed': True,
                     'data': error['data'],
                     'error': error['message'],
-                    'errid': error.get('errid'),
-                    'stack': error.get('stack'),
-                    'type': error['type']
+                    'errid': error['errid'] if 'errid' in error else None
                 })
         return result
 
-    def afterDownloadErrorReport(self, position, error, itemData=None):
-        if not itemData: itemData = {}
-        data = {'position': position }
-        data.update(itemData)
-        logger.exception("%s %s", position, error)
-        self.downloadObject.errors.append({
-            'message': str(error),
-            'stack': traceback.format_exc(),
-            'data': data,
-            'type': "post"
-        })
-        if self.listener:
-            self.listener.send("updateQueue", {
-                'uuid': self.downloadObject.uuid,
-                'postFailed': True,
-                'data': data,
-                'error': str(error),
-                'stack': traceback.format_exc(),
-                'type': "post"
-            })
-
     def afterDownloadSingle(self, track):
-        if not self.downloadObject.extrasPath: self.downloadObject.extrasPath = Path(self.settings['downloadLocation'])
+        if not self.extrasPath: self.extrasPath = Path(self.settings['downloadLocation'])
 
         # Save Album Cover
-        try:
         if self.settings['saveArtwork'] and 'albumPath' in track:
             for image in track['albumURLs']:
                 downloadImage(image['url'], track['albumPath'] / f"{track['albumFilename']}.{image['ext']}", self.settings['overwriteFile'])
-        except Exception as e:
-            self.afterDownloadErrorReport("SaveLocalAlbumArt", e)
 
         # Save Artist Artwork
-        try:
         if self.settings['saveArtworkArtist'] and 'artistPath' in track:
             for image in track['artistURLs']:
                 downloadImage(image['url'], track['artistPath'] / f"{track['artistFilename']}.{image['ext']}", self.settings['overwriteFile'])
-        except Exception as e:
-            self.afterDownloadErrorReport("SaveLocalArtistArt", e)
 
         # Create searched logfile
-        try:
         if self.settings['logSearched'] and 'searched' in track:
             filename = f"{track.data.artist} - {track.data.title}"
-                with open(self.downloadObject.extrasPath / 'searched.txt', 'w+', encoding="utf-8") as f:
-                    searchedFile = f.read()
+            with open(self.extrasPath / 'searched.txt', 'wb+') as f:
+                searchedFile = f.read().decode('utf-8')
                 if not filename in searchedFile:
                     if searchedFile != "": searchedFile += "\r\n"
                     searchedFile += filename + "\r\n"
-                    f.write(searchedFile)
-        except Exception as e:
-            self.afterDownloadErrorReport("CreateSearchedLog", e)
+                f.write(searchedFile.encode('utf-8'))
 
         # Execute command after download
-        try:
         if self.settings['executeCommand'] != "":
-                execute(self.settings['executeCommand'].replace("%folder%", quote(str(self.downloadObject.extrasPath))).replace("%filename%", quote(track['filename'])))
-        except Exception as e:
-            self.afterDownloadErrorReport("ExecuteCommand", e)
+            execute(self.settings['executeCommand'].replace("%folder%", quote(str(self.extrasPath))).replace("%filename%", quote(track['filename'])), shell=True)
 
     def afterDownloadCollection(self, tracks):
-        if not self.downloadObject.extrasPath: self.downloadObject.extrasPath = Path(self.settings['downloadLocation'])
+        if not self.extrasPath: self.extrasPath = Path(self.settings['downloadLocation'])
         playlist = [None] * len(tracks)
         errors = ""
         searched = ""
@@ -612,61 +496,69 @@ class Downloader:
             if 'searched' in track: searched += track['searched'] + "\r\n"
 
             # Save Album Cover
-            try:
             if self.settings['saveArtwork'] and 'albumPath' in track:
                 for image in track['albumURLs']:
                     downloadImage(image['url'], track['albumPath'] / f"{track['albumFilename']}.{image['ext']}", self.settings['overwriteFile'])
-            except Exception as e:
-                self.afterDownloadErrorReport("SaveLocalAlbumArt", e, track['data'])
 
             # Save Artist Artwork
-            try:
             if self.settings['saveArtworkArtist'] and 'artistPath' in track:
                 for image in track['artistURLs']:
                     downloadImage(image['url'], track['artistPath'] / f"{track['artistFilename']}.{image['ext']}", self.settings['overwriteFile'])
-            except Exception as e:
-                self.afterDownloadErrorReport("SaveLocalArtistArt", e, track['data'])
 
             # Save filename for playlist file
             playlist[i] = track.get('filename', "")
 
         # Create errors logfile
-        try:
         if self.settings['logErrors'] and errors != "":
-                with open(self.downloadObject.extrasPath / 'errors.txt', 'w', encoding="utf-8") as f:
-                    f.write(errors)
-        except Exception as e:
-            self.afterDownloadErrorReport("CreateErrorLog", e)
+            with open(self.extrasPath / 'errors.txt', 'wb') as f:
+                f.write(errors.encode('utf-8'))
 
         # Create searched logfile
-        try:
         if self.settings['logSearched'] and searched != "":
-                with open(self.downloadObject.extrasPath / 'searched.txt', 'w', encoding="utf-8") as f:
-                    f.write(searched)
-        except Exception as e:
-            self.afterDownloadErrorReport("CreateSearchedLog", e)
+            with open(self.extrasPath / 'searched.txt', 'wb') as f:
+                f.write(searched.encode('utf-8'))
 
         # Save Playlist Artwork
-        try:
         if self.settings['saveArtwork'] and self.playlistCoverName and not self.settings['tags']['savePlaylistAsCompilation']:
             for image in self.playlistURLs:
-                    downloadImage(image['url'], self.downloadObject.extrasPath / f"{self.playlistCoverName}.{image['ext']}", self.settings['overwriteFile'])
-        except Exception as e:
-            self.afterDownloadErrorReport("SavePlaylistArt", e)
+                downloadImage(image['url'], self.extrasPath / f"{self.playlistCoverName}.{image['ext']}", self.settings['overwriteFile'])
 
         # Create M3U8 File
-        try:
         if self.settings['createM3U8File']:
             filename = generateDownloadObjectName(self.settings['playlistFilenameTemplate'], self.downloadObject, self.settings) or "playlist"
-                with open(self.downloadObject.extrasPath / f'{filename}.m3u8', 'w', encoding="utf-8") as f:
+            with open(self.extrasPath / f'{filename}.m3u8', 'wb') as f:
                 for line in playlist:
-                        f.write(line + "\n")
-        except Exception as e:
-            self.afterDownloadErrorReport("CreatePlaylistFile", e)
+                    f.write((line + "\n").encode('utf-8'))
 
         # Execute command after download
-        try:
         if self.settings['executeCommand'] != "":
-                execute(self.settings['executeCommand'].replace("%folder%", quote(str(self.downloadObject.extrasPath))))
-        except Exception as e:
-            self.afterDownloadErrorReport("ExecuteCommand", e)
+            execute(self.settings['executeCommand'].replace("%folder%", quote(str(self.extrasPath))), shell=True)
+
+class DownloadError(Exception):
+    """Base class for exceptions in this module."""
+
+errorMessages = {
+    'notOnDeezer': "Track not available on Deezer!",
+    'notEncoded': "Track not yet encoded!",
+    'notEncodedNoAlternative': "Track not yet encoded and no alternative found!",
+    'wrongBitrate': "Track not found at desired bitrate.",
+    'wrongBitrateNoAlternative': "Track not found at desired bitrate and no alternative found!",
+    'no360RA': "Track is not available in Reality Audio 360.",
+    'notAvailable': "Track not available on deezer's servers!",
+    'notAvailableNoAlternative': "Track not available on deezer's servers and no alternative found!",
+    'noSpaceLeft': "No space left on target drive, clean up some space for the tracks",
+    'albumDoesntExists': "Track's album does not exsist, failed to gather info"
+}
+
+class DownloadFailed(DownloadError):
+    def __init__(self, errid, track=None):
+        super().__init__()
+        self.errid = errid
+        self.message = errorMessages[self.errid]
+        self.track = track
+
+class PreferredBitrateNotFound(DownloadError):
+    pass
+
+class TrackNot360(DownloadError):
+    pass

deemix/errors.py

@@ -1,96 +0,0 @@
-class DeemixError(Exception):
-    """Base exception for this module"""
-
-class GenerationError(DeemixError):
-    """Generation related errors"""
-    def __init__(self, link, message, errid=None):
-        super().__init__()
-        self.link = link
-        self.message = message
-        self.errid = errid
-
-    def toDict(self):
-        return {
-            'link': self.link,
-            'error': self.message,
-            'errid': self.errid
-        }
-
-class ISRCnotOnDeezer(GenerationError):
-    def __init__(self, link):
-        super().__init__(link, "Track ISRC is not available on deezer", "ISRCnotOnDeezer")
-
-class NotYourPrivatePlaylist(GenerationError):
-    def __init__(self, link):
-        super().__init__(link, "You can't download others private playlists.", "notYourPrivatePlaylist")
-
-class TrackNotOnDeezer(GenerationError):
-    def __init__(self, link):
-        super().__init__(link, "Track not found on deezer!", "trackNotOnDeezer")
-
-class AlbumNotOnDeezer(GenerationError):
-    def __init__(self, link):
-        super().__init__(link, "Album not found on deezer!", "albumNotOnDeezer")
-
-class InvalidID(GenerationError):
-    def __init__(self, link):
-        super().__init__(link, "Link ID is invalid!", "invalidID")
-
-class LinkNotSupported(GenerationError):
-    def __init__(self, link):
-        super().__init__(link, "Link is not supported.", "unsupportedURL")
-
-class LinkNotRecognized(GenerationError):
-    def __init__(self, link):
-        super().__init__(link, "Link is not recognized.", "invalidURL")
-
-class DownloadError(DeemixError):
-    """Download related errors"""
-
-ErrorMessages = {
-    'notOnDeezer': "Track not available on Deezer!",
-    'notEncoded': "Track not yet encoded!",
-    'notEncodedNoAlternative': "Track not yet encoded and no alternative found!",
-    'wrongBitrate': "Track not found at desired bitrate.",
-    'wrongBitrateNoAlternative': "Track not found at desired bitrate and no alternative found!",
-    'wrongLicense': "Your account can't stream the track at the desired bitrate.",
-    'no360RA': "Track is not available in Reality Audio 360.",
-    'notAvailable': "Track not available on deezer's servers!",
-    'notAvailableNoAlternative': "Track not available on deezer's servers and no alternative found!",
-    'noSpaceLeft': "No space left on target drive, clean up some space for the tracks",
-    'albumDoesntExists': "Track's album does not exsist, failed to gather info.",
-    'notLoggedIn': "You need to login to download tracks.",
-    'wrongGeolocation': "Your account can't stream the track from your current country.",
-    'wrongGeolocationNoAlternative': "Your account can't stream the track from your current country and no alternative found."
-}
-
-class DownloadFailed(DownloadError):
-    def __init__(self, errid, track=None):
-        super().__init__()
-        self.errid = errid
-        self.message = ErrorMessages[self.errid]
-        self.track = track
-
-class PreferredBitrateNotFound(DownloadError):
-    pass
-
-class TrackNot360(DownloadError):
-    pass
-
-class DownloadCanceled(DownloadError):
-    pass
-
-class DownloadEmpty(DownloadError):
-    pass
-
-class TrackError(DeemixError):
-    """Track generation related errors"""
-
-class AlbumDoesntExists(TrackError):
-    pass
-
-class MD5NotFound(TrackError):
-    pass
-
-class NoDataToParse(TrackError):
-    pass

deemix/itemgen.py

@@ -1,52 +1,47 @@
 import logging
 
-from deezer.errors import GWAPIError, APIError
-from deezer.utils import map_user_playlist, map_track, map_album
-
 from deemix.types.DownloadObjects import Single, Collection
-from deemix.errors import GenerationError, ISRCnotOnDeezer, InvalidID, NotYourPrivatePlaylist
+from deezer.gw import GWAPIError, LyricsStatus
+from deezer.api import APIError
+from deezer.utils import map_user_playlist
 
 logger = logging.getLogger('deemix')
 
 def generateTrackItem(dz, link_id, bitrate, trackAPI=None, albumAPI=None):
-    # Get essential track info
-    if not trackAPI:
-        if str(link_id).startswith("isrc") or int(link_id) > 0:
+    # Check if is an isrc: url
+    if str(link_id).startswith("isrc"):
         try:
             trackAPI = dz.api.get_track(link_id)
         except APIError as e:
             raise GenerationError(f"https://deezer.com/track/{link_id}", str(e)) from e
 
-            # Check if is an isrc: url
-            if str(link_id).startswith("isrc"):
         if 'id' in trackAPI and 'title' in trackAPI:
             link_id = trackAPI['id']
         else:
             raise ISRCnotOnDeezer(f"https://deezer.com/track/{link_id}")
-        else:
-            trackAPI_gw = dz.gw.get_track(link_id)
-            trackAPI = map_track(trackAPI_gw)
-    else:
-        link_id = trackAPI['id']
-    if not str(link_id).strip('-').isdecimal(): raise InvalidID(f"https://deezer.com/track/{link_id}")
+    if not link_id.isdecimal(): raise InvalidID(f"https://deezer.com/track/{link_id}")
 
-    cover = None
-    if trackAPI['album']['cover_small']:
-        cover = trackAPI['album']['cover_small'][:-24] + '/75x75-000000-80-0-0.jpg'
-    else:
-        cover = f"https://e-cdns-images.dzcdn.net/images/cover/{trackAPI['md5_image']}/75x75-000000-80-0-0.jpg"
+    # Get essential track info
+    try:
+        trackAPI_gw = dz.gw.get_track_with_fallback(link_id)
+    except GWAPIError as e:
+        raise GenerationError(f"https://deezer.com/track/{link_id}", str(e)) from e
 
-    if 'track_token' in trackAPI: del trackAPI['track_token']
+    title = trackAPI_gw['SNG_TITLE'].strip()
+    if trackAPI_gw.get('VERSION') and trackAPI_gw['VERSION'] not in trackAPI_gw['SNG_TITLE']:
+        title += f" {trackAPI_gw['VERSION']}".strip()
+    explicit = bool(int(trackAPI_gw.get('EXPLICIT_LYRICS', 0)))
 
     return Single({
         'type': 'track',
         'id': link_id,
         'bitrate': bitrate,
-        'title': trackAPI['title'],
-        'artist': trackAPI['artist']['name'],
-        'cover': cover,
-        'explicit': trackAPI['explicit_lyrics'],
+        'title': title,
+        'artist': trackAPI_gw['ART_NAME'],
+        'cover': f"https://e-cdns-images.dzcdn.net/images/cover/{trackAPI_gw['ALB_PICTURE']}/75x75-000000-80-0-0.jpg",
+        'explicit': explicit,
         'single': {
+            'trackAPI_gw': trackAPI_gw,
             'trackAPI': trackAPI,
             'albumAPI': albumAPI
         }
@@ -69,25 +64,18 @@ def generateAlbumItem(dz, link_id, bitrate, rootArtist=None):
         link_id = albumAPI['id']
     else:
         try:
-            albumAPI_gw_page = dz.gw.get_album_page(link_id)
-            if 'DATA' in albumAPI_gw_page:
-                albumAPI = map_album(albumAPI_gw_page['DATA'])
-                link_id = albumAPI_gw_page['DATA']['ALB_ID']
-                albumAPI_new = dz.api.get_album(link_id)
-                albumAPI.update(albumAPI_new)
-            else:
-                raise GenerationError(f"https://deezer.com/album/{link_id}", "Can't find the album")
+            albumAPI = dz.api.get_album(link_id)
         except APIError as e:
             raise GenerationError(f"https://deezer.com/album/{link_id}", str(e)) from e
 
-    if not str(link_id).isdecimal(): raise InvalidID(f"https://deezer.com/album/{link_id}")
+    if not link_id.isdecimal(): raise InvalidID(f"https://deezer.com/album/{link_id}")
 
     # Get extra info about album
     # This saves extra api calls when downloading
     albumAPI_gw = dz.gw.get_album(link_id)
-    albumAPI_gw = map_album(albumAPI_gw)
-    albumAPI_gw.update(albumAPI)
-    albumAPI = albumAPI_gw
+    albumAPI['nb_disk'] = albumAPI_gw['NUMBER_DISK']
+    albumAPI['copyright'] = albumAPI_gw['COPYRIGHT']
+    albumAPI['release_date'] = albumAPI_gw['PHYSICAL_RELEASE_DATE']
     albumAPI['root_artist'] = rootArtist
 
     # If the album is a single download as a track
@@ -101,17 +89,18 @@ def generateAlbumItem(dz, link_id, bitrate, rootArtist=None):
     if albumAPI['cover_small'] is not None:
         cover = albumAPI['cover_small'][:-24] + '/75x75-000000-80-0-0.jpg'
     else:
-        cover = f"https://e-cdns-images.dzcdn.net/images/cover/{albumAPI['md5_image']}/75x75-000000-80-0-0.jpg"
+        cover = f"https://e-cdns-images.dzcdn.net/images/cover/{albumAPI_gw['ALB_PICTURE']}/75x75-000000-80-0-0.jpg"
 
     totalSize = len(tracksArray)
     albumAPI['nb_tracks'] = totalSize
     collection = []
     for pos, trackAPI in enumerate(tracksArray, start=1):
-        trackAPI = map_track(trackAPI)
-        if 'track_token' in trackAPI: del trackAPI['track_token']
-        trackAPI['position'] = pos
+        trackAPI['POSITION'] = pos
+        trackAPI['SIZE'] = totalSize
         collection.append(trackAPI)
 
+    explicit = albumAPI_gw.get('EXPLICIT_ALBUM_CONTENT', {}).get('EXPLICIT_LYRICS_STATUS', LyricsStatus.UNKNOWN) in [LyricsStatus.EXPLICIT, LyricsStatus.PARTIALLY_EXPLICIT]
+
     return Collection({
         'type': 'album',
         'id': link_id,
@@ -119,17 +108,17 @@ def generateAlbumItem(dz, link_id, bitrate, rootArtist=None):
         'title': albumAPI['title'],
         'artist': albumAPI['artist']['name'],
         'cover': cover,
-        'explicit': albumAPI['explicit_lyrics'],
+        'explicit': explicit,
         'size': totalSize,
         'collection': {
-            'tracks': collection,
+            'tracks_gw': collection,
             'albumAPI': albumAPI
         }
     })
 
 def generatePlaylistItem(dz, link_id, bitrate, playlistAPI=None, playlistTracksAPI=None):
     if not playlistAPI:
-        if not str(link_id).isdecimal(): raise InvalidID(f"https://deezer.com/playlist/{link_id}")
+        if not link_id.isdecimal(): raise InvalidID(f"https://deezer.com/playlist/{link_id}")
         # Get essential playlist info
         try:
             playlistAPI = dz.api.get_playlist(link_id)
@@ -156,11 +145,10 @@ def generatePlaylistItem(dz, link_id, bitrate, playlistAPI=None, playlistTracksA
     playlistAPI['nb_tracks'] = totalSize
     collection = []
     for pos, trackAPI in enumerate(playlistTracksAPI, start=1):
-        trackAPI = map_track(trackAPI)
-        if trackAPI['explicit_lyrics']:
+        if trackAPI.get('EXPLICIT_TRACK_CONTENT', {}).get('EXPLICIT_LYRICS_STATUS', LyricsStatus.UNKNOWN) in [LyricsStatus.EXPLICIT, LyricsStatus.PARTIALLY_EXPLICIT]:
             playlistAPI['explicit'] = True
-        if 'track_token' in trackAPI: del trackAPI['track_token']
-        trackAPI['position'] = pos
+        trackAPI['POSITION'] = pos
+        trackAPI['SIZE'] = totalSize
         collection.append(trackAPI)
 
     if 'explicit' not in playlistAPI: playlistAPI['explicit'] = False
@@ -175,13 +163,13 @@ def generatePlaylistItem(dz, link_id, bitrate, playlistAPI=None, playlistTracksA
         'explicit': playlistAPI['explicit'],
         'size': totalSize,
         'collection': {
-            'tracks': collection,
+            'tracks_gw': collection,
             'playlistAPI': playlistAPI
         }
     })
 
 def generateArtistItem(dz, link_id, bitrate, listener=None):
-    if not str(link_id).isdecimal(): raise InvalidID(f"https://deezer.com/artist/{link_id}")
+    if not link_id.isdecimal(): raise InvalidID(f"https://deezer.com/artist/{link_id}")
     # Get essential artist info
     try:
         artistAPI = dz.api.get_artist(link_id)
@@ -208,7 +196,7 @@ def generateArtistItem(dz, link_id, bitrate, listener=None):
     return albumList
 
 def generateArtistDiscographyItem(dz, link_id, bitrate, listener=None):
-    if not str(link_id).isdecimal(): raise InvalidID(f"https://deezer.com/artist/{link_id}/discography")
+    if not link_id.isdecimal(): raise InvalidID(f"https://deezer.com/artist/{link_id}/discography")
     # Get essential artist info
     try:
         artistAPI = dz.api.get_artist(link_id)
@@ -236,7 +224,7 @@ def generateArtistDiscographyItem(dz, link_id, bitrate, listener=None):
     return albumList
 
 def generateArtistTopItem(dz, link_id, bitrate):
-    if not str(link_id).isdecimal(): raise InvalidID(f"https://deezer.com/artist/{link_id}/top_track")
+    if not link_id.isdecimal(): raise InvalidID(f"https://deezer.com/artist/{link_id}/top_track")
     # Get essential artist info
     try:
         artistAPI = dz.api.get_artist(link_id)
@@ -275,3 +263,45 @@ def generateArtistTopItem(dz, link_id, bitrate):
 
     artistTopTracksAPI_gw = dz.gw.get_artist_toptracks(link_id)
     return generatePlaylistItem(dz, playlistAPI['id'], bitrate, playlistAPI=playlistAPI, playlistTracksAPI=artistTopTracksAPI_gw)
+
+class GenerationError(Exception):
+    def __init__(self, link, message, errid=None):
+        super().__init__()
+        self.link = link
+        self.message = message
+        self.errid = errid
+
+    def toDict(self):
+        return {
+            'link': self.link,
+            'error': self.message,
+            'errid': self.errid
+        }
+
+class ISRCnotOnDeezer(GenerationError):
+    def __init__(self, link):
+        super().__init__(link, "Track ISRC is not available on deezer", "ISRCnotOnDeezer")
+
+class NotYourPrivatePlaylist(GenerationError):
+    def __init__(self, link):
+        super().__init__(link, "You can't download others private playlists.", "notYourPrivatePlaylist")
+
+class TrackNotOnDeezer(GenerationError):
+    def __init__(self, link):
+        super().__init__(link, "Track not found on deezer!", "trackNotOnDeezer")
+
+class AlbumNotOnDeezer(GenerationError):
+    def __init__(self, link):
+        super().__init__(link, "Album not found on deezer!", "albumNotOnDeezer")
+
+class InvalidID(GenerationError):
+    def __init__(self, link):
+        super().__init__(link, "Link ID is invalid!", "invalidID")
+
+class LinkNotSupported(GenerationError):
+    def __init__(self, link):
+        super().__init__(link, "Link is not supported.", "unsupportedURL")
+
+class LinkNotRecognized(GenerationError):
+    def __init__(self, link):
+        super().__init__(link, "Link is not recognized.", "invalidURL")

deemix/plugins/spotify.py

@@ -1,19 +1,15 @@
 from concurrent.futures import ThreadPoolExecutor
 import json
-from copy import deepcopy
 from pathlib import Path
 import re
 from urllib.request import urlopen
-from deezer.errors import DataException
 from deemix.plugins import Plugin
 from deemix.utils.localpaths import getConfigFolder
-from deemix.itemgen import generateTrackItem, generateAlbumItem
-from deemix.errors import GenerationError, TrackNotOnDeezer, AlbumNotOnDeezer
-from deemix.types.DownloadObjects import Convertable, Collection
+from deemix.itemgen import generateTrackItem, generateAlbumItem, GenerationError, TrackNotOnDeezer, AlbumNotOnDeezer
+from deemix.types.DownloadObjects import Convertable
 
 import spotipy
 SpotifyClientCredentials = spotipy.oauth2.SpotifyClientCredentials
-CacheFileHandler = spotipy.cache_handler.CacheFileHandler
 
 class Spotify(Plugin):
     def __init__(self, configFolder=None):
@@ -58,7 +54,7 @@ class Spotify(Plugin):
 
         return (link, link_type, link_id)
 
-    def generateDownloadObject(self, dz, link, bitrate, listener):
+    def generateDownloadObject(self, dz, link, bitrate):
         (link, link_type, link_id) = self.parseLink(link)
 
         if link_type is None or link_id is None: return None
@@ -95,10 +91,7 @@ class Spotify(Plugin):
                     cachedTrack['id'] = trackID
                     cache['tracks'][link_id] = cachedTrack
                     self.saveCache(cache)
-
-            if cachedTrack.get('id', "0") != "0":
-                return generateTrackItem(dz, cachedTrack['id'], bitrate)
-
+            if cachedTrack['id'] != "0": return generateTrackItem(dz, cachedTrack['id'], bitrate)
         raise TrackNotOnDeezer(f"https://open.spotify.com/track/{link_id}")
 
     def generateAlbumItem(self, dz, link_id, bitrate):
@@ -119,9 +112,9 @@ class Spotify(Plugin):
         spotifyPlaylist = self.sp.playlist(link_id)
 
         playlistAPI = self._convertPlaylistStructure(spotifyPlaylist)
-        playlistAPI['various_artist'] = dz.api.get_artist(5080) # Useful for save as compilation
+        playlistAPI.various_artist = dz.api.get_artist(5080) # Useful for save as compilation
 
-        tracklistTemp = spotifyPlaylist['tracks']['items']
+        tracklistTemp = spotifyPlaylist.track.items
         while spotifyPlaylist['tracks']['next']:
             spotifyPlaylist['tracks'] = self.sp.next(spotifyPlaylist['tracks'])
             tracklistTemp += spotifyPlaylist['tracks']['items']
@@ -144,7 +137,7 @@ class Spotify(Plugin):
             'explicit': playlistAPI['explicit'],
             'size': len(tracklist),
             'collection': {
-                'tracks': [],
+                'tracks_gw': [],
                 'playlistAPI': playlistAPI
             },
             'plugin': 'spotify',
@@ -186,10 +179,8 @@ class Spotify(Plugin):
         }
         return cachedAlbum
 
-    def convertTrack(self, dz, downloadObject, track, pos, conversion, cache, listener):
+    def convertTrack(self, dz, downloadObject, track, pos, conversion, conversionNext, cache, listener):
         if downloadObject.isCanceled: return
-        trackAPI = None
-        cachedTrack = None
 
         if track['id'] in cache['tracks']:
             cachedTrack = cache['tracks'][track['id']]
@@ -202,7 +193,7 @@ class Spotify(Plugin):
             try:
                 trackAPI = dz.api.get_track_by_ISRC(cachedTrack['isrc'])
                 if 'id' not in trackAPI or 'title' not in trackAPI: trackAPI = None
-            except DataException: pass
+            except GenerationError: pass
         if self.settings['fallbackSearch'] and not trackAPI:
             if 'id' not in cachedTrack or cachedTrack['id'] == "0":
                 trackID = dz.api.get_track_id_from_metadata(
@@ -214,59 +205,46 @@ class Spotify(Plugin):
                     cachedTrack['id'] = trackID
                     cache['tracks'][track['id']] = cachedTrack
                     self.saveCache(cache)
-
-            if cachedTrack.get('id', "0") != "0":
-                trackAPI = dz.api.get_track(cachedTrack['id'])
+            if cachedTrack['id'] != "0": trackAPI = dz.api.get_track(cachedTrack['id'])
 
         if not trackAPI:
-            trackAPI = {
-                'id': "0",
-                'title': track['name'],
-                'duration': 0,
-                'md5_origin': 0,
-                'media_version': 0,
-                'filesizes': {},
-                'album': {
-                    'title': track['album']['name'],
-                    'md5_image': ""
-                },
-                'artist': {
-                    'id': 0,
-                    'name': track['artists'][0]['name']
+            deezerTrack = {
+                'SNG_ID': "0",
+                'SNG_TITLE': track['name'],
+                'DURATION': 0,
+                'MD5_ORIGIN': 0,
+                'MEDIA_VERSION': 0,
+                'FILESIZE': 0,
+                'ALB_TITLE': track['album']['name'],
+                'ALB_PICTURE': "",
+                'ART_ID': 0,
+                'ART_NAME': track['artists'][0]['name']
             }
-            }
-        trackAPI['position'] = pos+1
+        else:
+            deezerTrack = dz.gw.get_track_with_fallback(trackAPI['id'])
+        deezerTrack['_EXTRA_TRACK'] = trackAPI
+        deezerTrack['POSITION'] = pos+1
 
-        conversion['next'] += (1 / downloadObject.size) * 100
-        if round(conversion['next']) != conversion['now'] and round(conversion['next']) % 2 == 0:
-            conversion['now'] = round(conversion['next'])
-            if listener: listener.send("updateQueue", {'uuid': downloadObject.uuid, 'conversion': conversion['now']})
-
-        return trackAPI
+        conversionNext += (1 / downloadObject.size) * 100
+        if round(conversionNext) != conversion and round(conversionNext) % 2 == 0:
+            conversion = round(conversionNext)
+            if listener: listener.send("updateQueue", {'uuid': downloadObject.uuid, 'conversion': conversion})
 
     def convert(self, dz, downloadObject, settings, listener=None):
         cache = self.loadCache()
 
-        conversion = { 'now': 0, 'next': 0 }
+        conversion = 0
+        conversionNext = 0
 
         collection = [None] * len(downloadObject.conversion_data)
-        if listener: listener.send("startConversion", downloadObject.uuid)
         with ThreadPoolExecutor(settings['queueConcurrency']) as executor:
             for pos, track in enumerate(downloadObject.conversion_data, start=0):
                 collection[pos] = executor.submit(self.convertTrack,
                     dz, downloadObject,
                     track, pos,
-                    conversion,
+                    conversion, conversionNext,
                     cache, listener
-                ).result()
-
-        downloadObject.collection['tracks'] = collection
-        downloadObject.size = len(collection)
-        downloadObject = Collection(downloadObject.toDict())
-        if listener: listener.send("finishConversion", downloadObject.getSlimmedDict())
-
-        self.saveCache(cache)
-        return downloadObject
+                )
 
     @classmethod
     def _convertPlaylistStructure(cls, spotifyPlaylist):
@@ -295,7 +273,6 @@ class Spotify(Plugin):
             'picture_medium': cover or "https://e-cdns-images.dzcdn.net/images/cover/d41d8cd98f00b204e9800998ecf8427e/250x250-000000-80-0-0.jpg",
             'picture_big': cover or "https://e-cdns-images.dzcdn.net/images/cover/d41d8cd98f00b204e9800998ecf8427e/500x500-000000-80-0-0.jpg",
             'picture_xl': cover or "https://e-cdns-images.dzcdn.net/images/cover/d41d8cd98f00b204e9800998ecf8427e/1000x1000-000000-80-0-0.jpg",
-            'picture_thumbnail': cover or "https://e-cdns-images.dzcdn.net/images/cover/d41d8cd98f00b204e9800998ecf8427e/75x75-000000-80-0-0.jpg",
             'public': spotifyPlaylist['public'],
             'share': spotifyPlaylist['external_urls']['spotify'],
             'title': spotifyPlaylist['name'],
@@ -305,27 +282,19 @@ class Spotify(Plugin):
         return deezerPlaylist
 
     def loadSettings(self):
-        if not (self.configFolder / 'config.json').is_file():
-            with open(self.configFolder / 'config.json', 'w', encoding="utf-8") as f:
+        if not (self.configFolder / 'settings.json').is_file():
+            with open(self.configFolder / 'settings.json', 'w') as f:
                 json.dump({**self.credentials, **self.settings}, f, indent=2)
 
-        with open(self.configFolder / 'config.json', 'r', encoding="utf-8") as settingsFile:
-            try:
+        with open(self.configFolder / 'settings.json', 'r') as settingsFile:
             settings = json.load(settingsFile)
-            except json.decoder.JSONDecodeError:
-                with open(self.configFolder / 'config.json', 'w', encoding="utf-8") as f:
-                    json.dump({**self.credentials, **self.settings}, f, indent=2)
-                settings = deepcopy({**self.credentials, **self.settings})
-            except Exception:
-                settings = deepcopy({**self.credentials, **self.settings})
-
         self.setSettings(settings)
         self.checkCredentials()
 
     def saveSettings(self, newSettings=None):
         if newSettings: self.setSettings(newSettings)
         self.checkCredentials()
-        with open(self.configFolder / 'config.json', 'w', encoding="utf-8") as f:
+        with open(self.configFolder / 'settings.json', 'w') as f:
             json.dump({**self.credentials, **self.settings}, f, indent=2)
 
     def getSettings(self):
@@ -339,21 +308,15 @@ class Spotify(Plugin):
         self.settings = settings
 
     def loadCache(self):
-        cache = None
         if (self.configFolder / 'cache.json').is_file():
-            with open(self.configFolder / 'cache.json', 'r', encoding="utf-8") as f:
-                try:
+            with open(self.configFolder / 'cache.json', 'r') as f:
                 cache = json.load(f)
-                except json.decoder.JSONDecodeError:
-                    self.saveCache({'tracks': {}, 'albums': {}})
-                    cache = None
-                except Exception:
-                    cache = None
-        if not cache: cache = {'tracks': {}, 'albums': {}}
+        else:
+            cache = {'tracks': {}, 'albums': {}}
         return cache
 
     def saveCache(self, newCache):
-        with open(self.configFolder / 'cache.json', 'w', encoding="utf-8") as spotifyCache:
+        with open(self.configFolder / 'cache.json', 'w') as spotifyCache:
             json.dump(newCache, spotifyCache)
 
     def checkCredentials(self):
@@ -362,10 +325,8 @@ class Spotify(Plugin):
             return
 
         try:
-            cache_handler = CacheFileHandler(self.configFolder / ".auth-cache")
             client_credentials_manager = SpotifyClientCredentials(client_id=self.credentials['clientId'],
-                                                                  client_secret=self.credentials['clientSecret'],
-                                                                  cache_handler=cache_handler)
+                                                                  client_secret=self.credentials['clientSecret'])
             self.sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager)
             self.sp.user_playlists('spotify')
             self.enabled = True

deemix/settings.py

@@ -1,5 +1,4 @@
 import json
-from copy import deepcopy
 from pathlib import Path
 from os import makedirs
 from deezer import TrackFormats
@@ -21,93 +20,89 @@ class FeaturesOption():
     MOVE_TITLE = "2" # Move to track title
 
 DEFAULTS = {
-  "albumNameTemplate": "%artist% - %album%",
-  "albumTracknameTemplate": "%tracknumber% - %title%",
-  "albumVariousArtists": True,
-  "artistCasing": "nothing",
-  "artistImageTemplate": "folder",
-  "artistNameTemplate": "%artist%",
-  "coverImageTemplate": "cover",
-  "createAlbumFolder": True,
-  "createArtistFolder": False,
-  "createCDFolder": True,
-  "createM3U8File": False,
-  "createPlaylistFolder": True,
-  "createSingleFolder": False,
-  "createStructurePlaylist": False,
-  "dateFormat": "Y-M-D",
   "downloadLocation": str(localpaths.getMusicFolder()),
-  "embeddedArtworkPNG": False,
-  "embeddedArtworkSize": 800,
-  "executeCommand": "",
-  "fallbackBitrate": False,
-  "fallbackISRC": False,
-  "fallbackSearch": False,
-  "featuredToTitle": FeaturesOption.NO_CHANGE,
-  "feelingLucky": False,
+  "tracknameTemplate": "%artist% - %title%",
+  "albumTracknameTemplate": "%tracknumber% - %title%",
+  "playlistTracknameTemplate": "%position% - %artist% - %title%",
+  "createPlaylistFolder": True,
+  "playlistNameTemplate": "%playlist%",
+  "createArtistFolder": False,
+  "artistNameTemplate": "%artist%",
+  "createAlbumFolder": True,
+  "albumNameTemplate": "%artist% - %album%",
+  "createCDFolder": True,
+  "createStructurePlaylist": False,
+  "createSingleFolder": False,
+  "padTracks": True,
+  "paddingSize": "0",
   "illegalCharacterReplacer": "_",
-  "jpegImageQuality": 90,
-  "localArtworkFormat": "jpg",
-  "localArtworkSize": 1400,
+  "queueConcurrency": 3,
+  "maxBitrate": str(TrackFormats.MP3_320),
+  "fallbackBitrate": True,
+  "fallbackSearch": False,
   "logErrors": True,
   "logSearched": False,
-  "maxBitrate": TrackFormats.MP3_320,
   "overwriteFile": OverwriteOption.DONT_OVERWRITE,
-  "paddingSize": "0",
-  "padTracks": True,
+  "createM3U8File": False,
   "playlistFilenameTemplate": "playlist",
-  "playlistNameTemplate": "%playlist%",
-  "playlistTracknameTemplate": "%position% - %artist% - %title%",
-  "queueConcurrency": 3,
-  "removeAlbumVersion": False,
-  "removeDuplicateArtists": True,
+  "syncedLyrics": False,
+  "embeddedArtworkSize": 800,
+  "embeddedArtworkPNG": False,
+  "localArtworkSize": 1400,
+  "localArtworkFormat": "jpg",
   "saveArtwork": True,
+  "coverImageTemplate": "cover",
   "saveArtworkArtist": False,
-  "syncedLyrics": False,
+  "artistImageTemplate": "folder",
+  "jpegImageQuality": 80,
+  "dateFormat": "Y-M-D",
+  "albumVariousArtists": True,
+  "removeAlbumVersion": False,
+  "removeDuplicateArtists": False,
+  "featuredToTitle": FeaturesOption.NO_CHANGE,
+  "titleCasing": "nothing",
+  "artistCasing": "nothing",
+  "executeCommand": "",
   "tags": {
-    "album": True,
-    "albumArtist": True,
-    "artist": True,
-    "artists": True,
-    "barcode": True,
-    "bpm": True,
-    "composer": False,
-    "copyright": False,
-    "cover": True,
-    "coverDescriptionUTF8": False,
-    "date": True,
-    "discNumber": True,
-    "discTotal": False,
-    "explicit": False,
-    "genre": True,
-    "involvedPeople": False,
-    "isrc": True,
-    "label": True,
-    "length": True,
-    "lyrics": False,
-    "multiArtistSeparator": "default",
-    "rating": False,
-    "replayGain": False,
-    "saveID3v1": True,
-    "savePlaylistAsCompilation": False,
-    "singleAlbumArtist": False,
-    "source": False,
-    "syncedLyrics": False,
     "title": True,
+    "artist": True,
+    "album": True,
+    "cover": True,
     "trackNumber": True,
     "trackTotal": False,
-    "useNullSeparator": False,
+    "discNumber": True,
+    "discTotal": False,
+    "albumArtist": True,
+    "genre": True,
     "year": True,
-  },
-  "titleCasing": "nothing",
-  "tracknameTemplate": "%artist% - %title%",
+    "date": True,
+    "explicit": False,
+    "isrc": True,
+    "length": True,
+    "barcode": True,
+    "bpm": True,
+    "replayGain": False,
+    "label": True,
+    "lyrics": False,
+    "syncedLyrics": False,
+    "copyright": False,
+    "composer": False,
+    "involvedPeople": False,
+    "source": False,
+    "savePlaylistAsCompilation": False,
+    "useNullSeparator": False,
+    "saveID3v1": True,
+    "multiArtistSeparator": "default",
+    "singleAlbumArtist": False,
+    "coverDescriptionUTF8": False
+  }
 }
 
 def save(settings, configFolder=None):
     configFolder = Path(configFolder or localpaths.getConfigFolder())
     makedirs(configFolder, exist_ok=True) # Create config folder if it doesn't exsist
 
-    with open(configFolder / 'config.json', 'w', encoding="utf-8") as configFile:
+    with open(configFolder / 'config.json', 'w') as configFile:
         json.dump(settings, configFile, indent=2)
 
 def load(configFolder=None):
@@ -116,26 +111,16 @@ def load(configFolder=None):
     if not (configFolder / 'config.json').is_file(): save(DEFAULTS, configFolder) # Create config file if it doesn't exsist
 
     # Read config file
-    with open(configFolder / 'config.json', 'r', encoding="utf-8") as configFile:
-        try:
+    with open(configFolder / 'config.json', 'r') as configFile:
         settings = json.load(configFile)
-        except json.decoder.JSONDecodeError:
-            save(DEFAULTS, configFolder)
-            settings = deepcopy(DEFAULTS)
-        except Exception:
-            settings = deepcopy(DEFAULTS)
 
-    if check(settings) > 0:
-        try:
-            save(settings, configFolder) # Check the settings and save them if something changed
-        except:
-            print(f"Error saving config file {configFile.name}, continuing without saving.") 
+    if check(settings) > 0: save(settings, configFolder) # Check the settings and save them if something changed
     return settings
 
 def check(settings):
     changes = 0
     for i_set in DEFAULTS:
-        if not i_set in settings or not type(settings[i_set] is type(DEFAULTS[i_set])):
+        if not i_set in settings or not isinstance(settings[i_set], type(DEFAULTS[i_set])):
             settings[i_set] = DEFAULTS[i_set]
             changes += 1
     for i_set in DEFAULTS['tags']:

deemix/tagger.py

@@ -1,7 +1,7 @@
 from mutagen.flac import FLAC, Picture
 from mutagen.id3 import ID3, ID3NoHeaderError, \
     TXXX, TIT2, TPE1, TALB, TPE2, TRCK, TPOS, TCON, TYER, TDAT, TLEN, TBPM, \
-    TPUB, TSRC, USLT, SYLT, APIC, IPLS, TCOM, TCOP, TCMP, Encoding, PictureType, POPM
+    TPUB, TSRC, USLT, SYLT, APIC, IPLS, TCOM, TCOP, TCMP, Encoding, PictureType
 
 # Adds tags to a MP3 file
 def tagID3(path, track, save):
@@ -25,7 +25,6 @@ def tagID3(path, track, save):
                 tag.add(TPE1(text=track.artistsString))
             # Tag ARTISTS is added to keep the multiartist support when using a non standard tagging method
             # https://picard-docs.musicbrainz.org/en/appendices/tag_mapping.html#artists
-            if save['artists']:
             tag.add(TXXX(desc="ARTISTS", text=track.artists))
 
     if save['album']:
@@ -59,7 +58,7 @@ def tagID3(path, track, save):
         tag.add(TDAT(text=str(track.date.day) + str(track.date.month)))
     if save['length']:
         tag.add(TLEN(text=str(int(track.duration)*1000)))
-    if save['bpm'] and track.bpm:
+    if save['bpm']:
         tag.add(TBPM(text=str(track.bpm)))
     if save['label']:
         tag.add(TPUB(text=track.album.label))
@@ -90,7 +89,7 @@ def tagID3(path, track, save):
     if len(involved_people) > 0 and save['involvedPeople']:
         tag.add(IPLS(people=involved_people))
 
-    if save['copyright'] and track.copyright:
+    if save['copyright']:
         tag.add(TCOP(text=track.copyright))
     if save['savePlaylistAsCompilation'] and track.playlist or track.album.recordType == "compile":
         tag.add(TCMP(text="1"))
@@ -99,15 +98,6 @@ def tagID3(path, track, save):
         tag.add(TXXX(desc="SOURCE", text='Deezer'))
         tag.add(TXXX(desc="SOURCEID", text=str(track.id)))
 
-    if save['rating']:
-        rank = round((int(track.rank) / 10000) * 2.55)
-        if rank > 255 :
-            rank = 255
-        else:
-            rank = round(rank, 0)
-
-        tag.add(POPM(rating=rank))
-
     if save['cover'] and track.album.embeddedCoverPath:
 
         descEncoding = Encoding.LATIN1
@@ -146,7 +136,6 @@ def tagFLAC(path, track, save):
                 tag["ARTIST"] = track.artistsString
             # Tag ARTISTS is added to keep the multiartist support when using a non standard tagging method
             # https://picard-docs.musicbrainz.org/en/technical/tag_mapping.html#artists
-            if save['artists']:
             tag["ARTISTS"] = track.artists
 
     if save['album']:
@@ -179,7 +168,7 @@ def tagFLAC(path, track, save):
 
     if save['length']:
         tag["LENGTH"] = str(int(track.duration)*1000)
-    if save['bpm'] and track.bpm:
+    if save['bpm']:
         tag["BPM"] = str(track.bpm)
     if save['label']:
         tag["PUBLISHER"] = track.album.label
@@ -201,7 +190,7 @@ def tagFLAC(path, track, save):
         elif role == 'musicpublisher' and save['involvedPeople']:
             tag["ORGANIZATION"] = track.contributors['musicpublisher']
 
-    if save['copyright'] and track.copyright:
+    if save['copyright']:
         tag["COPYRIGHT"] = track.copyright
     if save['savePlaylistAsCompilation'] and track.playlist or track.album.recordType == "compile":
         tag["COMPILATION"] = "1"
@@ -210,10 +199,6 @@ def tagFLAC(path, track, save):
         tag["SOURCE"] = 'Deezer'
         tag["SOURCEID"] = str(track.id)
 
-    if save['rating']:
-        rank = round((int(track.rank) / 10000))
-        tag['RATING'] = str(rank)
-
     if save['cover'] and track.album.embeddedCoverPath:
         image = Picture()
         image.type = PictureType.COVER_FRONT

deemix/types/Album.py

@@ -1,3 +1,5 @@
+from deezer.gw import LyricsStatus
+
 from deemix.utils import removeDuplicateArtists, removeFeatures
 from deemix.types.Artist import Artist
 from deemix.types.Date import Date
@@ -28,7 +30,7 @@ class Album:
         self.rootArtist = None
         self.variousArtists = None
 
-        self.playlistID = None
+        self.playlistId = None
         self.owner = None
         self.isPlaylist = False
 
@@ -37,9 +39,8 @@ class Album:
 
         # Getting artist image ID
         # ex: https://e-cdns-images.dzcdn.net/images/artist/f2bc007e9133c946ac3c3907ddc5d2ea/56x56-000000-80-0-0.jpg
-        art_pic = albumAPI['artist'].get('picture_small')
-        if art_pic: art_pic = art_pic[art_pic.find('artist/') + 7:-24]
-        else: art_pic = ""
+        art_pic = albumAPI['artist']['picture_small']
+        art_pic = art_pic[art_pic.find('artist/') + 7:-24]
         self.mainArtist = Artist(
             albumAPI['artist']['id'],
             albumAPI['artist']['name'],
@@ -77,27 +78,21 @@ class Album:
                 self.artist[artist['role']].append(artist['name'])
 
         self.trackTotal = albumAPI['nb_tracks']
-        self.recordType = albumAPI.get('record_type', self.recordType)
+        self.recordType = albumAPI['record_type']
 
         self.barcode = albumAPI.get('upc', self.barcode)
         self.label = albumAPI.get('label', self.label)
         self.explicit = bool(albumAPI.get('explicit_lyrics', False))
-        release_date = albumAPI.get('release_date')
-        if 'physical_release_date' in albumAPI:
-            release_date = albumAPI['physical_release_date']
-        if release_date:
-            self.date.day = release_date[8:10]
-            self.date.month = release_date[5:7]
-            self.date.year = release_date[0:4]
+        if 'release_date' in albumAPI:
+            self.date.day = albumAPI["release_date"][8:10]
+            self.date.month = albumAPI["release_date"][5:7]
+            self.date.year = albumAPI["release_date"][0:4]
             self.date.fixDayMonth()
 
-        self.discTotal = albumAPI.get('nb_disk', "1")
-        self.copyright = albumAPI.get('copyright', "")
+        self.discTotal = albumAPI.get('nb_disk')
+        self.copyright = albumAPI.get('copyright')
 
-        if not self.pic.md5 or self.pic.md5 == "":
-            if albumAPI.get('md5_image'):
-                self.pic.md5 = albumAPI['md5_image']
-            elif albumAPI.get('cover_small'):
+        if self.pic.md5 == "":
             # Getting album cover MD5
             # ex: https://e-cdns-images.dzcdn.net/images/cover/2e018122cb56986277102d2041a592c8/56x56-000000-80-0-0.jpg
             alb_pic = albumAPI['cover_small']
@@ -107,6 +102,33 @@ class Album:
             for genre in albumAPI['genres']['data']:
                 self.genre.append(genre['name'])
 
+    def parseAlbumGW(self, albumAPI_gw):
+        self.title = albumAPI_gw['ALB_TITLE']
+        self.mainArtist = Artist(
+            art_id = albumAPI_gw['ART_ID'],
+            name = albumAPI_gw['ART_NAME'],
+            role = "Main"
+        )
+
+        self.artists = [albumAPI_gw['ART_NAME']]
+        self.trackTotal = albumAPI_gw['NUMBER_TRACK']
+        self.discTotal = albumAPI_gw['NUMBER_DISK']
+        self.label = albumAPI_gw.get('LABEL_NAME', self.label)
+
+        explicitLyricsStatus = albumAPI_gw.get('EXPLICIT_ALBUM_CONTENT', {}).get('EXPLICIT_LYRICS_STATUS', LyricsStatus.UNKNOWN)
+        self.explicit = explicitLyricsStatus in [LyricsStatus.EXPLICIT, LyricsStatus.PARTIALLY_EXPLICIT]
+
+        self.addExtraAlbumGWData(albumAPI_gw)
+
+    def addExtraAlbumGWData(self, albumAPI_gw):
+        if self.pic.md5 == "":
+            self.pic.md5 = albumAPI_gw['ALB_PICTURE']
+        if 'PHYSICAL_RELEASE_DATE' in albumAPI_gw:
+            self.date.day = albumAPI_gw["PHYSICAL_RELEASE_DATE"][8:10]
+            self.date.month = albumAPI_gw["PHYSICAL_RELEASE_DATE"][5:7]
+            self.date.year = albumAPI_gw["PHYSICAL_RELEASE_DATE"][0:4]
+            self.date.fixDayMonth()
+
     def makePlaylistCompilation(self, playlist):
         self.variousArtists = playlist.variousArtists
         self.mainArtist = playlist.mainArtist
@@ -121,7 +143,7 @@ class Album:
         self.explicit = playlist.explicit
         self.date = playlist.date
         self.discTotal = playlist.discTotal
-        self.playlistID = playlist.playlistID
+        self.playlistId = playlist.playlistId
         self.owner = playlist.owner
         self.pic = playlist.pic
         self.isPlaylist = True

deemix/types/DownloadObjects.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-
 class IDownloadObject:
     """DownloadObject Interface"""
     def __init__(self, obj):
@@ -16,8 +14,6 @@ class IDownloadObject:
         self.progress = obj.get('progress', 0)
         self.errors = obj.get('errors', [])
         self.files = obj.get('files', [])
-        self.extrasPath = obj.get('extrasPath', "")
-        if self.extrasPath: self.extrasPath = Path(self.extrasPath)
         self.progressNext = 0
         self.uuid = f"{self.type}_{self.id}_{self.bitrate}"
         self.isCanceled = False
@@ -39,7 +35,6 @@ class IDownloadObject:
             'progress': self.progress,
             'errors': self.errors,
             'files': self.files,
-            'extrasPath': str(self.extrasPath),
             '__type__': self.__type__
         }
 
@@ -70,8 +65,7 @@ class IDownloadObject:
             'artist': self.artist,
             'cover': self.cover,
             'explicit': self.explicit,
-            'size': self.size,
-            'extrasPath': str(self.extrasPath)
+            'size': self.size
         }
 
     def updateProgress(self, listener=None):

deemix/types/Picture.py

@@ -25,5 +25,5 @@ class StaticPicture:
     def __init__(self, url):
         self.staticURL = url
 
-    def getURL(self, _, __):
+    def getURL(self):
         return self.staticURL

deemix/types/Track.py

@@ -1,9 +1,9 @@
+from time import sleep
 import re
-from datetime import datetime
+import requests
 
-from deezer.utils import map_track, map_album
-from deezer.errors import APIError, GWAPIError
-from deemix.errors import NoDataToParse, AlbumDoesntExists
+from deezer.gw import GWAPIError
+from deezer.api import APIError
 
 from deemix.utils import removeFeatures, andCommaConcat, removeDuplicateArtists, generateReplayGainString, changeCase
 
@@ -23,11 +23,8 @@ class Track:
         self.title = name
         self.MD5 = ""
         self.mediaVersion = ""
-        self.trackToken = ""
-        self.trackTokenExpiration = 0
         self.duration = 0
         self.fallbackID = "0"
-        self.albumsFallback = []
         self.filesizes = {}
         self.local = False
         self.mainArtist = None
@@ -44,7 +41,6 @@ class Track:
         self.explicit = False
         self.ISRC = ""
         self.replayGain = ""
-        self.rank = 0
         self.playlist = None
         self.position = None
         self.searched = False
@@ -54,57 +50,78 @@ class Track:
         self.artistsString = ""
         self.mainArtistsString = ""
         self.featArtistsString = ""
-        self.urls = {}
 
-    def parseEssentialData(self, trackAPI):
-        self.id = str(trackAPI['id'])
-        self.duration = trackAPI['duration']
-        self.trackToken = trackAPI['track_token']
-        self.trackTokenExpiration = trackAPI['track_token_expire']
-        self.MD5 = trackAPI.get('md5_origin')
-        self.mediaVersion = trackAPI['media_version']
-        self.filesizes = trackAPI['filesizes']
+    def parseEssentialData(self, trackAPI_gw, trackAPI=None):
+        self.id = str(trackAPI_gw['SNG_ID'])
+        self.duration = trackAPI_gw['DURATION']
+        self.MD5 = trackAPI_gw.get('MD5_ORIGIN')
+        if not self.MD5:
+            if trackAPI and trackAPI.get('md5_origin'):
+                self.MD5 = trackAPI['md5_origin']
+            else:
+                raise MD5NotFound
+        self.mediaVersion = trackAPI_gw['MEDIA_VERSION']
         self.fallbackID = "0"
-        if 'fallback_id' in trackAPI:
-            self.fallbackID = trackAPI['fallback_id']
+        if 'FALLBACK' in trackAPI_gw:
+            self.fallbackID = trackAPI_gw['FALLBACK']['SNG_ID']
         self.local = int(self.id) < 0
-        self.urls = {}
 
-    def parseData(self, dz, track_id=None, trackAPI=None, albumAPI=None, playlistAPI=None):
-        if track_id and (not trackAPI or trackAPI and not trackAPI.get('track_token')):
-            trackAPI_new = dz.gw.get_track_with_fallback(track_id)
-            trackAPI_new = map_track(trackAPI_new)
-            if not trackAPI: trackAPI = {}
-            trackAPI_new.update(trackAPI)
-            trackAPI = trackAPI_new
-        elif not trackAPI: raise NoDataToParse
-
-        self.parseEssentialData(trackAPI)
-
-        # only public api has bpm
-        if not trackAPI.get('bpm') and not self.local:
+    def retriveFilesizes(self, dz):
+        guest_sid = dz.session.cookies.get('sid')
         try:
-                trackAPI_new = dz.api.get_track(trackAPI['id'])
-                trackAPI_new['release_date'] = trackAPI['release_date']
-                trackAPI.update(trackAPI_new)
-            except APIError: pass
+            site = requests.post(
+                "https://api.deezer.com/1.0/gateway.php",
+                params={
+                    'api_key': "4VCYIJUCDLOUELGD1V8WBVYBNVDYOXEWSLLZDONGBBDFVXTZJRXPR29JRLQFO6ZE",
+                    'sid': guest_sid,
+                    'input': '3',
+                    'output': '3',
+                    'method': 'song_getData'
+                },
+                timeout=30,
+                json={'sng_id': self.id},
+                headers=dz.http_headers
+            )
+            result_json = site.json()
+        except:
+            sleep(2)
+            self.retriveFilesizes(dz)
+        if len(result_json['error']):
+            raise TrackError(result_json.dumps(result_json['error']))
+        response = result_json.get("results", {})
+        filesizes = {}
+        for key, value in response.items():
+            if key.startswith("FILESIZE_"):
+                filesizes[key] = int(value)
+                filesizes[key+"_TESTED"] = False
+        self.filesizes = filesizes
+
+    def parseData(self, dz, track_id=None, trackAPI_gw=None, trackAPI=None, albumAPI_gw=None, albumAPI=None, playlistAPI=None):
+        if track_id and not trackAPI_gw: trackAPI_gw = dz.gw.get_track_with_fallback(track_id)
+        elif not trackAPI_gw: raise NoDataToParse
+        if not trackAPI:
+            try: trackAPI = dz.api.get_track(trackAPI_gw['SNG_ID'])
+            except APIError: trackAPI = None
+
+        self.parseEssentialData(trackAPI_gw, trackAPI)
 
         if self.local:
-            self.parseLocalTrackData(trackAPI)
+            self.parseLocalTrackData(trackAPI_gw)
         else:
-            self.parseTrack(trackAPI)
+            self.retriveFilesizes(dz)
+            self.parseTrackGW(trackAPI_gw)
 
             # Get Lyrics data
-            if not trackAPI.get("lyrics") and self.lyrics.id != "0":
-                try: trackAPI["lyrics"] = dz.gw.get_track_lyrics(self.id)
+            if not "LYRICS" in trackAPI_gw and self.lyrics.id != "0":
+                try: trackAPI_gw["LYRICS"] = dz.gw.get_track_lyrics(self.id)
                 except GWAPIError: self.lyrics.id = "0"
-            if self.lyrics.id != "0": self.lyrics.parseLyrics(trackAPI["lyrics"])
+            if self.lyrics.id != "0": self.lyrics.parseLyrics(trackAPI_gw["LYRICS"])
 
             # Parse Album Data
             self.album = Album(
-                alb_id = trackAPI['album']['id'],
-                title = trackAPI['album']['title'],
-                pic_md5 = trackAPI['album'].get('md5_origin')
+                alb_id = trackAPI_gw['ALB_ID'],
+                title = trackAPI_gw['ALB_TITLE'],
+                pic_md5 = trackAPI_gw.get('ALB_PICTURE')
             )
 
             # Get album Data
@@ -113,31 +130,28 @@ class Track:
                 except APIError: albumAPI = None
 
             # Get album_gw Data
-            # Only gw has disk number
-            if not albumAPI or albumAPI and not albumAPI.get('nb_disk'):
-                try:
-                    albumAPI_gw = dz.gw.get_album(self.album.id)
-                    albumAPI_gw = map_album(albumAPI_gw)
-                except GWAPIError: albumAPI_gw = {}
-                if not albumAPI: albumAPI = {}
-                albumAPI_gw.update(albumAPI)
-                albumAPI = albumAPI_gw
-
-            if not albumAPI: raise AlbumDoesntExists
+            if not albumAPI_gw:
+                try: albumAPI_gw = dz.gw.get_album(self.album.id)
+                except GWAPIError: albumAPI_gw = None
 
+            if albumAPI:
                 self.album.parseAlbum(albumAPI)
+            elif albumAPI_gw:
+                self.album.parseAlbumGW(albumAPI_gw)
                 # albumAPI_gw doesn't contain the artist cover
                 # Getting artist image ID
                 # ex: https://e-cdns-images.dzcdn.net/images/artist/f2bc007e9133c946ac3c3907ddc5d2ea/56x56-000000-80-0-0.jpg
-            if not self.album.mainArtist.pic.md5 or self.album.mainArtist.pic.md5 == "":
                 artistAPI = dz.api.get_artist(self.album.mainArtist.id)
                 self.album.mainArtist.pic.md5 = artistAPI['picture_small'][artistAPI['picture_small'].find('artist/') + 7:-24]
+            else:
+                raise AlbumDoesntExists
 
             # Fill missing data
+            if albumAPI_gw: self.album.addExtraAlbumGWData(albumAPI_gw)
             if self.album.date and not self.date: self.date = self.album.date
-            if 'genres' in trackAPI:
-                for genre in trackAPI['genres']:
-                    if genre not in self.album.genre: self.album.genre.append(genre)
+            if not self.album.discTotal: self.album.discTotal = albumAPI_gw.get('NUMBER_DISK', "1")
+            if not self.copyright: self.copyright = albumAPI_gw['COPYRIGHT']
+            self.parseTrack(trackAPI)
 
         # Remove unwanted charaters in track name
         # Example: track/127793
@@ -145,9 +159,9 @@ class Track:
 
         # Make sure there is at least one artist
         if len(self.artist['Main']) == 0:
-            self.artist['Main'] = [self.mainArtist.name]
+            self.artist['Main'] = [self.mainArtist['name']]
 
-        self.position = trackAPI.get('position')
+        self.position = trackAPI_gw.get('POSITION')
 
         # Add playlist data if track is in a playlist
         if playlistAPI: self.playlist = Playlist(playlistAPI)
@@ -155,54 +169,64 @@ class Track:
         self.generateMainFeatStrings()
         return self
 
-    def parseLocalTrackData(self, trackAPI):
+    def parseLocalTrackData(self, trackAPI_gw):
         # Local tracks has only the trackAPI_gw page and
         # contains only the tags provided by the file
-        self.title = trackAPI['title']
-        self.album = Album(title=trackAPI['album']['title'])
+        self.title = trackAPI_gw['SNG_TITLE']
+        self.album = Album(title=trackAPI_gw['ALB_TITLE'])
         self.album.pic = Picture(
-            md5 = trackAPI.get('md5_image', ""),
+            md5 = trackAPI_gw.get('ALB_PICTURE', ""),
             pic_type = "cover"
         )
-        self.mainArtist = Artist(name=trackAPI['artist']['name'], role="Main")
-        self.artists = [trackAPI['artist']['name']]
+        self.mainArtist = Artist(name=trackAPI_gw['ART_NAME'], role="Main")
+        self.artists = [trackAPI_gw['ART_NAME']]
         self.artist = {
-            'Main': [trackAPI['artist']['name']]
+            'Main': [trackAPI_gw['ART_NAME']]
         }
         self.album.artist = self.artist
         self.album.artists = self.artists
         self.album.date = self.date
         self.album.mainArtist = self.mainArtist
 
-    def parseTrack(self, trackAPI):
-        self.title = trackAPI['title']
+    def parseTrackGW(self, trackAPI_gw):
+        self.title = trackAPI_gw['SNG_TITLE'].strip()
+        if trackAPI_gw.get('VERSION') and not trackAPI_gw['VERSION'].strip() in self.title:
+            self.title += f" {trackAPI_gw['VERSION'].strip()}"
 
-        self.discNumber = trackAPI.get('disk_number')
-        self.explicit = trackAPI.get('explicit_lyrics', False)
-        self.copyright = trackAPI.get('copyright')
-        if 'gain' in trackAPI: self.replayGain = generateReplayGainString(trackAPI['gain'])
-        self.ISRC = trackAPI.get('isrc')
-        self.trackNumber = trackAPI['track_position']
-        self.contributors = trackAPI.get('song_contributors')
-        self.rank = trackAPI['rank']
-        self.bpm = trackAPI['bpm']
+        self.discNumber = trackAPI_gw.get('DISK_NUMBER')
+        self.explicit = bool(int(trackAPI_gw.get('EXPLICIT_LYRICS', "0")))
+        self.copyright = trackAPI_gw.get('COPYRIGHT')
+        if 'GAIN' in trackAPI_gw: self.replayGain = generateReplayGainString(trackAPI_gw['GAIN'])
+        self.ISRC = trackAPI_gw.get('ISRC')
+        self.trackNumber = trackAPI_gw['TRACK_NUMBER']
+        self.contributors = trackAPI_gw['SNG_CONTRIBUTORS']
 
-        self.lyrics = Lyrics(trackAPI.get('lyrics_id', "0"))
+        self.lyrics = Lyrics(trackAPI_gw.get('LYRICS_ID', "0"))
 
         self.mainArtist = Artist(
-            art_id = trackAPI['artist']['id'],
-            name = trackAPI['artist']['name'],
+            art_id = trackAPI_gw['ART_ID'],
+            name = trackAPI_gw['ART_NAME'],
             role = "Main",
-            pic_md5 = trackAPI['artist'].get('md5_image')
+            pic_md5 = trackAPI_gw.get('ART_PICTURE')
         )
 
-        if trackAPI.get('physical_release_date'):
-            self.date.day = trackAPI["physical_release_date"][8:10]
-            self.date.month = trackAPI["physical_release_date"][5:7]
-            self.date.year = trackAPI["physical_release_date"][0:4]
+        if 'PHYSICAL_RELEASE_DATE' in trackAPI_gw:
+            self.date.day = trackAPI_gw["PHYSICAL_RELEASE_DATE"][8:10]
+            self.date.month = trackAPI_gw["PHYSICAL_RELEASE_DATE"][5:7]
+            self.date.year = trackAPI_gw["PHYSICAL_RELEASE_DATE"][0:4]
             self.date.fixDayMonth()
 
-        for artist in trackAPI.get('contributors', []):
+    def parseTrack(self, trackAPI):
+        self.bpm = trackAPI['bpm']
+
+        if not self.replayGain and 'gain' in trackAPI:
+            self.replayGain = generateReplayGainString(trackAPI['gain'])
+        if not self.explicit:
+            self.explicit = trackAPI['explicit_lyrics']
+        if not self.discNumber:
+            self.discNumber = trackAPI['disk_number']
+
+        for artist in trackAPI['contributors']:
             isVariousArtists = str(artist['id']) == VARIOUS_ARTISTS
             isMainArtist = artist['role'] == "Main"
 
@@ -217,11 +241,6 @@ class Track:
                     self.artist[artist['role']] = []
                 self.artist[artist['role']].append(artist['name'])
 
-        if trackAPI.get('alternative_albums'):
-            for album in trackAPI['alternative_albums']['data']:
-                if 'RIGHTS' in album and album['RIGHTS'].get('STREAM_ADS_AVAILABLE') or album['RIGHTS'].get('STREAM_SUB_AVAILABLE'):
-                    self.albumsFallback.append(album['ALB_ID'])
-
     def removeDuplicateArtists(self):
         (self.artist, self.artists) = removeDuplicateArtists(self.artist, self.artists)
 
@@ -240,14 +259,6 @@ class Track:
         if 'Featured' in self.artist:
             self.featArtistsString = "feat. "+andCommaConcat(self.artist['Featured'])
 
-    def checkAndRenewTrackToken(self, dz):
-        now = datetime.now()
-        expiration = datetime.fromtimestamp(self.trackTokenExpiration)
-        if now > expiration:
-            newTrack = dz.gw.get_track_with_fallback(self.id)
-            self.trackToken = newTrack['TRACK_TOKEN']
-            self.trackTokenExpiration = newTrack['TRACK_TOKEN_EXPIRE']
-
     def applySettings(self, settings):
 
         # Check if should save the playlist as a compilation
@@ -320,3 +331,15 @@ class Track:
                 self.artistsString = separator.join(self.artist['Main'])
             else:
                 self.artistsString = separator.join(self.artists)
+
+class TrackError(Exception):
+    """Base class for exceptions in this module."""
+
+class AlbumDoesntExists(TrackError):
+    pass
+
+class MD5NotFound(TrackError):
+    pass
+
+class NoDataToParse(TrackError):
+    pass

deemix/utils/__init__.py

@@ -1,8 +1,6 @@
 import string
-import re
 from deezer import TrackFormats
 import os
-from deemix.errors import ErrorMessages
 
 USER_AGENT_HEADER = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) " \
                     "Chrome/79.0.3945.130 Safari/537.36"
@@ -35,35 +33,18 @@ def changeCase(txt, case_type):
     if case_type == "upper":
         return txt.upper()
     if case_type == "start":
-        txt = txt.strip().split(" ")
-        for i, word in enumerate(txt):
-            if word[0] in ['(', '{', '[', "'", '"']:
-                txt[i] = word[0] + word[1:].capitalize()
-            else:
-                txt[i] = word.capitalize()
-        return " ".join(txt)
+        return string.capwords(txt)
     if case_type == "sentence":
         return txt.capitalize()
     return str
 
 def removeFeatures(title):
     clean = title
-    found = False
-    pos = -1
-    if re.search(r"[\s(]\(?\s?feat\.?\s", clean):
-        pos = re.search(r"[\s(]\(?\s?feat\.?\s", clean).start(0)
-        found = True
-    if re.search(r"[\s(]\(?\s?ft\.?\s", clean):
-        pos = re.search(r"[\s(]\(?\s?ft\.?\s", clean).start(0)
-        found = True
-    openBracket = clean[pos] == '(' or clean[pos+1] == '('
-    otherBracket = clean.find('(', pos+2)
-    if found:
+    if "(feat." in clean.lower():
+        pos = clean.lower().find("(feat.")
         tempTrack = clean[:pos]
-        if ")" in clean and openBracket:
-            tempTrack += clean[clean.find(")", pos+2) + 1:]
-        if not openBracket and otherBracket != -1:
-            tempTrack += f" {clean[otherBracket:]}"
+        if ")" in clean:
+            tempTrack += clean[clean.find(")", pos + 1) + 1:]
         clean = tempTrack.strip()
         clean = ' '.join(clean.split())
     return clean
@@ -92,59 +73,3 @@ def removeDuplicateArtists(artist, artists):
     for role in artist.keys():
         artist[role] = uniqueArray(artist[role])
     return (artist, artists)
-
-def formatListener(key, data=None):
-    if key == "startAddingArtist":
-        return f"Started gathering {data['name']}'s albums ({data['id']})"
-    if key == "finishAddingArtist":
-        return f"Finished gathering {data['name']}'s albums ({data['id']})"
-    if key == "updateQueue":
-        uuid = f"[{data['uuid']}]"
-        if data.get('downloaded'):
-            shortFilepath = data['downloadPath'][len(data['extrasPath']):]
-            return f"{uuid} Completed download of {shortFilepath}"
-        if data.get('failed'):
-            return f"{uuid} {data['data']['artist']} - {data['data']['title']} :: {data['error']}"
-        if data.get('progress'):
-            return f"{uuid} Download at {data['progress']}%"
-        if data.get('conversion'):
-            return f"{uuid} Conversion at {data['conversion']}%"
-        return uuid
-    if key == "downloadInfo":
-        message = data['state']
-        if data['state'] == "getTags": message = "Getting tags."
-        elif data['state'] == "gotTags": message = "Tags got."
-        elif data['state'] == "getBitrate": message = "Getting download URL."
-        elif data['state'] == "bitrateFallback": message = "Desired bitrate not found, falling back to lower bitrate."
-        elif data['state'] == "searchFallback": message = "This track has been searched for, result might not be 100% exact."
-        elif data['state'] == "gotBitrate": message = "Download URL got."
-        elif data['state'] == "getAlbumArt": message = "Downloading album art."
-        elif data['state'] == "gotAlbumArt": message = "Album art downloaded."
-        elif data['state'] == "downloading":
-            message = "Downloading track."
-            if data['alreadyStarted']:
-                message += f" Recovering download from {data['value']}."
-            else:
-                message += f" Downloading {data['value']} bytes."
-        elif data['state'] == "downloaded": message = "Track downloaded."
-        elif data['state'] == "alreadyDownloaded": message = "Track already downloaded."
-        elif data['state'] == "tagging": message = "Tagging track."
-        elif data['state'] == "tagged": message = "Track tagged."
-        return f"[{data['uuid']}] {data['data']['artist']} - {data['data']['title']} :: {message}"
-    if key == "downloadWarn":
-        errorMessage = ErrorMessages[data['state']]
-        solutionMessage = ""
-        if data['solution'] == 'fallback': solutionMessage = "Using fallback id."
-        if data['solution'] == 'search': solutionMessage = "Searching for alternative."
-        return f"[{data['uuid']}] {data['data']['artist']} - {data['data']['title']} :: {errorMessage} {solutionMessage}"
-    if key == "currentItemCancelled":
-        return f"Current item cancelled ({data})"
-    if key == "removedFromQueue":
-        return f"[{data}] Removed from the queue"
-    if key == "finishDownload":
-        return f"[{data}] Finished downloading"
-    if key == "startConversion":
-        return f"[{data}] Started converting"
-    if key == "finishConversion":
-        return f"[{data['uuid']}] Finished converting"
-    return ""

deemix/utils/crypto.py

@@ -20,7 +20,7 @@ def generateBlowfishKey(trackId):
     bfKey = ""
     for i in range(16):
         bfKey += chr(ord(idMd5[i]) ^ ord(idMd5[i + 16]) ^ ord(SECRET[i]))
-    return str.encode(bfKey)
+    return bfKey
 
 def decryptChunk(key, data):
     return Blowfish.new(key, Blowfish.MODE_CBC, b"\x00\x01\x02\x03\x04\x05\x06\x07").decrypt(data)

deemix/utils/deezer.py

@@ -5,10 +5,8 @@ CLIENT_ID = "172365"
 CLIENT_SECRET = "fb0bec7ccc063dab0417eb7b0d847f34"
 
 def getAccessToken(email, password):
-    accessToken = None
     password = _md5(password)
     request_hash = _md5(''.join([CLIENT_ID, email, password, CLIENT_SECRET]))
-    try:
     response = requests.get(
         'https://api.deezer.com/auth/token',
         params={
@@ -19,17 +17,10 @@ def getAccessToken(email, password):
         },
         headers={"User-Agent": USER_AGENT_HEADER}
     ).json()
-        accessToken = response.get('access_token')
-        if accessToken == "undefined": accessToken = None
-    except Exception:
-        pass
-    return accessToken
+    return response.get('access_token')
 
-def getArlFromAccessToken(accessToken):
-    if not accessToken: return None
-    arl = None
+def getArtFromAccessToken(accessToken):
     session = requests.Session()
-    try:
     session.get(
         "https://api.deezer.com/platform/generic/track/3135556",
         headers={"Authorization": f"Bearer {accessToken}", "User-Agent": USER_AGENT_HEADER}
@@ -38,7 +29,4 @@ def getArlFromAccessToken(accessToken):
         'https://www.deezer.com/ajax/gw-light.php?method=user.getArl&input=3&api_version=1.0&api_token=null',
         headers={"User-Agent": USER_AGENT_HEADER}
     ).json()
-        arl = response.get('results')
-    except Exception:
-        pass
-    return arl
+    return response.get('results')

deemix/utils/localpaths.py

@@ -44,15 +44,12 @@ def getMusicFolder():
         musicdata = Path(os.getenv("XDG_MUSIC_DIR"))
         musicdata = checkPath(musicdata)
     if (homedata / '.config' / 'user-dirs.dirs').is_file() and musicdata == "":
-        with open(homedata / '.config' / 'user-dirs.dirs', 'r', encoding="utf-8") as f:
+        with open(homedata / '.config' / 'user-dirs.dirs', 'r') as f:
             userDirs = f.read()
-        musicdata_search = re.search(r"XDG_MUSIC_DIR=\"(.*)\"", userDirs)
-        if musicdata_search:
-            musicdata = musicdata_search.group(1)
+        musicdata = re.search(r"XDG_MUSIC_DIR=\"(.*)\"", userDirs).group(1)
         musicdata = Path(os.path.expandvars(musicdata))
         musicdata = checkPath(musicdata)
     if os.name == 'nt' and musicdata == "":
-        try:
         musicKeys = ['My Music', '{4BD8D571-6D19-48D3-BE97-422220080E43}']
         regData = os.popen(r'reg.exe query "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"').read().split('\r\n')
         for i, line in enumerate(regData):
@@ -63,8 +60,6 @@ def getMusicFolder():
                 musicdata = Path(line[3])
                 break
         musicdata = checkPath(musicdata)
-        except Exception:
-            musicdata = ""
     if musicdata == "":
         musicdata = homedata / 'Music'
         musicdata = checkPath(musicdata)

requirements.txt

@@ -2,5 +2,5 @@ click
 pycryptodomex
 mutagen
 requests
-deezer-py
 spotipy>=2.11.0
+deezer-py

setup.py

@@ -7,7 +7,7 @@ README = (HERE / "README.md").read_text()
 
 setup(
     name="deemix",
-    version="3.6.6",
+    version="3.0.0",
     description="A barebone deezer downloader library",
     long_description=README,
     long_description_content_type="text/markdown",
@@ -23,10 +23,7 @@ setup(
     python_requires='>=3.7',
     packages=find_packages(exclude=("tests",)),
     include_package_data=True,
-    install_requires=["click", "pycryptodomex", "mutagen", "requests", "deezer-py>=1.3.0"],
-    extras_require={
-        "spotify": ["spotipy>=2.11.0"]
-    },
+    install_requires=["click", "pycryptodomex", "mutagen", "requests", "spotipy>=2.11.0", "deezer-py"],
     entry_points={
         "console_scripts": [
             "deemix=deemix.__main__:download",

shell.nix

@@ -1,21 +0,0 @@
-{
-  pkgs ? import <nixpkgs> { },
-}:
-
-pkgs.mkShell {
-  buildInputs = [
-    pkgs.python312
-    pkgs.python312Packages.virtualenv
-  ];
-
-  shellHook = ''
-    if [ ! -d .venv ]; then
-      virtualenv .venv
-      . .venv/bin/activate
-      pip install -r requirements.txt
-      pip install -e .
-    else
-      . .venv/bin/activate
-    fi
-  '';
-}

updatePyPi.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+rm -rd build
+rm -rd dist
+#python -m bump
+#python -m bump deemix/__init__.py
+python3 setup.py sdist bdist_wheel
+python3 -m twine upload dist/*