ytdl-org
/
youtube-dl
1
0
Fork 0
Código Incidencias 0 Pull Requests 0 Lanzamientos 1077 Wiki Actividad
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
17774 Commits
9 Ramas
53MB
Rama: master
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde 'master'
${ noResults }
youtube-dl/test/test_YoutubeDL.py

925 líneas
36KB
Original Enlace permanente Blame Histórico 

  1. #!/usr/bin/env python

  2. # coding: utf-8

  3. 

  4. from __future__ import unicode_literals

  5. 

  6. # Allow direct execution

  7. import os

  8. import sys

  9. import unittest

  10. sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

  11. 

  12. import copy

  13. 

  14. from test.helper import FakeYDL, assertRegexpMatches

  15. from youtube_dl import YoutubeDL

  16. from youtube_dl.compat import compat_str, compat_urllib_error

  17. from youtube_dl.extractor import YoutubeIE

  18. from youtube_dl.extractor.common import InfoExtractor

  19. from youtube_dl.postprocessor.common import PostProcessor

  20. from youtube_dl.utils import ExtractorError, match_filter_func

  21. 

  22. TEST_URL = 'http://localhost/sample.mp4'

  23. 

  24. 

  25. class YDL(FakeYDL):

  26.     def __init__(self, *args, **kwargs):

  27.         super(YDL, self).__init__(*args, **kwargs)

  28.         self.downloaded_info_dicts = []

  29.         self.msgs = []

  30. 

  31.     def process_info(self, info_dict):

  32.         self.downloaded_info_dicts.append(info_dict)

  33. 

  34.     def to_screen(self, msg):

  35.         self.msgs.append(msg)

  36. 

  37. 

  38. def _make_result(formats, **kwargs):

  39.     res = {

  40.         'formats': formats,

  41.         'id': 'testid',

  42.         'title': 'testttitle',

  43.         'extractor': 'testex',

  44.         'extractor_key': 'TestEx',

  45.     }

  46.     res.update(**kwargs)

  47.     return res

  48. 

  49. 

  50. class TestFormatSelection(unittest.TestCase):

  51.     def test_prefer_free_formats(self):

  52.         # Same resolution => download webm

  53.         ydl = YDL()

  54.         ydl.params['prefer_free_formats'] = True

  55.         formats = [

  56.             {'ext': 'webm', 'height': 460, 'url': TEST_URL},

  57.             {'ext': 'mp4', 'height': 460, 'url': TEST_URL},

  58.         ]

  59.         info_dict = _make_result(formats)

  60.         yie = YoutubeIE(ydl)

  61.         yie._sort_formats(info_dict['formats'])

  62.         ydl.process_ie_result(info_dict)

  63.         downloaded = ydl.downloaded_info_dicts[0]

  64.         self.assertEqual(downloaded['ext'], 'webm')

  65. 

  66.         # Different resolution => download best quality (mp4)

  67.         ydl = YDL()

  68.         ydl.params['prefer_free_formats'] = True

  69.         formats = [

  70.             {'ext': 'webm', 'height': 720, 'url': TEST_URL},

  71.             {'ext': 'mp4', 'height': 1080, 'url': TEST_URL},

  72.         ]

  73.         info_dict['formats'] = formats

  74.         yie = YoutubeIE(ydl)

  75.         yie._sort_formats(info_dict['formats'])

  76.         ydl.process_ie_result(info_dict)

  77.         downloaded = ydl.downloaded_info_dicts[0]

  78.         self.assertEqual(downloaded['ext'], 'mp4')

  79. 

  80.         # No prefer_free_formats => prefer mp4 and flv for greater compatibility

  81.         ydl = YDL()

  82.         ydl.params['prefer_free_formats'] = False

  83.         formats = [

  84.             {'ext': 'webm', 'height': 720, 'url': TEST_URL},

  85.             {'ext': 'mp4', 'height': 720, 'url': TEST_URL},

  86.             {'ext': 'flv', 'height': 720, 'url': TEST_URL},

  87.         ]

  88.         info_dict['formats'] = formats

  89.         yie = YoutubeIE(ydl)

  90.         yie._sort_formats(info_dict['formats'])

  91.         ydl.process_ie_result(info_dict)

  92.         downloaded = ydl.downloaded_info_dicts[0]

  93.         self.assertEqual(downloaded['ext'], 'mp4')

  94. 

  95.         ydl = YDL()

  96.         ydl.params['prefer_free_formats'] = False

  97.         formats = [

  98.             {'ext': 'flv', 'height': 720, 'url': TEST_URL},

  99.             {'ext': 'webm', 'height': 720, 'url': TEST_URL},

  100.         ]

  101.         info_dict['formats'] = formats

  102.         yie = YoutubeIE(ydl)

  103.         yie._sort_formats(info_dict['formats'])

  104.         ydl.process_ie_result(info_dict)

  105.         downloaded = ydl.downloaded_info_dicts[0]

  106.         self.assertEqual(downloaded['ext'], 'flv')

  107. 

  108.     def test_format_selection(self):

  109.         formats = [

  110.             {'format_id': '35', 'ext': 'mp4', 'preference': 1, 'url': TEST_URL},

  111.             {'format_id': 'example-with-dashes', 'ext': 'webm', 'preference': 1, 'url': TEST_URL},

  112.             {'format_id': '45', 'ext': 'webm', 'preference': 2, 'url': TEST_URL},

  113.             {'format_id': '47', 'ext': 'webm', 'preference': 3, 'url': TEST_URL},

  114.             {'format_id': '2', 'ext': 'flv', 'preference': 4, 'url': TEST_URL},

  115.         ]

  116.         info_dict = _make_result(formats)

  117. 

  118.         ydl = YDL({'format': '20/47'})

  119.         ydl.process_ie_result(info_dict.copy())

  120.         downloaded = ydl.downloaded_info_dicts[0]

  121.         self.assertEqual(downloaded['format_id'], '47')

  122. 

  123.         ydl = YDL({'format': '20/71/worst'})

  124.         ydl.process_ie_result(info_dict.copy())

  125.         downloaded = ydl.downloaded_info_dicts[0]

  126.         self.assertEqual(downloaded['format_id'], '35')

  127. 

  128.         ydl = YDL()

  129.         ydl.process_ie_result(info_dict.copy())

  130.         downloaded = ydl.downloaded_info_dicts[0]

  131.         self.assertEqual(downloaded['format_id'], '2')

  132. 

  133.         ydl = YDL({'format': 'webm/mp4'})

  134.         ydl.process_ie_result(info_dict.copy())

  135.         downloaded = ydl.downloaded_info_dicts[0]

  136.         self.assertEqual(downloaded['format_id'], '47')

  137. 

  138.         ydl = YDL({'format': '3gp/40/mp4'})

  139.         ydl.process_ie_result(info_dict.copy())

  140.         downloaded = ydl.downloaded_info_dicts[0]

  141.         self.assertEqual(downloaded['format_id'], '35')

  142. 

  143.         ydl = YDL({'format': 'example-with-dashes'})

  144.         ydl.process_ie_result(info_dict.copy())

  145.         downloaded = ydl.downloaded_info_dicts[0]

  146.         self.assertEqual(downloaded['format_id'], 'example-with-dashes')

  147. 

  148.     def test_format_selection_audio(self):

  149.         formats = [

  150.             {'format_id': 'audio-low', 'ext': 'webm', 'preference': 1, 'vcodec': 'none', 'url': TEST_URL},

  151.             {'format_id': 'audio-mid', 'ext': 'webm', 'preference': 2, 'vcodec': 'none', 'url': TEST_URL},

  152.             {'format_id': 'audio-high', 'ext': 'flv', 'preference': 3, 'vcodec': 'none', 'url': TEST_URL},

  153.             {'format_id': 'vid', 'ext': 'mp4', 'preference': 4, 'url': TEST_URL},

  154.         ]

  155.         info_dict = _make_result(formats)

  156. 

  157.         ydl = YDL({'format': 'bestaudio'})

  158.         ydl.process_ie_result(info_dict.copy())

  159.         downloaded = ydl.downloaded_info_dicts[0]

  160.         self.assertEqual(downloaded['format_id'], 'audio-high')

  161. 

  162.         ydl = YDL({'format': 'worstaudio'})

  163.         ydl.process_ie_result(info_dict.copy())

  164.         downloaded = ydl.downloaded_info_dicts[0]

  165.         self.assertEqual(downloaded['format_id'], 'audio-low')

  166. 

  167.         formats = [

  168.             {'format_id': 'vid-low', 'ext': 'mp4', 'preference': 1, 'url': TEST_URL},

  169.             {'format_id': 'vid-high', 'ext': 'mp4', 'preference': 2, 'url': TEST_URL},

  170.         ]

  171.         info_dict = _make_result(formats)

  172. 

  173.         ydl = YDL({'format': 'bestaudio/worstaudio/best'})

  174.         ydl.process_ie_result(info_dict.copy())

  175.         downloaded = ydl.downloaded_info_dicts[0]

  176.         self.assertEqual(downloaded['format_id'], 'vid-high')

  177. 

  178.     def test_format_selection_audio_exts(self):

  179.         formats = [

  180.             {'format_id': 'mp3-64', 'ext': 'mp3', 'abr': 64, 'url': 'http://_', 'vcodec': 'none'},

  181.             {'format_id': 'ogg-64', 'ext': 'ogg', 'abr': 64, 'url': 'http://_', 'vcodec': 'none'},

  182.             {'format_id': 'aac-64', 'ext': 'aac', 'abr': 64, 'url': 'http://_', 'vcodec': 'none'},

  183.             {'format_id': 'mp3-32', 'ext': 'mp3', 'abr': 32, 'url': 'http://_', 'vcodec': 'none'},

  184.             {'format_id': 'aac-32', 'ext': 'aac', 'abr': 32, 'url': 'http://_', 'vcodec': 'none'},

  185.         ]

  186. 

  187.         info_dict = _make_result(formats)

  188.         ydl = YDL({'format': 'best'})

  189.         ie = YoutubeIE(ydl)

  190.         ie._sort_formats(info_dict['formats'])

  191.         ydl.process_ie_result(copy.deepcopy(info_dict))

  192.         downloaded = ydl.downloaded_info_dicts[0]

  193.         self.assertEqual(downloaded['format_id'], 'aac-64')

  194. 

  195.         ydl = YDL({'format': 'mp3'})

  196.         ie = YoutubeIE(ydl)

  197.         ie._sort_formats(info_dict['formats'])

  198.         ydl.process_ie_result(copy.deepcopy(info_dict))

  199.         downloaded = ydl.downloaded_info_dicts[0]

  200.         self.assertEqual(downloaded['format_id'], 'mp3-64')

  201. 

  202.         ydl = YDL({'prefer_free_formats': True})

  203.         ie = YoutubeIE(ydl)

  204.         ie._sort_formats(info_dict['formats'])

  205.         ydl.process_ie_result(copy.deepcopy(info_dict))

  206.         downloaded = ydl.downloaded_info_dicts[0]

  207.         self.assertEqual(downloaded['format_id'], 'ogg-64')

  208. 

  209.     def test_format_selection_video(self):

  210.         formats = [

  211.             {'format_id': 'dash-video-low', 'ext': 'mp4', 'preference': 1, 'acodec': 'none', 'url': TEST_URL},

  212.             {'format_id': 'dash-video-high', 'ext': 'mp4', 'preference': 2, 'acodec': 'none', 'url': TEST_URL},

  213.             {'format_id': 'vid', 'ext': 'mp4', 'preference': 3, 'url': TEST_URL},

  214.         ]

  215.         info_dict = _make_result(formats)

  216. 

  217.         ydl = YDL({'format': 'bestvideo'})

  218.         ydl.process_ie_result(info_dict.copy())

  219.         downloaded = ydl.downloaded_info_dicts[0]

  220.         self.assertEqual(downloaded['format_id'], 'dash-video-high')

  221. 

  222.         ydl = YDL({'format': 'worstvideo'})

  223.         ydl.process_ie_result(info_dict.copy())

  224.         downloaded = ydl.downloaded_info_dicts[0]

  225.         self.assertEqual(downloaded['format_id'], 'dash-video-low')

  226. 

  227.         ydl = YDL({'format': 'bestvideo[format_id^=dash][format_id$=low]'})

  228.         ydl.process_ie_result(info_dict.copy())

  229.         downloaded = ydl.downloaded_info_dicts[0]

  230.         self.assertEqual(downloaded['format_id'], 'dash-video-low')

  231. 

  232.         formats = [

  233.             {'format_id': 'vid-vcodec-dot', 'ext': 'mp4', 'preference': 1, 'vcodec': 'avc1.123456', 'acodec': 'none', 'url': TEST_URL},

  234.         ]

  235.         info_dict = _make_result(formats)

  236. 

  237.         ydl = YDL({'format': 'bestvideo[vcodec=avc1.123456]'})

  238.         ydl.process_ie_result(info_dict.copy())

  239.         downloaded = ydl.downloaded_info_dicts[0]

  240.         self.assertEqual(downloaded['format_id'], 'vid-vcodec-dot')

  241. 

  242.     def test_format_selection_string_ops(self):

  243.         formats = [

  244.             {'format_id': 'abc-cba', 'ext': 'mp4', 'url': TEST_URL},

  245.             {'format_id': 'zxc-cxz', 'ext': 'webm', 'url': TEST_URL},

  246.         ]

  247.         info_dict = _make_result(formats)

  248. 

  249.         # equals (=)

  250.         ydl = YDL({'format': '[format_id=abc-cba]'})

  251.         ydl.process_ie_result(info_dict.copy())

  252.         downloaded = ydl.downloaded_info_dicts[0]

  253.         self.assertEqual(downloaded['format_id'], 'abc-cba')

  254. 

  255.         # does not equal (!=)

  256.         ydl = YDL({'format': '[format_id!=abc-cba]'})

  257.         ydl.process_ie_result(info_dict.copy())

  258.         downloaded = ydl.downloaded_info_dicts[0]

  259.         self.assertEqual(downloaded['format_id'], 'zxc-cxz')

  260. 

  261.         ydl = YDL({'format': '[format_id!=abc-cba][format_id!=zxc-cxz]'})

  262.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())

  263. 

  264.         # starts with (^=)

  265.         ydl = YDL({'format': '[format_id^=abc]'})

  266.         ydl.process_ie_result(info_dict.copy())

  267.         downloaded = ydl.downloaded_info_dicts[0]

  268.         self.assertEqual(downloaded['format_id'], 'abc-cba')

  269. 

  270.         # does not start with (!^=)

  271.         ydl = YDL({'format': '[format_id!^=abc]'})

  272.         ydl.process_ie_result(info_dict.copy())

  273.         downloaded = ydl.downloaded_info_dicts[0]

  274.         self.assertEqual(downloaded['format_id'], 'zxc-cxz')

  275. 

  276.         ydl = YDL({'format': '[format_id!^=abc][format_id!^=zxc]'})

  277.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())

  278. 

  279.         # ends with ($=)

  280.         ydl = YDL({'format': '[format_id$=cba]'})

  281.         ydl.process_ie_result(info_dict.copy())

  282.         downloaded = ydl.downloaded_info_dicts[0]

  283.         self.assertEqual(downloaded['format_id'], 'abc-cba')

  284. 

  285.         # does not end with (!$=)

  286.         ydl = YDL({'format': '[format_id!$=cba]'})

  287.         ydl.process_ie_result(info_dict.copy())

  288.         downloaded = ydl.downloaded_info_dicts[0]

  289.         self.assertEqual(downloaded['format_id'], 'zxc-cxz')

  290. 

  291.         ydl = YDL({'format': '[format_id!$=cba][format_id!$=cxz]'})

  292.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())

  293. 

  294.         # contains (*=)

  295.         ydl = YDL({'format': '[format_id*=bc-cb]'})

  296.         ydl.process_ie_result(info_dict.copy())

  297.         downloaded = ydl.downloaded_info_dicts[0]

  298.         self.assertEqual(downloaded['format_id'], 'abc-cba')

  299. 

  300.         # does not contain (!*=)

  301.         ydl = YDL({'format': '[format_id!*=bc-cb]'})

  302.         ydl.process_ie_result(info_dict.copy())

  303.         downloaded = ydl.downloaded_info_dicts[0]

  304.         self.assertEqual(downloaded['format_id'], 'zxc-cxz')

  305. 

  306.         ydl = YDL({'format': '[format_id!*=abc][format_id!*=zxc]'})

  307.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())

  308. 

  309.         ydl = YDL({'format': '[format_id!*=-]'})

  310.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())

  311. 

  312.     def test_youtube_format_selection(self):

  313.         order = [

  314.             '38', '37', '46', '22', '45', '35', '44', '18', '34', '43', '6', '5', '17', '36', '13',

  315.             # Apple HTTP Live Streaming

  316.             '96', '95', '94', '93', '92', '132', '151',

  317.             # 3D

  318.             '85', '84', '102', '83', '101', '82', '100',

  319.             # Dash video

  320.             '137', '248', '136', '247', '135', '246',

  321.             '245', '244', '134', '243', '133', '242', '160',

  322.             # Dash audio

  323.             '141', '172', '140', '171', '139',

  324.         ]

  325. 

  326.         def format_info(f_id):

  327.             info = YoutubeIE._formats[f_id].copy()

  328. 

  329.             # XXX: In real cases InfoExtractor._parse_mpd_formats() fills up 'acodec'

  330.             # and 'vcodec', while in tests such information is incomplete since

  331.             # commit a6c2c24479e5f4827ceb06f64d855329c0a6f593

  332.             # test_YoutubeDL.test_youtube_format_selection is broken without

  333.             # this fix

  334.             if 'acodec' in info and 'vcodec' not in info:

  335.                 info['vcodec'] = 'none'

  336.             elif 'vcodec' in info and 'acodec' not in info:

  337.                 info['acodec'] = 'none'

  338. 

  339.             info['format_id'] = f_id

  340.             info['url'] = 'url:' + f_id

  341.             return info

  342.         formats_order = [format_info(f_id) for f_id in order]

  343. 

  344.         info_dict = _make_result(list(formats_order), extractor='youtube')

  345.         ydl = YDL({'format': 'bestvideo+bestaudio'})

  346.         yie = YoutubeIE(ydl)

  347.         yie._sort_formats(info_dict['formats'])

  348.         ydl.process_ie_result(info_dict)

  349.         downloaded = ydl.downloaded_info_dicts[0]

  350.         self.assertEqual(downloaded['format_id'], '137+141')

  351.         self.assertEqual(downloaded['ext'], 'mp4')

  352. 

  353.         info_dict = _make_result(list(formats_order), extractor='youtube')

  354.         ydl = YDL({'format': 'bestvideo[height>=999999]+bestaudio/best'})

  355.         yie = YoutubeIE(ydl)

  356.         yie._sort_formats(info_dict['formats'])

  357.         ydl.process_ie_result(info_dict)

  358.         downloaded = ydl.downloaded_info_dicts[0]

  359.         self.assertEqual(downloaded['format_id'], '38')

  360. 

  361.         info_dict = _make_result(list(formats_order), extractor='youtube')

  362.         ydl = YDL({'format': 'bestvideo/best,bestaudio'})

  363.         yie = YoutubeIE(ydl)

  364.         yie._sort_formats(info_dict['formats'])

  365.         ydl.process_ie_result(info_dict)

  366.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]

  367.         self.assertEqual(downloaded_ids, ['137', '141'])

  368. 

  369.         info_dict = _make_result(list(formats_order), extractor='youtube')

  370.         ydl = YDL({'format': '(bestvideo[ext=mp4],bestvideo[ext=webm])+bestaudio'})

  371.         yie = YoutubeIE(ydl)

  372.         yie._sort_formats(info_dict['formats'])

  373.         ydl.process_ie_result(info_dict)

  374.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]

  375.         self.assertEqual(downloaded_ids, ['137+141', '248+141'])

  376. 

  377.         info_dict = _make_result(list(formats_order), extractor='youtube')

  378.         ydl = YDL({'format': '(bestvideo[ext=mp4],bestvideo[ext=webm])[height<=720]+bestaudio'})

  379.         yie = YoutubeIE(ydl)

  380.         yie._sort_formats(info_dict['formats'])

  381.         ydl.process_ie_result(info_dict)

  382.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]

  383.         self.assertEqual(downloaded_ids, ['136+141', '247+141'])

  384. 

  385.         info_dict = _make_result(list(formats_order), extractor='youtube')

  386.         ydl = YDL({'format': '(bestvideo[ext=none]/bestvideo[ext=webm])+bestaudio'})

  387.         yie = YoutubeIE(ydl)

  388.         yie._sort_formats(info_dict['formats'])

  389.         ydl.process_ie_result(info_dict)

  390.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]

  391.         self.assertEqual(downloaded_ids, ['248+141'])

  392. 

  393.         for f1, f2 in zip(formats_order, formats_order[1:]):

  394.             info_dict = _make_result([f1, f2], extractor='youtube')

  395.             ydl = YDL({'format': 'best/bestvideo'})

  396.             yie = YoutubeIE(ydl)

  397.             yie._sort_formats(info_dict['formats'])

  398.             ydl.process_ie_result(info_dict)

  399.             downloaded = ydl.downloaded_info_dicts[0]

  400.             self.assertEqual(downloaded['format_id'], f1['format_id'])

  401. 

  402.             info_dict = _make_result([f2, f1], extractor='youtube')

  403.             ydl = YDL({'format': 'best/bestvideo'})

  404.             yie = YoutubeIE(ydl)

  405.             yie._sort_formats(info_dict['formats'])

  406.             ydl.process_ie_result(info_dict)

  407.             downloaded = ydl.downloaded_info_dicts[0]

  408.             self.assertEqual(downloaded['format_id'], f1['format_id'])

  409. 

  410.     def test_audio_only_extractor_format_selection(self):

  411.         # For extractors with incomplete formats (all formats are audio-only or

  412.         # video-only) best and worst should fallback to corresponding best/worst

  413.         # video-only or audio-only formats (as per

  414.         # https://github.com/ytdl-org/youtube-dl/pull/5556)

  415.         formats = [

  416.             {'format_id': 'low', 'ext': 'mp3', 'preference': 1, 'vcodec': 'none', 'url': TEST_URL},

  417.             {'format_id': 'high', 'ext': 'mp3', 'preference': 2, 'vcodec': 'none', 'url': TEST_URL},

  418.         ]

  419.         info_dict = _make_result(formats)

  420. 

  421.         ydl = YDL({'format': 'best'})

  422.         ydl.process_ie_result(info_dict.copy())

  423.         downloaded = ydl.downloaded_info_dicts[0]

  424.         self.assertEqual(downloaded['format_id'], 'high')

  425. 

  426.         ydl = YDL({'format': 'worst'})

  427.         ydl.process_ie_result(info_dict.copy())

  428.         downloaded = ydl.downloaded_info_dicts[0]

  429.         self.assertEqual(downloaded['format_id'], 'low')

  430. 

  431.     def test_format_not_available(self):

  432.         formats = [

  433.             {'format_id': 'regular', 'ext': 'mp4', 'height': 360, 'url': TEST_URL},

  434.             {'format_id': 'video', 'ext': 'mp4', 'height': 720, 'acodec': 'none', 'url': TEST_URL},

  435.         ]

  436.         info_dict = _make_result(formats)

  437. 

  438.         # This must fail since complete video-audio format does not match filter

  439.         # and extractor does not provide incomplete only formats (i.e. only

  440.         # video-only or audio-only).

  441.         ydl = YDL({'format': 'best[height>360]'})

  442.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())

  443. 

  444.     def test_format_selection_issue_10083(self):

  445.         # See https://github.com/ytdl-org/youtube-dl/issues/10083

  446.         formats = [

  447.             {'format_id': 'regular', 'height': 360, 'url': TEST_URL},

  448.             {'format_id': 'video', 'height': 720, 'acodec': 'none', 'url': TEST_URL},

  449.             {'format_id': 'audio', 'vcodec': 'none', 'url': TEST_URL},

  450.         ]

  451.         info_dict = _make_result(formats)

  452. 

  453.         ydl = YDL({'format': 'best[height>360]/bestvideo[height>360]+bestaudio'})

  454.         ydl.process_ie_result(info_dict.copy())

  455.         self.assertEqual(ydl.downloaded_info_dicts[0]['format_id'], 'video+audio')

  456. 

  457.     def test_invalid_format_specs(self):

  458.         def assert_syntax_error(format_spec):

  459.             ydl = YDL({'format': format_spec})

  460.             info_dict = _make_result([{'format_id': 'foo', 'url': TEST_URL}])

  461.             self.assertRaises(SyntaxError, ydl.process_ie_result, info_dict)

  462. 

  463.         assert_syntax_error('bestvideo,,best')

  464.         assert_syntax_error('+bestaudio')

  465.         assert_syntax_error('bestvideo+')

  466.         assert_syntax_error('/')

  467. 

  468.     def test_format_filtering(self):

  469.         formats = [

  470.             {'format_id': 'A', 'filesize': 500, 'width': 1000},

  471.             {'format_id': 'B', 'filesize': 1000, 'width': 500},

  472.             {'format_id': 'C', 'filesize': 1000, 'width': 400},

  473.             {'format_id': 'D', 'filesize': 2000, 'width': 600},

  474.             {'format_id': 'E', 'filesize': 3000},

  475.             {'format_id': 'F'},

  476.             {'format_id': 'G', 'filesize': 1000000},

  477.         ]

  478.         for f in formats:

  479.             f['url'] = 'http://_/'

  480.             f['ext'] = 'unknown'

  481.         info_dict = _make_result(formats)

  482. 

  483.         ydl = YDL({'format': 'best[filesize<3000]'})

  484.         ydl.process_ie_result(info_dict)

  485.         downloaded = ydl.downloaded_info_dicts[0]

  486.         self.assertEqual(downloaded['format_id'], 'D')

  487. 

  488.         ydl = YDL({'format': 'best[filesize<=3000]'})

  489.         ydl.process_ie_result(info_dict)

  490.         downloaded = ydl.downloaded_info_dicts[0]

  491.         self.assertEqual(downloaded['format_id'], 'E')

  492. 

  493.         ydl = YDL({'format': 'best[filesize <= ? 3000]'})

  494.         ydl.process_ie_result(info_dict)

  495.         downloaded = ydl.downloaded_info_dicts[0]

  496.         self.assertEqual(downloaded['format_id'], 'F')

  497. 

  498.         ydl = YDL({'format': 'best [filesize = 1000] [width>450]'})

  499.         ydl.process_ie_result(info_dict)

  500.         downloaded = ydl.downloaded_info_dicts[0]

  501.         self.assertEqual(downloaded['format_id'], 'B')

  502. 

  503.         ydl = YDL({'format': 'best [filesize = 1000] [width!=450]'})

  504.         ydl.process_ie_result(info_dict)

  505.         downloaded = ydl.downloaded_info_dicts[0]

  506.         self.assertEqual(downloaded['format_id'], 'C')

  507. 

  508.         ydl = YDL({'format': '[filesize>?1]'})

  509.         ydl.process_ie_result(info_dict)

  510.         downloaded = ydl.downloaded_info_dicts[0]

  511.         self.assertEqual(downloaded['format_id'], 'G')

  512. 

  513.         ydl = YDL({'format': '[filesize<1M]'})

  514.         ydl.process_ie_result(info_dict)

  515.         downloaded = ydl.downloaded_info_dicts[0]

  516.         self.assertEqual(downloaded['format_id'], 'E')

  517. 

  518.         ydl = YDL({'format': '[filesize<1MiB]'})

  519.         ydl.process_ie_result(info_dict)

  520.         downloaded = ydl.downloaded_info_dicts[0]

  521.         self.assertEqual(downloaded['format_id'], 'G')

  522. 

  523.         ydl = YDL({'format': 'all[width>=400][width<=600]'})

  524.         ydl.process_ie_result(info_dict)

  525.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]

  526.         self.assertEqual(downloaded_ids, ['B', 'C', 'D'])

  527. 

  528.         ydl = YDL({'format': 'best[height<40]'})

  529.         try:

  530.             ydl.process_ie_result(info_dict)

  531.         except ExtractorError:

  532.             pass

  533.         self.assertEqual(ydl.downloaded_info_dicts, [])

  534. 

  535.     def test_default_format_spec(self):

  536.         ydl = YDL({'simulate': True})

  537.         self.assertEqual(ydl._default_format_spec({}), 'bestvideo+bestaudio/best')

  538. 

  539.         ydl = YDL({})

  540.         self.assertEqual(ydl._default_format_spec({'is_live': True}), 'best/bestvideo+bestaudio')

  541. 

  542.         ydl = YDL({'simulate': True})

  543.         self.assertEqual(ydl._default_format_spec({'is_live': True}), 'bestvideo+bestaudio/best')

  544. 

  545.         ydl = YDL({'outtmpl': '-'})

  546.         self.assertEqual(ydl._default_format_spec({}), 'best/bestvideo+bestaudio')

  547. 

  548.         ydl = YDL({})

  549.         self.assertEqual(ydl._default_format_spec({}, download=False), 'bestvideo+bestaudio/best')

  550.         self.assertEqual(ydl._default_format_spec({'is_live': True}), 'best/bestvideo+bestaudio')

  551. 

  552. 

  553. class TestYoutubeDL(unittest.TestCase):

  554.     def test_subtitles(self):

  555.         def s_formats(lang, autocaption=False):

  556.             return [{

  557.                 'ext': ext,

  558.                 'url': 'http://localhost/video.%s.%s' % (lang, ext),

  559.                 '_auto': autocaption,

  560.             } for ext in ['vtt', 'srt', 'ass']]

  561.         subtitles = dict((l, s_formats(l)) for l in ['en', 'fr', 'es'])

  562.         auto_captions = dict((l, s_formats(l, True)) for l in ['it', 'pt', 'es'])

  563.         info_dict = {

  564.             'id': 'test',

  565.             'title': 'Test',

  566.             'url': 'http://localhost/video.mp4',

  567.             'subtitles': subtitles,

  568.             'automatic_captions': auto_captions,

  569.             'extractor': 'TEST',

  570.         }

  571. 

  572.         def get_info(params={}):

  573.             params.setdefault('simulate', True)

  574.             ydl = YDL(params)

  575.             ydl.report_warning = lambda *args, **kargs: None

  576.             return ydl.process_video_result(info_dict, download=False)

  577. 

  578.         result = get_info()

  579.         self.assertFalse(result.get('requested_subtitles'))

  580.         self.assertEqual(result['subtitles'], subtitles)

  581.         self.assertEqual(result['automatic_captions'], auto_captions)

  582. 

  583.         result = get_info({'writesubtitles': True})

  584.         subs = result['requested_subtitles']

  585.         self.assertTrue(subs)

  586.         self.assertEqual(set(subs.keys()), set(['en']))

  587.         self.assertTrue(subs['en'].get('data') is None)

  588.         self.assertEqual(subs['en']['ext'], 'ass')

  589. 

  590.         result = get_info({'writesubtitles': True, 'subtitlesformat': 'foo/srt'})

  591.         subs = result['requested_subtitles']

  592.         self.assertEqual(subs['en']['ext'], 'srt')

  593. 

  594.         result = get_info({'writesubtitles': True, 'subtitleslangs': ['es', 'fr', 'it']})

  595.         subs = result['requested_subtitles']

  596.         self.assertTrue(subs)

  597.         self.assertEqual(set(subs.keys()), set(['es', 'fr']))

  598. 

  599.         result = get_info({'writesubtitles': True, 'writeautomaticsub': True, 'subtitleslangs': ['es', 'pt']})

  600.         subs = result['requested_subtitles']

  601.         self.assertTrue(subs)

  602.         self.assertEqual(set(subs.keys()), set(['es', 'pt']))

  603.         self.assertFalse(subs['es']['_auto'])

  604.         self.assertTrue(subs['pt']['_auto'])

  605. 

  606.         result = get_info({'writeautomaticsub': True, 'subtitleslangs': ['es', 'pt']})

  607.         subs = result['requested_subtitles']

  608.         self.assertTrue(subs)

  609.         self.assertEqual(set(subs.keys()), set(['es', 'pt']))

  610.         self.assertTrue(subs['es']['_auto'])

  611.         self.assertTrue(subs['pt']['_auto'])

  612. 

  613.     def test_add_extra_info(self):

  614.         test_dict = {

  615.             'extractor': 'Foo',

  616.         }

  617.         extra_info = {

  618.             'extractor': 'Bar',

  619.             'playlist': 'funny videos',

  620.         }

  621.         YDL.add_extra_info(test_dict, extra_info)

  622.         self.assertEqual(test_dict['extractor'], 'Foo')

  623.         self.assertEqual(test_dict['playlist'], 'funny videos')

  624. 

  625.     def test_prepare_filename(self):

  626.         info = {

  627.             'id': '1234',

  628.             'ext': 'mp4',

  629.             'width': None,

  630.             'height': 1080,

  631.             'title1': '$PATH',

  632.             'title2': '%PATH%',

  633.         }

  634. 

  635.         def fname(templ):

  636.             ydl = YoutubeDL({'outtmpl': templ})

  637.             return ydl.prepare_filename(info)

  638.         self.assertEqual(fname('%(id)s.%(ext)s'), '1234.mp4')

  639.         self.assertEqual(fname('%(id)s-%(width)s.%(ext)s'), '1234-NA.mp4')

  640.         # Replace missing fields with 'NA'

  641.         self.assertEqual(fname('%(uploader_date)s-%(id)s.%(ext)s'), 'NA-1234.mp4')

  642.         self.assertEqual(fname('%(height)d.%(ext)s'), '1080.mp4')

  643.         self.assertEqual(fname('%(height)6d.%(ext)s'), '  1080.mp4')

  644.         self.assertEqual(fname('%(height)-6d.%(ext)s'), '1080  .mp4')

  645.         self.assertEqual(fname('%(height)06d.%(ext)s'), '001080.mp4')

  646.         self.assertEqual(fname('%(height) 06d.%(ext)s'), ' 01080.mp4')

  647.         self.assertEqual(fname('%(height)   06d.%(ext)s'), ' 01080.mp4')

  648.         self.assertEqual(fname('%(height)0 6d.%(ext)s'), ' 01080.mp4')

  649.         self.assertEqual(fname('%(height)0   6d.%(ext)s'), ' 01080.mp4')

  650.         self.assertEqual(fname('%(height)   0   6d.%(ext)s'), ' 01080.mp4')

  651.         self.assertEqual(fname('%%'), '%')

  652.         self.assertEqual(fname('%%%%'), '%%')

  653.         self.assertEqual(fname('%%(height)06d.%(ext)s'), '%(height)06d.mp4')

  654.         self.assertEqual(fname('%(width)06d.%(ext)s'), 'NA.mp4')

  655.         self.assertEqual(fname('%(width)06d.%%(ext)s'), 'NA.%(ext)s')

  656.         self.assertEqual(fname('%%(width)06d.%(ext)s'), '%(width)06d.mp4')

  657.         self.assertEqual(fname('Hello %(title1)s'), 'Hello $PATH')

  658.         self.assertEqual(fname('Hello %(title2)s'), 'Hello %PATH%')

  659. 

  660.     def test_format_note(self):

  661.         ydl = YoutubeDL()

  662.         self.assertEqual(ydl._format_note({}), '')

  663.         assertRegexpMatches(self, ydl._format_note({

  664.             'vbr': 10,

  665.         }), r'^\s*10k$')

  666.         assertRegexpMatches(self, ydl._format_note({

  667.             'fps': 30,

  668.         }), r'^30fps$')

  669. 

  670.     def test_postprocessors(self):

  671.         filename = 'post-processor-testfile.mp4'

  672.         audiofile = filename + '.mp3'

  673. 

  674.         class SimplePP(PostProcessor):

  675.             def run(self, info):

  676.                 with open(audiofile, 'wt') as f:

  677.                     f.write('EXAMPLE')

  678.                 return [info['filepath']], info

  679. 

  680.         def run_pp(params, PP):

  681.             with open(filename, 'wt') as f:

  682.                 f.write('EXAMPLE')

  683.             ydl = YoutubeDL(params)

  684.             ydl.add_post_processor(PP())

  685.             ydl.post_process(filename, {'filepath': filename})

  686. 

  687.         run_pp({'keepvideo': True}, SimplePP)

  688.         self.assertTrue(os.path.exists(filename), '%s doesn\'t exist' % filename)

  689.         self.assertTrue(os.path.exists(audiofile), '%s doesn\'t exist' % audiofile)

  690.         os.unlink(filename)

  691.         os.unlink(audiofile)

  692. 

  693.         run_pp({'keepvideo': False}, SimplePP)

  694.         self.assertFalse(os.path.exists(filename), '%s exists' % filename)

  695.         self.assertTrue(os.path.exists(audiofile), '%s doesn\'t exist' % audiofile)

  696.         os.unlink(audiofile)

  697. 

  698.         class ModifierPP(PostProcessor):

  699.             def run(self, info):

  700.                 with open(info['filepath'], 'wt') as f:

  701.                     f.write('MODIFIED')

  702.                 return [], info

  703. 

  704.         run_pp({'keepvideo': False}, ModifierPP)

  705.         self.assertTrue(os.path.exists(filename), '%s doesn\'t exist' % filename)

  706.         os.unlink(filename)

  707. 

  708.     def test_match_filter(self):

  709.         class FilterYDL(YDL):

  710.             def __init__(self, *args, **kwargs):

  711.                 super(FilterYDL, self).__init__(*args, **kwargs)

  712.                 self.params['simulate'] = True

  713. 

  714.             def process_info(self, info_dict):

  715.                 super(YDL, self).process_info(info_dict)

  716. 

  717.             def _match_entry(self, info_dict, incomplete):

  718.                 res = super(FilterYDL, self)._match_entry(info_dict, incomplete)

  719.                 if res is None:

  720.                     self.downloaded_info_dicts.append(info_dict)

  721.                 return res

  722. 

  723.         first = {

  724.             'id': '1',

  725.             'url': TEST_URL,

  726.             'title': 'one',

  727.             'extractor': 'TEST',

  728.             'duration': 30,

  729.             'filesize': 10 * 1024,

  730.             'playlist_id': '42',

  731.             'uploader': "變態妍字幕版 太妍 тест",

  732.             'creator': "тест ' 123 ' тест--",

  733.         }

  734.         second = {

  735.             'id': '2',

  736.             'url': TEST_URL,

  737.             'title': 'two',

  738.             'extractor': 'TEST',

  739.             'duration': 10,

  740.             'description': 'foo',

  741.             'filesize': 5 * 1024,

  742.             'playlist_id': '43',

  743.             'uploader': "тест 123",

  744.         }

  745.         videos = [first, second]

  746. 

  747.         def get_videos(filter_=None):

  748.             ydl = FilterYDL({'match_filter': filter_})

  749.             for v in videos:

  750.                 ydl.process_ie_result(v, download=True)

  751.             return [v['id'] for v in ydl.downloaded_info_dicts]

  752. 

  753.         res = get_videos()

  754.         self.assertEqual(res, ['1', '2'])

  755. 

  756.         def f(v):

  757.             if v['id'] == '1':

  758.                 return None

  759.             else:

  760.                 return 'Video id is not 1'

  761.         res = get_videos(f)

  762.         self.assertEqual(res, ['1'])

  763. 

  764.         f = match_filter_func('duration < 30')

  765.         res = get_videos(f)

  766.         self.assertEqual(res, ['2'])

  767. 

  768.         f = match_filter_func('description = foo')

  769.         res = get_videos(f)

  770.         self.assertEqual(res, ['2'])

  771. 

  772.         f = match_filter_func('description =? foo')

  773.         res = get_videos(f)

  774.         self.assertEqual(res, ['1', '2'])

  775. 

  776.         f = match_filter_func('filesize > 5KiB')

  777.         res = get_videos(f)

  778.         self.assertEqual(res, ['1'])

  779. 

  780.         f = match_filter_func('playlist_id = 42')

  781.         res = get_videos(f)

  782.         self.assertEqual(res, ['1'])

  783. 

  784.         f = match_filter_func('uploader = "變態妍字幕版 太妍 тест"')

  785.         res = get_videos(f)

  786.         self.assertEqual(res, ['1'])

  787. 

  788.         f = match_filter_func('uploader != "變態妍字幕版 太妍 тест"')

  789.         res = get_videos(f)

  790.         self.assertEqual(res, ['2'])

  791. 

  792.         f = match_filter_func('creator = "тест \' 123 \' тест--"')

  793.         res = get_videos(f)

  794.         self.assertEqual(res, ['1'])

  795. 

  796.         f = match_filter_func("creator = 'тест \\' 123 \\' тест--'")

  797.         res = get_videos(f)

  798.         self.assertEqual(res, ['1'])

  799. 

  800.         f = match_filter_func(r"creator = 'тест \' 123 \' тест--' & duration > 30")

  801.         res = get_videos(f)

  802.         self.assertEqual(res, [])

  803. 

  804.     def test_playlist_items_selection(self):

  805.         entries = [{

  806.             'id': compat_str(i),

  807.             'title': compat_str(i),

  808.             'url': TEST_URL,

  809.         } for i in range(1, 5)]

  810.         playlist = {

  811.             '_type': 'playlist',

  812.             'id': 'test',

  813.             'entries': entries,

  814.             'extractor': 'test:playlist',

  815.             'extractor_key': 'test:playlist',

  816.             'webpage_url': 'http://example.com',

  817.         }

  818. 

  819.         def get_downloaded_info_dicts(params):

  820.             ydl = YDL(params)

  821.             # make a deep copy because the dictionary and nested entries

  822.             # can be modified

  823.             ydl.process_ie_result(copy.deepcopy(playlist))

  824.             return ydl.downloaded_info_dicts

  825. 

  826.         def get_ids(params):

  827.             return [int(v['id']) for v in get_downloaded_info_dicts(params)]

  828. 

  829.         result = get_ids({})

  830.         self.assertEqual(result, [1, 2, 3, 4])

  831. 

  832.         result = get_ids({'playlistend': 10})

  833.         self.assertEqual(result, [1, 2, 3, 4])

  834. 

  835.         result = get_ids({'playlistend': 2})

  836.         self.assertEqual(result, [1, 2])

  837. 

  838.         result = get_ids({'playliststart': 10})

  839.         self.assertEqual(result, [])

  840. 

  841.         result = get_ids({'playliststart': 2})

  842.         self.assertEqual(result, [2, 3, 4])

  843. 

  844.         result = get_ids({'playlist_items': '2-4'})

  845.         self.assertEqual(result, [2, 3, 4])

  846. 

  847.         result = get_ids({'playlist_items': '2,4'})

  848.         self.assertEqual(result, [2, 4])

  849. 

  850.         result = get_ids({'playlist_items': '10'})

  851.         self.assertEqual(result, [])

  852. 

  853.         result = get_ids({'playlist_items': '3-10'})

  854.         self.assertEqual(result, [3, 4])

  855. 

  856.         result = get_ids({'playlist_items': '2-4,3-4,3'})

  857.         self.assertEqual(result, [2, 3, 4])

  858. 

  859.         # Tests for https://github.com/ytdl-org/youtube-dl/issues/10591

  860.         # @{

  861.         result = get_downloaded_info_dicts({'playlist_items': '2-4,3-4,3'})

  862.         self.assertEqual(result[0]['playlist_index'], 2)

  863.         self.assertEqual(result[1]['playlist_index'], 3)

  864. 

  865.         result = get_downloaded_info_dicts({'playlist_items': '2-4,3-4,3'})

  866.         self.assertEqual(result[0]['playlist_index'], 2)

  867.         self.assertEqual(result[1]['playlist_index'], 3)

  868.         self.assertEqual(result[2]['playlist_index'], 4)

  869. 

  870.         result = get_downloaded_info_dicts({'playlist_items': '4,2'})

  871.         self.assertEqual(result[0]['playlist_index'], 4)

  872.         self.assertEqual(result[1]['playlist_index'], 2)

  873.         # @}

  874. 

  875.     def test_urlopen_no_file_protocol(self):

  876.         # see https://github.com/ytdl-org/youtube-dl/issues/8227

  877.         ydl = YDL()

  878.         self.assertRaises(compat_urllib_error.URLError, ydl.urlopen, 'file:///etc/passwd')

  879. 

  880.     def test_do_not_override_ie_key_in_url_transparent(self):

  881.         ydl = YDL()

  882. 

  883.         class Foo1IE(InfoExtractor):

  884.             _VALID_URL = r'foo1:'

  885. 

  886.             def _real_extract(self, url):

  887.                 return {

  888.                     '_type': 'url_transparent',

  889.                     'url': 'foo2:',

  890.                     'ie_key': 'Foo2',

  891.                     'title': 'foo1 title',

  892.                     'id': 'foo1_id',

  893.                 }

  894. 

  895.         class Foo2IE(InfoExtractor):

  896.             _VALID_URL = r'foo2:'

  897. 

  898.             def _real_extract(self, url):

  899.                 return {

  900.                     '_type': 'url',

  901.                     'url': 'foo3:',

  902.                     'ie_key': 'Foo3',

  903.                 }

  904. 

  905.         class Foo3IE(InfoExtractor):

  906.             _VALID_URL = r'foo3:'

  907. 

  908.             def _real_extract(self, url):

  909.                 return _make_result([{'url': TEST_URL}], title='foo3 title')

  910. 

  911.         ydl.add_info_extractor(Foo1IE(ydl))

  912.         ydl.add_info_extractor(Foo2IE(ydl))

  913.         ydl.add_info_extractor(Foo3IE(ydl))

  914.         ydl.extract_info('foo1:')

  915.         downloaded = ydl.downloaded_info_dicts[0]

  916.         self.assertEqual(downloaded['url'], TEST_URL)

  917.         self.assertEqual(downloaded['title'], 'foo1 title')

  918.         self.assertEqual(downloaded['id'], 'testid')

  919.         self.assertEqual(downloaded['extractor'], 'testex')

  920.         self.assertEqual(downloaded['extractor_key'], 'TestEx')

  921. 

  922. 

  923. if __name__ == '__main__':

  924.     unittest.main()