import requests from requests import get from concurrent.futures import ThreadPoolExecutor from time import sleep from os.path import sep as pathSep from pathlib import Path from shlex import quote import re import errno from ssl import SSLError from os import makedirs from urllib3.exceptions import SSLError as u3SSLError from deemix.types.DownloadObjects import Single, Collection from deemix.types.Track import Track, AlbumDoesntExists from deemix.utils import changeCase from deemix.utils.pathtemplates import generateFilename, generateFilepath, settingsRegexAlbum, settingsRegexArtist, settingsRegexPlaylistFile from deezer import TrackFormats from deemix import USER_AGENT_HEADER from deemix.taggers import tagID3, tagFLAC from deemix.decryption import generateStreamURL, generateBlowfishKey from deemix.settings import OverwriteOption from Cryptodome.Cipher import Blowfish from mutagen.flac import FLACNoHeaderError, error as FLACError import logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger('deemix') from tempfile import gettempdir TEMPDIR = Path(gettempdir()) / 'deemix-imgs' if not TEMPDIR.is_dir(): makedirs(TEMPDIR) 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' } 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" } def downloadImage(url, path, overwrite=OverwriteOption.DONT_OVERWRITE): if not path.is_file() or overwrite in [OverwriteOption.OVERWRITE, OverwriteOption.ONLY_TAGS, OverwriteOption.KEEP_BOTH]: 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 'cdns-images.dzcdn.net' in url: urlBase = url[:url.rfind("/")+1] pictureUrl = url[len(urlBase):] pictureSize = int(pictureUrl[:pictureUrl.find("x")]) if pictureSize > 1200: logger.warn("Couldn't download "+str(pictureSize)+"x"+str(pictureSize)+" image, falling back to 1200x1200") sleep(1) return downloadImage(urlBase+pictureUrl.replace(str(pictureSize)+"x"+str(pictureSize), '1200x1200'), path, overwrite) logger.error("Image not found: "+url) except (requests.exceptions.ConnectionError, requests.exceptions.ChunkedEncodingError, u3SSLError) as e: logger.error("Couldn't download Image, retrying in 5 seconds...: "+url+"\n") sleep(5) return downloadImage(url, path, overwrite) except OSError as e: if e.errno == errno.ENOSPC: raise DownloadFailed("noSpaceLeft") else: logger.exception(f"Error while downloading an image, you should report this to the developers: {str(e)}") except Exception as e: logger.exception(f"Error while downloading an image, you should report this to the developers: {str(e)}") if path.is_file(): path.unlink() return None else: return path def getPreferredBitrate(track, preferredBitrate, shouldFallback, downloadObjectUUID=None, interface=None): if track.localTrack: return TrackFormats.LOCAL falledBack = False 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 = int(preferredBitrate) in formats_360 if not shouldFallback: formats = formats_360 formats.update(formats_non_360) elif is360format: formats = formats_360 else: formats = formats_non_360 for formatNumber, formatName in formats.items(): if formatNumber <= int(preferredBitrate): 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"]: request = requests.head( generateStreamURL(track.id, track.MD5, track.mediaVersion, formatNumber), headers={'User-Agent': USER_AGENT_HEADER}, timeout=30 ) try: request.raise_for_status() return formatNumber except requests.exceptions.HTTPError: # if the format is not available, Deezer returns a 403 error pass if not shouldFallback: raise PreferredBitrateNotFound else: if not falledBack: falledBack = True logger.info(f"[{track.mainArtist.name} - {track.title}] Fallback to lower bitrate") if interface and downloadObjectUUID: interface.send('queueUpdate', { 'uuid': downloadObjectUUID, 'bitrateFallback': True, 'data': { 'id': track.id, 'title': track.title, 'artist': track.mainArtist.name }, }) if is360format: raise TrackNot360 return TrackFormats.DEFAULT class Downloader: def __init__(self, dz, downloadObject, settings, interface=None): self.dz = dz self.downloadObject = downloadObject self.settings = settings self.bitrate = downloadObject.bitrate self.interface = interface self.downloadPercentage = 0 self.lastPercentage = 0 self.extrasPath = None self.playlistCoverName = None self.playlistURLs = [] def start(self): if isinstance(self.downloadObject, Single): result = self.downloadWrapper(self.downloadObject.single['trackAPI_gw'], self.downloadObject.single['trackAPI'], self.downloadObject.single['albumAPI']) if result: self.singleAfterDownload(result) elif isinstance(self.downloadObject, Collection): tracks = [None] * len(self.downloadObject.collection['tracks_gw']) with ThreadPoolExecutor(self.settings['queueConcurrency']) as executor: for pos, track in enumerate(self.downloadObject.collection['tracks_gw'], start=0): tracks[pos] = executor.submit(self.downloadWrapper, track, None, self.downloadObject.collection['albumAPI'], self.downloadObject.collection['playlistAPI']) self.collectionAfterDownload(tracks) if self.interface: self.interface.send("finishDownload", self.downloadObject.uuid) return self.extrasPath def download(self, trackAPI_gw, trackAPI=None, albumAPI=None, playlistAPI=None, track=None): result = {} if trackAPI_gw['SNG_ID'] == "0": raise DownloadFailed("notOnDeezer") # Create Track object print(track) if not track: logger.info(f"[{trackAPI_gw['ART_NAME']} - {trackAPI_gw['SNG_TITLE']}] Getting the tags") try: track = Track().parseData( dz=self.dz, trackAPI_gw=trackAPI_gw, trackAPI=trackAPI, albumAPI=albumAPI, playlistAPI=playlistAPI ) except AlbumDoesntExists: raise DownloadError('albumDoesntExists') # Check if track not yet encoded if track.MD5 == '': raise DownloadFailed("notEncoded", track) # Choose the target bitrate try: selectedFormat = getPreferredBitrate( track, self.bitrate, self.settings['fallbackBitrate'], self.downloadObject.uuid, self.interface ) except PreferredBitrateNotFound: raise DownloadFailed("wrongBitrate", track) except TrackNot360: raise DownloadFailed("no360RA") track.selectedFormat = selectedFormat track.album.bitrate = selectedFormat # Generate covers URLs embeddedImageFormat = f'jpg-{self.settings["jpegImageQuality"]}' if self.settings['embeddedArtworkPNG']: imageFormat = 'png' track.applySettings(self.settings, TEMPDIR, embeddedImageFormat) # Generate filename and filepath from metadata filename = generateFilename(track, self.settings, "%artist% - %title%") (filepath, artistPath, coverPath, extrasPath) = generateFilepath(track, self.settings) # Remove subfolders from filename and add it to filepath if pathSep in filename: tempPath = filename[:filename.rfind(pathSep)] filepath = filepath / tempPath filename = filename[filename.rfind(pathSep) + len(pathSep):] # Make sure the filepath exists makedirs(filepath, exist_ok=True) writepath = filepath / f"{filename}{extensions[track.selectedFormat]}" # Save extrasPath if extrasPath: if not self.extrasPath: self.extrasPath = extrasPath result['filename'] = str(writepath)[len(str(extrasPath))+ len(pathSep):] # Download and cache coverart logger.info(f"[{track.mainArtist.name} - {track.title}] Getting the album cover") track.album.embeddedCoverPath = downloadImage(track.album.embeddedCoverURL, track.album.embeddedCoverPath) # Save local album art if coverPath: result['albumURLs'] = [] for format in self.settings['localArtworkFormat'].split(","): if format in ["png","jpg"]: extendedFormat = format if extendedFormat == "jpg": extendedFormat += f"-{self.settings['jpegImageQuality']}" url = track.album.pic.generatePictureURL(self.settings['localArtworkSize'], extendedFormat) if self.settings['tags']['savePlaylistAsCompilation'] \ and track.playlist \ and track.playlist.pic.url \ and not format.startswith("jpg"): continue result['albumURLs'].append({'url': url, 'ext': format}) result['albumPath'] = coverPath result['albumFilename'] = f"{settingsRegexAlbum(self.settings['coverImageTemplate'], track.album, self.settings, track.playlist)}" # Save artist art if artistPath: result['artistURLs'] = [] for format in self.settings['localArtworkFormat'].split(","): if format in ["png","jpg"]: extendedFormat = format if extendedFormat == "jpg": extendedFormat += f"-{self.settings['jpegImageQuality']}" url = track.album.mainArtist.pic.generatePictureURL(self.settings['localArtworkSize'], extendedFormat) if track.album.mainArtist.pic.md5 == "" and not format.startswith("jpg"): continue result['artistURLs'].append({'url': url, 'ext': format}) result['artistPath'] = artistPath result['artistFilename'] = f"{settingsRegexArtist(self.settings['artistImageTemplate'], track.album.mainArtist, self.settings, rootArtist=track.album.rootArtist)}" # Save playlist art if track.playlist: if not len(self.playlistURLs): for format in self.settings['localArtworkFormat'].split(","): if format in ["png","jpg"]: extendedFormat = format if extendedFormat == "jpg": extendedFormat += f"-{self.settings['jpegImageQuality']}" url = track.playlist.pic.generatePictureURL(self.settings['localArtworkSize'], extendedFormat) if track.playlist.pic.url and not format.startswith("jpg"): continue self.playlistURLs.append({'url': url, 'ext': format}) if not self.playlistCoverName: track.playlist.bitrate = selectedFormat track.playlist.dateString = track.playlist.date.format(self.settings['dateFormat']) self.playlistCoverName = f"{settingsRegexAlbum(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", 'wb') as f: f.write(track.lyrics.sync.encode('utf-8')) # 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) i = 1 currentFilename = baseFilename+' ('+str(i)+')'+ extensions[track.selectedFormat] while Path(currentFilename).is_file(): i += 1 currentFilename = baseFilename+' ('+str(i)+')'+ extensions[track.selectedFormat] trackAlreadyDownloaded = False writepath = Path(currentFilename) if not trackAlreadyDownloaded or self.settings['overwriteFile'] == OverwriteOption.OVERWRITE: logger.info(f"[{track.mainArtist.name} - {track.title}] Downloading the track") track.downloadUrl = generateStreamURL(track.id, track.MD5, track.mediaVersion, track.selectedFormat) def downloadMusic(track, trackAPI_gw): try: with open(writepath, 'wb') as stream: self.streamTrack(stream, track) except DownloadCancelled: if writepath.is_file(): writepath.unlink() raise DownloadCancelled except (requests.exceptions.HTTPError, DownloadEmpty): if writepath.is_file(): writepath.unlink() if track.fallbackId != "0": logger.warn(f"[{track.mainArtist.name} - {track.title}] Track not available, using fallback id") newTrack = self.dz.gw.get_track_with_fallback(track.fallbackId) track.parseEssentialData(newTrack) track.retriveFilesizes(self.dz) return False elif not track.searched and self.settings['fallbackSearch']: logger.warn(f"[{track.mainArtist.name} - {track.title}] Track not available, searching for alternative") 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) track.parseEssentialData(newTrack) track.retriveFilesizes(self.dz) track.searched = True if self.interface: self.interface.send('queueUpdate', { 'uuid': self.downloadObject.uuid, 'searchFallback': True, 'data': { 'id': track.id, 'title': track.title, 'artist': track.mainArtist.name }, }) return False else: raise DownloadFailed("notAvailableNoAlternative") else: raise DownloadFailed("notAvailable") except (requests.exceptions.ConnectionError, requests.exceptions.ChunkedEncodingError) as e: if writepath.is_file(): writepath.unlink() logger.warn(f"[{track.mainArtist.name} - {track.title}] Error while downloading the track, trying again in 5s...") sleep(5) return downloadMusic(track, trackAPI_gw) except OSError as e: if e.errno == errno.ENOSPC: raise DownloadFailed("noSpaceLeft") else: if writepath.is_file(): writepath.unlink() logger.exception(f"[{track.mainArtist.name} - {track.title}] Error while downloading the track, you should report this to the developers: {str(e)}") raise e except Exception as e: if writepath.is_file(): writepath.unlink() logger.exception(f"[{track.mainArtist.name} - {track.title}] Error while downloading the track, you should report this to the developers: {str(e)}") raise e return True try: trackDownloaded = downloadMusic(track, trackAPI_gw) except Exception as e: raise e if not trackDownloaded: return self.download(trackAPI_gw, track=track) else: logger.info(f"[{track.mainArtist.name} - {track.title}] Skipping track as it's already downloaded") self.completeTrackPercentage() # Adding tags if (not trackAlreadyDownloaded or self.settings['overwriteFile'] in [OverwriteOption.ONLY_TAGS, OverwriteOption.OVERWRITE]) and not track.localTrack: logger.info(f"[{track.mainArtist.name} - {track.title}] Applying tags to the track") if track.selectedFormat in [TrackFormats.MP3_320, TrackFormats.MP3_128, TrackFormats.DEFAULT]: tagID3(writepath, track, self.settings['tags']) elif track.selectedFormat == TrackFormats.FLAC: try: tagFLAC(writepath, track, self.settings['tags']) except (FLACNoHeaderError, FLACError): if writepath.is_file(): writepath.unlink() logger.warn(f"[{track.mainArtist.name} - {track.title}] Track not available in FLAC, falling back if necessary") self.removeTrackPercentage() track.filesizes['FILESIZE_FLAC'] = "0" track.filesizes['FILESIZE_FLAC_TESTED'] = True return self.download(trackAPI_gw, track=track) if track.searched: result['searched'] = f"{track.mainArtist.name} - {track.title}" logger.info(f"[{track.mainArtist.name} - {track.title}] Track download completed\n{str(writepath)}") self.downloadObject.downloaded += 1 self.downloadObject.files.append(str(writepath)) self.downloadObject.extrasPath = str(self.extrasPath) if self.interface: self.interface.send("updateQueue", {'uuid': self.downloadObject.uuid, 'downloaded': True, 'downloadPath': str(writepath), 'extrasPath': str(self.extrasPath)}) return result def streamTrack(self, stream, track, start=0): headers=dict(self.dz.http_headers) if range != 0: headers['Range'] = f'bytes={start}-' chunkLength = start percentage = 0 itemName = f"[{track.mainArtist.name} - {track.title}]" try: with self.dz.session.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"] logger.info(f'{itemName} downloading range {responseRange}') else: logger.info(f'{itemName} downloading {complete} bytes') for chunk in request.iter_content(2048 * 3): if len(chunk) >= 2048: chunk = Blowfish.new(blowfish_key, Blowfish.MODE_CBC, b"\x00\x01\x02\x03\x04\x05\x06\x07").decrypt(chunk[0:2048]) + chunk[2048:] stream.write(chunk) chunkLength += len(chunk) if isinstance(self.downloadObject, Single): percentage = (chunkLength / (complete + start)) * 100 self.downloadPercentage = percentage else: chunkProgres = (len(chunk) / (complete + start)) / self.downloadObject.size * 100 self.downloadPercentage += chunkProgres self.updatePercentage() except (SSLError, u3SSLError) as e: logger.info(f'{itemName} retrying from byte {chunkLength}') return self.streamTrack(stream, track, chunkLength) except (requests.exceptions.ConnectionError, requests.exceptions.ReadTimeout): sleep(2) return self.streamTrack(stream, track, start) def updatePercentage(self): if round(self.downloadPercentage) != self.lastPercentage and round(self.downloadPercentage) % 2 == 0: self.lastPercentage = round(self.downloadPercentage) self.downloadObject.progress = self.lastPercentage if self.interface: self.interface.send("updateQueue", {'uuid': self.downloadObject.uuid, 'progress': self.lastPercentage}) def completeTrackPercentage(self): if isinstance(self.downloadObject, Single): self.downloadPercentage = 100 else: self.downloadPercentage += (1 / self.downloadObject.size) * 100 self.updatePercentage() def removeTrackPercentage(self): if isinstance(self.downloadObject, Single): self.downloadPercentage = 0 else: self.downloadPercentage -= (1 / self.downloadObject.size) * 100 self.updatePercentage() def downloadWrapper(self, trackAPI_gw, trackAPI=None, albumAPI=None, playlistAPI=None, track=None): # Temp metadata to generate logs 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() try: result = self.download(trackAPI_gw, trackAPI, albumAPI, playlistAPI, track) except DownloadFailed as error: if error.track: track = error.track if track.fallbackId != "0": logger.warn(f"[{track.mainArtist.name} - {track.title}] {error.message} Using fallback id") newTrack = self.dz.gw.get_track_with_fallback(track.fallbackId) track.parseEssentialData(newTrack) track.retriveFilesizes(self.dz) return self.downloadWrapper(trackAPI_gw, trackAPI, albumAPI, playlistAPI, track) elif not track.searched and self.settings['fallbackSearch']: logger.warn(f"[{track.mainArtist.name} - {track.title}] {error.message} Searching for alternative") 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) track.parseEssentialData(newTrack) track.retriveFilesizes(self.dz) track.searched = True if self.interface: self.interface.send('queueUpdate', { 'uuid': self.queueItem.uuid, 'searchFallback': True, 'data': { 'id': track.id, 'title': track.title, 'artist': track.mainArtist.name }, }) return self.downloadWrapper(trackAPI_gw, trackAPI, albumAPI, playlistAPI, track) else: error.errid += "NoAlternative" error.message = errorMessages[error.errid] logger.error(f"[{tempTrack['artist']} - {tempTrack['title']}] {error.message}") result = {'error': { 'message': error.message, 'errid': error.errid, 'data': tempTrack }} except Exception as e: logger.exception(f"[{tempTrack['artist']} - {tempTrack['title']}] {str(e)}") result = {'error': { 'message': str(e), 'data': tempTrack }} if 'error' in result: self.completeTrackPercentage() self.downloadObject.failed += 1 self.downloadObject.errors.append(result['error']) if self.interface: error = result['error'] self.interface.send("updateQueue", { 'uuid': self.downloadObject.uuid, 'failed': True, 'data': error['data'], 'error': error['message'], 'errid': error['errid'] if 'errid' in error else None }) return result def singleAfterDownload(self, result): if not self.extrasPath: self.extrasPath = Path(self.settings['downloadLocation']) # Save Album Cover if self.settings['saveArtwork'] and 'albumPath' in result: for image in result['albumURLs']: downloadImage(image['url'], result['albumPath'] / f"{result['albumFilename']}.{image['ext']}", self.settings['overwriteFile']) # Save Artist Artwork if self.settings['saveArtworkArtist'] and 'artistPath' in result: for image in result['artistURLs']: downloadImage(image['url'], result['artistPath'] / f"{result['artistFilename']}.{image['ext']}", self.settings['overwriteFile']) # Create searched logfile if self.settings['logSearched'] and 'searched' in result: with open(self.extrasPath / 'searched.txt', 'wb+') as f: orig = f.read().decode('utf-8') if not result['searched'] in orig: if orig != "": orig += "\r\n" orig += result['searched'] + "\r\n" f.write(orig.encode('utf-8')) # Execute command after download if self.settings['executeCommand'] != "": execute(self.settings['executeCommand'].replace("%folder%", quote(str(self.extrasPath))).replace("%filename%", quote(result['filename'])), shell=True) def collectionAfterDownload(self, tracks): if not self.extrasPath: self.extrasPath = Path(self.settings['downloadLocation']) playlist = [None] * len(tracks) errors = "" searched = "" for i in range(len(tracks)): result = tracks[i].result() if not result: return None # Check if item is cancelled # Log errors to file if result.get('error'): if not result['error'].get('data'): result['error']['data'] = {'id': "0", 'title': 'Unknown', 'artist': 'Unknown'} errors += f"{result['error']['data']['id']} | {result['error']['data']['artist']} - {result['error']['data']['title']} | {result['error']['message']}\r\n" # Log searched to file if 'searched' in result: searched += result['searched'] + "\r\n" # Save Album Cover if self.settings['saveArtwork'] and 'albumPath' in result: for image in result['albumURLs']: downloadImage(image['url'], result['albumPath'] / f"{result['albumFilename']}.{image['ext']}", self.settings['overwriteFile']) # Save Artist Artwork if self.settings['saveArtworkArtist'] and 'artistPath' in result: for image in result['artistURLs']: downloadImage(image['url'], result['artistPath'] / f"{result['artistFilename']}.{image['ext']}", self.settings['overwriteFile']) # Save filename for playlist file playlist[i] = result.get('filename', "") # Create errors logfile if self.settings['logErrors'] and errors != "": with open(self.extrasPath / 'errors.txt', 'wb') as f: f.write(errors.encode('utf-8')) # Create searched logfile if self.settings['logSearched'] and searched != "": with open(self.extrasPath / 'searched.txt', 'wb') as f: f.write(searched.encode('utf-8')) # Save Playlist Artwork if self.settings['saveArtwork'] and self.playlistCoverName and not self.settings['tags']['savePlaylistAsCompilation']: for image in self.playlistURLs: downloadImage(image['url'], self.extrasPath / f"{self.playlistCoverName}.{image['ext']}", self.settings['overwriteFile']) # Create M3U8 File if self.settings['createM3U8File']: filename = settingsRegexPlaylistFile(self.settings['playlistFilenameTemplate'], self.downloadObject, self.settings) or "playlist" with open(self.extrasPath / f'{filename}.m3u8', 'wb') as f: for line in playlist: f.write((line + "\n").encode('utf-8')) # Execute command after download if self.settings['executeCommand'] != "": execute(self.settings['executeCommand'].replace("%folder%", quote(str(self.extrasPath))), shell=True) class DownloadError(Exception): """Base class for exceptions in this module.""" pass class DownloadFailed(DownloadError): def __init__(self, errid, track=None): self.errid = errid self.message = errorMessages[self.errid] self.track = track class DownloadCancelled(DownloadError): pass class DownloadEmpty(DownloadError): pass class PreferredBitrateNotFound(DownloadError): pass class TrackNot360(DownloadError): pass