def download_metadata(self, url: str, process_ie_data: bool):
self._cache.clean()
cache_key = f"{url}{process_ie_data}"
cached_data = self._cache.get(cache_key)
self._logger.debug(
"Downloading metadata", url=url, cached=cached_data is not None
)
if cached_data:
return cached_data
options = {
# Allow getting the _type value set to URL when passing a playlist entry
"noplaylist": True,
"extract_flat": False,
# Causes ydl to return None on error
"ignoreerrors": True,
"quiet": True,
"progress_hooks": [],
}
ydl = YoutubeDL(options)
with ydl:
try:
metadata = ydl.extract_info(
url, download=False, process=process_ie_data
)
self._cache.register(cache_key, metadata)
return metadata
except Exception as e:
self._logger.error("Downloading metadata error", url=url, error=e)
return None
def zap(session, service, **kwargs):
errormsg = None
if service and "http" in service.toString():
url = service.toString()
url = url.split(":")
if len(url) > 9:
url = url[10]
if YoutubeDL is not None and url.startswith("YT-DLP%3a//"):
url = url.replace("YT-DLP%3a//", "")
url = url.replace("%3a", ":")
try:
ydl = YoutubeDL({"format": "b", "no_color": True})
result = ydl.extract_info(url, download=False)
result = ydl.sanitize_info(result)
if result and result.get("url"):
url = result["url"]
print("[ChannelSelection] zap / YoutubeDLP result url %s" % url)
return (url, errormsg)
else:
errormsg = "No Link found!"
print("[ChannelSelection] zap / YoutubeDLP no streams")
except Exception as e:
errormsg = str(e)
print("[ChannelSelection] zap / YoutubeDLP failed %s" % str(e))
pass
return (None, errormsg)
def test_post_hooks(self):
self.params['post_hooks'] = [self.hook_one, self.hook_two]
ydl = YoutubeDL(self.params)
ydl.download([TEST_ID])
self.assertEqual(self.stored_name_1, EXPECTED_NAME,
'Not the expected name from hook 1')
self.assertEqual(self.stored_name_2, EXPECTED_NAME,
'Not the expected name from hook 2')
def test_proxy_with_idn(self):
ydl = YoutubeDL({
'proxy': f'127.0.0.1:{self.port}',
})
url = 'http://中文.tw/'
response = ydl.urlopen(url).read().decode()
# b'xn--fiq228c' is '中文'.encode('idna')
self.assertEqual(response, 'normal: http://xn--fiq228c.tw/')
def test_nocheckcertificate(self):
ydl = YoutubeDL({'logger': FakeLogger()})
self.assertRaises(Exception, ydl.extract_info,
'https://127.0.0.1:%d/video.html' % self.port)
ydl = YoutubeDL({'logger': FakeLogger(), 'nocheckcertificate': True})
r = ydl.extract_info('https://127.0.0.1:%d/video.html' % self.port)
self.assertEqual(r['entries'][0]['url'],
'https://127.0.0.1:%d/vid.mp4' % self.port)
def test_unicode_path_redirection(self):
# XXX: Python 3 http server does not allow non-ASCII header values
if sys.version_info[0] == 3:
return
ydl = YoutubeDL({'logger': FakeLogger()})
r = ydl.extract_info('http://127.0.0.1:%d/302' % self.port)
self.assertEqual(r['entries'][0]['url'],
'http://127.0.0.1:%d/vid.mp4' % self.port)
def test_format_note(self):
ydl = YoutubeDL()
self.assertEqual(ydl._format_note({}), '')
assertRegexpMatches(self, ydl._format_note({
'vbr': 10,
}), r'^\s*10k$')
assertRegexpMatches(self, ydl._format_note({
'fps': 30,
}), r'^30fps$')
def _run_test(self, **params):
ydl = YoutubeDL({
'logger': FakeLogger(),
# Disable client-side validation of unacceptable self-signed testcert.pem
# The test is of a check on the server side, so unaffected
'nocheckcertificate': True,
**params,
})
r = ydl.extract_info('https://127.0.0.1:%d/video.html' % self.port)
self.assertEqual(r['entries'][0]['url'],
'https://127.0.0.1:%d/vid.mp4' % self.port)
def test_proxy(self):
geo_proxy = f'127.0.0.1:{self.geo_port}'
ydl = YoutubeDL({
'proxy': f'127.0.0.1:{self.port}',
'geo_verification_proxy': geo_proxy,
})
url = 'http://foo.com/bar'
response = ydl.urlopen(url).read().decode()
self.assertEqual(response, f'normal: {url}')
req = urllib.request.Request(url)
req.add_header('Ytdl-request-proxy', geo_proxy)
response = ydl.urlopen(req).read().decode()
self.assertEqual(response, f'geo: {url}')
def test_proxy(self):
geo_proxy = '127.0.0.1:{0}'.format(self.geo_port)
ydl = YoutubeDL({
'proxy': '127.0.0.1:{0}'.format(self.port),
'geo_verification_proxy': geo_proxy,
})
url = 'http://foo.com/bar'
response = ydl.urlopen(url).read().decode('utf-8')
self.assertEqual(response, 'normal: {0}'.format(url))
req = compat_urllib_request.Request(url)
req.add_header('Ytdl-request-proxy', geo_proxy)
response = ydl.urlopen(req).read().decode('utf-8')
self.assertEqual(response, 'geo: {0}'.format(url))
def init():
global ydl, log_file
ydl_opts = {
'continuedl': True,
'outtmpl': {
'default': '%(title)s-%(id)s.%(ext)s'
},
'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]',
'noplaylist': True
}
ydl = YoutubeDL(ydl_opts)
ydl.add_default_info_extractors()
log_file = open("log.txt", "a")
os.chdir(VID_PATH)
def get_url(self) -> None:
"""
Getting the youtube direct link with yt-dlp, intended to be used
with a QThread. It's guaranteed that either a success signal or a
fail signal will be emitted.
"""
with YoutubeDL(self.options) as ytdl:
try:
data = ytdl.extract_info(self.query, download=False)
except Exception as e:
# Any kind of error has to be caught, so that it doesn't only
# send the error signal when the download wasn't successful
# (a DownloadError from yt_dlp).
logging.info("yt-dlp wasn't able to obtain the video: %s",
str(e))
self.fail.emit()
else:
if len(data['entries']) == 0:
logging.info("yt-dlp returned no entries")
self.fail.emit()
else:
self.success.emit(data)
finally:
self.finish.emit()
def extractMetaData(self, link, qual, name):
if "hotstar" in link or "sonyliv" in link:
self.opts['geo_bypass_country'] = 'IN'
with YoutubeDL(self.opts) as ydl:
try:
result = ydl.extract_info(link, download=False)
if name == "":
name = ydl.prepare_filename(result)
else:
name = name
# noobway hack for changing extension after converting to mp3
if qual == "audio":
name = name.replace(".mp4", ".mp3").replace(".webm", ".mp3")
except DownloadError as e:
self.onDownloadError(str(e))
return
if result.get('direct'):
return None
if 'entries' in result:
video = result['entries'][0]
for v in result['entries']:
if v and v.get('filesize'):
self.size += float(v['filesize'])
# For playlists, ydl.prepare-filename returns the following format: <Playlist Name>-<Id of playlist>.NA
self.name = name.split(f"-{result['id']}")[0]
self.vid_id = video.get('id')
self.is_playlist = True
else:
video = result
if video.get('filesize'):
self.size = float(video.get('filesize'))
self.name = name
self.vid_id = video.get('id')
return video
def extractMetaData(self, link, name, get_info=False):
if get_info:
self.opts['playlist_items'] = '0'
with YoutubeDL(self.opts) as ydl:
try:
result = ydl.extract_info(link, download=False)
if get_info:
return result
realName = ydl.prepare_filename(result)
except DownloadError as e:
if get_info:
raise e
self.__onDownloadError(str(e))
return
if 'entries' in result:
for v in result['entries']:
try:
self.size += v['filesize_approx']
except (KeyError, TypeError):
pass
self.is_playlist = True
if name == "":
self.name = str(realName).split(f" [{result['id']}]")[0]
else:
self.name = name
else:
ext = realName.split('.')[-1]
if name == "":
self.name = str(realName).split(
f" [{result['id']}]")[0] + '.' + ext
else:
self.name = f"{name}.{ext}"
def download_playlist_and_convert(self, link):
print("\n[+] Reading playlist %s ..." % (link, ))
try:
with YoutubeDL(self.ydl_opts_playlists) as ydl:
playlist_dict = ydl.extract_info(link, download=False)
title = playlist_dict.get("title", None)
title = title.replace(":", "")
newdir = self.directory_original + "\\" + title
if not os.path.exists(newdir):
os.makedirs(newdir)
for video in playlist_dict["entries"]:
if video:
id_video = video.get("id")
title = video.get("title")
link = "https://www.youtube.com/watch?v=" + id_video
print("\n[+] Video found : %s - %s" % (
title,
link,
))
filename = self.download_video(link, False)
only_name = os.path.basename(filename)
savefile = newdir + "\\" + only_name
self.convert_to_mp3(self.TEMP_VIDEO, savefile)
time.sleep(5)
except:
print("\n[-] Error download playlist")
pass
def get_file_ext(url):
"""
Get the file extension of the audio file that would be extracted from the
given YouTube video URL.
:param url: YouTube video URL
"""
opts = {
# Always use the best audio quality available
'format': 'bestaudio/best',
'forcefilename': True,
'noplaylist': True
}
# Try up to 3 times as youtubedl tends to be flakey
for _ in range(settings.YOUTUBE_MAX_RETRIES):
try:
with YoutubeDL(opts) as ydl:
info = ydl.extract_info(url, download=False)
filename = ydl.prepare_filename(info)
_, file_extension = os.path.splitext(filename)
return file_extension
except DownloadError:
# Allow for retry
pass
raise Exception('get_file_ext failed')
async def gget(uri, opts):
import yt_dlp.utils
yt_dlp.utils.std_headers[
'User-Agent'] = '" Not A;Brand";v="99", "Chromium";v="102", "Google Chrome";v="102"'
with YoutubeDL(opts) as ydl:
a = ydl.extract_info(uri, download=True)
nama = ydl.prepare_filename(a)
return a, nama
def download(url, request_options):
if request_options.get("platform") == "duboku":
args = get_duboku_args(request_options)
duboku.main(args['dir'], args['file'], args['from_ep'], args['to_ep'], url, sys.stdout, args['debug'],
args['proxy'], args['proxy_local'], args['downloadAll'])
else:
with YoutubeDL(get_ydl_options(request_options)) as ydl:
ydl.download([url])
def test_parse_cmd(self):
pp = ExecPP(YoutubeDL(), '')
info = {'filepath': 'file name'}
cmd = 'echo %s' % compat_shlex_quote(info['filepath'])
self.assertEqual(pp.parse_cmd('echo', info), cmd)
self.assertEqual(pp.parse_cmd('echo {}', info), cmd)
self.assertEqual(pp.parse_cmd('echo %(filepath)q', info), cmd)
def test_parse_cmd(self):
pp = ExecAfterDownloadPP(YoutubeDL(), '')
info = {'filepath': 'file name'}
quoted_filepath = compat_shlex_quote(info['filepath'])
self.assertEqual(pp.parse_cmd('echo', info), 'echo %s' % quoted_filepath)
self.assertEqual(pp.parse_cmd('echo.{}', info), 'echo.%s' % quoted_filepath)
self.assertEqual(pp.parse_cmd('echo "%(filepath)s"', info), 'echo "%s"' % info['filepath'])
class YtDlpResolver:
def __init__(self):
self.ytdl = YoutubeDL(ytdl_opts)
def get_url(self, video_id: str):
try:
return self.ytdl.extract_info(f'https://www.youtube.com/watch?v={video_id}', download=False)['url']
except Exception as ex:
raise PluginError(ex)
def list_playlist(url, dl_proxy):
ydl_opts = {
'proxy': dl_proxy,
'quiet': True,
'dump_single_json': True,
'extract_flat': True,
}
with YoutubeDL(ydl_opts) as ydl:
return ydl.extract_info(url)
def download_video(url):
ydl_opts = {
# 'quiet': True,
"logger": MyLogger()
}
with YoutubeDL(ydl_opts) as ydl:
logger.debug("Downloading video at %s", url)
info_dict = ydl.extract_info(url, download=True)
filename = ydl.prepare_filename(info_dict)
return filename
def downloadVideo(link):
try:
li = ["sex"]
li[0] = link
with YoutubeDL(ydl_opts) as ydl:
info = ydl.extract_info(link, download=True)
return ydl.prepare_filename(info)
except:
print("cannot download")
return 1
def get_meta_info(url):
"""
Get metadata info from YouTube video.
:param url: YouTube video URL
"""
opts = {
'format': 'bestaudio/best',
'forcefilename': True,
'noplaylist': True
}
# Try up to 3 times, as youtubedl tends to be flakey
for _ in range(settings.YOUTUBE_MAX_RETRIES):
try:
with YoutubeDL(opts) as ydl:
info = ydl.extract_info(url, download=False)
filename = ydl.prepare_filename(info)
parsed_artist = ''
parsed_title = ''
# Use youtube_title_parse library to attempt to parse the YouTube video title into
# the track's artist and title.
result = get_artist_title(info['title'])
if result:
parsed_artist, parsed_title = result
metadata = {
# YT video title
'title': info['title'],
# YT video uploader
'uploader': info['uploader'],
# YT video's embedded track artist (some official songs)
'embedded_artist':
info['artist'] if 'artist' in info else '',
# YT video's embedded track title (some official songs)
'embedded_title': info['track'] if 'track' in info else '',
# Artist name parsed from the YouTube video title
'parsed_artist': parsed_artist,
# Title parsed from the YouTube video title
'parsed_title': parsed_title,
# Duration of YouTube video in seconds
'duration': info['duration'],
# YouTube video URL
'url': info['webpage_url'],
# Filename (including extension)
'filename': filename
}
return metadata
except KeyError:
pass
except DownloadError:
# Allow for retry
pass
raise DownloadError('Unable to parse YouTube link')
def test_create_basenames_from_ydl_info_dict_video(self):
ydl = YoutubeDL()
result = self.tu.create_basenames_from_ydl_info_dict(
ydl, info_dict_video)
expected_result = set([
'Video and Blog Competition 2017 - Bank Indonesia & '
'NET TV #BIGoesToCampus [hlG3LeFaQwU]'
])
self.assertEqual(result, expected_result)
def download(self, params, ep):
params['logger'] = FakeLogger()
ydl = YoutubeDL(params)
downloader = HttpFD(ydl, params)
filename = 'testfile.mp4'
try_rm(encodeFilename(filename))
self.assertTrue(downloader.real_download(filename, {
'url': 'http://127.0.0.1:%d/%s' % (self.port, ep),
}))
self.assertEqual(os.path.getsize(encodeFilename(filename)), TEST_SIZE)
try_rm(encodeFilename(filename))
def queryNameFromURL(url):
"""Query video title from URL
"""
with YoutubeDL(ydl_opts) as ydl:
info = ydl.extract_info(url, download=False)
if info is None:
return -1
return info['title']
def __download(self, link):
try:
with YoutubeDL(self.opts) as ydl:
try:
ydl.download([link])
except DownloadError as e:
self.onDownloadError(str(e))
return
self.__onDownloadComplete()
except ValueError:
LOGGER.info("Download Cancelled by User!")
self.onDownloadError("Download Cancelled by User!")
def get(
self,
url: str,
extra_info: Optional[Dict[str, Any]] = None,
process: bool = False,
) -> List[Track]:
if not (url or extra_info):
raise errors.InvalidArgumentError()
with YoutubeDL(self._ydl_config) as ydl:
if not extra_info:
info = ydl.extract_info(url, process=False)
else:
info = extra_info
info_type = None
if "_type" in info:
info_type = info["_type"]
if info_type == "url" and not info["ie_key"]:
return self.get(info["url"], process=False)
elif info_type == "playlist":
tracks: List[Track] = []
for entry in info["entries"]:
data = self.get("", extra_info=entry, process=False)
tracks += data
return tracks
if not process:
return [
Track(service=self.name,
extra_info=info,
type=TrackType.Dynamic)
]
try:
stream = ydl.process_ie_result(info)
except Exception:
raise errors.ServiceError()
if "url" in stream:
url = stream["url"]
else:
raise errors.ServiceError()
title = stream["title"]
if "uploader" in stream:
title += " - {}".format(stream["uploader"])
format = stream["ext"]
if "is_live" in stream and stream["is_live"]:
type = TrackType.Live
else:
type = TrackType.Default
return [
Track(service=self.name,
url=url,
name=title,
format=format,
type=type)
]
