673 lines
30 KiB
Python
673 lines
30 KiB
Python
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
|
|
from pathlib import Path
|
|
from shlex import quote
|
|
import errno
|
|
|
|
import logging
|
|
from tempfile import gettempdir
|
|
|
|
import requests
|
|
from requests import get
|
|
|
|
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.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.settings import OverwriteOption
|
|
from deemix.errors import DownloadFailed, MD5NotFound, DownloadCanceled, PreferredBitrateNotFound, TrackNot360, AlbumDoesntExists, DownloadError, ErrorMessages
|
|
|
|
logger = logging.getLogger('deemix')
|
|
|
|
extensions = {
|
|
TrackFormats.FLAC: '.flac',
|
|
TrackFormats.LOCAL: '.mp3',
|
|
TrackFormats.MP3_320: '.mp3',
|
|
TrackFormats.MP3_128: '.mp3',
|
|
TrackFormats.DEFAULT: '.mp3',
|
|
TrackFormats.MP4_RA3: '.mp4',
|
|
TrackFormats.MP4_RA2: '.mp4',
|
|
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)
|
|
|
|
def downloadImage(url, path, overwrite=OverwriteOption.DONT_OVERWRITE):
|
|
if path.is_file() and overwrite not in [OverwriteOption.OVERWRITE, OverwriteOption.ONLY_TAGS, OverwriteOption.KEEP_BOTH]: return path
|
|
|
|
try:
|
|
image = get(url, headers={'User-Agent': USER_AGENT_HEADER}, timeout=30)
|
|
image.raise_for_status()
|
|
with open(path, 'wb') as f:
|
|
f.write(image.content)
|
|
return path
|
|
except requests.exceptions.HTTPError:
|
|
if path.is_file(): path.unlink()
|
|
if 'cdns-images.dzcdn.net' in url:
|
|
urlBase = url[:url.rfind("/")+1]
|
|
pictureUrl = url[len(urlBase):]
|
|
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):
|
|
if path.is_file(): path.unlink()
|
|
sleep(5)
|
|
return downloadImage(url, path, overwrite)
|
|
except OSError as e:
|
|
if path.is_file(): path.unlink()
|
|
if e.errno == errno.ENOSPC: raise DownloadFailed("noSpaceLeft") from e
|
|
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)
|
|
|
|
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",
|
|
TrackFormats.MP3_320: "MP3_320",
|
|
TrackFormats.MP3_128: "MP3_128",
|
|
}
|
|
formats_360 = {
|
|
TrackFormats.MP4_RA3: "MP4_RA3",
|
|
TrackFormats.MP4_RA2: "MP4_RA2",
|
|
TrackFormats.MP4_RA1: "MP4_RA1",
|
|
}
|
|
|
|
is360format = preferredBitrate in formats_360.keys()
|
|
if not shouldFallback:
|
|
formats = formats_360
|
|
formats.update(formats_non_360)
|
|
elif is360format:
|
|
formats = formats_360
|
|
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
|
|
return formatNumber
|
|
|
|
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', {
|
|
'uuid': uuid,
|
|
'state': 'bitrateFallback',
|
|
'data': {
|
|
'id': track.id,
|
|
'title': track.title,
|
|
'artist': track.mainArtist.name
|
|
},
|
|
})
|
|
if is360format: raise TrackNot360
|
|
url = getCorrectURL(track, "MP3_MISC", TrackFormats.DEFAULT, feelingLucky)
|
|
track.urls["MP3_MISC"] = url
|
|
return TrackFormats.DEFAULT
|
|
|
|
class Downloader:
|
|
def __init__(self, dz, downloadObject, settings, listener=None):
|
|
self.dz = dz
|
|
self.downloadObject = downloadObject
|
|
self.settings = settings
|
|
self.bitrate = downloadObject.bitrate
|
|
self.listener = listener
|
|
|
|
self.playlistCoverName = None
|
|
self.playlistURLs = []
|
|
|
|
def start(self):
|
|
if not self.downloadObject.isCanceled:
|
|
if isinstance(self.downloadObject, Single):
|
|
track = self.downloadWrapper({
|
|
'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'])
|
|
with ThreadPoolExecutor(self.settings['queueConcurrency']) as executor:
|
|
for pos, track in enumerate(self.downloadObject.collection['tracks'], start=0):
|
|
tracks[pos] = executor.submit(self.downloadWrapper, {
|
|
'trackAPI': track,
|
|
'albumAPI': self.downloadObject.collection.get('albumAPI'),
|
|
'playlistAPI': self.downloadObject.collection.get('playlistAPI')
|
|
})
|
|
self.afterDownloadCollection(tracks)
|
|
|
|
if self.listener:
|
|
if self.downloadObject.isCanceled:
|
|
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 = 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")
|
|
|
|
itemData = {
|
|
'id': trackAPI['id'],
|
|
'title': trackAPI['title'],
|
|
'artist': trackAPI['artist']['name']
|
|
}
|
|
|
|
# Create Track object
|
|
if not track:
|
|
self.log(itemData, "getTags")
|
|
try:
|
|
track = Track().parseData(
|
|
dz=self.dz,
|
|
track_id=trackAPI['id'],
|
|
trackAPI=trackAPI,
|
|
albumAPI=albumAPI,
|
|
playlistAPI=playlistAPI
|
|
)
|
|
except AlbumDoesntExists as e:
|
|
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
|
|
}
|
|
|
|
# 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.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)
|
|
|
|
# Generate filename and filepath from metadata
|
|
(filename, filepath, artistPath, coverPath, extrasPath) = generatePath(track, self.downloadObject, self.settings)
|
|
|
|
# Make sure the filepath exists
|
|
makedirs(filepath, exist_ok=True)
|
|
extension = extensions[track.bitrate]
|
|
writepath = filepath / f"{filename}{extension}"
|
|
|
|
# Save extrasPath
|
|
if extrasPath and not self.downloadObject.extrasPath: self.downloadObject.extrasPath = extrasPath
|
|
|
|
# Generate covers URLs
|
|
embeddedImageFormat = f'jpg-{self.settings["jpegImageQuality"]}'
|
|
if self.settings['embeddedArtworkPNG']: embeddedImageFormat = 'png'
|
|
|
|
track.album.embeddedCoverURL = track.album.pic.getURL(self.settings['embeddedArtworkSize'], embeddedImageFormat)
|
|
ext = track.album.embeddedCoverURL[-4:]
|
|
if ext[0] != ".": ext = ".jpg" # Check for Spotify images
|
|
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")
|
|
track.album.embeddedCoverPath = downloadImage(track.album.embeddedCoverURL, track.album.embeddedCoverPath)
|
|
self.log(itemData, "gotAlbumArt")
|
|
|
|
# Save local album art
|
|
if coverPath:
|
|
returnData['albumURLs'] = []
|
|
for pic_format in self.settings['localArtworkFormat'].split(","):
|
|
if pic_format in ["png","jpg"]:
|
|
extendedFormat = pic_format
|
|
if extendedFormat == "jpg": extendedFormat += f"-{self.settings['jpegImageQuality']}"
|
|
url = track.album.pic.getURL(self.settings['localArtworkSize'], extendedFormat)
|
|
# Skip non deezer pictures at the wrong format
|
|
if isinstance(track.album.pic, StaticPicture) and pic_format != "jpg":
|
|
continue
|
|
returnData['albumURLs'].append({'url': url, 'ext': pic_format})
|
|
returnData['albumPath'] = coverPath
|
|
returnData['albumFilename'] = generateAlbumName(self.settings['coverImageTemplate'], track.album, self.settings, track.playlist)
|
|
|
|
# Save artist art
|
|
if artistPath:
|
|
returnData['artistURLs'] = []
|
|
for pic_format in self.settings['localArtworkFormat'].split(","):
|
|
# Deezer doesn't support png artist images
|
|
if pic_format == "jpg":
|
|
extendedFormat = f"{pic_format}-{self.settings['jpegImageQuality']}"
|
|
url = track.album.mainArtist.pic.getURL(self.settings['localArtworkSize'], extendedFormat)
|
|
if track.album.mainArtist.pic.md5 == "": continue
|
|
returnData['artistURLs'].append({'url': url, 'ext': pic_format})
|
|
returnData['artistPath'] = artistPath
|
|
returnData['artistFilename'] = generateArtistName(self.settings['artistImageTemplate'], track.album.mainArtist, self.settings, rootArtist=track.album.rootArtist)
|
|
|
|
# Save playlist art
|
|
if track.playlist:
|
|
if len(self.playlistURLs) == 0:
|
|
for pic_format in self.settings['localArtworkFormat'].split(","):
|
|
if pic_format in ["png","jpg"]:
|
|
extendedFormat = pic_format
|
|
if extendedFormat == "jpg": extendedFormat += f"-{self.settings['jpegImageQuality']}"
|
|
url = track.playlist.pic.getURL(self.settings['localArtworkSize'], extendedFormat)
|
|
if isinstance(track.playlist.pic, StaticPicture) and pic_format != "jpg": continue
|
|
self.playlistURLs.append({'url': url, 'ext': pic_format})
|
|
if not self.playlistCoverName:
|
|
track.playlist.bitrate = selectedFormat
|
|
track.playlist.dateString = track.playlist.date.format(self.settings['dateFormat'])
|
|
self.playlistCoverName = generateAlbumName(self.settings['coverImageTemplate'], track.playlist, self.settings, track.playlist)
|
|
|
|
# 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)
|
|
|
|
# Check for overwrite settings
|
|
trackAlreadyDownloaded = writepath.is_file()
|
|
|
|
# Don't overwrite and don't mind extension
|
|
if not trackAlreadyDownloaded and self.settings['overwriteFile'] == OverwriteOption.DONT_CHECK_EXT:
|
|
exts = ['.mp3', '.flac', '.opus', '.m4a']
|
|
baseFilename = str(filepath / filename)
|
|
for ext in exts:
|
|
trackAlreadyDownloaded = Path(baseFilename+ext).is_file()
|
|
if trackAlreadyDownloaded: break
|
|
# Don't overwrite and keep both files
|
|
if trackAlreadyDownloaded and self.settings['overwriteFile'] == OverwriteOption.KEEP_BOTH:
|
|
baseFilename = str(filepath / filename)
|
|
c = 1
|
|
currentFilename = baseFilename+' ('+str(c)+')'+ extension
|
|
while Path(currentFilename).is_file():
|
|
c += 1
|
|
currentFilename = baseFilename+' ('+str(c)+')'+ extension
|
|
trackAlreadyDownloaded = False
|
|
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)
|
|
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")
|
|
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")
|
|
if extension == '.mp3':
|
|
tagID3(writepath, track, self.settings['tags'])
|
|
elif extension == '.flac':
|
|
try:
|
|
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']}")
|
|
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")
|
|
|
|
if track.searched: returnData['searched'] = True
|
|
self.downloadObject.downloaded += 1
|
|
if self.listener: self.listener.send("updateQueue", {
|
|
'uuid': self.downloadObject.uuid,
|
|
'downloaded': True,
|
|
'downloadPath': str(writepath),
|
|
'extrasPath': str(self.downloadObject.extrasPath)
|
|
})
|
|
returnData['filename'] = str(writepath)[len(str(extrasPath))+ len(pathSep):]
|
|
returnData['data'] = itemData
|
|
returnData['path'] = str(writepath)
|
|
self.downloadObject.files.append(returnData)
|
|
return returnData
|
|
|
|
def downloadWrapper(self, extraData, track=None):
|
|
trackAPI = extraData['trackAPI']
|
|
# Temp metadata to generate logs
|
|
itemData = {
|
|
'id': trackAPI['id'],
|
|
'title': trackAPI['title'],
|
|
'artist': trackAPI['artist']['name']
|
|
}
|
|
|
|
try:
|
|
result = self.download(extraData, track)
|
|
except DownloadFailed as error:
|
|
if error.track:
|
|
track = error.track
|
|
if track.fallbackID != "0":
|
|
self.warn(itemData, error.errid, 'fallback')
|
|
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)
|
|
return self.downloadWrapper(extraData, track)
|
|
if not track.searched and self.settings['fallbackSearch']:
|
|
self.warn(itemData, error.errid, 'search')
|
|
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.searched = True
|
|
self.log(itemData, "searchFallback")
|
|
return self.downloadWrapper(extraData, track)
|
|
error.errid += "NoAlternative"
|
|
error.message = ErrorMessages[error.errid]
|
|
result = {'error': {
|
|
'message': error.message,
|
|
'errid': error.errid,
|
|
'data': itemData,
|
|
'type': "track"
|
|
}}
|
|
except Exception as e:
|
|
logger.exception("%s %s", f"{itemData['artist']} - {itemData['title']}", e)
|
|
result = {'error': {
|
|
'message': str(e),
|
|
'data': itemData,
|
|
'stack': traceback.format_exc(),
|
|
'type': "track"
|
|
}}
|
|
|
|
if 'error' in result:
|
|
self.downloadObject.completeTrackProgress(self.listener)
|
|
self.downloadObject.failed += 1
|
|
self.downloadObject.errors.append(result['error'])
|
|
if self.listener:
|
|
error = result['error']
|
|
self.listener.send("updateQueue", {
|
|
'uuid': self.downloadObject.uuid,
|
|
'failed': True,
|
|
'data': error['data'],
|
|
'error': error['message'],
|
|
'errid': error.get('errid'),
|
|
'stack': error.get('stack'),
|
|
'type': error['type']
|
|
})
|
|
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'])
|
|
|
|
# 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()
|
|
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)
|
|
|
|
# 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)
|
|
|
|
def afterDownloadCollection(self, tracks):
|
|
if not self.downloadObject.extrasPath: self.downloadObject.extrasPath = Path(self.settings['downloadLocation'])
|
|
playlist = [None] * len(tracks)
|
|
errors = ""
|
|
searched = ""
|
|
|
|
for i, track in enumerate(tracks):
|
|
track = track.result()
|
|
if not track: return # Check if item is cancelled
|
|
|
|
# Log errors to file
|
|
if track.get('error'):
|
|
if not track['error'].get('data'): track['error']['data'] = {'id': "0", 'title': 'Unknown', 'artist': 'Unknown'}
|
|
errors += f"{track['error']['data']['id']} | {track['error']['data']['artist']} - {track['error']['data']['title']} | {track['error']['message']}\r\n"
|
|
|
|
# Log searched to file
|
|
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)
|
|
|
|
# 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)
|
|
|
|
# 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)
|
|
|
|
# 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:
|
|
for line in playlist:
|
|
f.write(line + "\n")
|
|
except Exception as e:
|
|
self.afterDownloadErrorReport("CreatePlaylistFile", e)
|
|
|
|
# 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)
|