-#!/usr/bin/env python
+#!/usr/bin/env python3
# coding: utf-8
from __future__ import unicode_literals
import copy
from test.helper import FakeYDL, assertRegexpMatches
-from youtube_dl import YoutubeDL
-from youtube_dl.compat import compat_str, compat_urllib_error
-from youtube_dl.extractor import YoutubeIE
-from youtube_dl.extractor.common import InfoExtractor
-from youtube_dl.postprocessor.common import PostProcessor
-from youtube_dl.utils import ExtractorError, match_filter_func
+from yt_dlp import YoutubeDL
+from yt_dlp.compat import compat_str, compat_urllib_error
+from yt_dlp.extractor import YoutubeIE
+from yt_dlp.extractor.common import InfoExtractor
+from yt_dlp.postprocessor.common import PostProcessor
+from yt_dlp.utils import ExtractorError, float_or_none, match_filter_func
TEST_URL = 'http://localhost/sample.mp4'
self.msgs = []
def process_info(self, info_dict):
+ info_dict.pop('__original_infodict', None)
self.downloaded_info_dicts.append(info_dict)
def to_screen(self, msg):
'title': 'testttitle',
'extractor': 'testex',
'extractor_key': 'TestEx',
+ 'webpage_url': 'http://example.com/watch?v=shenanigans',
}
res.update(**kwargs)
return res
downloaded = ydl.downloaded_info_dicts[0]
self.assertEqual(downloaded['ext'], 'mp4')
- # No prefer_free_formats => prefer mp4 and flv for greater compatibility
+ # No prefer_free_formats => prefer mp4 and webm
ydl = YDL()
ydl.params['prefer_free_formats'] = False
formats = [
yie._sort_formats(info_dict['formats'])
ydl.process_ie_result(info_dict)
downloaded = ydl.downloaded_info_dicts[0]
- self.assertEqual(downloaded['ext'], 'flv')
+ self.assertEqual(downloaded['ext'], 'webm')
def test_format_selection(self):
formats = [
def test_format_selection_string_ops(self):
formats = [
{'format_id': 'abc-cba', 'ext': 'mp4', 'url': TEST_URL},
+ {'format_id': 'zxc-cxz', 'ext': 'webm', 'url': TEST_URL},
]
info_dict = _make_result(formats)
# does not equal (!=)
ydl = YDL({'format': '[format_id!=abc-cba]'})
+ ydl.process_ie_result(info_dict.copy())
+ downloaded = ydl.downloaded_info_dicts[0]
+ self.assertEqual(downloaded['format_id'], 'zxc-cxz')
+
+ ydl = YDL({'format': '[format_id!=abc-cba][format_id!=zxc-cxz]'})
self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
# starts with (^=)
self.assertEqual(downloaded['format_id'], 'abc-cba')
# does not start with (!^=)
- ydl = YDL({'format': '[format_id!^=abc-cba]'})
+ ydl = YDL({'format': '[format_id!^=abc]'})
+ ydl.process_ie_result(info_dict.copy())
+ downloaded = ydl.downloaded_info_dicts[0]
+ self.assertEqual(downloaded['format_id'], 'zxc-cxz')
+
+ ydl = YDL({'format': '[format_id!^=abc][format_id!^=zxc]'})
self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
# ends with ($=)
self.assertEqual(downloaded['format_id'], 'abc-cba')
# does not end with (!$=)
- ydl = YDL({'format': '[format_id!$=abc-cba]'})
+ ydl = YDL({'format': '[format_id!$=cba]'})
+ ydl.process_ie_result(info_dict.copy())
+ downloaded = ydl.downloaded_info_dicts[0]
+ self.assertEqual(downloaded['format_id'], 'zxc-cxz')
+
+ ydl = YDL({'format': '[format_id!$=cba][format_id!$=cxz]'})
self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
# contains (*=)
- ydl = YDL({'format': '[format_id*=-]'})
+ ydl = YDL({'format': '[format_id*=bc-cb]'})
ydl.process_ie_result(info_dict.copy())
downloaded = ydl.downloaded_info_dicts[0]
self.assertEqual(downloaded['format_id'], 'abc-cba')
# does not contain (!*=)
+ ydl = YDL({'format': '[format_id!*=bc-cb]'})
+ ydl.process_ie_result(info_dict.copy())
+ downloaded = ydl.downloaded_info_dicts[0]
+ self.assertEqual(downloaded['format_id'], 'zxc-cxz')
+
+ ydl = YDL({'format': '[format_id!*=abc][format_id!*=zxc]'})
+ self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
+
ydl = YDL({'format': '[format_id!*=-]'})
self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
def test_youtube_format_selection(self):
+ # FIXME: Rewrite in accordance with the new format sorting options
+ return
+
order = [
'38', '37', '46', '22', '45', '35', '44', '18', '34', '43', '6', '5', '17', '36', '13',
# Apple HTTP Live Streaming
yie._sort_formats(info_dict['formats'])
ydl.process_ie_result(info_dict)
downloaded = ydl.downloaded_info_dicts[0]
- self.assertEqual(downloaded['format_id'], '137+141')
+ self.assertEqual(downloaded['format_id'], '248+172')
self.assertEqual(downloaded['ext'], 'mp4')
info_dict = _make_result(list(formats_order), extractor='youtube')
# For extractors with incomplete formats (all formats are audio-only or
# video-only) best and worst should fallback to corresponding best/worst
# video-only or audio-only formats (as per
- # https://github.com/rg3/youtube-dl/pull/5556)
+ # https://github.com/ytdl-org/youtube-dl/pull/5556)
formats = [
{'format_id': 'low', 'ext': 'mp3', 'preference': 1, 'vcodec': 'none', 'url': TEST_URL},
{'format_id': 'high', 'ext': 'mp3', 'preference': 2, 'vcodec': 'none', 'url': TEST_URL},
self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
def test_format_selection_issue_10083(self):
- # See https://github.com/rg3/youtube-dl/issues/10083
+ # See https://github.com/ytdl-org/youtube-dl/issues/10083
formats = [
{'format_id': 'regular', 'height': 360, 'url': TEST_URL},
{'format_id': 'video', 'height': 720, 'acodec': 'none', 'url': TEST_URL},
def test_default_format_spec(self):
ydl = YDL({'simulate': True})
- self.assertEqual(ydl._default_format_spec({}), 'bestvideo+bestaudio/best')
+ self.assertEqual(ydl._default_format_spec({}), 'bestvideo*+bestaudio/best')
ydl = YDL({})
self.assertEqual(ydl._default_format_spec({'is_live': True}), 'best/bestvideo+bestaudio')
ydl = YDL({'simulate': True})
- self.assertEqual(ydl._default_format_spec({'is_live': True}), 'bestvideo+bestaudio/best')
+ self.assertEqual(ydl._default_format_spec({'is_live': True}), 'bestvideo*+bestaudio/best')
ydl = YDL({'outtmpl': '-'})
self.assertEqual(ydl._default_format_spec({}), 'best/bestvideo+bestaudio')
ydl = YDL({})
- self.assertEqual(ydl._default_format_spec({}, download=False), 'bestvideo+bestaudio/best')
+ self.assertEqual(ydl._default_format_spec({}, download=False), 'bestvideo*+bestaudio/best')
self.assertEqual(ydl._default_format_spec({'is_live': True}), 'best/bestvideo+bestaudio')
'subtitles': subtitles,
'automatic_captions': auto_captions,
'extractor': 'TEST',
+ 'webpage_url': 'http://example.com/watch?v=shenanigans',
}
def get_info(params={}):
self.assertTrue(subs)
self.assertEqual(set(subs.keys()), set(['es', 'fr']))
+ result = get_info({'writesubtitles': True, 'subtitleslangs': ['all', '-en']})
+ subs = result['requested_subtitles']
+ self.assertTrue(subs)
+ self.assertEqual(set(subs.keys()), set(['es', 'fr']))
+
+ result = get_info({'writesubtitles': True, 'subtitleslangs': ['en', 'fr', '-en']})
+ subs = result['requested_subtitles']
+ self.assertTrue(subs)
+ self.assertEqual(set(subs.keys()), set(['fr']))
+
+ result = get_info({'writesubtitles': True, 'subtitleslangs': ['-en', 'en']})
+ subs = result['requested_subtitles']
+ self.assertTrue(subs)
+ self.assertEqual(set(subs.keys()), set(['en']))
+
+ result = get_info({'writesubtitles': True, 'subtitleslangs': ['e.+']})
+ subs = result['requested_subtitles']
+ self.assertTrue(subs)
+ self.assertEqual(set(subs.keys()), set(['es', 'en']))
+
result = get_info({'writesubtitles': True, 'writeautomaticsub': True, 'subtitleslangs': ['es', 'pt']})
subs = result['requested_subtitles']
self.assertTrue(subs)
self.assertEqual(test_dict['extractor'], 'Foo')
self.assertEqual(test_dict['playlist'], 'funny videos')
- def test_prepare_filename(self):
- info = {
- 'id': '1234',
- 'ext': 'mp4',
- 'width': None,
- 'height': 1080,
- 'title1': '$PATH',
- 'title2': '%PATH%',
- }
+ outtmpl_info = {
+ 'id': '1234',
+ 'ext': 'mp4',
+ 'width': None,
+ 'height': 1080,
+ 'title1': '$PATH',
+ 'title2': '%PATH%',
+ 'title3': 'foo/bar\\test',
+ 'timestamp': 1618488000,
+ 'duration': 100000,
+ 'playlist_index': 1,
+ '_last_playlist_index': 100,
+ 'n_entries': 10,
+ 'formats': [{'id': 'id1'}, {'id': 'id2'}, {'id': 'id3'}]
+ }
+
+ def test_prepare_outtmpl(self):
+ def out(tmpl, **params):
+ params['outtmpl'] = tmpl
+ ydl = YoutubeDL(params)
+ ydl._num_downloads = 1
+ outtmpl, tmpl_dict = ydl.prepare_outtmpl(tmpl, self.outtmpl_info)
+ return outtmpl % tmpl_dict
+
+ self.assertEqual(out('%(id)s.%(ext)s'), '1234.mp4')
+ self.assertEqual(out('%(duration_string)s'), '27:46:40')
+ self.assertTrue(float_or_none(out('%(epoch)d')))
+ self.assertEqual(out('%(resolution)s'), '1080p')
+ self.assertEqual(out('%(playlist_index)s'), '001')
+ self.assertEqual(out('%(autonumber)s'), '00001')
+ self.assertEqual(out('%(autonumber+2)03d', autonumber_start=3), '005')
+ self.assertEqual(out('%(autonumber)s', autonumber_size=3), '001')
+
+ self.assertEqual(out('%%'), '%')
+ self.assertEqual(out('%%%%'), '%%')
+ self.assertEqual(out('%(invalid@tmpl|def)s', outtmpl_na_placeholder='none'), 'none')
+ self.assertEqual(out('%()s'), 'NA')
+ self.assertEqual(out('%s'), '%s')
+
+ NA_TEST_OUTTMPL = '%(uploader_date)s-%(width)d-%(x|def)s-%(id)s.%(ext)s'
+ self.assertEqual(out(NA_TEST_OUTTMPL), 'NA-NA-def-1234.mp4')
+ self.assertEqual(out(NA_TEST_OUTTMPL, outtmpl_na_placeholder='none'), 'none-none-def-1234.mp4')
+ self.assertEqual(out(NA_TEST_OUTTMPL, outtmpl_na_placeholder=''), '--def-1234.mp4')
+
+ FMT_TEST_OUTTMPL = '%%(height)%s.%%(ext)s'
+ self.assertEqual(out(FMT_TEST_OUTTMPL % 's'), '1080.mp4')
+ self.assertEqual(out(FMT_TEST_OUTTMPL % 'd'), '1080.mp4')
+ self.assertEqual(out(FMT_TEST_OUTTMPL % '6d'), ' 1080.mp4')
+ self.assertEqual(out(FMT_TEST_OUTTMPL % '-6d'), '1080 .mp4')
+ self.assertEqual(out(FMT_TEST_OUTTMPL % '06d'), '001080.mp4')
+ self.assertEqual(out(FMT_TEST_OUTTMPL % ' 06d'), ' 01080.mp4')
+ self.assertEqual(out(FMT_TEST_OUTTMPL % ' 06d'), ' 01080.mp4')
+ self.assertEqual(out(FMT_TEST_OUTTMPL % '0 6d'), ' 01080.mp4')
+ self.assertEqual(out(FMT_TEST_OUTTMPL % '0 6d'), ' 01080.mp4')
+ self.assertEqual(out(FMT_TEST_OUTTMPL % ' 0 6d'), ' 01080.mp4')
+
+ self.assertEqual(out('%(id)d'), '1234')
+ self.assertEqual(out('%(id)d %(id)r'), "1234 '1234'")
+ self.assertEqual(out('%(ext)s-%(ext|def)d'), 'mp4-def')
+ self.assertEqual(out('%(width|0)04d'), '0000')
+ self.assertEqual(out('%(width|)d', outtmpl_na_placeholder='none'), '')
+
+ FORMATS = self.outtmpl_info['formats']
+ self.assertEqual(out('%(timestamp+-1000>%H-%M-%S)s'), '11-43-20')
+ self.assertEqual(out('%(id+1-height+3)05d'), '00158')
+ self.assertEqual(out('%(width+100)05d'), 'NA')
+ self.assertEqual(out('%(formats.0)s'), str(FORMATS[0]))
+ self.assertEqual(out('%(formats.-1.id)s'), str(FORMATS[-1]['id']))
+ self.assertEqual(out('%(formats.3)s'), 'NA')
+ self.assertEqual(out('%(formats.:2:-1)r'), repr(FORMATS[:2:-1]))
+ self.assertEqual(out('%(formats.0.id.-1+id)f'), '1235.000000')
+ def test_prepare_filename(self):
def fname(templ):
- ydl = YoutubeDL({'outtmpl': templ})
- return ydl.prepare_filename(info)
- self.assertEqual(fname('%(id)s.%(ext)s'), '1234.mp4')
- self.assertEqual(fname('%(id)s-%(width)s.%(ext)s'), '1234-NA.mp4')
- # Replace missing fields with 'NA'
- self.assertEqual(fname('%(uploader_date)s-%(id)s.%(ext)s'), 'NA-1234.mp4')
- self.assertEqual(fname('%(height)d.%(ext)s'), '1080.mp4')
- self.assertEqual(fname('%(height)6d.%(ext)s'), ' 1080.mp4')
- self.assertEqual(fname('%(height)-6d.%(ext)s'), '1080 .mp4')
- self.assertEqual(fname('%(height)06d.%(ext)s'), '001080.mp4')
- self.assertEqual(fname('%(height) 06d.%(ext)s'), ' 01080.mp4')
- self.assertEqual(fname('%(height) 06d.%(ext)s'), ' 01080.mp4')
- self.assertEqual(fname('%(height)0 6d.%(ext)s'), ' 01080.mp4')
- self.assertEqual(fname('%(height)0 6d.%(ext)s'), ' 01080.mp4')
- self.assertEqual(fname('%(height) 0 6d.%(ext)s'), ' 01080.mp4')
+ params = {'outtmpl': templ}
+ ydl = YoutubeDL(params)
+ return ydl.prepare_filename(self.outtmpl_info)
+
self.assertEqual(fname('%%'), '%')
self.assertEqual(fname('%%%%'), '%%')
- self.assertEqual(fname('%%(height)06d.%(ext)s'), '%(height)06d.mp4')
+ self.assertEqual(fname('%%(width)06d.%(ext)s'), '%(width)06d.mp4')
self.assertEqual(fname('%(width)06d.%(ext)s'), 'NA.mp4')
self.assertEqual(fname('%(width)06d.%%(ext)s'), 'NA.%(ext)s')
self.assertEqual(fname('%%(width)06d.%(ext)s'), '%(width)06d.mp4')
+
self.assertEqual(fname('Hello %(title1)s'), 'Hello $PATH')
self.assertEqual(fname('Hello %(title2)s'), 'Hello %PATH%')
+ self.assertEqual(fname('%(title3)s'), 'foo_bar_test')
+ self.assertEqual(fname('%(formats.0)s'), "{'id' - 'id1'}")
+
+ self.assertEqual(fname('%(id)r %(height)r'), "'1234' 1080")
+ self.assertEqual(fname('%(formats.0)r'), "{'id' - 'id1'}")
+
def test_format_note(self):
ydl = YoutubeDL()
self.assertEqual(ydl._format_note({}), '')
def process_info(self, info_dict):
super(YDL, self).process_info(info_dict)
- def _match_entry(self, info_dict, incomplete):
+ def _match_entry(self, info_dict, incomplete=False):
res = super(FilterYDL, self)._match_entry(info_dict, incomplete)
if res is None:
self.downloaded_info_dicts.append(info_dict)
'playlist_id': '42',
'uploader': "變態妍字幕版 太妍 тест",
'creator': "тест ' 123 ' тест--",
+ 'webpage_url': 'http://example.com/watch?v=shenanigans',
}
second = {
'id': '2',
'filesize': 5 * 1024,
'playlist_id': '43',
'uploader': "тест 123",
+ 'webpage_url': 'http://example.com/watch?v=SHENANIGANS',
}
videos = [first, second]
'webpage_url': 'http://example.com',
}
- def get_ids(params):
+ def get_downloaded_info_dicts(params):
ydl = YDL(params)
- # make a copy because the dictionary can be modified
- ydl.process_ie_result(playlist.copy())
- return [int(v['id']) for v in ydl.downloaded_info_dicts]
+ # make a deep copy because the dictionary and nested entries
+ # can be modified
+ ydl.process_ie_result(copy.deepcopy(playlist))
+ return ydl.downloaded_info_dicts
+
+ def get_ids(params):
+ return [int(v['id']) for v in get_downloaded_info_dicts(params)]
result = get_ids({})
self.assertEqual(result, [1, 2, 3, 4])
result = get_ids({'playlist_items': '2-4,3-4,3'})
self.assertEqual(result, [2, 3, 4])
+ # Tests for https://github.com/ytdl-org/youtube-dl/issues/10591
+ # @{
+ result = get_downloaded_info_dicts({'playlist_items': '2-4,3-4,3'})
+ self.assertEqual(result[0]['playlist_index'], 2)
+ self.assertEqual(result[1]['playlist_index'], 3)
+
+ result = get_downloaded_info_dicts({'playlist_items': '2-4,3-4,3'})
+ self.assertEqual(result[0]['playlist_index'], 2)
+ self.assertEqual(result[1]['playlist_index'], 3)
+ self.assertEqual(result[2]['playlist_index'], 4)
+
+ result = get_downloaded_info_dicts({'playlist_items': '4,2'})
+ self.assertEqual(result[0]['playlist_index'], 4)
+ self.assertEqual(result[1]['playlist_index'], 2)
+ # @}
+
def test_urlopen_no_file_protocol(self):
- # see https://github.com/rg3/youtube-dl/issues/8227
+ # see https://github.com/ytdl-org/youtube-dl/issues/8227
ydl = YDL()
self.assertRaises(compat_urllib_error.URLError, ydl.urlopen, 'file:///etc/passwd')
self.assertEqual(downloaded['extractor'], 'testex')
self.assertEqual(downloaded['extractor_key'], 'TestEx')
+ # Test case for https://github.com/ytdl-org/youtube-dl/issues/27064
+ def test_ignoreerrors_for_playlist_with_url_transparent_iterable_entries(self):
+
+ class _YDL(YDL):
+ def __init__(self, *args, **kwargs):
+ super(_YDL, self).__init__(*args, **kwargs)
+
+ def trouble(self, s, tb=None):
+ pass
+
+ ydl = _YDL({
+ 'format': 'extra',
+ 'ignoreerrors': True,
+ })
+
+ class VideoIE(InfoExtractor):
+ _VALID_URL = r'video:(?P<id>\d+)'
+
+ def _real_extract(self, url):
+ video_id = self._match_id(url)
+ formats = [{
+ 'format_id': 'default',
+ 'url': 'url:',
+ }]
+ if video_id == '0':
+ raise ExtractorError('foo')
+ if video_id == '2':
+ formats.append({
+ 'format_id': 'extra',
+ 'url': TEST_URL,
+ })
+ return {
+ 'id': video_id,
+ 'title': 'Video %s' % video_id,
+ 'formats': formats,
+ }
+
+ class PlaylistIE(InfoExtractor):
+ _VALID_URL = r'playlist:'
+
+ def _entries(self):
+ for n in range(3):
+ video_id = compat_str(n)
+ yield {
+ '_type': 'url_transparent',
+ 'ie_key': VideoIE.ie_key(),
+ 'id': video_id,
+ 'url': 'video:%s' % video_id,
+ 'title': 'Video Transparent %s' % video_id,
+ }
+
+ def _real_extract(self, url):
+ return self.playlist_result(self._entries())
+
+ ydl.add_info_extractor(VideoIE(ydl))
+ ydl.add_info_extractor(PlaylistIE(ydl))
+ info = ydl.extract_info('playlist:')
+ entries = info['entries']
+ self.assertEqual(len(entries), 3)
+ self.assertTrue(entries[0] is None)
+ self.assertTrue(entries[1] is None)
+ self.assertEqual(len(ydl.downloaded_info_dicts), 1)
+ downloaded = ydl.downloaded_info_dicts[0]
+ self.assertEqual(entries[2], downloaded)
+ self.assertEqual(downloaded['url'], TEST_URL)
+ self.assertEqual(downloaded['title'], 'Video Transparent 2')
+ self.assertEqual(downloaded['id'], '2')
+ self.assertEqual(downloaded['extractor'], 'Video')
+ self.assertEqual(downloaded['extractor_key'], 'Video')
+
if __name__ == '__main__':
unittest.main()