def main():
with redirect_stdout(stdout_capture_streaming):
yt_uri = "8cOJhLM66D4"
yt_country = "FR"
argv = f"-f best --no-part --no-cache-dir -o /dev/null --newline --geo-bypass-country {yt_country} https://youtu.be/{yt_uri}"
youtube_dl.main(argv.split())
def setup_debug3():
try:
youtube_dl.main()
except:
wf(stackprinter.format(sys.exc_info()), 'logs/error.except.main3.log',
'a')
raise
def run(self):
self.download_status_bar.set_status(Status.PROCESSING)
self.download_status_bar.append_log('Start of `' + self.name + '`\n')
#Redirect ytdl stdout to a string FIXME android: redirect output somehow prevent downloads
if platform != 'android':
sys_stdout = sys.stdout
str_stdout = StringIO()
sys.stdout = str_stdout
try:
youtube_dl.main(self.ytdl_args)
except SystemExit: #ignore ytdl calls to sys.exit()
pass
except Exception: #ignore exception 'str' object has no attribute 'write'
pass
if platform != 'android':
#redirect back stedout to system stdout
sys.stdout = sys_stdout
log = str_stdout.getvalue() #TODO: get output every n seconds instead of waiting end of youtube_dl.main
self.download_status_bar.append_log(log)
self.download_status_bar.append_log('End of `' + self.name + '`\n')
self.download_status_bar.set_status(Status.DONE)
def download_entry(self, entry, config):
"""Calls Youtube-Dl with new config and fails the entry on error
Raises:
PluginError if operation fails
"""
# video URLs have to be the last items in the list
entry_config = list(config['ytdl-config'])
entry_config.append(entry['url'])
if entry.task.manager.options.test:
log.info('Would start Youtube-Dl with "%s"', entry_config)
return
log.debug('Starting Youtube-Dl with "%s"', entry_config)
try:
youtube_dl.main(entry_config)
except SystemExit as e:
if e.code != 0:
entry.fail('Youtube-Dl returned error code: %s' % str(e))
except Exception as e:
raise PluginError('Unknown error: %s' % str(e), log)
return
def getvid(url):
_u = urlparse(url)
# If yt, we can directly get the audio file from the video
if _u.netloc == 'www.youtube.com':
write('getvid', 'Is YT', True)
vidId = _u.query.split('v=')[1]
os.chdir('temp')
youtube_dl.main(['-x', vidId])
os.chdir('..')
elif _u.netloc == 'youtu.be':
write('getvid', 'Is YT', True)
vidId = _u.path[1:]
os.chdir('temp')
with youtube_dl.YoutubeDL() as ydl:
ydl.download([vidId])
os.chdir('..')
else:
# Oh boy
resp = requests.get(url)
page = BeautifulSoup(resp.text)
vids = page.select('video')
for i in vids:
src = i.attrs['src']
if src.startswith('blob:'):
# Impossible to handle sadly
pass
else:
_s = urlparse(src)
filename = _s.path.split('/')[-1]
os.chdir('temp')
with open(filename, 'w+') as f:
f.write(requests.get(src).content)
extractaudio.extract(filename, filename + '.mp3')
os.chdir('..')
def setup():
import sys
import os
sys.path.insert(0, '/Users/alberthan/VSCodeProjects/HDLogger')
hd_tracer = hdTracer(vars_to_watch)
oldout, olderr = sys.stdout, sys.stderr
sys.stdout = newout = io.StringIO()
sys.stderr = newerr = io.StringIO()
sys.settrace(hd_tracer.trace_dispatch)
try:
youtube_dl.main()
# except SystemExit as err:
# wf(stackprinter.format(err), 'logs/system_exit.expected_error.log', 'a')
# print('--- expected SystemExit: \x1b[1;32mSuccess\x1b[0m')
except:
wf(stackprinter.format(sys.exc_info()), 'logs/error.except.main.log',
'a')
raise
finally:
# hd_tracer.varswatcher.write_var_history()
output, error = newout.getvalue(), newerr.getvalue()
print(output)
wf(output, 'logs/stdout.finally.log', 'a')
wf(error, 'logs/stderr.finally.log', 'a')
return (inspect.currentframe(), globals(), locals())
def resolve(self, url, resolver):
if 'plugin://' in url: return
if not self.started: self.start()
self.info_dicts = []
stdout, stderr, exit = sys.stdout, sys.stderr, sys.exit
# prevent youtube_dl from shutting us down, discard stderr/stdout
sys.exit = self.noexit
sys.stderr = sys.stdout = self.devnull
# TODO: --cookies (https://github.com/rg3/youtube-dl/issues/41)
# --max-downloads (overuse triggers '402: Payment Required')
# v2015.04.26+: explicitly setting '-f best' to avoid new 'merged format' separate a/v urls
youtube_dl.main(['-s', '--no-playlist', '-f', 'best', url])
sys.stdout, sys.stderr, sys.exit = stdout, stderr, exit
if len(self.info_dicts) > 0:
# get the first result
i = self.info_dicts[0]
if i.get('url') is None and i.get('requested_formats') is not None:
# v 2014.12.10+ (shouldn't happen, but just in case)
req = info_dict.get('requested_formats')
if len(req) == 1:
i = req[0]
else:
raise 'Error: multiple "merged format" urls received'
# from pprint import pprint
# pprint(i)
details = {}
if 'http_headers' in i:
headers = {k:v for k,v in i['http_headers'].items() if not k.lower().startswith('accept')}
if headers:
details['headers'] = headers
resolver.add(i['url'] + i.get('play_path', ''), i.get('fulltitle'), i.get('thumbnail'),
details=details if details else None)
def run():
command = (f'youtube-dl '
f'-f {quality}[ext={ext}]/'
f'{quality}video+bestaudio/bestaudio '
f'--merge-output-format "{ext}" '
f'-o "{path}" '
f'{url}')
youtube_dl.main(shlex.split(command)[1:])
def youtube_dl_main_x(argv=None):
ytdl_common.sanitize_filename = ytdl_YoutubeDL.sanitize_filename = limit_len_sanitize_filename
ytdl_common.InfoExtractor = NewInfoExtractor
youtube_dl.extractor.GenericIE = GenericInfoExtractor
youtube_dl.extractor.IwaraIE = IwaraIE
youtube_dl.extractor.PornHubIE = PornHubIE
youtube_dl.extractor.XVideosIE = XVideosIE
youtube_dl.main(argv)
def run_youtube_dl(self, args):
# this is the only way to use the youtube-dl config file, if you
# directly pass the args to youtube_dl.main it doesn't read it
with unittest.mock.patch('sys.argv', ['youtube-dl'] + args):
try:
youtube_dl.main()
except SystemExit as err:
if err.code != 0:
raise YoutubeDLError(err.code)
def main():
print '\("`v")/ Start!'
URL = getBaseURL()
soup = getSoup(URL)
vimeoIDs = getVimeoId(soup)
VIMEO = 'http://vimeo.com/'
urls = map(lambda x: VIMEO + x, vimeoIDs)
ytdl_param = ['-t', '-A']
youtube_dl.main(ytdl_param + urls)
print '\("`v")/ END!'
def main():
print '\("`v")/ Start!'
URL = getBaseURL()
soup = getSoup(URL)
vimeoIDs = getVimeoId(soup)
VIMEO = 'http://vimeo.com/'
urls = map(lambda x: VIMEO+x,vimeoIDs)
ytdl_param = ['-t', '-A']
youtube_dl.main(ytdl_param+urls)
print '\("`v")/ END!'
def download():
print request.form.get("url")
link = request.form.get("url")
title = get_title()
try:
print os.path.join(UPLOAD_FOLDER,title)
youtube_dl.main(['-f', '85/84/83/82/38/37/22/18/120/35/34','-o',"/var/www/video/uploads/" + title + '.%(ext)s', link])
except: # messy hack - this triggers each time, but all seems to work ok. if omitted an exception is thrown
pass
title += ".mp4"
try:
return send_from_directory(UPLOAD_FOLDER, title, as_attachment=True)
except:
return render_template("index.html", failed=True)
def setup_hunter_call():
sys.path.insert(0, '/Users/alberthan/VSCodeProjects/HDLogger')
lines = io.StringIO()
try:
with hunter.trace(filename__contains="youtube",
action=hunter.CallPrinter(stream=lines)):
youtube_dl.main()
except:
wf(stackprinter.format(sys.exc_info()), 'logs/error.except.main.log',
'a')
raise
finally:
output = lines.getvalue()
wf(output, 'logs/huntercall.finally.log', 'a')
return (inspect.currentframe(), globals(), locals())
def resolve(self, url, resolver):
if 'plugin://' in url: return
if not self.started: self.start()
self.info_dicts = []
stdout, stderr, exit = sys.stdout, sys.stderr, sys.exit
# prevent youtube_dl from shutting us down, discard stderr/stdout
sys.exit = self.noexit
sys.stderr = sys.stdout = self.devnull
# TODO: --cookies (https://github.com/rg3/youtube-dl/issues/41)
# --max-downloads (overuse triggers '402: Payment Required')
youtube_dl.main(['-s', url])
sys.stdout, sys.stderr, sys.exit = stdout, stderr, exit
u = '\n'.join([(i['url'] + i.get('play_path', '')) for i in self.info_dicts])
if u:
i = self.info_dicts[0]
resolver.add(u, i.get('fulltitle'), i.get('thumbnail'))
async def ytlink(ctx, url: str):
#queue? make a list!
song_there = os.path.isfile("song.mp3")
try:
if song_there:
os.remove("song.mp3")
except Exception:
await ctx.send("uh.. something went really wrong")
return
songtitle = youtube_dl.main(url + '--get-title')
await ctx.send(songtitle)
voice = get(client.voice_clients, guild=ctx.guild)
ydl_opts = {
'format':
'bestaudio/best',
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'mp3',
'preferredquality': '192',
}],
}
with youtube_dl.YoutubeDL(ydl_opts) as ydl:
ydl.download([url])
for file in os.listdir("./"):
if file.endswith(".mp3"):
os.rename(file, 'song.mp3')
voice.play(discord.FFmpegPCMAudio("song.mp3"))
voice.volume = 100
voice.is_playing()
def downloader(download_queue):
# importing locally, this takes forever, while script is silent
import youtube_dl
while True:
url = download_queue.get(True)
pid = os.fork()
if not pid:
print('Downloading... ({})'.format(url))
youtube_dl.main(['--no-check-certificate', url.split()[-1]])
exit()
os.wait()
print('Download finished')
_a.makeToast('Finished: {}...'.format(url[:10]))
_a.vibrate(1000)
os.system('df .')
def downloadUrl(url, args, outputDir=os.path.join(home, "Music/Downloads")):
''' Fragment from here
http://stackoverflow.com/questions/18054500/how-to-use-youtube-dl-from-a-python-programm
'''
if not os.path.isdir(outputDir):
os.makedirs(outputDir)
outputFile = os.path.join(outputDir, '%(title)s-%(id)s.%(ext)s')
if "--playlist" not in args:
opts = ["-k", "-x", "-o", "{}".format(outputFile)
, "--audio-format", "mp3"
, "--no-playlist" ] + [ url ]
else:
print("[INFO] Downloading playlist from youtube.")
opts = ["-k", "-x", "-o", "{}".format(outputFile)
, "--audio-format", "mp3" ] + [ url ]
youtube_dl.main(opts)
def setup_debug():
import sys, os
sys.path.insert(0, '/Users/alberthan/VSCodeProjects/HDLogger')
hd_tracer = hdTracer()
sys.settrace(hd_tracer.trace_dispatch)
try:
youtube_dl.main()
# except SystemExit as err:
# wf(stackprinter.format(err), 'logs/system_exit.expected_error.log', 'a')
# print('--- expected SystemExit: \x1b[1;32mSuccess\x1b[0m')
except:
wf(stackprinter.format(sys.exc_info()), 'logs/error.except.main.log',
'a')
raise
finally:
# hd_tracer.varswatcher.write_var_history()
wf(output, 'logs/setup_debug.finally0.log', 'a')
return (inspect.currentframe(), globals(), locals())
def setup_debug2():
import sys, os
sys.path.insert(0, '/Users/alberthan/VSCodeProjects/HDLogger')
hd_tracer = hdTracer()
oldout, olderr = sys.stdout, sys.stderr
sys.stdout = newout = io.StringIO()
sys.stderr = newerr = io.StringIO()
sys.settrace(hd_tracer.trace_dispatch)
try:
youtube_dl.main()
except:
wf(stackprinter.format(sys.exc_info()), 'logs/error.except.main.log',
'a')
raise
finally:
output, error = newout.getvalue(), newerr.getvalue()
wf(output, 'logs/stdout.finally2.log', 'a')
wf(error, 'logs/stderr.finally2.log', 'a')
return (inspect.currentframe(), globals(), locals())
def downloadUrl(url, args, outputDir=os.path.join(home, "Music/Downloads")):
''' Fragment from here
http://stackoverflow.com/questions/18054500/how-to-use-youtube-dl-from-a-python-programm
'''
if not os.path.isdir(outputDir):
os.makedirs(outputDir)
outputFile = os.path.join(outputDir, '%(title)s-%(id)s.%(ext)s')
if "--playlist" not in args:
opts = [
"-k", "-x", "-o", "{}".format(outputFile), "--audio-format", "mp3",
"--no-playlist"
] + [url]
else:
print("[INFO] Downloading playlist from youtube.")
opts = [
"-k", "-x", "-o", "{}".format(outputFile), "--audio-format", "mp3"
] + [url]
youtube_dl.main(opts)
def resolve(self, url, resolver):
if 'plugin://' in url: return
if not self.started: self.start()
self.info_dicts = []
stdout, stderr, exit = sys.stdout, sys.stderr, sys.exit
# prevent youtube_dl from shutting us down, discard stderr/stdout
sys.exit = self.noexit
sys.stderr = sys.stdout = self.devnull
# TODO: --cookies (https://github.com/rg3/youtube-dl/issues/41)
# --max-downloads (overuse triggers '402: Payment Required')
# v2015.04.26+: explicitly setting '-f best' to avoid new 'merged format' separate a/v urls
youtube_dl.main(['-s', '--no-playlist', '-f', 'best', url])
sys.stdout, sys.stderr, sys.exit = stdout, stderr, exit
if len(self.info_dicts) > 0:
# get the first result
i = self.info_dicts[0]
if i.get('url') is None and i.get('requested_formats') is not None:
# v 2014.12.10+ (shouldn't happen, but just in case)
req = info_dict.get('requested_formats')
if len(req) == 1:
i = req[0]
else:
raise 'Error: multiple "merged format" urls received'
# from pprint import pprint
# pprint(i)
details = {}
if 'http_headers' in i:
headers = {
k: v
for k, v in i['http_headers'].items()
if not k.lower().startswith('accept')
}
if headers:
details['headers'] = headers
resolver.add(i['url'] + i.get('play_path', ''),
i.get('fulltitle'),
i.get('thumbnail'),
details=details if details else None)
def dispatch(path, videos):
"""
@param path unicode
@param videos [str]
@return bool
"""
dprint("enter")
import youtube_dl
oname = os.path.join(path, '%(title)s.%(ext)s')
argv = [
'-o',
oname,
None, # vid
#'--restrict-filenames',
]
ret = []
for vid in videos:
argv[-1] = vid
try:
youtube_dl.main(argv)
except SystemExit, e:
dprint("exit code = %s" % e.code)
ret.append(e.code)
def ydl_main():
from youtube_dl import main
main()
def get_videos():
opts = [
"-o", "./Videos/%(title)s.%(ext)s",
"https://www.youtube.com/playlist?list=PLD63A284B7615313A"
]
youtube_dl.main(opts)
import feedparser import sys import urlparse import youtube_dl print 'Olls Youtube Subscription Downloader' feedUrl = 'http://gdata.youtube.com/feeds/api/users/' + sys.argv[1] + '/uploads?max-results=1&alt=rss&orderby=published' print 'Feed URL: ' + feedUrl + '\n' feed = feedparser.parse(feedUrl) videoLink = feed['entries'][0]['links'][0]['href'] print 'Video Link: ' + videoLink + '\n' youtube_dl.main(videoLink)
self.buff = ''
self.__console__ = sys.stdout
def write(self, outstream):
self.buff += outstream
def flush(self):
''
def get_data(self):
return self.buff
def reset(self):
sys.stdout = self.__console__
def get_play_url(id):
r_obj = my_print()
sys.stdout = r_obj
youtube_dl.main([u'-j', id])
r_obj.reset()
return r_obj.get_data()
if __name__ == '__main__':
# print get_play_url(u'http://www.ted.com/talks/r_luke_dubois_insightful_human_portraits_made_from_data')
youtube_dl.main([
sys.argv[1], '-j', '--no-check-certificate',
'--youtube-skip-dash-manifest', '--restrict-filenames'
])
def download(vids, what):
if (what == 'video'):
vid = vids[0]
print(vid)
ydl = youtube_dl.YoutubeDL({'outtmpl': '%(id)s%(ext)s'})
with ydl:
result = ydl.extract_info(
vid,
download=False # We just want to extract the info
)
video = result
# print(video)
# print(json.dumps(video, indent = 2))
print('---------------------------\n')
print(video['title'])
count = 1
choices = {}
audio = 1000
for v_format in video['formats']:
# print(v_format['format'] + " " + v_format['ext'])
f = v_format['format'].split(' - ')[0]
first_word = v_format['format'].split()[2]
if (first_word == 'audio'):
audio = min(audio, int(f))
continue
# print(first_word)
# print(f)
try:
print('{}. {} - {} ({}MB)'.format(
count, v_format['format'].split(' - ')[1], v_format['ext'],
float(v_format['filesize']) / 1000000))
except:
print('{}. {} - {}'.format(count,
v_format['format'].split(' - ')[1],
v_format['ext']))
choices[str(count)] = [f, first_word]
count += 1
# print(choices)
choice = input(': ')
if (not (re.match(r'^([0-9]+)$', str(choice)) and int(choice) >= 1
and int(choice) <= int(count - 1))):
choice = str(count - 1)
opt = [
'-cif',
str(choices[choice][0] + '+' + str(audio)), '-o',
'%(title)s.%(ext)s', vid
]
youtube_dl.main(opt)
else:
# ydl = youtube_dl.YoutubeDL({'outtmpl': '%(id)s%(ext)s'})
# with ydl:
# result = ydl.extract_info(
# vid,
# download=False # We just want to extract the info
# )
# video = result
# # print(video)
# # print(json.dumps(video, indent = 2))
# print(video['title'])
# # print('----------------------')
# for v_format in video['formats']:
# # print(v_format['format'] + " " + v_format['ext'])
# f = v_format['format'].split(' - ')[0]
# first_word = v_format['format'].split()[2]
# if(first_word == 'audio'):
# opt = ['-f', f, vid]
# youtube_dl.main(opt)
opt = [
'--extract-audio', '--audio-format', 'mp3', '-o',
'%(title)s.%(ext)s'
]
for v in vids:
opt.append(v)
youtube_dl.main(opt)
def main():
options = {
'url': '',
'file_format': 'mp3',
'audio_only': True,
'no_md': False,
'no_smart_md': False,
'no_dl': False,
'verbose': False,
'download_folder': config.get_config('download_folder'),
'output_template': config.get_config('output_template'),
}
video_formats = ['mp4']
audio_formats = ['mp3', 'wav', 'm4a']
id3_metadata_formats = ['mp3']
ytdl_output_template = os.path.join(options['download_folder'],
options['output_template'])
# parse arguments
for arg in sys.argv[1:]:
if arg in audio_formats:
options['audio_only'] = True
options['file_format'] = arg
elif arg in video_formats:
options['audio_only'] = False
options['file_format'] = arg
elif arg in ['--no-md']:
options['no_md'] = True
elif arg in ['--no-smart-md']:
options['no_smart_md'] = True
elif arg in ['--no-dl']:
options['no_dl'] = True
elif arg in ['-v', '--verbose']:
options['verbose'] = True
elif '.' in arg:
parsed_url = urlparse(arg)
url = arg
if (parsed_url.scheme == ''): url = 'https://' + url
print(url)
options['url'] = url
else:
log.fatal('Unknown argument:', arg)
if options['url'] == '':
log.fatal('No URL provided')
# get info
log('Fetching URL info')
ytdl_get_info_options = {
'outtmpl': ytdl_output_template,
'quiet': False if options['verbose'] else True,
}
with youtube_dl.YoutubeDL(ytdl_get_info_options) as ytdl:
try:
info_result = ytdl.extract_info(options['url'], download=False)
except Exception as err:
if options['verbose']: logging.exception(err)
log.fatal('youtube-dl failed to get URL info')
if options['verbose']: log.pretty(info_result)
# delete None properties/indexes
def callback(value):
return value != None
cleaned_info_result = deep_filter(copy.deepcopy(info_result), callback)
# restructure
url_info = copy.deepcopy(cleaned_info_result)
if 'entries' in cleaned_info_result:
videos = cleaned_info_result['entries']
playlist_info = copy.deepcopy(cleaned_info_result)
del playlist_info['entries']
else:
videos = [cleaned_info_result]
playlist_info = {}
# generate ytdl arguments
ytdl_args = []
if options['audio_only']:
ytdl_args += ['-x']
ytdl_args += ['-f', 'best']
ytdl_args += ['--audio-format', options['file_format']]
else:
ytdl_args += ['-f', 'bestvideo+bestaudio']
ytdl_args += ['--recode-video', options['file_format']]
ytdl_args += ['--audio-quality', '0']
ytdl_args += ['-o', ytdl_output_template]
if options['file_format'] in ['mp3', 'm4a', 'mp4']:
ytdl_args += ['--embed-thumbnail']
if not options['verbose']:
ytdl_args += ['--quiet']
# band-aid solution for 403 error caused by cache
ytdl_args += ['--rm-cache-dir']
video_index = -1
first_video_artist = ''
errors = []
for video in videos:
video_index += 1
try:
filename = ytdl.prepare_filename(video)
except (Exception, SystemExit) as err:
if options['verbose']: logging.exception(err)
error_msg = 'Failed to generate a filename for URL: ' + green(
video['webpage_url'])
if len(videos) == 1: log.fatal(error_msg)
log.error(error_msg)
errors.append(video)
continue
filename_split = filename.split('.')
filename_split[len(filename_split) - 1] = options['file_format']
filename = '.'.join(filename_split)
if options['verbose']:
# print youtube-dl command:
command = green('youtube-dl command: ') + 'youtube-dl '
for arg in ytdl_args + [video['webpage_url']]:
if ' ' in arg or '&' in arg: command += "'" + arg + "' "
else: command += arg + ' '
log(command)
if options['no_dl']:
continue
log('Downloading')
# download
try:
youtube_dl.main(ytdl_args + [video['webpage_url']])
except (Exception, SystemExit) as err:
if type(err) == SystemExit and err.code == 0:
# don't treat sys.exit(0) as error
pass
else:
if options['verbose']: logging.exception(err)
error_msg = 'Failed to download URL: ' + green(
video['webpage_url'])
if len(videos) == 1: log.fatal(error_msg)
log.error(error_msg)
errors.append(video)
continue
log('Saved as', filename)
# id3 tags
if options['file_format'] in id3_metadata_formats and not options[
'no_md']:
log('Adding metadata to file')
# get artist/title from title
parsed_title = {}
if not options['no_smart_md']:
if 'title' in video and video['title'].count(' - ') == 1:
split_title = video['title'].split(' - ')
parsed_title['artist'] = split_title[0]
parsed_title['title'] = split_title[1]
md = {}
playlist = True if len(videos) > 1 else False
# smart title
if 'title' in parsed_title:
smart_title = True
else:
smart_title = False
# title
if 'title' in video:
md['title'] = video['title']
elif 'track' in video:
md['title'] = video['track']
# smart artist
if 'artist' in parsed_title:
smart_artist = True
else:
smart_artist = False
# artist
if 'uploader' in video:
md['artist'] = video['uploader']
elif 'artist' in video:
md['artist'] = video['artist']
# youtube music artist
if video['extractor'] == 'youtube' \
and video['uploader'].endswith(' - Topic') \
and 'artist' in video:
if 'categories' not in video:
md['artist'] = video['artist']
elif video['categories'] == ['Music']:
md['artist'] = video['artist']
use_first_video_artist = False
if playlist:
#album
if 'title' in playlist_info:
md['album'] = playlist_info['title']
elif 'playlist_title' in video:
md['album'] = video['playlist_title']
elif 'playlist' in video and type(video['playlist']) == str:
md['album'] = video['playlist']
#album_artist
if 'uploader' in playlist_info:
md['album_artist'] = playlist_info['uploader']
elif 'playlist_uploader' in video:
md['album_artist'] = video['playlist_uploader']
else:
use_first_video_artist = True
# track_number
if 'playlist_index' in video:
md['track_number'] = video['playlist_index']
else:
md['track_number'] = video_index + 1
# track_count
if 'n_entries' in video:
md['track_count'] = video['n_entries']
else:
md['track_count'] = len(videos)
# year
def is_int(number):
try:
int(number)
return True
except ValueError:
return False
if 'release_date' in video and is_int(video['release_date'][:4]):
md['year'] = video['release_date'][:4]
elif 'publish_date' in video and is_int(video['publish_date'][:4]):
md['year'] = video['publish_date'][:4]
elif 'upload_date' in video and is_int(video['upload_date'][:4]):
md['year'] = video['upload_date'][:4]
dumb_md = copy.deepcopy(md)
if smart_title: md['title'] = parsed_title['title']
if smart_artist: md['artist'] = parsed_title['artist']
if playlist:
# save artist of first video
if video_index == 0 and 'artist' in md:
first_video_artist = md['artist']
# use first video's artist as album artist if no other is found
if use_first_video_artist:
md['album_artist'] = first_video_artist
md = config.user_md_parser(md, dumb_md, video, url_info)
md_module.add_metadata(filename, md)
if len(errors) >= 1:
msg = 'There were errors when downloading the following URLs:'
for video in errors:
msg += f'\n- {green(video["webpage_url"])}: {video["uploader"]} - {video["title"]}'
log.fatal(msg)
log('Done')
import youtube_dl title = "test" link = "http://www.youtube.com/watch?v=a1Y73sPHKxw" #print(youtube_dl.main(['-f', '85/84/83/82/38/37/22/18/120/35/34','-o','/home/gareth/video/uploads/' + title + '.%(ext)s', link, '-s', '--get-filename'])) #youtube_dl.main([link, '--all-format', '--get-filename', '--get-format']) print "-----------------" print (youtube_dl.main([link, '--all-format', '--get-format'])) print (12345)
#!/usr/bin/env python
# install youtube_dl and fake ctypes in lib/python2.7/site-packages
import os
import youtube_dl
import androidhelper
print "trying to retrieve from clipboard"
try:
os.chdir("/mnt/sdcard/Download")
except:
print "failed chdir /mnt/sdcard/Download"
print "working in", os.getcwd()
the_url = androidhelper.Android().getClipboard().result
the_url = the_url.split()[-1]
if __name__ == "__main__":
youtube_dl.main(["--format", "m4a", the_url])
def download_meiju_episode(self, collector, meiju_ename, season_id, episode_id, save_folder_path):
# Check whether collector instance invalid
if collector is None:
logger.error("Collector instance is None")
return
# Check whether invalid input parameter
if save_folder_path is None or len(save_folder_path) == 0:
logger.error("Invalid folder path")
return
# Check whether need to create dir
if not os.path.exists(save_folder_path):
os.makedirs(save_folder_path)
logger.debug("Create directory %s" % save_folder_path)
# Check whether dir contains the Meiju folder
if save_folder_path.find(meiju_ename.replace(" ", "_")) == -1:
save_folder_path = os.path.join(save_folder_path, meiju_ename.replace(" ", "_"))
if not os.path.exists(save_folder_path):
os.makedirs(save_folder_path)
# Check whether dir contains Season folder
if save_folder_path.find("Season"+str(season_id)) == -1:
save_folder_path = os.path.join(save_folder_path, "Season"+str(season_id))
if not os.path.exists(save_folder_path):
os.makedirs(save_folder_path)
# Check whether download file already exists
output_file_name = "Season" + str(season_id) + "Ep" + str(episode_id) + ".mp4"
output_file_path = os.path.join(os.path.abspath(save_folder_path), output_file_name)
if os.path.exists(output_file_path):
logger.debug("File %s already exists, no need to download" % output_file_path)
return
# Get episode instace
if meiju_ename in collector.meiju_ename_inst_dict:
meiju_inst = collector.meiju_ename_inst_dict[meiju_ename]
if season_id in meiju_inst.season_id_inst_dict:
season_inst = meiju_inst.season_id_inst_dict[season_id]
if episode_id in season_inst.episode_id_inst_dict:
episode_inst = season_inst.episode_id_inst_dict[episode_id]
episode_url = episode_inst.url
cookiejar = CookieJar()
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookiejar))
values = {"log": "us02",
"pwd": "0000",
"redirect_to": episode_url,
"a": "login",
"Submit": "%E7%99%BB%E5%85%A5"}
data = urllib.urlencode(values)
response = opener.open(episode_url, data)
response_str = response.read()
soup = BeautifulSoup(response_str.replace("\n",""), "html.parser")
# First we lookup videomega first
iframe_tag_list = soup.find_all("iframe", src=re.compile("videomega"))
if len(iframe_tag_list) != 0:
for iframe_tag in iframe_tag_list:
urlstr = iframe_tag["src"][:iframe_tag["src"].find("&")]
logger.debug("Videomega URL: %s" % urlstr)
logger.debug("Save to file %s" % output_file_path)
# Sometimes when iframe tag is under script tag, BeautifulSoup cannot parse it
else:
pattern = r"src=\"(http:\/\/videomega.tv\/view.php\?ref=.+)\""
regex = re.compile(pattern)
match = regex.search(response_str)
urlstr = match.group(1)[:match.group(1).find("&")]
logger.debug("Videomega URL: %s" % urlstr)
logger.debug("Save to file %s" % output_file_path)
# If there is part file, first we backup it
part_file_path = output_file_path + ".part"
if os.path.exists(part_file_path):
shutil.copyfile(part_file_path, part_file_path + ".bak")
# Use youtube-dl to download the video
argv = ["-o", unicode(output_file_path), urlstr]
try:
youtube_dl.main(argv)
# If download completes, we need to check the file size to decide whether succeed
file_size = os.path.getsize(output_file_path)
# If file size less than 1M, just remove the file and recover the part file
if file_size < 1000000:
os.remove(output_file_path)
if os.path.exists(part_file_path + ".bak"):
shutil.move(part_file_path + ".bak", part_file_path)
# If file size is ok, we just remove the part backup file
else:
if os.path.exists(part_file_path + ".bak"):
os.remove(part_file_path + ".bak")
except:
logger.error("Error downloading the video")
# Remove the backup of part file
if os.path.exists(part_file_path + ".bak"):
os.remove(part_file_path + ".bak")
else:
logger.error("Failed to lookup Episode instance with Episode Id %d" % episode_id)
return
else:
logger.error("Failed to lookup Season instance with Season Id %d" % season_id)
return
else:
logger.error("Failed to lookup Meiju with English name %s" % meiju_ename)
return
def youtube_dl(options):
try:
yt.main(options)
except SystemExit as e: # yt.main calls sys.exit
if e.code != 0:
raise e
#! /usr/bin/env python
from youtube_dl import main
from sys import argv
if __name__ == '__main__':
url = "https://www.youtube.com/playlist?list=PLdN-rWQpN5Rp5OCjOQsR4RR8Kz7EQAFKy"
user = "******"
if argv[1] == "--music":
cmd = [
"--yes-playlist", "-o", "~/Zene/%(title)s.%(ext)s",
"--username={}".format(user), "-x", url
]
else:
cmd = [
"--yes-playlist", "-o", "~/Videók/%(title)s.%(ext)s",
"--username={}".format(user), url
]
main(cmd)
#!/usr/bin/env python
import youtube_dl
DOWNLOAD_DIR = '/media/NETCODE-VIDEOS/%(title)s.%(ext)s'
with open('urls.txt', 'w+') as urls:
with open('links.csv', 'r') as f:
for line in f:
print line
if 'link,title' in line:
print "link,title"
continue
url='http://player.vimeo.com/video/{id}\n'.format(id=line.split(',')[0])
print url
urls.write(url)
youtube_dl.main([url,'-a', 'urls.txt', '-o', DOWNLOAD_DIR])
os.chdir(target)
pending = glob.glob('*.part')
if not pending:
print('---\nNo pending files.')
exit()
print('---\nFound {} pending files:\n---'.format(len(pending)))
print('\n---\n'.join(pending))
os.system('df .')
start = time.time()
print('Importing youtube_dl...')
import youtube_dl
print('Done in {:.1f} s'.format(time.time() - start))
android = androidhelper.Android()
for pending_file in pending:
the_url = pending_file[:-5]
filename, _ = os.path.splitext(the_url)
the_url = filename[-11:]
print('---\nTo download: {}\n---'.format(the_url))
if not os.fork():
youtube_dl.main(['--no-check-certificate', the_url])
os.wait()
os.system('df .')
android.vibrate(1000)
print('---')
#!/usr/bin/env python
# install youtube_dl and fake ctypes in lib/python2.7/site-packages
import os
import youtube_dl
import androidhelper
print "trying to retrieve from clipboard"
try:
os.chdir('/mnt/sdcard/Download')
except:
print 'failed chdir /mnt/sdcard/Download'
print 'working in', os.getcwd()
the_url = androidhelper.Android().getClipboard().result
the_url = the_url.split()[-1]
if __name__ == '__main__':
youtube_dl.main([the_url])
def get_videos():
opts = ["-o", "./Videos/%(title)s.%(ext)s",
"https://www.youtube.com/playlist?list=PLD63A284B7615313A"]
youtube_dl.main(opts)
def inicio():
try:
raise ValueError #gera um erro para acessar o except
except ValueError:
print("pegamos uma excessão")
def teste():
try:
numeroteste = int(input("digite um numero entre 0 e 10: "))
if 0 < numeroteste > 10:
raise MeuErro
else:
print(f"deu tudo certo, o numero escolhido foi {numeroteste}")
except MeuErro:
print(f"entrada invalida!{numeroteste}")
class MeuErro(Exception):
def __str__(self):
return "numero já digitado!"
teste()
raise MeuErro
if __name__ == "__main__":
main()
target = os.path.dirname(__file__) + '/../../Download'
try:
os.chdir(target)
except OSError:
print('failed changing directory:', target)
exit()
os.system('df .')
android = androidhelper.Android()
if not android.checkWifiState().result:
print('Not on WiFi, exiting.')
exit()
the_url = android.getClipboard().result
the_url = the_url.split()[-1]
def after_download():
os.system('df .')
android.vibrate(2000)
atexit.register(after_download)
print('Starting download of: ' + the_url)
import youtube_dl
youtube_dl.main(['--no-check-certificate', '--format', 'm4a', the_url])
def get_play_url(id):
r_obj = my_print()
sys.stdout = r_obj
youtube_dl.main([u'-j', id])
r_obj.reset()
return r_obj.get_data()
#!/usr/bin/env python
from __future__ import unicode_literals
# Execute with
# $ python youtube_dl/__main__.py (2.6+)
# $ python -m youtube_dl (2.7+)
import sys
if __package__ is None and not hasattr(sys, "frozen"):
# direct call of __main__.py
import os.path
path = os.path.realpath(os.path.abspath(__file__))
sys.path.insert(0, os.path.dirname(os.path.dirname(path)))
import youtube_dl
if __name__ == '__main__':
youtube_dl.main()
import os, sys, io, pathlib, subprocess
from PyQt5 import uic
from PyQt5.QtWidgets import QApplication, QFileDialog
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import pyqtSlot, pyqtSignal, QRunnable, QObject, QThreadPool
import youtube_dl
# if this script was called with the youtube-dl module, we need to run that
_expect_mod = False
for index, arg in enumerate(sys.argv):
if arg == "-m":
_expect_mod = True
if _expect_mod:
if arg == "youtube_dl":
# run youtube-dl with remaining args
youtube_dl.main(sys.argv[index+1:])
exit()
class DownloadSignals(QObject):
"""Possible signals from a DownloadWorker"""
finished = pyqtSignal(int)
message = pyqtSignal(str)
ready = pyqtSignal(str)
class DownloadWorker(QRunnable):
'''
Worker thread for downloading the youtube video. By running the
subprocess in a separate thread, the PyQt5 will not hang.
'''
signals = DownloadSignals()
