richard
/
youtube-dl-gui
mirror of https://github.com/shihxuancheng/youtube-dl-gui.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Reindent to 4-spaces

doc-issue-template
MrS0m30n3 11 years ago
parent
cc0b2ad9a5
commit
961dcb5576
11 changed files with 1996 additions and 2006 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      setup.py
  2. 335
      youtube_dl_gui/DownloadThread.py
  3. 87
      youtube_dl_gui/LogManager.py
  4. 349
      youtube_dl_gui/OptionsHandler.py
  5. 359
      youtube_dl_gui/OutputHandler.py
  6. 49
      youtube_dl_gui/UpdateThread.py
  7. 107
      youtube_dl_gui/Utils.py
  8. 2375
      youtube_dl_gui/YoutubeDLGUI.py
  9. 319
      youtube_dl_gui/YoutubeDLInterpreter.py
  10. 19
      youtube_dl_gui/__init__.py
  11. 1
      youtube_dl_gui/__main__.py

2
setup.py
View File

@ -21,5 +21,5 @@ setup(name=__appname__,
author_email=__contact__, author_email=__contact__,
url=__projecturl__, url=__projecturl__,
packages=['youtube_dl_gui'], packages=['youtube_dl_gui'],
data_files=[('lib/python2.7/site-packages/youtube_dl_gui/icons',
data_files=[('lib/python2.7/site-packages/youtube_dl_gui/icons',
['youtube_dl_gui/icons/youtube-dl-gui.png'])]) ['youtube_dl_gui/icons/youtube-dl-gui.png'])])

335
youtube_dl_gui/DownloadThread.py
View File

@ -13,7 +13,7 @@ from .OutputHandler import (
OutputFormatter OutputFormatter
) )
from .Utils import (
from .Utils import (
get_encoding, get_encoding,
encode_list, encode_list,
remove_file, remove_file,
@ -25,171 +25,170 @@ MAX_DOWNLOAD_THREADS = 3
PUBLISHER_TOPIC = 'download' PUBLISHER_TOPIC = 'download'
class DownloadManager(Thread): class DownloadManager(Thread):
def __init__(self, options, downloadlist, clear_dash_files, logmanager=None):
super(DownloadManager, self).__init__()
self.clear_dash_files = clear_dash_files
self.downloadlist = downloadlist
self.logmanager = logmanager
self.options = options
self.running = True
self.procList = []
self.procNo = 0
self.start()
def run(self):
while self.running:
if self.downloadlist:
# Extract url, index from data
url, index = self.extract_data()
# Wait for your turn if there are not more positions in 'queue'
while self.procNo >= MAX_DOWNLOAD_THREADS:
proc = self.check_queue()
if proc != None:
self.procList.remove(proc)
self.procNo -= 1
sleep(1)
# If we still running create new ProcessWrapper thread
if self.running:
self.procList.append(
ProcessWrapper(
self.options,
url,
index,
self.clear_dash_files,
self.logmanager
)
)
self.procNo += 1
else:
# Return True if at least one process is alive else return False
if not self.downloading():
self.running = False
else:
sleep(0.1)
# If we reach here close down all child threads
self.terminate_all()
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('finish'))
def downloading(self):
for proc in self.procList:
if proc.isAlive():
return True
return False
def _add_download_item(self, downloadItem):
self.downloadlist.append(downloadItem)
def extract_data(self):
data = self.downloadlist.pop(0)
url = data['url']
index = data['index']
return url, index
def terminate_all(self):
for proc in self.procList:
if proc.isAlive():
proc.close()
proc.join()
def check_queue(self):
for proc in self.procList:
if not self.running: break
if not proc.isAlive():
return proc
return None
def close(self):
self.procNo = 0
self.running = False
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('close'))
def __init__(self, options, downloadlist, clear_dash_files, logmanager=None):
super(DownloadManager, self).__init__()
self.clear_dash_files = clear_dash_files
self.downloadlist = downloadlist
self.logmanager = logmanager
self.options = options
self.running = True
self.procList = []
self.procNo = 0
self.start()
def run(self):
while self.running:
if self.downloadlist:
# Extract url, index from data
url, index = self.extract_data()
# Wait for your turn if there are not more positions in 'queue'
while self.procNo >= MAX_DOWNLOAD_THREADS:
proc = self.check_queue()
if proc != None:
self.procList.remove(proc)
self.procNo -= 1
sleep(1)
# If we still running create new ProcessWrapper thread
if self.running:
self.procList.append(
ProcessWrapper(
self.options,
url,
index,
self.clear_dash_files,
self.logmanager
)
)
self.procNo += 1
else:
# Return True if at least one process is alive else return False
if not self.downloading():
self.running = False
else:
sleep(0.1)
# If we reach here close down all child threads
self.terminate_all()
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('finish'))
def downloading(self):
for proc in self.procList:
if proc.isAlive():
return True
return False
def _add_download_item(self, downloadItem):
self.downloadlist.append(downloadItem)
def extract_data(self):
data = self.downloadlist.pop(0)
url = data['url']
index = data['index']
return url, index
def terminate_all(self):
for proc in self.procList:
if proc.isAlive():
proc.close()
proc.join()
def check_queue(self):
for proc in self.procList:
if not self.running: break
if not proc.isAlive():
return proc
return None
def close(self):
self.procNo = 0
self.running = False
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('close'))
class ProcessWrapper(Thread): class ProcessWrapper(Thread):
def __init__(self, options, url, index, clear_dash_files, log=None):
super(ProcessWrapper, self).__init__()
self.clear_dash_files = clear_dash_files
self.options = options
self.index = index
self.log = log
self.url = url
self.filenames = []
self.stopped = False
self.error = False
self.proc = None
self.start()
def run(self):
self.proc = self.create_process(self.get_cmd(), self.get_process_info())
# while subprocess is alive and NOT the current thread
while self.proc_is_alive():
# read stdout, stderr from proc
stdout, stderr = self.read()
if stdout != '':
# pass stdout to output formatter
data = OutputFormatter(stdout).get_data()
if self.clear_dash_files: self.add_file(data)
# add index to data pack
data.index = self.index
# send data back to caller
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, data)
if stderr != '':
self.error = True
self.write_to_log(stderr)
if not self.stopped:
if self.clear_dash_files:
self.clear_dash()
if not self.error:
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('finish', self.index))
else:
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('error', self.index))
def add_file(self, dataPack):
if dataPack.header == 'filename':
self.filenames.append(dataPack.data)
def write_to_log(self, data):
if self.log != None:
self.log.write(data)
def clear_dash(self):
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('remove', self.index))
for f in self.filenames:
if file_exist(f):
remove_file(f)
def close(self):
self.proc.kill()
self.stopped = True
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('close', self.index))
def proc_is_alive(self):
return self.proc.poll() == None
def read(self):
stdout = ''
stderr = ''
stdout = self.proc.stdout.readline()
if stdout == '':
stderr = self.proc.stderr.readline()
return stdout.rstrip(), stderr.rstrip()
def create_process(self, cmd, info):
return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, startupinfo=info)
def get_cmd(self):
enc = get_encoding()
if enc != None:
cmd = encode_list(self.options + [self.url], enc)
else:
cmd = self.options + [self.url]
return cmd
def get_process_info(self):
if get_os_type() == 'nt':
info = subprocess.STARTUPINFO()
info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
return info
else:
return None
def __init__(self, options, url, index, clear_dash_files, log=None):
super(ProcessWrapper, self).__init__()
self.clear_dash_files = clear_dash_files
self.options = options
self.index = index
self.log = log
self.url = url
self.filenames = []
self.stopped = False
self.error = False
self.proc = None
self.start()
def run(self):
self.proc = self.create_process(self.get_cmd(), self.get_process_info())
# while subprocess is alive and NOT the current thread
while self.proc_is_alive():
# read stdout, stderr from proc
stdout, stderr = self.read()
if stdout != '':
# pass stdout to output formatter
data = OutputFormatter(stdout).get_data()
if self.clear_dash_files: self.add_file(data)
# add index to data pack
data.index = self.index
# send data back to caller
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, data)
if stderr != '':
self.error = True
self.write_to_log(stderr)
if not self.stopped:
if self.clear_dash_files:
self.clear_dash()
if not self.error:
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('finish', self.index))
else:
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('error', self.index))
def add_file(self, dataPack):
if dataPack.header == 'filename':
self.filenames.append(dataPack.data)
def write_to_log(self, data):
if self.log != None:
self.log.write(data)
def clear_dash(self):
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('remove', self.index))
for f in self.filenames:
if file_exist(f):
remove_file(f)
def close(self):
self.proc.kill()
self.stopped = True
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, DataPack('close', self.index))
def proc_is_alive(self):
return self.proc.poll() == None
def read(self):
stdout = ''
stderr = ''
stdout = self.proc.stdout.readline()
if stdout == '':
stderr = self.proc.stderr.readline()
return stdout.rstrip(), stderr.rstrip()
def create_process(self, cmd, info):
return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, startupinfo=info)
def get_cmd(self):
enc = get_encoding()
if enc != None:
cmd = encode_list(self.options + [self.url], enc)
else:
cmd = self.options + [self.url]
return cmd
def get_process_info(self):
if get_os_type() == 'nt':
info = subprocess.STARTUPINFO()
info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
return info
else:
return None

87
youtube_dl_gui/LogManager.py
View File

@ -13,48 +13,47 @@ LOG_FILENAME = 'log'
LOG_FILESIZE = 524288 # 524288B = 512kB LOG_FILESIZE = 524288 # 524288B = 512kB
class LogManager(): class LogManager():
def __init__(self, path, add_time=False):
self.path = fix_path(path) + LOG_FILENAME
self.add_time = add_time
self.init_log()
self.auto_clear_log()
def auto_clear_log(self):
if self.size() > LOG_FILESIZE:
self.clear()
def init_log(self):
if not file_exist(self.path):
self.clear()
def size(self):
return get_filesize(self.path)
def clear(self):
with open(self.path, 'w') as fl:
fl.write('')
def write(self, data):
with open(self.path, 'a') as fl:
if self.add_time:
t = '[%s] ' % strftime('%c')
fl.write(t)
fl.write(data)
fl.write('\n')
def __init__(self, path, add_time=False):
self.path = fix_path(path) + LOG_FILENAME
self.add_time = add_time
self.init_log()
self.auto_clear_log()
def auto_clear_log(self):
if self.size() > LOG_FILESIZE:
self.clear()
def init_log(self):
if not file_exist(self.path):
self.clear()
def size(self):
return get_filesize(self.path)
def clear(self):
with open(self.path, 'w') as fl:
fl.write('')
def write(self, data):
with open(self.path, 'a') as fl:
if self.add_time:
t = '[%s] ' % strftime('%c')
fl.write(t)
fl.write(data)
fl.write('\n')
class LogGUI(wx.Frame): class LogGUI(wx.Frame):
title = 'Log Viewer'
def __init__(self, path, parent=None, id=-1):
wx.Frame.__init__(self, parent, id, self.title, size=(650, 200))
panel = wx.Panel(self)
textArea = wx.TextCtrl(panel, -1, style = wx.TE_MULTILINE | wx.TE_READONLY | wx.HSCROLL)
sizer = wx.BoxSizer()
sizer.Add(textArea, 1, wx.EXPAND)
panel.SetSizerAndFit(sizer)
textArea.LoadFile(path)
title = 'Log Viewer'
def __init__(self, path, parent=None, id=-1):
wx.Frame.__init__(self, parent, id, self.title, size=(650, 200))
panel = wx.Panel(self)
textArea = wx.TextCtrl(panel, -1, style = wx.TE_MULTILINE | wx.TE_READONLY | wx.HSCROLL)
sizer = wx.BoxSizer()
sizer.Add(textArea, 1, wx.EXPAND)
panel.SetSizerAndFit(sizer)
textArea.LoadFile(path)

349
youtube_dl_gui/OptionsHandler.py
View File

@ -14,178 +14,177 @@ LINUX_FILES_PATH = get_HOME() + '/.youtube-dl-gui'
WINDOWS_FILES_PATH = get_HOME() + '\\youtube-dl-gui' WINDOWS_FILES_PATH = get_HOME() + '\\youtube-dl-gui'
class OptionsHandler(): class OptionsHandler():
settings_abs_path = ''
def __init__(self, statusBarWrite):
self.statusBarWrite = statusBarWrite
self.set_settings_path()
self.load_default()
self.load_settings()
def load_settings(self):
if not file_exist(self.get_config_path()):
makedir(self.get_config_path())
if file_exist(self.settings_abs_path):
self.load_from_file()
def load_default(self):
self.savePath = get_HOME()
self.videoFormat = "default"
self.dashAudioFormat = "NO SOUND"
self.clearDashFiles = False
self.toAudio = False
self.keepVideo = False
self.audioFormat = "mp3"
self.audioQuality = "mid"
self.outputFormat = "title"
self.outputTemplate = '%(uploader)s/%(title)s.%(ext)s'
self.startTrack = 1
self.endTrack = 0
self.maxDownloads = 0
self.minFileSize = "0"
self.maxFileSize = "0"
self.writeSubs = False
self.writeAllSubs = False
self.writeAutoSubs = False
self.embedSubs = False
self.subsLang = "English"
self.openDownloadDir = False
self.ignoreErrors = True
self.writeDescription = False
self.writeInfo = False
self.writeThumbnail = False
self.retries = 10
self.userAgent = ""
self.referer = ""
self.proxy = ""
self.username = ""
self.password = ""
self.videoPass = ""
self.updatePath = self.get_config_path()
self.autoUpdate = False
self.cmdArgs = ""
self.enableLog = True
self.writeTimeToLog = True
def get_config_path(self):
if get_os_type() == 'nt':
return WINDOWS_FILES_PATH
else:
return LINUX_FILES_PATH
def set_settings_path(self):
self.settings_abs_path = self.get_config_path()
self.settings_abs_path = fix_path(self.settings_abs_path)
self.settings_abs_path += SETTINGS_FILENAME
def read_from_file(self):
f = open(self.settings_abs_path, 'r')
options = f.readlines()
f.close()
return options
def extract_options(self, options):
opts = []
for option in options:
opt = option.split('=')
if not len(opt) < 2:
opts.append(opt[1].rstrip('\n'))
return opts
def check_settings_file_version(self, options):
data = options.pop(0).rstrip('\n')
name, version = data.split('=')
if name == 'Version' and version == __version__:
return True
else:
return False
def load_from_file(self):
options = self.read_from_file()
if self.check_settings_file_version(options):
opts = self.extract_options(options)
try:
self.savePath = opts[0].decode('utf8')
self.videoFormat = opts[1]
self.dashAudioFormat = opts[2]
self.clearDashFiles = opts[3] in ['True']
self.toAudio = opts[4] in ['True']
self.keepVideo = opts[5] in ['True']
self.audioFormat = opts[6]
self.audioQuality = opts[7]
self.outputFormat = opts[8]
self.outputTemplate = opts[9]
self.startTrack = int(opts[10])
self.endTrack = int(opts[11])
self.maxDownloads = int(opts[12])
self.minFileSize = opts[13]
self.maxFileSize = opts[14]
self.writeSubs = opts[15] in ['True']
self.writeAllSubs = opts[16] in ['True']
self.writeAutoSubs = opts[17] in ['True']
self.embedSubs = opts[18] in ['True']
self.subsLang = opts[19]
self.openDownloadDir = opts[20] in ['True']
self.ignoreErrors = opts[21] in ['True']
self.writeDescription = opts[22] in ['True']
self.writeInfo = opts[23] in ['True']
self.writeThumbnail = opts[24] in ['True']
self.retries = int(opts[25])
self.userAgent = opts[26]
self.referer = opts[27]
self.proxy = opts[28]
self.username = opts[29]
self.updatePath = opts[30].decode('utf8')
self.autoUpdate = opts[31] in ['True']
self.cmdArgs = opts[32]
self.enableLog = opts[33] in ['True']
self.writeTimeToLog = opts[34] in ['True']
except:
self.statusBarWrite('Error while loading settings file. Loading default settings.')
self.load_default()
else:
self.statusBarWrite('Settings file version problem. Loading default settings.')
self.load_default()
def save_to_file(self):
f = open(self.settings_abs_path, 'w')
f.write('Version='+__version__+'\n')
f.write('SavePath='+self.savePath.encode('utf-8')+'\n')
f.write('VideoFormat='+str(self.videoFormat)+'\n')
f.write('DashAudioFormat='+str(self.dashAudioFormat)+'\n')
f.write('ClearDashFiles='+str(self.clearDashFiles)+'\n')
f.write('ToAudio='+str(self.toAudio)+'\n')
f.write('KeepVideo='+str(self.keepVideo)+'\n')
f.write('AudioFormat='+str(self.audioFormat)+'\n')
f.write('AudioQuality='+str(self.audioQuality)+'\n')
f.write('OutputFormat='+str(self.outputFormat)+'\n')
f.write('OutputTemplate='+str(self.outputTemplate)+'\n')
f.write('StartTrack='+str(self.startTrack)+'\n')
f.write('EndTrack='+str(self.endTrack)+'\n')
f.write('MaxDownloads='+str(self.maxDownloads)+'\n')
f.write('MinFileSize='+str(self.minFileSize)+'\n')
f.write('MaxFileSize='+str(self.maxFileSize)+'\n')
f.write('WriteSubtitles='+str(self.writeSubs)+'\n')
f.write('WriteAllSubtitles='+str(self.writeAllSubs)+'\n')
f.write('WriteAutoSubtitles='+str(self.writeAutoSubs)+'\n')
f.write('EmbedSubs='+str(self.embedSubs)+'\n')
f.write('SubtitlesLanguage='+str(self.subsLang)+'\n')
f.write('OpenDownloadDirectory='+str(self.openDownloadDir)+'\n')
f.write('IgnoreErrors='+str(self.ignoreErrors)+'\n')
f.write('WriteDescription='+str(self.writeDescription)+'\n')
f.write('WriteInfo='+str(self.writeInfo)+'\n')
f.write('WriteThumbnail='+str(self.writeThumbnail)+'\n')
f.write('Retries='+str(self.retries)+'\n')
f.write('UserAgent='+str(self.userAgent)+'\n')
f.write('Referer='+str(self.referer)+'\n')
f.write('Proxy='+str(self.proxy)+'\n')
f.write('Username='+str(self.username)+'\n')
# We dont store password & videoPass for security reasons
f.write('UpdatePath='+self.updatePath.encode('utf-8')+'\n')
f.write('AutoUpdate='+str(self.autoUpdate)+'\n')
f.write('CmdArgs='+str(self.cmdArgs)+'\n')
f.write('EnableLog='+str(self.enableLog)+'\n')
f.write('WriteTimeToLog='+str(self.writeTimeToLog)+'\n')
f.close()
settings_abs_path = ''
def __init__(self, statusBarWrite):
self.statusBarWrite = statusBarWrite
self.set_settings_path()
self.load_default()
self.load_settings()
def load_settings(self):
if not file_exist(self.get_config_path()):
makedir(self.get_config_path())
if file_exist(self.settings_abs_path):
self.load_from_file()
def load_default(self):
self.savePath = get_HOME()
self.videoFormat = "default"
self.dashAudioFormat = "NO SOUND"
self.clearDashFiles = False
self.toAudio = False
self.keepVideo = False
self.audioFormat = "mp3"
self.audioQuality = "mid"
self.outputFormat = "title"
self.outputTemplate = '%(uploader)s/%(title)s.%(ext)s'
self.startTrack = 1
self.endTrack = 0
self.maxDownloads = 0
self.minFileSize = "0"
self.maxFileSize = "0"
self.writeSubs = False
self.writeAllSubs = False
self.writeAutoSubs = False
self.embedSubs = False
self.subsLang = "English"
self.openDownloadDir = False
self.ignoreErrors = True
self.writeDescription = False
self.writeInfo = False
self.writeThumbnail = False
self.retries = 10
self.userAgent = ""
self.referer = ""
self.proxy = ""
self.username = ""
self.password = ""
self.videoPass = ""
self.updatePath = self.get_config_path()
self.autoUpdate = False
self.cmdArgs = ""
self.enableLog = True
self.writeTimeToLog = True
def get_config_path(self):
if get_os_type() == 'nt':
return WINDOWS_FILES_PATH
else:
return LINUX_FILES_PATH
def set_settings_path(self):
self.settings_abs_path = self.get_config_path()
self.settings_abs_path = fix_path(self.settings_abs_path)
self.settings_abs_path += SETTINGS_FILENAME
def read_from_file(self):
f = open(self.settings_abs_path, 'r')
options = f.readlines()
f.close()
return options
def extract_options(self, options):
opts = []
for option in options:
opt = option.split('=')
if not len(opt) < 2:
opts.append(opt[1].rstrip('\n'))
return opts
def check_settings_file_version(self, options):
data = options.pop(0).rstrip('\n')
name, version = data.split('=')
if name == 'Version' and version == __version__:
return True
else:
return False
def load_from_file(self):
options = self.read_from_file()
if self.check_settings_file_version(options):
opts = self.extract_options(options)
try:
self.savePath = opts[0].decode('utf8')
self.videoFormat = opts[1]
self.dashAudioFormat = opts[2]
self.clearDashFiles = opts[3] in ['True']
self.toAudio = opts[4] in ['True']
self.keepVideo = opts[5] in ['True']
self.audioFormat = opts[6]
self.audioQuality = opts[7]
self.outputFormat = opts[8]
self.outputTemplate = opts[9]
self.startTrack = int(opts[10])
self.endTrack = int(opts[11])
self.maxDownloads = int(opts[12])
self.minFileSize = opts[13]
self.maxFileSize = opts[14]
self.writeSubs = opts[15] in ['True']
self.writeAllSubs = opts[16] in ['True']
self.writeAutoSubs = opts[17] in ['True']
self.embedSubs = opts[18] in ['True']
self.subsLang = opts[19]
self.openDownloadDir = opts[20] in ['True']
self.ignoreErrors = opts[21] in ['True']
self.writeDescription = opts[22] in ['True']
self.writeInfo = opts[23] in ['True']
self.writeThumbnail = opts[24] in ['True']
self.retries = int(opts[25])
self.userAgent = opts[26]
self.referer = opts[27]
self.proxy = opts[28]
self.username = opts[29]
self.updatePath = opts[30].decode('utf8')
self.autoUpdate = opts[31] in ['True']
self.cmdArgs = opts[32]
self.enableLog = opts[33] in ['True']
self.writeTimeToLog = opts[34] in ['True']
except:
self.statusBarWrite('Error while loading settings file. Loading default settings.')
self.load_default()
else:
self.statusBarWrite('Settings file version problem. Loading default settings.')
self.load_default()
def save_to_file(self):
f = open(self.settings_abs_path, 'w')
f.write('Version='+__version__+'\n')
f.write('SavePath='+self.savePath.encode('utf-8')+'\n')
f.write('VideoFormat='+str(self.videoFormat)+'\n')
f.write('DashAudioFormat='+str(self.dashAudioFormat)+'\n')
f.write('ClearDashFiles='+str(self.clearDashFiles)+'\n')
f.write('ToAudio='+str(self.toAudio)+'\n')
f.write('KeepVideo='+str(self.keepVideo)+'\n')
f.write('AudioFormat='+str(self.audioFormat)+'\n')
f.write('AudioQuality='+str(self.audioQuality)+'\n')
f.write('OutputFormat='+str(self.outputFormat)+'\n')
f.write('OutputTemplate='+str(self.outputTemplate)+'\n')
f.write('StartTrack='+str(self.startTrack)+'\n')
f.write('EndTrack='+str(self.endTrack)+'\n')
f.write('MaxDownloads='+str(self.maxDownloads)+'\n')
f.write('MinFileSize='+str(self.minFileSize)+'\n')
f.write('MaxFileSize='+str(self.maxFileSize)+'\n')
f.write('WriteSubtitles='+str(self.writeSubs)+'\n')
f.write('WriteAllSubtitles='+str(self.writeAllSubs)+'\n')
f.write('WriteAutoSubtitles='+str(self.writeAutoSubs)+'\n')
f.write('EmbedSubs='+str(self.embedSubs)+'\n')
f.write('SubtitlesLanguage='+str(self.subsLang)+'\n')
f.write('OpenDownloadDirectory='+str(self.openDownloadDir)+'\n')
f.write('IgnoreErrors='+str(self.ignoreErrors)+'\n')
f.write('WriteDescription='+str(self.writeDescription)+'\n')
f.write('WriteInfo='+str(self.writeInfo)+'\n')
f.write('WriteThumbnail='+str(self.writeThumbnail)+'\n')
f.write('Retries='+str(self.retries)+'\n')
f.write('UserAgent='+str(self.userAgent)+'\n')
f.write('Referer='+str(self.referer)+'\n')
f.write('Proxy='+str(self.proxy)+'\n')
f.write('Username='+str(self.username)+'\n')
# We dont store password & videoPass for security reasons
f.write('UpdatePath='+self.updatePath.encode('utf-8')+'\n')
f.write('AutoUpdate='+str(self.autoUpdate)+'\n')
f.write('CmdArgs='+str(self.cmdArgs)+'\n')
f.write('EnableLog='+str(self.enableLog)+'\n')
f.write('WriteTimeToLog='+str(self.writeTimeToLog)+'\n')
f.close()

359
youtube_dl_gui/OutputHandler.py
View File

@ -7,186 +7,185 @@ from .Utils import (
) )
class DownloadHandler(): class DownloadHandler():
def __init__(self, ListCtrl):
self.ListCtrl = ListCtrl
self.finished = False
self.closed = False
self.error = False
self.init_handlers()
def init_handlers(self):
''' Initialise handlers '''
self.handlers = [None for i in range(self.ListCtrl.ListIndex)]
def _has_closed(self):
return self.closed
def _has_finished(self):
return self.finished
def _has_error(self):
return self.error
def _add_empty_handler(self):
self.handlers.append(None)
def handle(self, msg):
''' Handles msg base to Signals.txt '''
pack = msg.data
if pack.index == -1:
self.global_handler(pack)
else:
self.index_handler(pack)
def global_handler(self, pack):
''' Manage global index = -1 '''
if pack.header == 'close':
self.closed = True
elif pack.header == 'finish':
self.finished = True
def index_handler(self, pack):
''' Manage handlers base on index '''
if self.handlers[pack.index] == None:
self.handlers[pack.index] = IndexDownloadHandler(self.ListCtrl, pack.index)
self.handlers[pack.index].handle(pack)
if self.handlers[pack.index].has_error():
self.error = True
def __init__(self, ListCtrl):
self.ListCtrl = ListCtrl
self.finished = False
self.closed = False
self.error = False
self.init_handlers()
def init_handlers(self):
''' Initialise handlers '''
self.handlers = [None for i in range(self.ListCtrl.ListIndex)]
def _has_closed(self):
return self.closed
def _has_finished(self):
return self.finished
def _has_error(self):
return self.error
def _add_empty_handler(self):
self.handlers.append(None)
def handle(self, msg):
''' Handles msg base to Signals.txt '''
pack = msg.data
if pack.index == -1:
self.global_handler(pack)
else:
self.index_handler(pack)
def global_handler(self, pack):
''' Manage global index = -1 '''
if pack.header == 'close':
self.closed = True
elif pack.header == 'finish':
self.finished = True
def index_handler(self, pack):
''' Manage handlers base on index '''
if self.handlers[pack.index] == None:
self.handlers[pack.index] = IndexDownloadHandler(self.ListCtrl, pack.index)
self.handlers[pack.index].handle(pack)
if self.handlers[pack.index].has_error():
self.error = True
class IndexDownloadHandler(): class IndexDownloadHandler():
def __init__(self, ListCtrl, index):
self.ListCtrl = ListCtrl
self.index = index
self.err = False
self.info = ''
def has_error(self):
return self.err
def handle(self, pack):
''' Handle its pack for current index '''
if pack.header == 'finish':
self.finish()
elif pack.header == 'close':
self.close()
elif pack.header == 'error':
self.error()
elif pack.header == 'playlist':
self.playlist(pack.data)
elif pack.header == 'youtube':
self.pre_proc()
elif pack.header == 'download':
self.download(pack.data)
elif pack.header == 'ffmpeg':
self.post_proc()
elif pack.header == 'remove':
self.remove()
elif pack.header == 'filename':
self.filename(pack.data)
def finish(self):
self.ListCtrl._write_data(self.index, 4, '')
self.ListCtrl._write_data(self.index, 5, 'Finished')
def close(self):
self.ListCtrl._write_data(self.index, 3, '')
self.ListCtrl._write_data(self.index, 4, '')
self.ListCtrl._write_data(self.index, 5, 'Stopped')
def error(self):
self.err = True
self.ListCtrl._write_data(self.index, 3, '')
self.ListCtrl._write_data(self.index, 4, '')
self.ListCtrl._write_data(self.index, 5, 'Error')
def pre_proc(self):
self.ListCtrl._write_data(self.index, 5, 'Pre-Processing %s' % self.info)
def post_proc(self):
self.ListCtrl._write_data(self.index, 4, '')
self.ListCtrl._write_data(self.index, 5, 'Post-Processing %s' % self.info)
def download(self, data):
self.ListCtrl._write_data(self.index, 1, data[0])
self.ListCtrl._write_data(self.index, 2, data[1])
self.ListCtrl._write_data(self.index, 3, data[2])
self.ListCtrl._write_data(self.index, 4, data[3])
self.ListCtrl._write_data(self.index, 5, 'Downloading %s' % self.info)
def playlist(self, data):
self.ListCtrl._write_data(self.index, 1, '')
self.ListCtrl._write_data(self.index, 2, '')
self.ListCtrl._write_data(self.index, 3, '')
self.ListCtrl._write_data(self.index, 4, '')
self.info = '%s/%s' % (data[0], data[1])
def remove(self):
self.ListCtrl._write_data(self.index, 5, 'Removing DASH Files')
def filename(self, fl):
self.ListCtrl._write_data(self.index, 0, get_filename(fl))
def __init__(self, ListCtrl, index):
self.ListCtrl = ListCtrl
self.index = index
self.err = False
self.info = ''
def has_error(self):
return self.err
def handle(self, pack):
''' Handle its pack for current index '''
if pack.header == 'finish':
self.finish()
elif pack.header == 'close':
self.close()
elif pack.header == 'error':
self.error()
elif pack.header == 'playlist':
self.playlist(pack.data)
elif pack.header == 'youtube':
self.pre_proc()
elif pack.header == 'download':
self.download(pack.data)
elif pack.header == 'ffmpeg':
self.post_proc()
elif pack.header == 'remove':
self.remove()
elif pack.header == 'filename':
self.filename(pack.data)
def finish(self):
self.ListCtrl._write_data(self.index, 4, '')
self.ListCtrl._write_data(self.index, 5, 'Finished')
def close(self):
self.ListCtrl._write_data(self.index, 3, '')
self.ListCtrl._write_data(self.index, 4, '')
self.ListCtrl._write_data(self.index, 5, 'Stopped')
def error(self):
self.err = True
self.ListCtrl._write_data(self.index, 3, '')
self.ListCtrl._write_data(self.index, 4, '')
self.ListCtrl._write_data(self.index, 5, 'Error')
def pre_proc(self):
self.ListCtrl._write_data(self.index, 5, 'Pre-Processing %s' % self.info)
def post_proc(self):
self.ListCtrl._write_data(self.index, 4, '')
self.ListCtrl._write_data(self.index, 5, 'Post-Processing %s' % self.info)
def download(self, data):
self.ListCtrl._write_data(self.index, 1, data[0])
self.ListCtrl._write_data(self.index, 2, data[1])
self.ListCtrl._write_data(self.index, 3, data[2])
self.ListCtrl._write_data(self.index, 4, data[3])
self.ListCtrl._write_data(self.index, 5, 'Downloading %s' % self.info)
def playlist(self, data):
self.ListCtrl._write_data(self.index, 1, '')
self.ListCtrl._write_data(self.index, 2, '')
self.ListCtrl._write_data(self.index, 3, '')
self.ListCtrl._write_data(self.index, 4, '')
self.info = '%s/%s' % (data[0], data[1])
def remove(self):
self.ListCtrl._write_data(self.index, 5, 'Removing DASH Files')
def filename(self, fl):
self.ListCtrl._write_data(self.index, 0, get_filename(fl))
class DataPack(): class DataPack():
def __init__(self, header, index=-1, data=None):
self.header = header
self.index = index
self.data = data
def __init__(self, header, index=-1, data=None):
self.header = header
self.index = index
self.data = data
class OutputFormatter(): class OutputFormatter():
def __init__(self, stdout):
dataPack = None
self.stdout = remove_empty_items(string_to_array(stdout))
# extract header from stdout
header = self.extract_header()
# extract special headers filename, playlist
header = self.set_filename_header(header)
header = self.set_playlist_header(header)
# extract data base on header
data = self.extract_data(header)
# extract special ignore header base on header, data
header = self.set_ignore_header(header, data)
# create data pack
self.dataPack = DataPack(header, data=data)
def extract_header(self):
header = self.stdout.pop(0).replace('[', '').replace(']', '')
return header
def extract_data(self, header):
''' Extract data base on header '''
if header == 'download':
if '%' in self.stdout[0]:
if self.stdout[0] != '100%':
''' size, percent, eta, speed '''
return [self.stdout[2], self.stdout[0], self.stdout[6], self.stdout[4]]
if header == 'playlist':
return [self.stdout[2], self.stdout[4]]
if header == 'filename':
return ' '.join(self.stdout[1:])
return None
def set_filename_header(self, header):
if header != 'ffmpeg':
if self.stdout[0] == 'Destination:':
return 'filename'
return header
def set_playlist_header(self, header):
if header == 'download':
if self.stdout[0] == 'Downloading' and self.stdout[1] == 'video':
return 'playlist'
return header
def set_ignore_header(self, header, data):
if header == 'download' and data == None:
return 'ignore'
return header
def get_data(self):
return self.dataPack
def __init__(self, stdout):
dataPack = None
self.stdout = remove_empty_items(string_to_array(stdout))
# extract header from stdout
header = self.extract_header()
# extract special headers filename, playlist
header = self.set_filename_header(header)
header = self.set_playlist_header(header)
# extract data base on header
data = self.extract_data(header)
# extract special ignore header base on header, data
header = self.set_ignore_header(header, data)
# create data pack
self.dataPack = DataPack(header, data=data)
def extract_header(self):
header = self.stdout.pop(0).replace('[', '').replace(']', '')
return header
def extract_data(self, header):
''' Extract data base on header '''
if header == 'download':
if '%' in self.stdout[0]:
if self.stdout[0] != '100%':
''' size, percent, eta, speed '''
return [self.stdout[2], self.stdout[0], self.stdout[6], self.stdout[4]]
if header == 'playlist':
return [self.stdout[2], self.stdout[4]]
if header == 'filename':
return ' '.join(self.stdout[1:])
return None
def set_filename_header(self, header):
if header != 'ffmpeg':
if self.stdout[0] == 'Destination:':
return 'filename'
return header
def set_playlist_header(self, header):
if header == 'download':
if self.stdout[0] == 'Downloading' and self.stdout[1] == 'video':
return 'playlist'
return header
def set_ignore_header(self, header, data):
if header == 'download' and data == None:
return 'ignore'
return header
def get_data(self):
return self.dataPack

49
youtube_dl_gui/UpdateThread.py
View File

@ -18,28 +18,27 @@ PUBLISHER_TOPIC = 'update'
DOWNLOAD_TIMEOUT = 20 DOWNLOAD_TIMEOUT = 20
class UpdateThread(Thread): class UpdateThread(Thread):
def __init__(self, updatePath, youtubeDLFile):
super(UpdateThread, self).__init__()
self.youtubeDLFile = youtubeDLFile
self.updatePath = fix_path(updatePath)
self.url = LATEST_YOUTUBE_DL + youtubeDLFile
self.check_path()
self.start()
def run(self):
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, "Downloading latest youtube-dl. Please wait...")
try:
f = urlopen(self.url, timeout=DOWNLOAD_TIMEOUT)
with open(self.updatePath + self.youtubeDLFile, 'wb') as lf:
lf.write(f.read())
msg = 'Youtube-dl downloaded correctly'
except (HTTPError, URLError, IOError) as e:
msg = 'Youtube-dl download failed ' + str(e)
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, msg)
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, 'finish')
def check_path(self):
if not file_exist(self.updatePath):
makedir(self.updatePath)
def __init__(self, updatePath, youtubeDLFile):
super(UpdateThread, self).__init__()
self.youtubeDLFile = youtubeDLFile
self.updatePath = fix_path(updatePath)
self.url = LATEST_YOUTUBE_DL + youtubeDLFile
self.check_path()
self.start()
def run(self):
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, "Downloading latest youtube-dl. Please wait...")
try:
f = urlopen(self.url, timeout=DOWNLOAD_TIMEOUT)
with open(self.updatePath + self.youtubeDLFile, 'wb') as lf:
lf.write(f.read())
msg = 'Youtube-dl downloaded correctly'
except (HTTPError, URLError, IOError) as e:
msg = 'Youtube-dl download failed ' + str(e)
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, msg)
CallAfter(Publisher.sendMessage, PUBLISHER_TOPIC, 'finish')
def check_path(self):
if not file_exist(self.updatePath):
makedir(self.updatePath)

107
youtube_dl_gui/Utils.py
View File

@ -6,81 +6,80 @@ import locale
import subprocess import subprocess
def remove_empty_items(array): def remove_empty_items(array):
return [x for x in array if x != '']
return [x for x in array if x != '']
def remove_spaces(string): def remove_spaces(string):
return string.replace(' ', '')
return string.replace(' ', '')
def string_to_array(string, char=' '): def string_to_array(string, char=' '):
return string.split(char)
return string.split(char)
def preferredencoding(): def preferredencoding():
try:
pref = locale.getpreferredencoding()
u'TEST'.encode(pref)
except:
pref = 'UTF-8'
return pref
try:
pref = locale.getpreferredencoding()
u'TEST'.encode(pref)
except:
pref = 'UTF-8'
return pref
def get_encoding(): def get_encoding():
if sys.version_info >= (3, 0):
if sys.version_info >= (3, 0):
return None
if sys.platform == 'win32':
# Refer to http://stackoverflow.com/a/9951851/35070
return preferredencoding()
return None return None
if sys.platform == 'win32':
# Refer to http://stackoverflow.com/a/9951851/35070
return preferredencoding()
return None
def encode_list(data_list, encoding): def encode_list(data_list, encoding):
return [x.encode(encoding, 'ignore') for x in data_list]
return [x.encode(encoding, 'ignore') for x in data_list]
def video_is_dash(video): def video_is_dash(video):
return "DASH" in video
return "DASH" in video
def have_dash_audio(audio): def have_dash_audio(audio):
return audio != "NO SOUND"
return audio != "NO SOUND"
def remove_file(filename): def remove_file(filename):
os.remove(filename)
os.remove(filename)
def get_path_seperator(): def get_path_seperator():
return '\\' if os.name == 'nt' else '/'
return '\\' if os.name == 'nt' else '/'
def fix_path(path): def fix_path(path):
if path != '' and path[-1:] != get_path_seperator():
path += get_path_seperator()
return path
if path != '' and path[-1:] != get_path_seperator():
path += get_path_seperator()
return path
def get_HOME(): def get_HOME():
return os.path.expanduser("~")
return os.path.expanduser("~")
def add_PATH(path): def add_PATH(path):
os.environ["PATH"] += os.pathsep + path
os.environ["PATH"] += os.pathsep + path
def abs_path(path): def abs_path(path):
path_list = path.split(get_path_seperator())
for i in range(len(path_list)):
if path_list[i] == '~':
path_list[i] = get_HOME()
return get_path_seperator().join(path_list)
path_list = path.split(get_path_seperator())
for i in range(len(path_list)):
if path_list[i] == '~':
path_list[i] = get_HOME()
return get_path_seperator().join(path_list)
def file_exist(filename): def file_exist(filename):
return os.path.exists(filename)
return os.path.exists(filename)
def get_os_type(): def get_os_type():
return os.name
return os.name
def get_filesize(path): def get_filesize(path):
return os.path.getsize(path)
return os.path.getsize(path)
def makedir(path): def makedir(path):
os.makedirs(path)
os.makedirs(path)
def get_filename(path): def get_filename(path):
return path.split(get_path_seperator())[-1]
return path.split(get_path_seperator())[-1]
def open_dir(path): def open_dir(path):
if os.name == 'nt':
os.startfile(path)
else:
subprocess.call(('xdg-open', path))
if os.name == 'nt':
os.startfile(path)
else:
subprocess.call(('xdg-open', path))

2375
youtube_dl_gui/YoutubeDLGUI.py
File diff suppressed because it is too large
View File

319
youtube_dl_gui/YoutubeDLInterpreter.py
View File

@ -5,7 +5,7 @@ Parse OptionHandler object into list
and call youtube_dl.main(list) using and call youtube_dl.main(list) using
subprocess (we use this method to let subprocess (we use this method to let
youtube_dl.main() handle all the hard youtube_dl.main() handle all the hard
work)
work)
''' '''
from .Utils import ( from .Utils import (
@ -15,168 +15,167 @@ from .Utils import (
add_PATH add_PATH
) )
LANGUAGES = {"English":"en",
"Greek":"gr",
"Portuguese":"pt",
"French":"fr",
"Italian":"it",
"Russian":"ru",
"Spanish":"es",
"German":"de"}
LANGUAGES = {"English":"en",
"Greek":"gr",
"Portuguese":"pt",
"French":"fr",
"Italian":"it",
"Russian":"ru",
"Spanish":"es",
"German":"de"}
VIDEOFORMATS = {"default":"0", VIDEOFORMATS = {"default":"0",
"mp4 [1280x720]":"22",
"mp4 [640x360]":"18",
"webm [640x360]":"43",
"flv [400x240]":"5",
"3gp [320x240]":"36",
"mp4 1080p(DASH)":"137",
"mp4 720p(DASH)":"136",
"mp4 480p(DASH)":"135",
"mp4 360p(DASH)":"134"}
"mp4 [1280x720]":"22",
"mp4 [640x360]":"18",
"webm [640x360]":"43",
"flv [400x240]":"5",
"3gp [320x240]":"36",
"mp4 1080p(DASH)":"137",
"mp4 720p(DASH)":"136",
"mp4 480p(DASH)":"135",
"mp4 360p(DASH)":"134"}
DASH_AUDIO_FORMATS = {"NO SOUND":"None", DASH_AUDIO_FORMATS = {"NO SOUND":"None",
"DASH m4a audio 128k":"140",
"DASH webm audio 48k":"171"}
"DASH m4a audio 128k":"140",
"DASH webm audio 48k":"171"}
AUDIO_Q = {"high":"0", AUDIO_Q = {"high":"0",
"mid":"5",
"low":"9"}
"mid":"5",
"low":"9"}
class YoutubeDLInterpreter(): class YoutubeDLInterpreter():
def __init__(self, optionsList, youtubeDLFile):
self.youtubeDLFile = youtubeDLFile
self.optionsList = optionsList
self.opts = []
self.set_os()
self.set_progress_opts()
self.set_output_opts()
self.set_auth_opts()
self.set_connection_opts()
self.set_video_opts()
self.set_playlist_opts()
self.set_filesystem_opts()
self.set_subtitles_opts()
self.set_audio_opts()
self.set_other_opts()
def get_options(self):
return self.opts
def set_os(self):
if get_os_type() == 'nt':
self.opts = [self.youtubeDLFile]
add_PATH(self.optionsList.updatePath)
else:
path = fix_path(self.optionsList.updatePath)
self.opts = ['python', path + self.youtubeDLFile]
def set_progress_opts(self):
''' Do NOT change this option '''
self.opts.append('--newline')
def set_playlist_opts(self):
if self.optionsList.startTrack != 1:
self.opts.append('--playlist-start')
self.opts.append(str(self.optionsList.startTrack))
if self.optionsList.endTrack != 0:
self.opts.append('--playlist-end')
self.opts.append(str(self.optionsList.endTrack))
if self.optionsList.maxDownloads != 0:
self.opts.append('--max-downloads')
self.opts.append(str(self.optionsList.maxDownloads))
if self.optionsList.minFileSize != '0':
self.opts.append('--min-filesize')
self.opts.append(self.optionsList.minFileSize)
if self.optionsList.maxFileSize != '0':
self.opts.append('--max-filesize')
self.opts.append(self.optionsList.maxFileSize)
def set_auth_opts(self):
if self.optionsList.username != '':
self.opts.append('-u')
self.opts.append(self.optionsList.username)
if self.optionsList.password != '':
self.opts.append('-p')
self.opts.append(self.optionsList.password)
if self.optionsList.videoPass != '':
self.opts.append('--video-password')
self.opts.append(self.optionsList.videoPass)
def set_connection_opts(self):
if self.optionsList.retries != 10:
self.opts.append('-R')
self.opts.append(str(self.optionsList.retries))
if self.optionsList.proxy != '':
self.opts.append('--proxy')
self.opts.append(self.optionsList.proxy)
if self.optionsList.userAgent != '':
self.opts.append('--user-agent')
self.opts.append(self.optionsList.userAgent)
if self.optionsList.referer != '':
self.opts.append('--referer')
self.opts.append(self.optionsList.referer)
def set_video_opts(self):
if self.optionsList.videoFormat != 'default':
self.opts.append('-f')
if video_is_dash(self.optionsList.videoFormat):
vf = VIDEOFORMATS[self.optionsList.videoFormat]
af = DASH_AUDIO_FORMATS[self.optionsList.dashAudioFormat]
if af != 'None':
self.opts.append(vf+'+'+af)
else:
self.opts.append(vf)
else:
self.opts.append(VIDEOFORMATS[self.optionsList.videoFormat])
def set_filesystem_opts(self):
if self.optionsList.ignoreErrors:
self.opts.append('-i')
if self.optionsList.writeDescription:
self.opts.append('--write-description')
if self.optionsList.writeInfo:
self.opts.append('--write-info-json')
if self.optionsList.writeThumbnail:
self.opts.append('--write-thumbnail')
def set_subtitles_opts(self):
if self.optionsList.writeAllSubs:
self.opts.append('--all-subs')
if (self.optionsList.writeAutoSubs):
self.opts.append('--write-auto-sub')
if self.optionsList.writeSubs:
self.opts.append('--write-sub')
if self.optionsList.subsLang != 'English':
self.opts.append('--sub-lang')
self.opts.append(LANGUAGES[self.optionsList.subsLang])
if self.optionsList.embedSubs:
self.opts.append('--embed-subs')
def set_output_opts(self):
path = fix_path(self.optionsList.savePath)
self.opts.append('-o')
if self.optionsList.outputFormat == 'id':
self.opts.append(path + '%(id)s.%(ext)s')
elif self.optionsList.outputFormat == 'title':
self.opts.append(path + '%(title)s.%(ext)s')
elif self.optionsList.outputFormat == 'custom':
self.opts.append(path + self.optionsList.outputTemplate)
def set_audio_opts(self):
if self.optionsList.toAudio:
self.opts.append('-x')
self.opts.append('--audio-format')
self.opts.append(self.optionsList.audioFormat)
if self.optionsList.audioQuality != 'mid':
self.opts.append('--audio-quality')
self.opts.append(AUDIO_Q[self.optionsList.audioQuality])
if self.optionsList.keepVideo:
self.opts.append('-k')
def set_other_opts(self):
if self.optionsList.cmdArgs != '':
for option in self.optionsList.cmdArgs.split():
self.opts.append(option)
def __init__(self, optionsList, youtubeDLFile):
self.youtubeDLFile = youtubeDLFile
self.optionsList = optionsList
self.opts = []
self.set_os()
self.set_progress_opts()
self.set_output_opts()
self.set_auth_opts()
self.set_connection_opts()
self.set_video_opts()
self.set_playlist_opts()
self.set_filesystem_opts()
self.set_subtitles_opts()
self.set_audio_opts()
self.set_other_opts()
def get_options(self):
return self.opts
def set_os(self):
if get_os_type() == 'nt':
self.opts = [self.youtubeDLFile]
add_PATH(self.optionsList.updatePath)
else:
path = fix_path(self.optionsList.updatePath)
self.opts = ['python', path + self.youtubeDLFile]
def set_progress_opts(self):
''' Do NOT change this option '''
self.opts.append('--newline')
def set_playlist_opts(self):
if self.optionsList.startTrack != 1:
self.opts.append('--playlist-start')
self.opts.append(str(self.optionsList.startTrack))
if self.optionsList.endTrack != 0:
self.opts.append('--playlist-end')
self.opts.append(str(self.optionsList.endTrack))
if self.optionsList.maxDownloads != 0:
self.opts.append('--max-downloads')
self.opts.append(str(self.optionsList.maxDownloads))
if self.optionsList.minFileSize != '0':
self.opts.append('--min-filesize')
self.opts.append(self.optionsList.minFileSize)
if self.optionsList.maxFileSize != '0':
self.opts.append('--max-filesize')
self.opts.append(self.optionsList.maxFileSize)
def set_auth_opts(self):
if self.optionsList.username != '':
self.opts.append('-u')
self.opts.append(self.optionsList.username)
if self.optionsList.password != '':
self.opts.append('-p')
self.opts.append(self.optionsList.password)
if self.optionsList.videoPass != '':
self.opts.append('--video-password')
self.opts.append(self.optionsList.videoPass)
def set_connection_opts(self):
if self.optionsList.retries != 10:
self.opts.append('-R')
self.opts.append(str(self.optionsList.retries))
if self.optionsList.proxy != '':
self.opts.append('--proxy')
self.opts.append(self.optionsList.proxy)
if self.optionsList.userAgent != '':
self.opts.append('--user-agent')
self.opts.append(self.optionsList.userAgent)
if self.optionsList.referer != '':
self.opts.append('--referer')
self.opts.append(self.optionsList.referer)
def set_video_opts(self):
if self.optionsList.videoFormat != 'default':
self.opts.append('-f')
if video_is_dash(self.optionsList.videoFormat):
vf = VIDEOFORMATS[self.optionsList.videoFormat]
af = DASH_AUDIO_FORMATS[self.optionsList.dashAudioFormat]
if af != 'None':
self.opts.append(vf+'+'+af)
else:
self.opts.append(vf)
else:
self.opts.append(VIDEOFORMATS[self.optionsList.videoFormat])
def set_filesystem_opts(self):
if self.optionsList.ignoreErrors:
self.opts.append('-i')
if self.optionsList.writeDescription:
self.opts.append('--write-description')
if self.optionsList.writeInfo:
self.opts.append('--write-info-json')
if self.optionsList.writeThumbnail:
self.opts.append('--write-thumbnail')
def set_subtitles_opts(self):
if self.optionsList.writeAllSubs:
self.opts.append('--all-subs')
if (self.optionsList.writeAutoSubs):
self.opts.append('--write-auto-sub')
if self.optionsList.writeSubs:
self.opts.append('--write-sub')
if self.optionsList.subsLang != 'English':
self.opts.append('--sub-lang')
self.opts.append(LANGUAGES[self.optionsList.subsLang])
if self.optionsList.embedSubs:
self.opts.append('--embed-subs')
def set_output_opts(self):
path = fix_path(self.optionsList.savePath)
self.opts.append('-o')
if self.optionsList.outputFormat == 'id':
self.opts.append(path + '%(id)s.%(ext)s')
elif self.optionsList.outputFormat == 'title':
self.opts.append(path + '%(title)s.%(ext)s')
elif self.optionsList.outputFormat == 'custom':
self.opts.append(path + self.optionsList.outputTemplate)
def set_audio_opts(self):
if self.optionsList.toAudio:
self.opts.append('-x')
self.opts.append('--audio-format')
self.opts.append(self.optionsList.audioFormat)
if self.optionsList.audioQuality != 'mid':
self.opts.append('--audio-quality')
self.opts.append(AUDIO_Q[self.optionsList.audioQuality])
if self.optionsList.keepVideo:
self.opts.append('-k')
def set_other_opts(self):
if self.optionsList.cmdArgs != '':
for option in self.optionsList.cmdArgs.split():
self.opts.append(option)

19
youtube_dl_gui/__init__.py
View File

@ -3,11 +3,11 @@
from sys import exit from sys import exit
try: try:
import wx
import wx
except ImportError, e: except ImportError, e:
print '[ERROR]', e
print 'Please install latest wx.Python'
exit(1)
print '[ERROR]', e
print 'Please install latest wx.Python'
exit(1)
from .YoutubeDLGUI import MainFrame from .YoutubeDLGUI import MainFrame
from .version import __version__ from .version import __version__
@ -23,9 +23,8 @@ from .data import (
) )
def main(): def main():
app = wx.App()
frame = MainFrame()
frame.Centre()
frame.Show()
app.MainLoop()
app = wx.App()
frame = MainFrame()
frame.Centre()
frame.Show()
app.MainLoop()

1
youtube_dl_gui/__main__.py
View File

@ -12,4 +12,3 @@ import youtube_dl_gui
if __name__ == '__main__': if __name__ == '__main__':
youtube_dl_gui.main() youtube_dl_gui.main()
Write Preview
Loading…
Cancel
Save