_ Git - youtube-dl/blob - youtube_dl/extractor/youtube.py

   1 # coding: utf-8
   2
   3 from __future__ import unicode_literals
   4
   5
   6 import itertools
   7 import json
   8 import os.path
   9 import random
  10 import re
  11 import time
  12 import traceback
  13
  14 from .common import InfoExtractor, SearchInfoExtractor
  15 from ..jsinterp import JSInterpreter
  16 from ..swfinterp import SWFInterpreter
  17 from ..compat import (
  18     compat_chr,
  19     compat_parse_qs,
  20     compat_urllib_parse_unquote,
  21     compat_urllib_parse_unquote_plus,
  22     compat_urllib_parse_urlencode,
  23     compat_urllib_parse_urlparse,
  24     compat_urlparse,
  25     compat_str,
  26 )
  27 from ..utils import (
  28     clean_html,
  29     error_to_compat_str,
  30     ExtractorError,
  31     float_or_none,
  32     get_element_by_attribute,
  33     get_element_by_id,
  34     int_or_none,
  35     mimetype2ext,
  36     orderedSet,
  37     parse_codecs,
  38     parse_duration,
  39     remove_quotes,
  40     remove_start,
  41     sanitized_Request,
  42     smuggle_url,
  43     str_to_int,
  44     try_get,
  45     unescapeHTML,
  46     unified_strdate,
  47     unsmuggle_url,
  48     uppercase_escape,
  49     urlencode_postdata,
  50 )
  51
  52
  53 class YoutubeBaseInfoExtractor(InfoExtractor):
  54     """Provide base functions for Youtube extractors"""
  55     _LOGIN_URL = 'https://accounts.google.com/ServiceLogin'
  56     _TWOFACTOR_URL = 'https://accounts.google.com/signin/challenge'
  57     _PASSWORD_CHALLENGE_URL = 'https://accounts.google.com/signin/challenge/sl/password'
  58     _NETRC_MACHINE = 'youtube'
  59     # If True it will raise an error if no login info is provided
  60     _LOGIN_REQUIRED = False
  61
  62     _PLAYLIST_ID_RE = r'(?:PL|LL|EC|UU|FL|RD|UL|TL)[0-9A-Za-z-_]{10,}'
  63
  64     def _set_language(self):
  65         self._set_cookie(
  66             '.youtube.com', 'PREF', 'f1=50000000&hl=en',
  67             # YouTube sets the expire time to about two months
  68             expire_time=time.time() + 2 * 30 * 24 * 3600)
  69
  70     def _ids_to_results(self, ids):
  71         return [
  72             self.url_result(vid_id, 'Youtube', video_id=vid_id)
  73             for vid_id in ids]
  74
  75     def _login(self):
  76         """
  77         Attempt to log in to YouTube.
  78         True is returned if successful or skipped.
  79         False is returned if login failed.
  80
  81         If _LOGIN_REQUIRED is set and no authentication was provided, an error is raised.
  82         """
  83         (username, password) = self._get_login_info()
  84         # No authentication to be performed
  85         if username is None:
  86             if self._LOGIN_REQUIRED:
  87                 raise ExtractorError('No login info available, needed for using %s.' % self.IE_NAME, expected=True)
  88             return True
  89
  90         login_page = self._download_webpage(
  91             self._LOGIN_URL, None,
  92             note='Downloading login page',
  93             errnote='unable to fetch login page', fatal=False)
  94         if login_page is False:
  95             return
  96
  97         login_form = self._hidden_inputs(login_page)
  98
  99         login_form.update({
 100             'checkConnection': 'youtube',
 101             'Email': username,
 102             'Passwd': password,
 103         })
 104
 105         login_results = self._download_webpage(
 106             self._PASSWORD_CHALLENGE_URL, None,
 107             note='Logging in', errnote='unable to log in', fatal=False,
 108             data=urlencode_postdata(login_form))
 109         if login_results is False:
 110             return False
 111
 112         error_msg = self._html_search_regex(
 113             r'<[^>]+id="errormsg_0_Passwd"[^>]*>([^<]+)<',
 114             login_results, 'error message', default=None)
 115         if error_msg:
 116             raise ExtractorError('Unable to login: %s' % error_msg, expected=True)
 117
 118         if re.search(r'id="errormsg_0_Passwd"', login_results) is not None:
 119             raise ExtractorError('Please use your account password and a two-factor code instead of an application-specific password.', expected=True)
 120
 121         # Two-Factor
 122         # TODO add SMS and phone call support - these require making a request and then prompting the user
 123
 124         if re.search(r'(?i)<form[^>]+id="challenge"', login_results) is not None:
 125             tfa_code = self._get_tfa_info('2-step verification code')
 126
 127             if not tfa_code:
 128                 self._downloader.report_warning(
 129                     'Two-factor authentication required. Provide it either interactively or with --twofactor <code>'
 130                     '(Note that only TOTP (Google Authenticator App) codes work at this time.)')
 131                 return False
 132
 133             tfa_code = remove_start(tfa_code, 'G-')
 134
 135             tfa_form_strs = self._form_hidden_inputs('challenge', login_results)
 136
 137             tfa_form_strs.update({
 138                 'Pin': tfa_code,
 139                 'TrustDevice': 'on',
 140             })
 141
 142             tfa_data = urlencode_postdata(tfa_form_strs)
 143
 144             tfa_req = sanitized_Request(self._TWOFACTOR_URL, tfa_data)
 145             tfa_results = self._download_webpage(
 146                 tfa_req, None,
 147                 note='Submitting TFA code', errnote='unable to submit tfa', fatal=False)
 148
 149             if tfa_results is False:
 150                 return False
 151
 152             if re.search(r'(?i)<form[^>]+id="challenge"', tfa_results) is not None:
 153                 self._downloader.report_warning('Two-factor code expired or invalid. Please try again, or use a one-use backup code instead.')
 154                 return False
 155             if re.search(r'(?i)<form[^>]+id="gaia_loginform"', tfa_results) is not None:
 156                 self._downloader.report_warning('unable to log in - did the page structure change?')
 157                 return False
 158             if re.search(r'smsauth-interstitial-reviewsettings', tfa_results) is not None:
 159                 self._downloader.report_warning('Your Google account has a security notice. Please log in on your web browser, resolve the notice, and try again.')
 160                 return False
 161
 162         if re.search(r'(?i)<form[^>]+id="gaia_loginform"', login_results) is not None:
 163             self._downloader.report_warning('unable to log in: bad username or password')
 164             return False
 165         return True
 166
 167     def _real_initialize(self):
 168         if self._downloader is None:
 169             return
 170         self._set_language()
 171         if not self._login():
 172             return
 173
 174
 175 class YoutubeEntryListBaseInfoExtractor(YoutubeBaseInfoExtractor):
 176     # Extract entries from page with "Load more" button
 177     def _entries(self, page, playlist_id):
 178         more_widget_html = content_html = page
 179         for page_num in itertools.count(1):
 180             for entry in self._process_page(content_html):
 181                 yield entry
 182
 183             mobj = re.search(r'data-uix-load-more-href="/?(?P<more>[^"]+)"', more_widget_html)
 184             if not mobj:
 185                 break
 186
 187             more = self._download_json(
 188                 'https://youtube.com/%s' % mobj.group('more'), playlist_id,
 189                 'Downloading page #%s' % page_num,
 190                 transform_source=uppercase_escape)
 191             content_html = more['content_html']
 192             if not content_html.strip():
 193                 # Some webpages show a "Load more" button but they don't
 194                 # have more videos
 195                 break
 196             more_widget_html = more['load_more_widget_html']
 197
 198
 199 class YoutubePlaylistBaseInfoExtractor(YoutubeEntryListBaseInfoExtractor):
 200     def _process_page(self, content):
 201         for video_id, video_title in self.extract_videos_from_page(content):
 202             yield self.url_result(video_id, 'Youtube', video_id, video_title)
 203
 204     def extract_videos_from_page(self, page):
 205         ids_in_page = []
 206         titles_in_page = []
 207         for mobj in re.finditer(self._VIDEO_RE, page):
 208             # The link with index 0 is not the first video of the playlist (not sure if still actual)
 209             if 'index' in mobj.groupdict() and mobj.group('id') == '0':
 210                 continue
 211             video_id = mobj.group('id')
 212             video_title = unescapeHTML(mobj.group('title'))
 213             if video_title:
 214                 video_title = video_title.strip()
 215             try:
 216                 idx = ids_in_page.index(video_id)
 217                 if video_title and not titles_in_page[idx]:
 218                     titles_in_page[idx] = video_title
 219             except ValueError:
 220                 ids_in_page.append(video_id)
 221                 titles_in_page.append(video_title)
 222         return zip(ids_in_page, titles_in_page)
 223
 224
 225 class YoutubePlaylistsBaseInfoExtractor(YoutubeEntryListBaseInfoExtractor):
 226     def _process_page(self, content):
 227         for playlist_id in orderedSet(re.findall(
 228                 r'<h3[^>]+class="[^"]*yt-lockup-title[^"]*"[^>]*><a[^>]+href="/?playlist\?list=([0-9A-Za-z-_]{10,})"',
 229                 content)):
 230             yield self.url_result(
 231                 'https://www.youtube.com/playlist?list=%s' % playlist_id, 'YoutubePlaylist')
 232
 233     def _real_extract(self, url):
 234         playlist_id = self._match_id(url)
 235         webpage = self._download_webpage(url, playlist_id)
 236         title = self._og_search_title(webpage, fatal=False)
 237         return self.playlist_result(self._entries(webpage, playlist_id), playlist_id, title)
 238
 239
 240 class YoutubeIE(YoutubeBaseInfoExtractor):
 241     IE_DESC = 'YouTube.com'
 242     _VALID_URL = r"""(?x)^
 243                      (
 244                          (?:https?://|//)                                    # http(s):// or protocol-independent URL
 245                          (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/|
 246                             (?:www\.)?deturl\.com/www\.youtube\.com/|
 247                             (?:www\.)?pwnyoutube\.com/|
 248                             (?:www\.)?yourepeat\.com/|
 249                             tube\.majestyc\.net/|
 250                             youtube\.googleapis\.com/)                        # the various hostnames, with wildcard subdomains
 251                          (?:.*?\#/)?                                          # handle anchor (#/) redirect urls
 252                          (?:                                                  # the various things that can precede the ID:
 253                              (?:(?:v|embed|e)/(?!videoseries))                # v/ or embed/ or e/
 254                              |(?:                                             # or the v= param in all its forms
 255                                  (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)?  # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
 256                                  (?:\?|\#!?)                                  # the params delimiter ? or # or #!
 257                                  (?:.*?[&;])??                                # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&amp;v=V36LpHqtcDY)
 258                                  v=
 259                              )
 260                          ))
 261                          |(?:
 262                             youtu\.be|                                        # just youtu.be/xxxx
 263                             vid\.plus|                                        # or vid.plus/xxxx
 264                             zwearz\.com/watch|                                # or zwearz.com/watch/xxxx
 265                          )/
 266                          |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
 267                          )
 268                      )?                                                       # all until now is optional -> you can pass the naked ID
 269                      ([0-9A-Za-z_-]{11})                                      # here is it! the YouTube video ID
 270                      (?!.*?\blist=
 271                         (?:
 272                             %(playlist_id)s|                                  # combined list/video URLs are handled by the playlist IE
 273                             WL                                                # WL are handled by the watch later IE
 274                         )
 275                      )
 276                      (?(1).+)?                                                # if we found the ID, everything can follow
 277                      $""" % {'playlist_id': YoutubeBaseInfoExtractor._PLAYLIST_ID_RE}
 278     _NEXT_URL_RE = r'[\?&]next_url=([^&]+)'
 279     _formats = {
 280         '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
 281         '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
 282         '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
 283         '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
 284         '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
 285         '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
 286         '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
 287         '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
 288         # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
 289         '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
 290         '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
 291         '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
 292         '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
 293         '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
 294         '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
 295         '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
 296         '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
 297         '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
 298
 299
 300         # 3D videos
 301         '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
 302         '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
 303         '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
 304         '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
 305         '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
 306         '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
 307         '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
 308
 309         # Apple HTTP Live Streaming
 310         '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
 311         '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
 312         '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
 313         '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
 314         '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
 315         '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
 316         '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
 317         '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
 318
 319         # DASH mp4 video
 320         '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
 321         '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
 322         '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
 323         '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
 324         '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
 325         '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'},  # Height can vary (https://github.com/rg3/youtube-dl/issues/4559)
 326         '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
 327         '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
 328         '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
 329         '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
 330         '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
 331         '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
 332
 333         # Dash mp4 audio
 334         '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
 335         '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
 336         '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
 337         '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
 338         '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
 339         '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
 340         '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
 341
 342         # Dash webm
 343         '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 344         '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 345         '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 346         '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 347         '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 348         '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 349         '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
 350         '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 351         '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 352         '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 353         '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 354         '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 355         '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 356         '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 357         '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 358         # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
 359         '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 360         '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
 361         '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
 362         '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
 363         '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 364         '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
 365
 366         # Dash webm audio
 367         '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
 368         '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
 369
 370         # Dash webm audio with opus inside
 371         '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
 372         '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
 373         '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
 374
 375         # RTMP (unnamed)
 376         '_rtmp': {'protocol': 'rtmp'},
 377     }
 378     _SUBTITLE_FORMATS = ('ttml', 'vtt')
 379
 380     _GEO_BYPASS = False
 381
 382     IE_NAME = 'youtube'
 383     _TESTS = [
 384         {
 385             'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
 386             'info_dict': {
 387                 'id': 'BaW_jenozKc',
 388                 'ext': 'mp4',
 389                 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
 390                 'uploader': 'Philipp Hagemeister',
 391                 'uploader_id': 'phihag',
 392                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/phihag',
 393                 'upload_date': '20121002',
 394                 'license': 'Standard YouTube License',
 395                 'description': 'test chars:  "\'/\\ä↭𝕐\ntest URL: https://github.com/rg3/youtube-dl/issues/1892\n\nThis is a test video for youtube-dl.\n\nFor more information, contact phihag@phihag.de .',
 396                 'categories': ['Science & Technology'],
 397                 'tags': ['youtube-dl'],
 398                 'duration': 10,
 399                 'like_count': int,
 400                 'dislike_count': int,
 401                 'start_time': 1,
 402                 'end_time': 9,
 403             }
 404         },
 405         {
 406             'url': 'https://www.youtube.com/watch?v=UxxajLWwzqY',
 407             'note': 'Test generic use_cipher_signature video (#897)',
 408             'info_dict': {
 409                 'id': 'UxxajLWwzqY',
 410                 'ext': 'mp4',
 411                 'upload_date': '20120506',
 412                 'title': 'Icona Pop - I Love It (feat. Charli XCX) [OFFICIAL VIDEO]',
 413                 'alt_title': 'I Love It (feat. Charli XCX)',
 414                 'description': 'md5:f3ceb5ef83a08d95b9d146f973157cc8',
 415                 'tags': ['Icona Pop i love it', 'sweden', 'pop music', 'big beat records', 'big beat', 'charli',
 416                          'xcx', 'charli xcx', 'girls', 'hbo', 'i love it', "i don't care", 'icona', 'pop',
 417                          'iconic ep', 'iconic', 'love', 'it'],
 418                 'duration': 180,
 419                 'uploader': 'Icona Pop',
 420                 'uploader_id': 'IconaPop',
 421                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/IconaPop',
 422                 'license': 'Standard YouTube License',
 423                 'creator': 'Icona Pop',
 424             }
 425         },
 426         {
 427             'url': 'https://www.youtube.com/watch?v=07FYdnEawAQ',
 428             'note': 'Test VEVO video with age protection (#956)',
 429             'info_dict': {
 430                 'id': '07FYdnEawAQ',
 431                 'ext': 'mp4',
 432                 'upload_date': '20130703',
 433                 'title': 'Justin Timberlake - Tunnel Vision (Explicit)',
 434                 'alt_title': 'Tunnel Vision',
 435                 'description': 'md5:64249768eec3bc4276236606ea996373',
 436                 'duration': 419,
 437                 'uploader': 'justintimberlakeVEVO',
 438                 'uploader_id': 'justintimberlakeVEVO',
 439                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/justintimberlakeVEVO',
 440                 'license': 'Standard YouTube License',
 441                 'creator': 'Justin Timberlake',
 442                 'age_limit': 18,
 443             }
 444         },
 445         {
 446             'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
 447             'note': 'Embed-only video (#1746)',
 448             'info_dict': {
 449                 'id': 'yZIXLfi8CZQ',
 450                 'ext': 'mp4',
 451                 'upload_date': '20120608',
 452                 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
 453                 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
 454                 'uploader': 'SET India',
 455                 'uploader_id': 'setindia',
 456                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/setindia',
 457                 'license': 'Standard YouTube License',
 458                 'age_limit': 18,
 459             }
 460         },
 461         {
 462             'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=UxxajLWwzqY',
 463             'note': 'Use the first video ID in the URL',
 464             'info_dict': {
 465                 'id': 'BaW_jenozKc',
 466                 'ext': 'mp4',
 467                 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
 468                 'uploader': 'Philipp Hagemeister',
 469                 'uploader_id': 'phihag',
 470                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/phihag',
 471                 'upload_date': '20121002',
 472                 'license': 'Standard YouTube License',
 473                 'description': 'test chars:  "\'/\\ä↭𝕐\ntest URL: https://github.com/rg3/youtube-dl/issues/1892\n\nThis is a test video for youtube-dl.\n\nFor more information, contact phihag@phihag.de .',
 474                 'categories': ['Science & Technology'],
 475                 'tags': ['youtube-dl'],
 476                 'duration': 10,
 477                 'like_count': int,
 478                 'dislike_count': int,
 479             },
 480             'params': {
 481                 'skip_download': True,
 482             },
 483         },
 484         {
 485             'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
 486             'note': '256k DASH audio (format 141) via DASH manifest',
 487             'info_dict': {
 488                 'id': 'a9LDPn-MO4I',
 489                 'ext': 'm4a',
 490                 'upload_date': '20121002',
 491                 'uploader_id': '8KVIDEO',
 492                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/8KVIDEO',
 493                 'description': '',
 494                 'uploader': '8KVIDEO',
 495                 'license': 'Standard YouTube License',
 496                 'title': 'UHDTV TEST 8K VIDEO.mp4'
 497             },
 498             'params': {
 499                 'youtube_include_dash_manifest': True,
 500                 'format': '141',
 501             },
 502             'skip': 'format 141 not served anymore',
 503         },
 504         # DASH manifest with encrypted signature
 505         {
 506             'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
 507             'info_dict': {
 508                 'id': 'IB3lcPjvWLA',
 509                 'ext': 'm4a',
 510                 'title': 'Afrojack, Spree Wilson - The Spark ft. Spree Wilson',
 511                 'description': 'md5:12e7067fa6735a77bdcbb58cb1187d2d',
 512                 'duration': 244,
 513                 'uploader': 'AfrojackVEVO',
 514                 'uploader_id': 'AfrojackVEVO',
 515                 'upload_date': '20131011',
 516                 'license': 'Standard YouTube License',
 517             },
 518             'params': {
 519                 'youtube_include_dash_manifest': True,
 520                 'format': '141/bestaudio[ext=m4a]',
 521             },
 522         },
 523         # JS player signature function name containing $
 524         {
 525             'url': 'https://www.youtube.com/watch?v=nfWlot6h_JM',
 526             'info_dict': {
 527                 'id': 'nfWlot6h_JM',
 528                 'ext': 'm4a',
 529                 'title': 'Taylor Swift - Shake It Off',
 530                 'alt_title': 'Shake It Off',
 531                 'description': 'md5:95f66187cd7c8b2c13eb78e1223b63c3',
 532                 'duration': 242,
 533                 'uploader': 'TaylorSwiftVEVO',
 534                 'uploader_id': 'TaylorSwiftVEVO',
 535                 'upload_date': '20140818',
 536                 'license': 'Standard YouTube License',
 537                 'creator': 'Taylor Swift',
 538             },
 539             'params': {
 540                 'youtube_include_dash_manifest': True,
 541                 'format': '141/bestaudio[ext=m4a]',
 542             },
 543         },
 544         # Controversy video
 545         {
 546             'url': 'https://www.youtube.com/watch?v=T4XJQO3qol8',
 547             'info_dict': {
 548                 'id': 'T4XJQO3qol8',
 549                 'ext': 'mp4',
 550                 'duration': 219,
 551                 'upload_date': '20100909',
 552                 'uploader': 'The Amazing Atheist',
 553                 'uploader_id': 'TheAmazingAtheist',
 554                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/TheAmazingAtheist',
 555                 'license': 'Standard YouTube License',
 556                 'title': 'Burning Everyone\'s Koran',
 557                 'description': 'SUBSCRIBE: http://www.youtube.com/saturninefilms\n\nEven Obama has taken a stand against freedom on this issue: http://www.huffingtonpost.com/2010/09/09/obama-gma-interview-quran_n_710282.html',
 558             }
 559         },
 560         # Normal age-gate video (No vevo, embed allowed)
 561         {
 562             'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
 563             'info_dict': {
 564                 'id': 'HtVdAasjOgU',
 565                 'ext': 'mp4',
 566                 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
 567                 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
 568                 'duration': 142,
 569                 'uploader': 'The Witcher',
 570                 'uploader_id': 'WitcherGame',
 571                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/WitcherGame',
 572                 'upload_date': '20140605',
 573                 'license': 'Standard YouTube License',
 574                 'age_limit': 18,
 575             },
 576         },
 577         # Age-gate video with encrypted signature
 578         {
 579             'url': 'https://www.youtube.com/watch?v=6kLq3WMV1nU',
 580             'info_dict': {
 581                 'id': '6kLq3WMV1nU',
 582                 'ext': 'mp4',
 583                 'title': 'Dedication To My Ex (Miss That) (Lyric Video)',
 584                 'description': 'md5:33765bb339e1b47e7e72b5490139bb41',
 585                 'duration': 247,
 586                 'uploader': 'LloydVEVO',
 587                 'uploader_id': 'LloydVEVO',
 588                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/LloydVEVO',
 589                 'upload_date': '20110629',
 590                 'license': 'Standard YouTube License',
 591                 'age_limit': 18,
 592             },
 593         },
 594         # video_info is None (https://github.com/rg3/youtube-dl/issues/4421)
 595         {
 596             'url': '__2ABJjxzNo',
 597             'info_dict': {
 598                 'id': '__2ABJjxzNo',
 599                 'ext': 'mp4',
 600                 'duration': 266,
 601                 'upload_date': '20100430',
 602                 'uploader_id': 'deadmau5',
 603                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/deadmau5',
 604                 'creator': 'deadmau5',
 605                 'description': 'md5:12c56784b8032162bb936a5f76d55360',
 606                 'uploader': 'deadmau5',
 607                 'license': 'Standard YouTube License',
 608                 'title': 'Deadmau5 - Some Chords (HD)',
 609                 'alt_title': 'Some Chords',
 610             },
 611             'expected_warnings': [
 612                 'DASH manifest missing',
 613             ]
 614         },
 615         # Olympics (https://github.com/rg3/youtube-dl/issues/4431)
 616         {
 617             'url': 'lqQg6PlCWgI',
 618             'info_dict': {
 619                 'id': 'lqQg6PlCWgI',
 620                 'ext': 'mp4',
 621                 'duration': 6085,
 622                 'upload_date': '20150827',
 623                 'uploader_id': 'olympic',
 624                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/olympic',
 625                 'license': 'Standard YouTube License',
 626                 'description': 'HO09  - Women -  GER-AUS - Hockey - 31 July 2012 - London 2012 Olympic Games',
 627                 'uploader': 'Olympic',
 628                 'title': 'Hockey - Women -  GER-AUS - London 2012 Olympic Games',
 629             },
 630             'params': {
 631                 'skip_download': 'requires avconv',
 632             }
 633         },
 634         # Non-square pixels
 635         {
 636             'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
 637             'info_dict': {
 638                 'id': '_b-2C3KPAM0',
 639                 'ext': 'mp4',
 640                 'stretched_ratio': 16 / 9.,
 641                 'duration': 85,
 642                 'upload_date': '20110310',
 643                 'uploader_id': 'AllenMeow',
 644                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/AllenMeow',
 645                 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
 646                 'uploader': '孫艾倫',
 647                 'license': 'Standard YouTube License',
 648                 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
 649             },
 650         },
 651         # url_encoded_fmt_stream_map is empty string
 652         {
 653             'url': 'qEJwOuvDf7I',
 654             'info_dict': {
 655                 'id': 'qEJwOuvDf7I',
 656                 'ext': 'webm',
 657                 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
 658                 'description': '',
 659                 'upload_date': '20150404',
 660                 'uploader_id': 'spbelect',
 661                 'uploader': 'Наблюдатели Петербурга',
 662             },
 663             'params': {
 664                 'skip_download': 'requires avconv',
 665             },
 666             'skip': 'This live event has ended.',
 667         },
 668         # Extraction from multiple DASH manifests (https://github.com/rg3/youtube-dl/pull/6097)
 669         {
 670             'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
 671             'info_dict': {
 672                 'id': 'FIl7x6_3R5Y',
 673                 'ext': 'mp4',
 674                 'title': 'md5:7b81415841e02ecd4313668cde88737a',
 675                 'description': 'md5:116377fd2963b81ec4ce64b542173306',
 676                 'duration': 220,
 677                 'upload_date': '20150625',
 678                 'uploader_id': 'dorappi2000',
 679                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/dorappi2000',
 680                 'uploader': 'dorappi2000',
 681                 'license': 'Standard YouTube License',
 682                 'formats': 'mincount:32',
 683             },
 684         },
 685         # DASH manifest with segment_list
 686         {
 687             'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
 688             'md5': '8ce563a1d667b599d21064e982ab9e31',
 689             'info_dict': {
 690                 'id': 'CsmdDsKjzN8',
 691                 'ext': 'mp4',
 692                 'upload_date': '20150501',  # According to '<meta itemprop="datePublished"', but in other places it's 20150510
 693                 'uploader': 'Airtek',
 694                 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
 695                 'uploader_id': 'UCzTzUmjXxxacNnL8I3m4LnQ',
 696                 'license': 'Standard YouTube License',
 697                 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
 698             },
 699             'params': {
 700                 'youtube_include_dash_manifest': True,
 701                 'format': '135',  # bestvideo
 702             },
 703             'skip': 'This live event has ended.',
 704         },
 705         {
 706             # Multifeed videos (multiple cameras), URL is for Main Camera
 707             'url': 'https://www.youtube.com/watch?v=jqWvoWXjCVs',
 708             'info_dict': {
 709                 'id': 'jqWvoWXjCVs',
 710                 'title': 'teamPGP: Rocket League Noob Stream',
 711                 'description': 'md5:dc7872fb300e143831327f1bae3af010',
 712             },
 713             'playlist': [{
 714                 'info_dict': {
 715                     'id': 'jqWvoWXjCVs',
 716                     'ext': 'mp4',
 717                     'title': 'teamPGP: Rocket League Noob Stream (Main Camera)',
 718                     'description': 'md5:dc7872fb300e143831327f1bae3af010',
 719                     'duration': 7335,
 720                     'upload_date': '20150721',
 721                     'uploader': 'Beer Games Beer',
 722                     'uploader_id': 'beergamesbeer',
 723                     'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/beergamesbeer',
 724                     'license': 'Standard YouTube License',
 725                 },
 726             }, {
 727                 'info_dict': {
 728                     'id': '6h8e8xoXJzg',
 729                     'ext': 'mp4',
 730                     'title': 'teamPGP: Rocket League Noob Stream (kreestuh)',
 731                     'description': 'md5:dc7872fb300e143831327f1bae3af010',
 732                     'duration': 7337,
 733                     'upload_date': '20150721',
 734                     'uploader': 'Beer Games Beer',
 735                     'uploader_id': 'beergamesbeer',
 736                     'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/beergamesbeer',
 737                     'license': 'Standard YouTube License',
 738                 },
 739             }, {
 740                 'info_dict': {
 741                     'id': 'PUOgX5z9xZw',
 742                     'ext': 'mp4',
 743                     'title': 'teamPGP: Rocket League Noob Stream (grizzle)',
 744                     'description': 'md5:dc7872fb300e143831327f1bae3af010',
 745                     'duration': 7337,
 746                     'upload_date': '20150721',
 747                     'uploader': 'Beer Games Beer',
 748                     'uploader_id': 'beergamesbeer',
 749                     'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/beergamesbeer',
 750                     'license': 'Standard YouTube License',
 751                 },
 752             }, {
 753                 'info_dict': {
 754                     'id': 'teuwxikvS5k',
 755                     'ext': 'mp4',
 756                     'title': 'teamPGP: Rocket League Noob Stream (zim)',
 757                     'description': 'md5:dc7872fb300e143831327f1bae3af010',
 758                     'duration': 7334,
 759                     'upload_date': '20150721',
 760                     'uploader': 'Beer Games Beer',
 761                     'uploader_id': 'beergamesbeer',
 762                     'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/beergamesbeer',
 763                     'license': 'Standard YouTube License',
 764                 },
 765             }],
 766             'params': {
 767                 'skip_download': True,
 768             },
 769         },
 770         {
 771             # Multifeed video with comma in title (see https://github.com/rg3/youtube-dl/issues/8536)
 772             'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
 773             'info_dict': {
 774                 'id': 'gVfLd0zydlo',
 775                 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
 776             },
 777             'playlist_count': 2,
 778             'skip': 'Not multifeed anymore',
 779         },
 780         {
 781             'url': 'https://vid.plus/FlRa-iH7PGw',
 782             'only_matching': True,
 783         },
 784         {
 785             'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
 786             'only_matching': True,
 787         },
 788         {
 789             # Title with JS-like syntax "};" (see https://github.com/rg3/youtube-dl/issues/7468)
 790             # Also tests cut-off URL expansion in video description (see
 791             # https://github.com/rg3/youtube-dl/issues/1892,
 792             # https://github.com/rg3/youtube-dl/issues/8164)
 793             'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
 794             'info_dict': {
 795                 'id': 'lsguqyKfVQg',
 796                 'ext': 'mp4',
 797                 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
 798                 'alt_title': 'Dark Walk',
 799                 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
 800                 'duration': 133,
 801                 'upload_date': '20151119',
 802                 'uploader_id': 'IronSoulElf',
 803                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/IronSoulElf',
 804                 'uploader': 'IronSoulElf',
 805                 'license': 'Standard YouTube License',
 806                 'creator': 'Todd Haberman, Daniel Law Heath & Aaron Kaplan',
 807             },
 808             'params': {
 809                 'skip_download': True,
 810             },
 811         },
 812         {
 813             # Tags with '};' (see https://github.com/rg3/youtube-dl/issues/7468)
 814             'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
 815             'only_matching': True,
 816         },
 817         {
 818             # Video with yt:stretch=17:0
 819             'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
 820             'info_dict': {
 821                 'id': 'Q39EVAstoRM',
 822                 'ext': 'mp4',
 823                 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
 824                 'description': 'md5:ee18a25c350637c8faff806845bddee9',
 825                 'upload_date': '20151107',
 826                 'uploader_id': 'UCCr7TALkRbo3EtFzETQF1LA',
 827                 'uploader': 'CH GAMER DROID',
 828             },
 829             'params': {
 830                 'skip_download': True,
 831             },
 832             'skip': 'This video does not exist.',
 833         },
 834         {
 835             # Video licensed under Creative Commons
 836             'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
 837             'info_dict': {
 838                 'id': 'M4gD1WSo5mA',
 839                 'ext': 'mp4',
 840                 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
 841                 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
 842                 'duration': 721,
 843                 'upload_date': '20150127',
 844                 'uploader_id': 'BerkmanCenter',
 845                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/BerkmanCenter',
 846                 'uploader': 'The Berkman Klein Center for Internet & Society',
 847                 'license': 'Creative Commons Attribution license (reuse allowed)',
 848             },
 849             'params': {
 850                 'skip_download': True,
 851             },
 852         },
 853         {
 854             # Channel-like uploader_url
 855             'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
 856             'info_dict': {
 857                 'id': 'eQcmzGIKrzg',
 858                 'ext': 'mp4',
 859                 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
 860                 'description': 'md5:dda0d780d5a6e120758d1711d062a867',
 861                 'duration': 4060,
 862                 'upload_date': '20151119',
 863                 'uploader': 'Bernie 2016',
 864                 'uploader_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
 865                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
 866                 'license': 'Creative Commons Attribution license (reuse allowed)',
 867             },
 868             'params': {
 869                 'skip_download': True,
 870             },
 871         },
 872         {
 873             'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;amp;v=V36LpHqtcDY',
 874             'only_matching': True,
 875         },
 876         {
 877             # YouTube Red paid video (https://github.com/rg3/youtube-dl/issues/10059)
 878             'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
 879             'only_matching': True,
 880         },
 881         {
 882             # Rental video preview
 883             'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
 884             'info_dict': {
 885                 'id': 'uGpuVWrhIzE',
 886                 'ext': 'mp4',
 887                 'title': 'Piku - Trailer',
 888                 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
 889                 'upload_date': '20150811',
 890                 'uploader': 'FlixMatrix',
 891                 'uploader_id': 'FlixMatrixKaravan',
 892                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/FlixMatrixKaravan',
 893                 'license': 'Standard YouTube License',
 894             },
 895             'params': {
 896                 'skip_download': True,
 897             },
 898         },
 899         {
 900             # YouTube Red video with episode data
 901             'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
 902             'info_dict': {
 903                 'id': 'iqKdEhx-dD4',
 904                 'ext': 'mp4',
 905                 'title': 'Isolation - Mind Field (Ep 1)',
 906                 'description': 'md5:8013b7ddea787342608f63a13ddc9492',
 907                 'duration': 2085,
 908                 'upload_date': '20170118',
 909                 'uploader': 'Vsauce',
 910                 'uploader_id': 'Vsauce',
 911                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/Vsauce',
 912                 'license': 'Standard YouTube License',
 913                 'series': 'Mind Field',
 914                 'season_number': 1,
 915                 'episode_number': 1,
 916             },
 917             'params': {
 918                 'skip_download': True,
 919             },
 920             'expected_warnings': [
 921                 'Skipping DASH manifest',
 922             ],
 923         },
 924         {
 925             # itag 212
 926             'url': '1t24XAntNCY',
 927             'only_matching': True,
 928         },
 929         {
 930             # geo restricted to JP
 931             'url': 'sJL6WA-aGkQ',
 932             'only_matching': True,
 933         },
 934         {
 935             'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
 936             'only_matching': True,
 937         },
 938     ]
 939
 940     def __init__(self, *args, **kwargs):
 941         super(YoutubeIE, self).__init__(*args, **kwargs)
 942         self._player_cache = {}
 943
 944     def report_video_info_webpage_download(self, video_id):
 945         """Report attempt to download video info webpage."""
 946         self.to_screen('%s: Downloading video info webpage' % video_id)
 947
 948     def report_information_extraction(self, video_id):
 949         """Report attempt to extract video information."""
 950         self.to_screen('%s: Extracting video information' % video_id)
 951
 952     def report_unavailable_format(self, video_id, format):
 953         """Report extracted video URL."""
 954         self.to_screen('%s: Format %s not available' % (video_id, format))
 955
 956     def report_rtmp_download(self):
 957         """Indicate the download will use the RTMP protocol."""
 958         self.to_screen('RTMP download detected')
 959
 960     def _signature_cache_id(self, example_sig):
 961         """ Return a string representation of a signature """
 962         return '.'.join(compat_str(len(part)) for part in example_sig.split('.'))
 963
 964     def _extract_signature_function(self, video_id, player_url, example_sig):
 965         id_m = re.match(
 966             r'.*?-(?P<id>[a-zA-Z0-9_-]+)(?:/watch_as3|/html5player(?:-new)?|(?:/[a-z]{2}_[A-Z]{2})?/base)?\.(?P<ext>[a-z]+)$',
 967             player_url)
 968         if not id_m:
 969             raise ExtractorError('Cannot identify player %r' % player_url)
 970         player_type = id_m.group('ext')
 971         player_id = id_m.group('id')
 972
 973         # Read from filesystem cache
 974         func_id = '%s_%s_%s' % (
 975             player_type, player_id, self._signature_cache_id(example_sig))
 976         assert os.path.basename(func_id) == func_id
 977
 978         cache_spec = self._downloader.cache.load('youtube-sigfuncs', func_id)
 979         if cache_spec is not None:
 980             return lambda s: ''.join(s[i] for i in cache_spec)
 981
 982         download_note = (
 983             'Downloading player %s' % player_url
 984             if self._downloader.params.get('verbose') else
 985             'Downloading %s player %s' % (player_type, player_id)
 986         )
 987         if player_type == 'js':
 988             code = self._download_webpage(
 989                 player_url, video_id,
 990                 note=download_note,
 991                 errnote='Download of %s failed' % player_url)
 992             res = self._parse_sig_js(code)
 993         elif player_type == 'swf':
 994             urlh = self._request_webpage(
 995                 player_url, video_id,
 996                 note=download_note,
 997                 errnote='Download of %s failed' % player_url)
 998             code = urlh.read()
 999             res = self._parse_sig_swf(code)
1000         else:
1001             assert False, 'Invalid player type %r' % player_type
1002
1003         test_string = ''.join(map(compat_chr, range(len(example_sig))))
1004         cache_res = res(test_string)
1005         cache_spec = [ord(c) for c in cache_res]
1006
1007         self._downloader.cache.store('youtube-sigfuncs', func_id, cache_spec)
1008         return res
1009
1010     def _print_sig_code(self, func, example_sig):
1011         def gen_sig_code(idxs):
1012             def _genslice(start, end, step):
1013                 starts = '' if start == 0 else str(start)
1014                 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
1015                 steps = '' if step == 1 else (':%d' % step)
1016                 return 's[%s%s%s]' % (starts, ends, steps)
1017
1018             step = None
1019             # Quelch pyflakes warnings - start will be set when step is set
1020             start = '(Never used)'
1021             for i, prev in zip(idxs[1:], idxs[:-1]):
1022                 if step is not None:
1023                     if i - prev == step:
1024                         continue
1025                     yield _genslice(start, prev, step)
1026                     step = None
1027                     continue
1028                 if i - prev in [-1, 1]:
1029                     step = i - prev
1030                     start = prev
1031                     continue
1032                 else:
1033                     yield 's[%d]' % prev
1034             if step is None:
1035                 yield 's[%d]' % i
1036             else:
1037                 yield _genslice(start, i, step)
1038
1039         test_string = ''.join(map(compat_chr, range(len(example_sig))))
1040         cache_res = func(test_string)
1041         cache_spec = [ord(c) for c in cache_res]
1042         expr_code = ' + '.join(gen_sig_code(cache_spec))
1043         signature_id_tuple = '(%s)' % (
1044             ', '.join(compat_str(len(p)) for p in example_sig.split('.')))
1045         code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
1046                 '    return %s\n') % (signature_id_tuple, expr_code)
1047         self.to_screen('Extracted signature function:\n' + code)
1048
1049     def _parse_sig_js(self, jscode):
1050         funcname = self._search_regex(
1051             (r'(["\'])signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
1052              r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\('),
1053             jscode, 'Initial JS player signature function name', group='sig')
1054
1055         jsi = JSInterpreter(jscode)
1056         initial_function = jsi.extract_function(funcname)
1057         return lambda s: initial_function([s])
1058
1059     def _parse_sig_swf(self, file_contents):
1060         swfi = SWFInterpreter(file_contents)
1061         TARGET_CLASSNAME = 'SignatureDecipher'
1062         searched_class = swfi.extract_class(TARGET_CLASSNAME)
1063         initial_function = swfi.extract_function(searched_class, 'decipher')
1064         return lambda s: initial_function([s])
1065
1066     def _decrypt_signature(self, s, video_id, player_url, age_gate=False):
1067         """Turn the encrypted s field into a working signature"""
1068
1069         if player_url is None:
1070             raise ExtractorError('Cannot decrypt signature without player_url')
1071
1072         if player_url.startswith('//'):
1073             player_url = 'https:' + player_url
1074         elif not re.match(r'https?://', player_url):
1075             player_url = compat_urlparse.urljoin(
1076                 'https://www.youtube.com', player_url)
1077         try:
1078             player_id = (player_url, self._signature_cache_id(s))
1079             if player_id not in self._player_cache:
1080                 func = self._extract_signature_function(
1081                     video_id, player_url, s
1082                 )
1083                 self._player_cache[player_id] = func
1084             func = self._player_cache[player_id]
1085             if self._downloader.params.get('youtube_print_sig_code'):
1086                 self._print_sig_code(func, s)
1087             return func(s)
1088         except Exception as e:
1089             tb = traceback.format_exc()
1090             raise ExtractorError(
1091                 'Signature extraction failed: ' + tb, cause=e)
1092
1093     def _get_subtitles(self, video_id, webpage):
1094         try:
1095             subs_doc = self._download_xml(
1096                 'https://video.google.com/timedtext?hl=en&type=list&v=%s' % video_id,
1097                 video_id, note=False)
1098         except ExtractorError as err:
1099             self._downloader.report_warning('unable to download video subtitles: %s' % error_to_compat_str(err))
1100             return {}
1101
1102         sub_lang_list = {}
1103         for track in subs_doc.findall('track'):
1104             lang = track.attrib['lang_code']
1105             if lang in sub_lang_list:
1106                 continue
1107             sub_formats = []
1108             for ext in self._SUBTITLE_FORMATS:
1109                 params = compat_urllib_parse_urlencode({
1110                     'lang': lang,
1111                     'v': video_id,
1112                     'fmt': ext,
1113                     'name': track.attrib['name'].encode('utf-8'),
1114                 })
1115                 sub_formats.append({
1116                     'url': 'https://www.youtube.com/api/timedtext?' + params,
1117                     'ext': ext,
1118                 })
1119             sub_lang_list[lang] = sub_formats
1120         if not sub_lang_list:
1121             self._downloader.report_warning('video doesn\'t have subtitles')
1122             return {}
1123         return sub_lang_list
1124
1125     def _get_ytplayer_config(self, video_id, webpage):
1126         patterns = (
1127             # User data may contain arbitrary character sequences that may affect
1128             # JSON extraction with regex, e.g. when '};' is contained the second
1129             # regex won't capture the whole JSON. Yet working around by trying more
1130             # concrete regex first keeping in mind proper quoted string handling
1131             # to be implemented in future that will replace this workaround (see
1132             # https://github.com/rg3/youtube-dl/issues/7468,
1133             # https://github.com/rg3/youtube-dl/pull/7599)
1134             r';ytplayer\.config\s*=\s*({.+?});ytplayer',
1135             r';ytplayer\.config\s*=\s*({.+?});',
1136         )
1137         config = self._search_regex(
1138             patterns, webpage, 'ytplayer.config', default=None)
1139         if config:
1140             return self._parse_json(
1141                 uppercase_escape(config), video_id, fatal=False)
1142
1143     def _get_automatic_captions(self, video_id, webpage):
1144         """We need the webpage for getting the captions url, pass it as an
1145            argument to speed up the process."""
1146         self.to_screen('%s: Looking for automatic captions' % video_id)
1147         player_config = self._get_ytplayer_config(video_id, webpage)
1148         err_msg = 'Couldn\'t find automatic captions for %s' % video_id
1149         if not player_config:
1150             self._downloader.report_warning(err_msg)
1151             return {}
1152         try:
1153             args = player_config['args']
1154             caption_url = args.get('ttsurl')
1155             if caption_url:
1156                 timestamp = args['timestamp']
1157                 # We get the available subtitles
1158                 list_params = compat_urllib_parse_urlencode({
1159                     'type': 'list',
1160                     'tlangs': 1,
1161                     'asrs': 1,
1162                 })
1163                 list_url = caption_url + '&' + list_params
1164                 caption_list = self._download_xml(list_url, video_id)
1165                 original_lang_node = caption_list.find('track')
1166                 if original_lang_node is None:
1167                     self._downloader.report_warning('Video doesn\'t have automatic captions')
1168                     return {}
1169                 original_lang = original_lang_node.attrib['lang_code']
1170                 caption_kind = original_lang_node.attrib.get('kind', '')
1171
1172                 sub_lang_list = {}
1173                 for lang_node in caption_list.findall('target'):
1174                     sub_lang = lang_node.attrib['lang_code']
1175                     sub_formats = []
1176                     for ext in self._SUBTITLE_FORMATS:
1177                         params = compat_urllib_parse_urlencode({
1178                             'lang': original_lang,
1179                             'tlang': sub_lang,
1180                             'fmt': ext,
1181                             'ts': timestamp,
1182                             'kind': caption_kind,
1183                         })
1184                         sub_formats.append({
1185                             'url': caption_url + '&' + params,
1186                             'ext': ext,
1187                         })
1188                     sub_lang_list[sub_lang] = sub_formats
1189                 return sub_lang_list
1190
1191             # Some videos don't provide ttsurl but rather caption_tracks and
1192             # caption_translation_languages (e.g. 20LmZk1hakA)
1193             caption_tracks = args['caption_tracks']
1194             caption_translation_languages = args['caption_translation_languages']
1195             caption_url = compat_parse_qs(caption_tracks.split(',')[0])['u'][0]
1196             parsed_caption_url = compat_urllib_parse_urlparse(caption_url)
1197             caption_qs = compat_parse_qs(parsed_caption_url.query)
1198
1199             sub_lang_list = {}
1200             for lang in caption_translation_languages.split(','):
1201                 lang_qs = compat_parse_qs(compat_urllib_parse_unquote_plus(lang))
1202                 sub_lang = lang_qs.get('lc', [None])[0]
1203                 if not sub_lang:
1204                     continue
1205                 sub_formats = []
1206                 for ext in self._SUBTITLE_FORMATS:
1207                     caption_qs.update({
1208                         'tlang': [sub_lang],
1209                         'fmt': [ext],
1210                     })
1211                     sub_url = compat_urlparse.urlunparse(parsed_caption_url._replace(
1212                         query=compat_urllib_parse_urlencode(caption_qs, True)))
1213                     sub_formats.append({
1214                         'url': sub_url,
1215                         'ext': ext,
1216                     })
1217                 sub_lang_list[sub_lang] = sub_formats
1218             return sub_lang_list
1219         # An extractor error can be raise by the download process if there are
1220         # no automatic captions but there are subtitles
1221         except (KeyError, ExtractorError):
1222             self._downloader.report_warning(err_msg)
1223             return {}
1224
1225     def _mark_watched(self, video_id, video_info):
1226         playback_url = video_info.get('videostats_playback_base_url', [None])[0]
1227         if not playback_url:
1228             return
1229         parsed_playback_url = compat_urlparse.urlparse(playback_url)
1230         qs = compat_urlparse.parse_qs(parsed_playback_url.query)
1231
1232         # cpn generation algorithm is reverse engineered from base.js.
1233         # In fact it works even with dummy cpn.
1234         CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
1235         cpn = ''.join((CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16)))
1236
1237         qs.update({
1238             'ver': ['2'],
1239             'cpn': [cpn],
1240         })
1241         playback_url = compat_urlparse.urlunparse(
1242             parsed_playback_url._replace(query=compat_urllib_parse_urlencode(qs, True)))
1243
1244         self._download_webpage(
1245             playback_url, video_id, 'Marking watched',
1246             'Unable to mark watched', fatal=False)
1247
1248     @classmethod
1249     def extract_id(cls, url):
1250         mobj = re.match(cls._VALID_URL, url, re.VERBOSE)
1251         if mobj is None:
1252             raise ExtractorError('Invalid URL: %s' % url)
1253         video_id = mobj.group(2)
1254         return video_id
1255
1256     def _extract_annotations(self, video_id):
1257         url = 'https://www.youtube.com/annotations_invideo?features=1&legacy=1&video_id=%s' % video_id
1258         return self._download_webpage(url, video_id, note='Searching for annotations.', errnote='Unable to download video annotations.')
1259
1260     @staticmethod
1261     def _extract_chapters(description, duration):
1262         if not description:
1263             return None
1264         chapter_lines = re.findall(
1265             r'(?:^|<br\s*/>)([^<]*<a[^>]+onclick=["\']yt\.www\.watch\.player\.seekTo[^>]+>(\d{1,2}:\d{1,2}(?::\d{1,2})?)</a>[^>]*)(?=$|<br\s*/>)',
1266             description)
1267         if not chapter_lines:
1268             return None
1269         chapters = []
1270         for next_num, (chapter_line, time_point) in enumerate(
1271                 chapter_lines, start=1):
1272             start_time = parse_duration(time_point)
1273             if start_time is None:
1274                 continue
1275             end_time = (duration if next_num == len(chapter_lines)
1276                         else parse_duration(chapter_lines[next_num][1]))
1277             if end_time is None:
1278                 continue
1279             chapter_title = re.sub(
1280                 r'<a[^>]+>[^<]+</a>', '', chapter_line).strip(' \t-')
1281             chapter_title = re.sub(r'\s+', ' ', chapter_title)
1282             chapters.append({
1283                 'start_time': start_time,
1284                 'end_time': end_time,
1285                 'title': chapter_title,
1286             })
1287         return chapters
1288
1289     def _real_extract(self, url):
1290         url, smuggled_data = unsmuggle_url(url, {})
1291
1292         proto = (
1293             'http' if self._downloader.params.get('prefer_insecure', False)
1294             else 'https')
1295
1296         start_time = None
1297         end_time = None
1298         parsed_url = compat_urllib_parse_urlparse(url)
1299         for component in [parsed_url.fragment, parsed_url.query]:
1300             query = compat_parse_qs(component)
1301             if start_time is None and 't' in query:
1302                 start_time = parse_duration(query['t'][0])
1303             if start_time is None and 'start' in query:
1304                 start_time = parse_duration(query['start'][0])
1305             if end_time is None and 'end' in query:
1306                 end_time = parse_duration(query['end'][0])
1307
1308         # Extract original video URL from URL with redirection, like age verification, using next_url parameter
1309         mobj = re.search(self._NEXT_URL_RE, url)
1310         if mobj:
1311             url = proto + '://www.youtube.com/' + compat_urllib_parse_unquote(mobj.group(1)).lstrip('/')
1312         video_id = self.extract_id(url)
1313
1314         # Get video webpage
1315         url = proto + '://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1&bpctr=9999999999' % video_id
1316         video_webpage = self._download_webpage(url, video_id)
1317
1318         # Attempt to extract SWF player URL
1319         mobj = re.search(r'swfConfig.*?"(https?:\\/\\/.*?watch.*?-.*?\.swf)"', video_webpage)
1320         if mobj is not None:
1321             player_url = re.sub(r'\\(.)', r'\1', mobj.group(1))
1322         else:
1323             player_url = None
1324
1325         dash_mpds = []
1326
1327         def add_dash_mpd(video_info):
1328             dash_mpd = video_info.get('dashmpd')
1329             if dash_mpd and dash_mpd[0] not in dash_mpds:
1330                 dash_mpds.append(dash_mpd[0])
1331
1332         # Get video info
1333         embed_webpage = None
1334         is_live = None
1335         if re.search(r'player-age-gate-content">', video_webpage) is not None:
1336             age_gate = True
1337             # We simulate the access to the video from www.youtube.com/v/{video_id}
1338             # this can be viewed without login into Youtube
1339             url = proto + '://www.youtube.com/embed/%s' % video_id
1340             embed_webpage = self._download_webpage(url, video_id, 'Downloading embed webpage')
1341             data = compat_urllib_parse_urlencode({
1342                 'video_id': video_id,
1343                 'eurl': 'https://youtube.googleapis.com/v/' + video_id,
1344                 'sts': self._search_regex(
1345                     r'"sts"\s*:\s*(\d+)', embed_webpage, 'sts', default=''),
1346             })
1347             video_info_url = proto + '://www.youtube.com/get_video_info?' + data
1348             video_info_webpage = self._download_webpage(
1349                 video_info_url, video_id,
1350                 note='Refetching age-gated info webpage',
1351                 errnote='unable to download video info webpage')
1352             video_info = compat_parse_qs(video_info_webpage)
1353             add_dash_mpd(video_info)
1354         else:
1355             age_gate = False
1356             video_info = None
1357             # Try looking directly into the video webpage
1358             ytplayer_config = self._get_ytplayer_config(video_id, video_webpage)
1359             if ytplayer_config:
1360                 args = ytplayer_config['args']
1361                 if args.get('url_encoded_fmt_stream_map'):
1362                     # Convert to the same format returned by compat_parse_qs
1363                     video_info = dict((k, [v]) for k, v in args.items())
1364                     add_dash_mpd(video_info)
1365                 # Rental video is not rented but preview is available (e.g.
1366                 # https://www.youtube.com/watch?v=yYr8q0y5Jfg,
1367                 # https://github.com/rg3/youtube-dl/issues/10532)
1368                 if not video_info and args.get('ypc_vid'):
1369                     return self.url_result(
1370                         args['ypc_vid'], YoutubeIE.ie_key(), video_id=args['ypc_vid'])
1371                 if args.get('livestream') == '1' or args.get('live_playback') == 1:
1372                     is_live = True
1373             if not video_info or self._downloader.params.get('youtube_include_dash_manifest', True):
1374                 # We also try looking in get_video_info since it may contain different dashmpd
1375                 # URL that points to a DASH manifest with possibly different itag set (some itags
1376                 # are missing from DASH manifest pointed by webpage's dashmpd, some - from DASH
1377                 # manifest pointed by get_video_info's dashmpd).
1378                 # The general idea is to take a union of itags of both DASH manifests (for example
1379                 # video with such 'manifest behavior' see https://github.com/rg3/youtube-dl/issues/6093)
1380                 self.report_video_info_webpage_download(video_id)
1381                 for el_type in ['&el=info', '&el=embedded', '&el=detailpage', '&el=vevo', '']:
1382                     video_info_url = (
1383                         '%s://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en'
1384                         % (proto, video_id, el_type))
1385                     video_info_webpage = self._download_webpage(
1386                         video_info_url,
1387                         video_id, note=False,
1388                         errnote='unable to download video info webpage')
1389                     get_video_info = compat_parse_qs(video_info_webpage)
1390                     if get_video_info.get('use_cipher_signature') != ['True']:
1391                         add_dash_mpd(get_video_info)
1392                     if not video_info:
1393                         video_info = get_video_info
1394                     if 'token' in get_video_info:
1395                         # Different get_video_info requests may report different results, e.g.
1396                         # some may report video unavailability, but some may serve it without
1397                         # any complaint (see https://github.com/rg3/youtube-dl/issues/7362,
1398                         # the original webpage as well as el=info and el=embedded get_video_info
1399                         # requests report video unavailability due to geo restriction while
1400                         # el=detailpage succeeds and returns valid data). This is probably
1401                         # due to YouTube measures against IP ranges of hosting providers.
1402                         # Working around by preferring the first succeeded video_info containing
1403                         # the token if no such video_info yet was found.
1404                         if 'token' not in video_info:
1405                             video_info = get_video_info
1406                         break
1407         if 'token' not in video_info:
1408             if 'reason' in video_info:
1409                 if 'The uploader has not made this video available in your country.' in video_info['reason']:
1410                     regions_allowed = self._html_search_meta(
1411                         'regionsAllowed', video_webpage, default=None)
1412                     countries = regions_allowed.split(',') if regions_allowed else None
1413                     self.raise_geo_restricted(
1414                         msg=video_info['reason'][0], countries=countries)
1415                 raise ExtractorError(
1416                     'YouTube said: %s' % video_info['reason'][0],
1417                     expected=True, video_id=video_id)
1418             else:
1419                 raise ExtractorError(
1420                     '"token" parameter not in video info for unknown reason',
1421                     video_id=video_id)
1422
1423         # title
1424         if 'title' in video_info:
1425             video_title = video_info['title'][0]
1426         else:
1427             self._downloader.report_warning('Unable to extract video title')
1428             video_title = '_'
1429
1430         # description
1431         description_original = video_description = get_element_by_id("eow-description", video_webpage)
1432         if video_description:
1433             description_original = video_description = re.sub(r'''(?x)
1434                 <a\s+
1435                     (?:[a-zA-Z-]+="[^"]*"\s+)*?
1436                     (?:title|href)="([^"]+)"\s+
1437                     (?:[a-zA-Z-]+="[^"]*"\s+)*?
1438                     class="[^"]*"[^>]*>
1439                 [^<]+\.{3}\s*
1440                 </a>
1441             ''', r'\1', video_description)
1442             video_description = clean_html(video_description)
1443         else:
1444             fd_mobj = re.search(r'<meta name="description" content="([^"]+)"', video_webpage)
1445             if fd_mobj:
1446                 video_description = unescapeHTML(fd_mobj.group(1))
1447             else:
1448                 video_description = ''
1449
1450         if 'multifeed_metadata_list' in video_info and not smuggled_data.get('force_singlefeed', False):
1451             if not self._downloader.params.get('noplaylist'):
1452                 entries = []
1453                 feed_ids = []
1454                 multifeed_metadata_list = video_info['multifeed_metadata_list'][0]
1455                 for feed in multifeed_metadata_list.split(','):
1456                     # Unquote should take place before split on comma (,) since textual
1457                     # fields may contain comma as well (see
1458                     # https://github.com/rg3/youtube-dl/issues/8536)
1459                     feed_data = compat_parse_qs(compat_urllib_parse_unquote_plus(feed))
1460                     entries.append({
1461                         '_type': 'url_transparent',
1462                         'ie_key': 'Youtube',
1463                         'url': smuggle_url(
1464                             '%s://www.youtube.com/watch?v=%s' % (proto, feed_data['id'][0]),
1465                             {'force_singlefeed': True}),
1466                         'title': '%s (%s)' % (video_title, feed_data['title'][0]),
1467                     })
1468                     feed_ids.append(feed_data['id'][0])
1469                 self.to_screen(
1470                     'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
1471                     % (', '.join(feed_ids), video_id))
1472                 return self.playlist_result(entries, video_id, video_title, video_description)
1473             self.to_screen('Downloading just video %s because of --no-playlist' % video_id)
1474
1475         if 'view_count' in video_info:
1476             view_count = int(video_info['view_count'][0])
1477         else:
1478             view_count = None
1479
1480         # Check for "rental" videos
1481         if 'ypc_video_rental_bar_text' in video_info and 'author' not in video_info:
1482             raise ExtractorError('"rental" videos not supported. See https://github.com/rg3/youtube-dl/issues/359 for more information.', expected=True)
1483
1484         # Start extracting information
1485         self.report_information_extraction(video_id)
1486
1487         # uploader
1488         if 'author' not in video_info:
1489             raise ExtractorError('Unable to extract uploader name')
1490         video_uploader = compat_urllib_parse_unquote_plus(video_info['author'][0])
1491
1492         # uploader_id
1493         video_uploader_id = None
1494         video_uploader_url = None
1495         mobj = re.search(
1496             r'<link itemprop="url" href="(?P<uploader_url>https?://www.youtube.com/(?:user|channel)/(?P<uploader_id>[^"]+))">',
1497             video_webpage)
1498         if mobj is not None:
1499             video_uploader_id = mobj.group('uploader_id')
1500             video_uploader_url = mobj.group('uploader_url')
1501         else:
1502             self._downloader.report_warning('unable to extract uploader nickname')
1503
1504         # thumbnail image
1505         # We try first to get a high quality image:
1506         m_thumb = re.search(r'<span itemprop="thumbnail".*?href="(.*?)">',
1507                             video_webpage, re.DOTALL)
1508         if m_thumb is not None:
1509             video_thumbnail = m_thumb.group(1)
1510         elif 'thumbnail_url' not in video_info:
1511             self._downloader.report_warning('unable to extract video thumbnail')
1512             video_thumbnail = None
1513         else:   # don't panic if we can't find it
1514             video_thumbnail = compat_urllib_parse_unquote_plus(video_info['thumbnail_url'][0])
1515
1516         # upload date
1517         upload_date = self._html_search_meta(
1518             'datePublished', video_webpage, 'upload date', default=None)
1519         if not upload_date:
1520             upload_date = self._search_regex(
1521                 [r'(?s)id="eow-date.*?>(.*?)</span>',
1522                  r'id="watch-uploader-info".*?>.*?(?:Published|Uploaded|Streamed live|Started) on (.+?)</strong>'],
1523                 video_webpage, 'upload date', default=None)
1524             if upload_date:
1525                 upload_date = ' '.join(re.sub(r'[/,-]', r' ', mobj.group(1)).split())
1526         upload_date = unified_strdate(upload_date)
1527
1528         video_license = self._html_search_regex(
1529             r'<h4[^>]+class="title"[^>]*>\s*License\s*</h4>\s*<ul[^>]*>\s*<li>(.+?)</li',
1530             video_webpage, 'license', default=None)
1531
1532         m_music = re.search(
1533             r'<h4[^>]+class="title"[^>]*>\s*Music\s*</h4>\s*<ul[^>]*>\s*<li>(?P<title>.+?) by (?P<creator>.+?)(?:\(.+?\))?</li',
1534             video_webpage)
1535         if m_music:
1536             video_alt_title = remove_quotes(unescapeHTML(m_music.group('title')))
1537             video_creator = clean_html(m_music.group('creator'))
1538         else:
1539             video_alt_title = video_creator = None
1540
1541         m_episode = re.search(
1542             r'<div[^>]+id="watch7-headline"[^>]*>\s*<span[^>]*>.*?>(?P<series>[^<]+)</a></b>\s*S(?P<season>\d+)\s*•\s*E(?P<episode>\d+)</span>',
1543             video_webpage)
1544         if m_episode:
1545             series = m_episode.group('series')
1546             season_number = int(m_episode.group('season'))
1547             episode_number = int(m_episode.group('episode'))
1548         else:
1549             series = season_number = episode_number = None
1550
1551         m_cat_container = self._search_regex(
1552             r'(?s)<h4[^>]*>\s*Category\s*</h4>\s*<ul[^>]*>(.*?)</ul>',
1553             video_webpage, 'categories', default=None)
1554         if m_cat_container:
1555             category = self._html_search_regex(
1556                 r'(?s)<a[^<]+>(.*?)</a>', m_cat_container, 'category',
1557                 default=None)
1558             video_categories = None if category is None else [category]
1559         else:
1560             video_categories = None
1561
1562         video_tags = [
1563             unescapeHTML(m.group('content'))
1564             for m in re.finditer(self._meta_regex('og:video:tag'), video_webpage)]
1565
1566         def _extract_count(count_name):
1567             return str_to_int(self._search_regex(
1568                 r'-%s-button[^>]+><span[^>]+class="yt-uix-button-content"[^>]*>([\d,]+)</span>'
1569                 % re.escape(count_name),
1570                 video_webpage, count_name, default=None))
1571
1572         like_count = _extract_count('like')
1573         dislike_count = _extract_count('dislike')
1574
1575         # subtitles
1576         video_subtitles = self.extract_subtitles(video_id, video_webpage)
1577         automatic_captions = self.extract_automatic_captions(video_id, video_webpage)
1578
1579         video_duration = try_get(
1580             video_info, lambda x: int_or_none(x['length_seconds'][0]))
1581         if not video_duration:
1582             video_duration = parse_duration(self._html_search_meta(
1583                 'duration', video_webpage, 'video duration'))
1584
1585         # annotations
1586         video_annotations = None
1587         if self._downloader.params.get('writeannotations', False):
1588             video_annotations = self._extract_annotations(video_id)
1589
1590         chapters = self._extract_chapters(description_original, video_duration)
1591
1592         if 'conn' in video_info and video_info['conn'][0].startswith('rtmp'):
1593             self.report_rtmp_download()
1594             formats = [{
1595                 'format_id': '_rtmp',
1596                 'protocol': 'rtmp',
1597                 'url': video_info['conn'][0],
1598                 'player_url': player_url,
1599             }]
1600         elif len(video_info.get('url_encoded_fmt_stream_map', [''])[0]) >= 1 or len(video_info.get('adaptive_fmts', [''])[0]) >= 1:
1601             encoded_url_map = video_info.get('url_encoded_fmt_stream_map', [''])[0] + ',' + video_info.get('adaptive_fmts', [''])[0]
1602             if 'rtmpe%3Dyes' in encoded_url_map:
1603                 raise ExtractorError('rtmpe downloads are not supported, see https://github.com/rg3/youtube-dl/issues/343 for more information.', expected=True)
1604             formats_spec = {}
1605             fmt_list = video_info.get('fmt_list', [''])[0]
1606             if fmt_list:
1607                 for fmt in fmt_list.split(','):
1608                     spec = fmt.split('/')
1609                     if len(spec) > 1:
1610                         width_height = spec[1].split('x')
1611                         if len(width_height) == 2:
1612                             formats_spec[spec[0]] = {
1613                                 'resolution': spec[1],
1614                                 'width': int_or_none(width_height[0]),
1615                                 'height': int_or_none(width_height[1]),
1616                             }
1617             formats = []
1618             for url_data_str in encoded_url_map.split(','):
1619                 url_data = compat_parse_qs(url_data_str)
1620                 if 'itag' not in url_data or 'url' not in url_data:
1621                     continue
1622                 format_id = url_data['itag'][0]
1623                 url = url_data['url'][0]
1624
1625                 if 'sig' in url_data:
1626                     url += '&signature=' + url_data['sig'][0]
1627                 elif 's' in url_data:
1628                     encrypted_sig = url_data['s'][0]
1629                     ASSETS_RE = r'"assets":.+?"js":\s*("[^"]+")'
1630
1631                     jsplayer_url_json = self._search_regex(
1632                         ASSETS_RE,
1633                         embed_webpage if age_gate else video_webpage,
1634                         'JS player URL (1)', default=None)
1635                     if not jsplayer_url_json and not age_gate:
1636                         # We need the embed website after all
1637                         if embed_webpage is None:
1638                             embed_url = proto + '://www.youtube.com/embed/%s' % video_id
1639                             embed_webpage = self._download_webpage(
1640                                 embed_url, video_id, 'Downloading embed webpage')
1641                         jsplayer_url_json = self._search_regex(
1642                             ASSETS_RE, embed_webpage, 'JS player URL')
1643
1644                     player_url = json.loads(jsplayer_url_json)
1645                     if player_url is None:
1646                         player_url_json = self._search_regex(
1647                             r'ytplayer\.config.*?"url"\s*:\s*("[^"]+")',
1648                             video_webpage, 'age gate player URL')
1649                         player_url = json.loads(player_url_json)
1650
1651                     if self._downloader.params.get('verbose'):
1652                         if player_url is None:
1653                             player_version = 'unknown'
1654                             player_desc = 'unknown'
1655                         else:
1656                             if player_url.endswith('swf'):
1657                                 player_version = self._search_regex(
1658                                     r'-(.+?)(?:/watch_as3)?\.swf$', player_url,
1659                                     'flash player', fatal=False)
1660                                 player_desc = 'flash player %s' % player_version
1661                             else:
1662                                 player_version = self._search_regex(
1663                                     [r'html5player-([^/]+?)(?:/html5player(?:-new)?)?\.js',
1664                                      r'(?:www|player)-([^/]+)(?:/[a-z]{2}_[A-Z]{2})?/base\.js'],
1665                                     player_url,
1666                                     'html5 player', fatal=False)
1667                                 player_desc = 'html5 player %s' % player_version
1668
1669                         parts_sizes = self._signature_cache_id(encrypted_sig)
1670                         self.to_screen('{%s} signature length %s, %s' %
1671                                        (format_id, parts_sizes, player_desc))
1672
1673                     signature = self._decrypt_signature(
1674                         encrypted_sig, video_id, player_url, age_gate)
1675                     url += '&signature=' + signature
1676                 if 'ratebypass' not in url:
1677                     url += '&ratebypass=yes'
1678
1679                 dct = {
1680                     'format_id': format_id,
1681                     'url': url,
1682                     'player_url': player_url,
1683                 }
1684                 if format_id in self._formats:
1685                     dct.update(self._formats[format_id])
1686                 if format_id in formats_spec:
1687                     dct.update(formats_spec[format_id])
1688
1689                 # Some itags are not included in DASH manifest thus corresponding formats will
1690                 # lack metadata (see https://github.com/rg3/youtube-dl/pull/5993).
1691                 # Trying to extract metadata from url_encoded_fmt_stream_map entry.
1692                 mobj = re.search(r'^(?P<width>\d+)[xX](?P<height>\d+)$', url_data.get('size', [''])[0])
1693                 width, height = (int(mobj.group('width')), int(mobj.group('height'))) if mobj else (None, None)
1694
1695                 more_fields = {
1696                     'filesize': int_or_none(url_data.get('clen', [None])[0]),
1697                     'tbr': float_or_none(url_data.get('bitrate', [None])[0], 1000),
1698                     'width': width,
1699                     'height': height,
1700                     'fps': int_or_none(url_data.get('fps', [None])[0]),
1701                     'format_note': url_data.get('quality_label', [None])[0] or url_data.get('quality', [None])[0],
1702                 }
1703                 for key, value in more_fields.items():
1704                     if value:
1705                         dct[key] = value
1706                 type_ = url_data.get('type', [None])[0]
1707                 if type_:
1708                     type_split = type_.split(';')
1709                     kind_ext = type_split[0].split('/')
1710                     if len(kind_ext) == 2:
1711                         kind, _ = kind_ext
1712                         dct['ext'] = mimetype2ext(type_split[0])
1713                         if kind in ('audio', 'video'):
1714                             codecs = None
1715                             for mobj in re.finditer(
1716                                     r'(?P<key>[a-zA-Z_-]+)=(?P<quote>["\']?)(?P<val>.+?)(?P=quote)(?:;|$)', type_):
1717                                 if mobj.group('key') == 'codecs':
1718                                     codecs = mobj.group('val')
1719                                     break
1720                             if codecs:
1721                                 dct.update(parse_codecs(codecs))
1722                 formats.append(dct)
1723         elif video_info.get('hlsvp'):
1724             manifest_url = video_info['hlsvp'][0]
1725             formats = []
1726             m3u8_formats = self._extract_m3u8_formats(
1727                 manifest_url, video_id, 'mp4', fatal=False)
1728             for a_format in m3u8_formats:
1729                 itag = self._search_regex(
1730                     r'/itag/(\d+)/', a_format['url'], 'itag', default=None)
1731                 if itag:
1732                     a_format['format_id'] = itag
1733                     if itag in self._formats:
1734                         dct = self._formats[itag].copy()
1735                         dct.update(a_format)
1736                         a_format = dct
1737                 a_format['player_url'] = player_url
1738                 # Accept-Encoding header causes failures in live streams on Youtube and Youtube Gaming
1739                 a_format.setdefault('http_headers', {})['Youtubedl-no-compression'] = 'True'
1740                 formats.append(a_format)
1741         else:
1742             unavailable_message = self._html_search_regex(
1743                 r'(?s)<h1[^>]+id="unavailable-message"[^>]*>(.+?)</h1>',
1744                 video_webpage, 'unavailable message', default=None)
1745             if unavailable_message:
1746                 raise ExtractorError(unavailable_message, expected=True)
1747             raise ExtractorError('no conn, hlsvp or url_encoded_fmt_stream_map information found in video info')
1748
1749         # Look for the DASH manifest
1750         if self._downloader.params.get('youtube_include_dash_manifest', True):
1751             dash_mpd_fatal = True
1752             for mpd_url in dash_mpds:
1753                 dash_formats = {}
1754                 try:
1755                     def decrypt_sig(mobj):
1756                         s = mobj.group(1)
1757                         dec_s = self._decrypt_signature(s, video_id, player_url, age_gate)
1758                         return '/signature/%s' % dec_s
1759
1760                     mpd_url = re.sub(r'/s/([a-fA-F0-9\.]+)', decrypt_sig, mpd_url)
1761
1762                     for df in self._extract_mpd_formats(
1763                             mpd_url, video_id, fatal=dash_mpd_fatal,
1764                             formats_dict=self._formats):
1765                         # Do not overwrite DASH format found in some previous DASH manifest
1766                         if df['format_id'] not in dash_formats:
1767                             dash_formats[df['format_id']] = df
1768                         # Additional DASH manifests may end up in HTTP Error 403 therefore
1769                         # allow them to fail without bug report message if we already have
1770                         # some DASH manifest succeeded. This is temporary workaround to reduce
1771                         # burst of bug reports until we figure out the reason and whether it
1772                         # can be fixed at all.
1773                         dash_mpd_fatal = False
1774                 except (ExtractorError, KeyError) as e:
1775                     self.report_warning(
1776                         'Skipping DASH manifest: %r' % e, video_id)
1777                 if dash_formats:
1778                     # Remove the formats we found through non-DASH, they
1779                     # contain less info and it can be wrong, because we use
1780                     # fixed values (for example the resolution). See
1781                     # https://github.com/rg3/youtube-dl/issues/5774 for an
1782                     # example.
1783                     formats = [f for f in formats if f['format_id'] not in dash_formats.keys()]
1784                     formats.extend(dash_formats.values())
1785
1786         # Check for malformed aspect ratio
1787         stretched_m = re.search(
1788             r'<meta\s+property="og:video:tag".*?content="yt:stretch=(?P<w>[0-9]+):(?P<h>[0-9]+)">',
1789             video_webpage)
1790         if stretched_m:
1791             w = float(stretched_m.group('w'))
1792             h = float(stretched_m.group('h'))
1793             # yt:stretch may hold invalid ratio data (e.g. for Q39EVAstoRM ratio is 17:0).
1794             # We will only process correct ratios.
1795             if w > 0 and h > 0:
1796                 ratio = w / h
1797                 for f in formats:
1798                     if f.get('vcodec') != 'none':
1799                         f['stretched_ratio'] = ratio
1800
1801         self._sort_formats(formats)
1802
1803         self.mark_watched(video_id, video_info)
1804
1805         return {
1806             'id': video_id,
1807             'uploader': video_uploader,
1808             'uploader_id': video_uploader_id,
1809             'uploader_url': video_uploader_url,
1810             'upload_date': upload_date,
1811             'license': video_license,
1812             'creator': video_creator,
1813             'title': video_title,
1814             'alt_title': video_alt_title,
1815             'thumbnail': video_thumbnail,
1816             'description': video_description,
1817             'categories': video_categories,
1818             'tags': video_tags,
1819             'subtitles': video_subtitles,
1820             'automatic_captions': automatic_captions,
1821             'duration': video_duration,
1822             'age_limit': 18 if age_gate else 0,
1823             'annotations': video_annotations,
1824             'chapters': chapters,
1825             'webpage_url': proto + '://www.youtube.com/watch?v=%s' % video_id,
1826             'view_count': view_count,
1827             'like_count': like_count,
1828             'dislike_count': dislike_count,
1829             'average_rating': float_or_none(video_info.get('avg_rating', [None])[0]),
1830             'formats': formats,
1831             'is_live': is_live,
1832             'start_time': start_time,
1833             'end_time': end_time,
1834             'series': series,
1835             'season_number': season_number,
1836             'episode_number': episode_number,
1837         }
1838
1839
1840 class YoutubeSharedVideoIE(InfoExtractor):
1841     _VALID_URL = r'(?:https?:)?//(?:www\.)?youtube\.com/shared\?.*\bci=(?P<id>[0-9A-Za-z_-]{11})'
1842     IE_NAME = 'youtube:shared'
1843
1844     _TEST = {
1845         'url': 'https://www.youtube.com/shared?ci=1nEzmT-M4fU',
1846         'info_dict': {
1847             'id': 'uPDB5I9wfp8',
1848             'ext': 'webm',
1849             'title': 'Pocoyo: 90 minutos de episódios completos Português para crianças - PARTE 3',
1850             'description': 'md5:d9e4d9346a2dfff4c7dc4c8cec0f546d',
1851             'upload_date': '20160219',
1852             'uploader': 'Pocoyo - Português (BR)',
1853             'uploader_id': 'PocoyoBrazil',
1854         },
1855         'add_ie': ['Youtube'],
1856         'params': {
1857             # There are already too many Youtube downloads
1858             'skip_download': True,
1859         },
1860     }
1861
1862     def _real_extract(self, url):
1863         video_id = self._match_id(url)
1864
1865         webpage = self._download_webpage(url, video_id)
1866
1867         real_video_id = self._html_search_meta(
1868             'videoId', webpage, 'YouTube video id', fatal=True)
1869
1870         return self.url_result(real_video_id, YoutubeIE.ie_key())
1871
1872
1873 class YoutubePlaylistIE(YoutubePlaylistBaseInfoExtractor):
1874     IE_DESC = 'YouTube.com playlists'
1875     _VALID_URL = r"""(?x)(?:
1876                         (?:https?://)?
1877                         (?:\w+\.)?
1878                         (?:
1879                             youtube\.com/
1880                             (?:
1881                                (?:course|view_play_list|my_playlists|artist|playlist|watch|embed/(?:videoseries|[0-9A-Za-z_-]{11}))
1882                                \? (?:.*?[&;])*? (?:p|a|list)=
1883                             |  p/
1884                             )|
1885                             youtu\.be/[0-9A-Za-z_-]{11}\?.*?\blist=
1886                         )
1887                         (
1888                             (?:PL|LL|EC|UU|FL|RD|UL|TL)?[0-9A-Za-z-_]{10,}
1889                             # Top tracks, they can also include dots
1890                             |(?:MC)[\w\.]*
1891                         )
1892                         .*
1893                      |
1894                         (%(playlist_id)s)
1895                      )""" % {'playlist_id': YoutubeBaseInfoExtractor._PLAYLIST_ID_RE}
1896     _TEMPLATE_URL = 'https://www.youtube.com/playlist?list=%s&disable_polymer=true'
1897     _VIDEO_RE = r'href="\s*/watch\?v=(?P<id>[0-9A-Za-z_-]{11})&amp;[^"]*?index=(?P<index>\d+)(?:[^>]+>(?P<title>[^<]+))?'
1898     IE_NAME = 'youtube:playlist'
1899     _TESTS = [{
1900         'url': 'https://www.youtube.com/playlist?list=PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re',
1901         'info_dict': {
1902             'title': 'ytdl test PL',
1903             'id': 'PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re',
1904         },
1905         'playlist_count': 3,
1906     }, {
1907         'url': 'https://www.youtube.com/playlist?list=PLtPgu7CB4gbZDA7i_euNxn75ISqxwZPYx',
1908         'info_dict': {
1909             'id': 'PLtPgu7CB4gbZDA7i_euNxn75ISqxwZPYx',
1910             'title': 'YDL_Empty_List',
1911         },
1912         'playlist_count': 0,
1913         'skip': 'This playlist is private',
1914     }, {
1915         'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
1916         'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
1917         'info_dict': {
1918             'title': '29C3: Not my department',
1919             'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
1920         },
1921         'playlist_count': 95,
1922     }, {
1923         'note': 'issue #673',
1924         'url': 'PLBB231211A4F62143',
1925         'info_dict': {
1926             'title': '[OLD]Team Fortress 2 (Class-based LP)',
1927             'id': 'PLBB231211A4F62143',
1928         },
1929         'playlist_mincount': 26,
1930     }, {
1931         'note': 'Large playlist',
1932         'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
1933         'info_dict': {
1934             'title': 'Uploads from Cauchemar',
1935             'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
1936         },
1937         'playlist_mincount': 799,
1938     }, {
1939         'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
1940         'info_dict': {
1941             'title': 'YDL_safe_search',
1942             'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
1943         },
1944         'playlist_count': 2,
1945         'skip': 'This playlist is private',
1946     }, {
1947         'note': 'embedded',
1948         'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
1949         'playlist_count': 4,
1950         'info_dict': {
1951             'title': 'JODA15',
1952             'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
1953         }
1954     }, {
1955         'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
1956         'playlist_mincount': 485,
1957         'info_dict': {
1958             'title': '2017 華語最新單曲 (2/24更新)',
1959             'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
1960         }
1961     }, {
1962         'note': 'Embedded SWF player',
1963         'url': 'https://www.youtube.com/p/YN5VISEtHet5D4NEvfTd0zcgFk84NqFZ?hl=en_US&fs=1&rel=0',
1964         'playlist_count': 4,
1965         'info_dict': {
1966             'title': 'JODA7',
1967             'id': 'YN5VISEtHet5D4NEvfTd0zcgFk84NqFZ',
1968         }
1969     }, {
1970         'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
1971         'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
1972         'info_dict': {
1973             'title': 'Uploads from Interstellar Movie',
1974             'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
1975         },
1976         'playlist_mincount': 21,
1977     }, {
1978         # Playlist URL that does not actually serve a playlist
1979         'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
1980         'info_dict': {
1981             'id': 'FqZTN594JQw',
1982             'ext': 'webm',
1983             'title': "Smiley's People 01 detective, Adventure Series, Action",
1984             'uploader': 'STREEM',
1985             'uploader_id': 'UCyPhqAZgwYWZfxElWVbVJng',
1986             'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCyPhqAZgwYWZfxElWVbVJng',
1987             'upload_date': '20150526',
1988             'license': 'Standard YouTube License',
1989             'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
1990             'categories': ['People & Blogs'],
1991             'tags': list,
1992             'like_count': int,
1993             'dislike_count': int,
1994         },
1995         'params': {
1996             'skip_download': True,
1997         },
1998         'add_ie': [YoutubeIE.ie_key()],
1999     }, {
2000         'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
2001         'info_dict': {
2002             'id': 'yeWKywCrFtk',
2003             'ext': 'mp4',
2004             'title': 'Small Scale Baler and Braiding Rugs',
2005             'uploader': 'Backus-Page House Museum',
2006             'uploader_id': 'backuspagemuseum',
2007             'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/backuspagemuseum',
2008             'upload_date': '20161008',
2009             'license': 'Standard YouTube License',
2010             'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
2011             'categories': ['Nonprofits & Activism'],
2012             'tags': list,
2013             'like_count': int,
2014             'dislike_count': int,
2015         },
2016         'params': {
2017             'noplaylist': True,
2018             'skip_download': True,
2019         },
2020     }, {
2021         'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
2022         'only_matching': True,
2023     }, {
2024         'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
2025         'only_matching': True,
2026     }]
2027
2028     def _real_initialize(self):
2029         self._login()
2030
2031     def _extract_mix(self, playlist_id):
2032         # The mixes are generated from a single video
2033         # the id of the playlist is just 'RD' + video_id
2034         ids = []
2035         last_id = playlist_id[-11:]
2036         for n in itertools.count(1):
2037             url = 'https://youtube.com/watch?v=%s&list=%s' % (last_id, playlist_id)
2038             webpage = self._download_webpage(
2039                 url, playlist_id, 'Downloading page {0} of Youtube mix'.format(n))
2040             new_ids = orderedSet(re.findall(
2041                 r'''(?xs)data-video-username=".*?".*?
2042                            href="/watch\?v=([0-9A-Za-z_-]{11})&amp;[^"]*?list=%s''' % re.escape(playlist_id),
2043                 webpage))
2044             # Fetch new pages until all the videos are repeated, it seems that
2045             # there are always 51 unique videos.
2046             new_ids = [_id for _id in new_ids if _id not in ids]
2047             if not new_ids:
2048                 break
2049             ids.extend(new_ids)
2050             last_id = ids[-1]
2051
2052         url_results = self._ids_to_results(ids)
2053
2054         search_title = lambda class_name: get_element_by_attribute('class', class_name, webpage)
2055         title_span = (
2056             search_title('playlist-title') or
2057             search_title('title long-title') or
2058             search_title('title'))
2059         title = clean_html(title_span)
2060
2061         return self.playlist_result(url_results, playlist_id, title)
2062
2063     def _extract_playlist(self, playlist_id):
2064         url = self._TEMPLATE_URL % playlist_id
2065         page = self._download_webpage(url, playlist_id)
2066
2067         # the yt-alert-message now has tabindex attribute (see https://github.com/rg3/youtube-dl/issues/11604)
2068         for match in re.findall(r'<div class="yt-alert-message"[^>]*>([^<]+)</div>', page):
2069             match = match.strip()
2070             # Check if the playlist exists or is private
2071             mobj = re.match(r'[^<]*(?:The|This) playlist (?P<reason>does not exist|is private)[^<]*', match)
2072             if mobj:
2073                 reason = mobj.group('reason')
2074                 message = 'This playlist %s' % reason
2075                 if 'private' in reason:
2076                     message += ', use --username or --netrc to access it'
2077                 message += '.'
2078                 raise ExtractorError(message, expected=True)
2079             elif re.match(r'[^<]*Invalid parameters[^<]*', match):
2080                 raise ExtractorError(
2081                     'Invalid parameters. Maybe URL is incorrect.',
2082                     expected=True)
2083             elif re.match(r'[^<]*Choose your language[^<]*', match):
2084                 continue
2085             else:
2086                 self.report_warning('Youtube gives an alert message: ' + match)
2087
2088         playlist_title = self._html_search_regex(
2089             r'(?s)<h1 class="pl-header-title[^"]*"[^>]*>\s*(.*?)\s*</h1>',
2090             page, 'title', default=None)
2091
2092         has_videos = True
2093
2094         if not playlist_title:
2095             try:
2096                 # Some playlist URLs don't actually serve a playlist (e.g.
2097                 # https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4)
2098                 next(self._entries(page, playlist_id))
2099             except StopIteration:
2100                 has_videos = False
2101
2102         return has_videos, self.playlist_result(
2103             self._entries(page, playlist_id), playlist_id, playlist_title)
2104
2105     def _check_download_just_video(self, url, playlist_id):
2106         # Check if it's a video-specific URL
2107         query_dict = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
2108         video_id = query_dict.get('v', [None])[0] or self._search_regex(
2109             r'(?:(?:^|//)youtu\.be/|youtube\.com/embed/(?!videoseries))([0-9A-Za-z_-]{11})', url,
2110             'video id', default=None)
2111         if video_id:
2112             if self._downloader.params.get('noplaylist'):
2113                 self.to_screen('Downloading just video %s because of --no-playlist' % video_id)
2114                 return video_id, self.url_result(video_id, 'Youtube', video_id=video_id)
2115             else:
2116                 self.to_screen('Downloading playlist %s - add --no-playlist to just download video %s' % (playlist_id, video_id))
2117                 return video_id, None
2118         return None, None
2119
2120     def _real_extract(self, url):
2121         # Extract playlist id
2122         mobj = re.match(self._VALID_URL, url)
2123         if mobj is None:
2124             raise ExtractorError('Invalid URL: %s' % url)
2125         playlist_id = mobj.group(1) or mobj.group(2)
2126
2127         video_id, video = self._check_download_just_video(url, playlist_id)
2128         if video:
2129             return video
2130
2131         if playlist_id.startswith(('RD', 'UL', 'PU')):
2132             # Mixes require a custom extraction process
2133             return self._extract_mix(playlist_id)
2134
2135         has_videos, playlist = self._extract_playlist(playlist_id)
2136         if has_videos or not video_id:
2137             return playlist
2138
2139         # Some playlist URLs don't actually serve a playlist (see
2140         # https://github.com/rg3/youtube-dl/issues/10537).
2141         # Fallback to plain video extraction if there is a video id
2142         # along with playlist id.
2143         return self.url_result(video_id, 'Youtube', video_id=video_id)
2144
2145
2146 class YoutubeChannelIE(YoutubePlaylistBaseInfoExtractor):
2147     IE_DESC = 'YouTube.com channels'
2148     _VALID_URL = r'https?://(?:youtu\.be|(?:\w+\.)?youtube(?:-nocookie)?\.com)/channel/(?P<id>[0-9A-Za-z_-]+)'
2149     _TEMPLATE_URL = 'https://www.youtube.com/channel/%s/videos'
2150     _VIDEO_RE = r'(?:title="(?P<title>[^"]+)"[^>]+)?href="/watch\?v=(?P<id>[0-9A-Za-z_-]+)&?'
2151     IE_NAME = 'youtube:channel'
2152     _TESTS = [{
2153         'note': 'paginated channel',
2154         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
2155         'playlist_mincount': 91,
2156         'info_dict': {
2157             'id': 'UUKfVa3S1e4PHvxWcwyMMg8w',
2158             'title': 'Uploads from lex will',
2159         }
2160     }, {
2161         'note': 'Age restricted channel',
2162         # from https://www.youtube.com/user/DeusExOfficial
2163         'url': 'https://www.youtube.com/channel/UCs0ifCMCm1icqRbqhUINa0w',
2164         'playlist_mincount': 64,
2165         'info_dict': {
2166             'id': 'UUs0ifCMCm1icqRbqhUINa0w',
2167             'title': 'Uploads from Deus Ex',
2168         },
2169     }]
2170
2171     @classmethod
2172     def suitable(cls, url):
2173         return (False if YoutubePlaylistsIE.suitable(url) or YoutubeLiveIE.suitable(url)
2174                 else super(YoutubeChannelIE, cls).suitable(url))
2175
2176     def _build_template_url(self, url, channel_id):
2177         return self._TEMPLATE_URL % channel_id
2178
2179     def _real_extract(self, url):
2180         channel_id = self._match_id(url)
2181
2182         url = self._build_template_url(url, channel_id)
2183
2184         # Channel by page listing is restricted to 35 pages of 30 items, i.e. 1050 videos total (see #5778)
2185         # Workaround by extracting as a playlist if managed to obtain channel playlist URL
2186         # otherwise fallback on channel by page extraction
2187         channel_page = self._download_webpage(
2188             url + '?view=57', channel_id,
2189             'Downloading channel page', fatal=False)
2190         if channel_page is False:
2191             channel_playlist_id = False
2192         else:
2193             channel_playlist_id = self._html_search_meta(
2194                 'channelId', channel_page, 'channel id', default=None)
2195             if not channel_playlist_id:
2196                 channel_url = self._html_search_meta(
2197                     ('al:ios:url', 'twitter:app:url:iphone', 'twitter:app:url:ipad'),
2198                     channel_page, 'channel url', default=None)
2199                 if channel_url:
2200                     channel_playlist_id = self._search_regex(
2201                         r'vnd\.youtube://user/([0-9A-Za-z_-]+)',
2202                         channel_url, 'channel id', default=None)
2203         if channel_playlist_id and channel_playlist_id.startswith('UC'):
2204             playlist_id = 'UU' + channel_playlist_id[2:]
2205             return self.url_result(
2206                 compat_urlparse.urljoin(url, '/playlist?list=%s' % playlist_id), 'YoutubePlaylist')
2207
2208         channel_page = self._download_webpage(url, channel_id, 'Downloading page #1')
2209         autogenerated = re.search(r'''(?x)
2210                 class="[^"]*?(?:
2211                     channel-header-autogenerated-label|
2212                     yt-channel-title-autogenerated
2213                 )[^"]*"''', channel_page) is not None
2214
2215         if autogenerated:
2216             # The videos are contained in a single page
2217             # the ajax pages can't be used, they are empty
2218             entries = [
2219                 self.url_result(
2220                     video_id, 'Youtube', video_id=video_id,
2221                     video_title=video_title)
2222                 for video_id, video_title in self.extract_videos_from_page(channel_page)]
2223             return self.playlist_result(entries, channel_id)
2224
2225         try:
2226             next(self._entries(channel_page, channel_id))
2227         except StopIteration:
2228             alert_message = self._html_search_regex(
2229                 r'(?s)<div[^>]+class=(["\']).*?\byt-alert-message\b.*?\1[^>]*>(?P<alert>[^<]+)</div>',
2230                 channel_page, 'alert', default=None, group='alert')
2231             if alert_message:
2232                 raise ExtractorError('Youtube said: %s' % alert_message, expected=True)
2233
2234         return self.playlist_result(self._entries(channel_page, channel_id), channel_id)
2235
2236
2237 class YoutubeUserIE(YoutubeChannelIE):
2238     IE_DESC = 'YouTube.com user videos (URL or "ytuser" keyword)'
2239     _VALID_URL = r'(?:(?:https?://(?:\w+\.)?youtube\.com/(?:(?P<user>user|c)/)?(?!(?:attribution_link|watch|results)(?:$|[^a-z_A-Z0-9-])))|ytuser:)(?!feed/)(?P<id>[A-Za-z0-9_-]+)'
2240     _TEMPLATE_URL = 'https://www.youtube.com/%s/%s/videos'
2241     IE_NAME = 'youtube:user'
2242
2243     _TESTS = [{
2244         'url': 'https://www.youtube.com/user/TheLinuxFoundation',
2245         'playlist_mincount': 320,
2246         'info_dict': {
2247             'id': 'UUfX55Sx5hEFjoC3cNs6mCUQ',
2248             'title': 'Uploads from The Linux Foundation',
2249         }
2250     }, {
2251         # Only available via https://www.youtube.com/c/12minuteathlete/videos
2252         # but not https://www.youtube.com/user/12minuteathlete/videos
2253         'url': 'https://www.youtube.com/c/12minuteathlete/videos',
2254         'playlist_mincount': 249,
2255         'info_dict': {
2256             'id': 'UUVjM-zV6_opMDx7WYxnjZiQ',
2257             'title': 'Uploads from 12 Minute Athlete',
2258         }
2259     }, {
2260         'url': 'ytuser:phihag',
2261         'only_matching': True,
2262     }, {
2263         'url': 'https://www.youtube.com/c/gametrailers',
2264         'only_matching': True,
2265     }, {
2266         'url': 'https://www.youtube.com/gametrailers',
2267         'only_matching': True,
2268     }, {
2269         # This channel is not available, geo restricted to JP
2270         'url': 'https://www.youtube.com/user/kananishinoSMEJ/videos',
2271         'only_matching': True,
2272     }]
2273
2274     @classmethod
2275     def suitable(cls, url):
2276         # Don't return True if the url can be extracted with other youtube
2277         # extractor, the regex would is too permissive and it would match.
2278         other_yt_ies = iter(klass for (name, klass) in globals().items() if name.startswith('Youtube') and name.endswith('IE') and klass is not cls)
2279         if any(ie.suitable(url) for ie in other_yt_ies):
2280             return False
2281         else:
2282             return super(YoutubeUserIE, cls).suitable(url)
2283
2284     def _build_template_url(self, url, channel_id):
2285         mobj = re.match(self._VALID_URL, url)
2286         return self._TEMPLATE_URL % (mobj.group('user') or 'user', mobj.group('id'))
2287
2288
2289 class YoutubeLiveIE(YoutubeBaseInfoExtractor):
2290     IE_DESC = 'YouTube.com live streams'
2291     _VALID_URL = r'(?P<base_url>https?://(?:\w+\.)?youtube\.com/(?:(?:user|channel|c)/)?(?P<id>[^/]+))/live'
2292     IE_NAME = 'youtube:live'
2293
2294     _TESTS = [{
2295         'url': 'https://www.youtube.com/user/TheYoungTurks/live',
2296         'info_dict': {
2297             'id': 'a48o2S1cPoo',
2298             'ext': 'mp4',
2299             'title': 'The Young Turks - Live Main Show',
2300             'uploader': 'The Young Turks',
2301             'uploader_id': 'TheYoungTurks',
2302             'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/TheYoungTurks',
2303             'upload_date': '20150715',
2304             'license': 'Standard YouTube License',
2305             'description': 'md5:438179573adcdff3c97ebb1ee632b891',
2306             'categories': ['News & Politics'],
2307             'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
2308             'like_count': int,
2309             'dislike_count': int,
2310         },
2311         'params': {
2312             'skip_download': True,
2313         },
2314     }, {
2315         'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
2316         'only_matching': True,
2317     }, {
2318         'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
2319         'only_matching': True,
2320     }, {
2321         'url': 'https://www.youtube.com/TheYoungTurks/live',
2322         'only_matching': True,
2323     }]
2324
2325     def _real_extract(self, url):
2326         mobj = re.match(self._VALID_URL, url)
2327         channel_id = mobj.group('id')
2328         base_url = mobj.group('base_url')
2329         webpage = self._download_webpage(url, channel_id, fatal=False)
2330         if webpage:
2331             page_type = self._og_search_property(
2332                 'type', webpage, 'page type', default=None)
2333             video_id = self._html_search_meta(
2334                 'videoId', webpage, 'video id', default=None)
2335             if page_type == 'video' and video_id and re.match(r'^[0-9A-Za-z_-]{11}$', video_id):
2336                 return self.url_result(video_id, YoutubeIE.ie_key())
2337         return self.url_result(base_url)
2338
2339
2340 class YoutubePlaylistsIE(YoutubePlaylistsBaseInfoExtractor):
2341     IE_DESC = 'YouTube.com user/channel playlists'
2342     _VALID_URL = r'https?://(?:\w+\.)?youtube\.com/(?:user|channel)/(?P<id>[^/]+)/playlists'
2343     IE_NAME = 'youtube:playlists'
2344
2345     _TESTS = [{
2346         'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
2347         'playlist_mincount': 4,
2348         'info_dict': {
2349             'id': 'ThirstForScience',
2350             'title': 'Thirst for Science',
2351         },
2352     }, {
2353         # with "Load more" button
2354         'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
2355         'playlist_mincount': 70,
2356         'info_dict': {
2357             'id': 'igorkle1',
2358             'title': 'Игорь Клейнер',
2359         },
2360     }, {
2361         'url': 'https://www.youtube.com/channel/UCiU1dHvZObB2iP6xkJ__Icw/playlists',
2362         'playlist_mincount': 17,
2363         'info_dict': {
2364             'id': 'UCiU1dHvZObB2iP6xkJ__Icw',
2365             'title': 'Chem Player',
2366         },
2367     }]
2368
2369
2370 class YoutubeSearchIE(SearchInfoExtractor, YoutubePlaylistIE):
2371     IE_DESC = 'YouTube.com searches'
2372     # there doesn't appear to be a real limit, for example if you search for
2373     # 'python' you get more than 8.000.000 results
2374     _MAX_RESULTS = float('inf')
2375     IE_NAME = 'youtube:search'
2376     _SEARCH_KEY = 'ytsearch'
2377     _EXTRA_QUERY_ARGS = {}
2378     _TESTS = []
2379
2380     def _get_n_results(self, query, n):
2381         """Get a specified number of results for a query"""
2382
2383         videos = []
2384         limit = n
2385
2386         url_query = {
2387             'search_query': query.encode('utf-8'),
2388         }
2389         url_query.update(self._EXTRA_QUERY_ARGS)
2390         result_url = 'https://www.youtube.com/results?' + compat_urllib_parse_urlencode(url_query)
2391
2392         for pagenum in itertools.count(1):
2393             data = self._download_json(
2394                 result_url, video_id='query "%s"' % query,
2395                 note='Downloading page %s' % pagenum,
2396                 errnote='Unable to download API page',
2397                 query={'spf': 'navigate'})
2398             html_content = data[1]['body']['content']
2399
2400             if 'class="search-message' in html_content:
2401                 raise ExtractorError(
2402                     '[youtube] No video results', expected=True)
2403
2404             new_videos = self._ids_to_results(orderedSet(re.findall(
2405                 r'href="/watch\?v=(.{11})', html_content)))
2406             videos += new_videos
2407             if not new_videos or len(videos) > limit:
2408                 break
2409             next_link = self._html_search_regex(
2410                 r'href="(/results\?[^"]*\bsp=[^"]+)"[^>]*>\s*<span[^>]+class="[^"]*\byt-uix-button-content\b[^"]*"[^>]*>Next',
2411                 html_content, 'next link', default=None)
2412             if next_link is None:
2413                 break
2414             result_url = compat_urlparse.urljoin('https://www.youtube.com/', next_link)
2415
2416         if len(videos) > n:
2417             videos = videos[:n]
2418         return self.playlist_result(videos, query)
2419
2420
2421 class YoutubeSearchDateIE(YoutubeSearchIE):
2422     IE_NAME = YoutubeSearchIE.IE_NAME + ':date'
2423     _SEARCH_KEY = 'ytsearchdate'
2424     IE_DESC = 'YouTube.com searches, newest videos first'
2425     _EXTRA_QUERY_ARGS = {'search_sort': 'video_date_uploaded'}
2426
2427
2428 class YoutubeSearchURLIE(YoutubePlaylistBaseInfoExtractor):
2429     IE_DESC = 'YouTube.com search URLs'
2430     IE_NAME = 'youtube:search_url'
2431     _VALID_URL = r'https?://(?:www\.)?youtube\.com/results\?(.*?&)?(?:search_query|q)=(?P<query>[^&]+)(?:[&]|$)'
2432     _VIDEO_RE = r'href="\s*/watch\?v=(?P<id>[0-9A-Za-z_-]{11})(?:[^"]*"[^>]+\btitle="(?P<title>[^"]+))?'
2433     _TESTS = [{
2434         'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
2435         'playlist_mincount': 5,
2436         'info_dict': {
2437             'title': 'youtube-dl test video',
2438         }
2439     }, {
2440         'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
2441         'only_matching': True,
2442     }]
2443
2444     def _real_extract(self, url):
2445         mobj = re.match(self._VALID_URL, url)
2446         query = compat_urllib_parse_unquote_plus(mobj.group('query'))
2447         webpage = self._download_webpage(url, query)
2448         return self.playlist_result(self._process_page(webpage), playlist_title=query)
2449
2450
2451 class YoutubeShowIE(YoutubePlaylistsBaseInfoExtractor):
2452     IE_DESC = 'YouTube.com (multi-season) shows'
2453     _VALID_URL = r'https?://(?:www\.)?youtube\.com/show/(?P<id>[^?#]*)'
2454     IE_NAME = 'youtube:show'
2455     _TESTS = [{
2456         'url': 'https://www.youtube.com/show/airdisasters',
2457         'playlist_mincount': 5,
2458         'info_dict': {
2459             'id': 'airdisasters',
2460             'title': 'Air Disasters',
2461         }
2462     }]
2463
2464     def _real_extract(self, url):
2465         playlist_id = self._match_id(url)
2466         return super(YoutubeShowIE, self)._real_extract(
2467             'https://www.youtube.com/show/%s/playlists' % playlist_id)
2468
2469
2470 class YoutubeFeedsInfoExtractor(YoutubeBaseInfoExtractor):
2471     """
2472     Base class for feed extractors
2473     Subclasses must define the _FEED_NAME and _PLAYLIST_TITLE properties.
2474     """
2475     _LOGIN_REQUIRED = True
2476
2477     @property
2478     def IE_NAME(self):
2479         return 'youtube:%s' % self._FEED_NAME
2480
2481     def _real_initialize(self):
2482         self._login()
2483
2484     def _real_extract(self, url):
2485         page = self._download_webpage(
2486             'https://www.youtube.com/feed/%s' % self._FEED_NAME, self._PLAYLIST_TITLE)
2487
2488         # The extraction process is the same as for playlists, but the regex
2489         # for the video ids doesn't contain an index
2490         ids = []
2491         more_widget_html = content_html = page
2492         for page_num in itertools.count(1):
2493             matches = re.findall(r'href="\s*/watch\?v=([0-9A-Za-z_-]{11})', content_html)
2494
2495             # 'recommended' feed has infinite 'load more' and each new portion spins
2496             # the same videos in (sometimes) slightly different order, so we'll check
2497             # for unicity and break when portion has no new videos
2498             new_ids = filter(lambda video_id: video_id not in ids, orderedSet(matches))
2499             if not new_ids:
2500                 break
2501
2502             ids.extend(new_ids)
2503
2504             mobj = re.search(r'data-uix-load-more-href="/?(?P<more>[^"]+)"', more_widget_html)
2505             if not mobj:
2506                 break
2507
2508             more = self._download_json(
2509                 'https://youtube.com/%s' % mobj.group('more'), self._PLAYLIST_TITLE,
2510                 'Downloading page #%s' % page_num,
2511                 transform_source=uppercase_escape)
2512             content_html = more['content_html']
2513             more_widget_html = more['load_more_widget_html']
2514
2515         return self.playlist_result(
2516             self._ids_to_results(ids), playlist_title=self._PLAYLIST_TITLE)
2517
2518
2519 class YoutubeWatchLaterIE(YoutubePlaylistIE):
2520     IE_NAME = 'youtube:watchlater'
2521     IE_DESC = 'Youtube watch later list, ":ytwatchlater" for short (requires authentication)'
2522     _VALID_URL = r'https?://(?:www\.)?youtube\.com/(?:feed/watch_later|(?:playlist|watch)\?(?:.+&)?list=WL)|:ytwatchlater'
2523
2524     _TESTS = [{
2525         'url': 'https://www.youtube.com/playlist?list=WL',
2526         'only_matching': True,
2527     }, {
2528         'url': 'https://www.youtube.com/watch?v=bCNU9TrbiRk&index=1&list=WL',
2529         'only_matching': True,
2530     }]
2531
2532     def _real_extract(self, url):
2533         _, video = self._check_download_just_video(url, 'WL')
2534         if video:
2535             return video
2536         _, playlist = self._extract_playlist('WL')
2537         return playlist
2538
2539
2540 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor):
2541     IE_NAME = 'youtube:favorites'
2542     IE_DESC = 'YouTube.com favourite videos, ":ytfav" for short (requires authentication)'
2543     _VALID_URL = r'https?://(?:www\.)?youtube\.com/my_favorites|:ytfav(?:ou?rites)?'
2544     _LOGIN_REQUIRED = True
2545
2546     def _real_extract(self, url):
2547         webpage = self._download_webpage('https://www.youtube.com/my_favorites', 'Youtube Favourites videos')
2548         playlist_id = self._search_regex(r'list=(.+?)["&]', webpage, 'favourites playlist id')
2549         return self.url_result(playlist_id, 'YoutubePlaylist')
2550
2551
2552 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor):
2553     IE_DESC = 'YouTube.com recommended videos, ":ytrec" for short (requires authentication)'
2554     _VALID_URL = r'https?://(?:www\.)?youtube\.com/feed/recommended|:ytrec(?:ommended)?'
2555     _FEED_NAME = 'recommended'
2556     _PLAYLIST_TITLE = 'Youtube Recommended videos'
2557
2558
2559 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor):
2560     IE_DESC = 'YouTube.com subscriptions feed, "ytsubs" keyword (requires authentication)'
2561     _VALID_URL = r'https?://(?:www\.)?youtube\.com/feed/subscriptions|:ytsubs(?:criptions)?'
2562     _FEED_NAME = 'subscriptions'
2563     _PLAYLIST_TITLE = 'Youtube Subscriptions'
2564
2565
2566 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor):
2567     IE_DESC = 'Youtube watch history, ":ythistory" for short (requires authentication)'
2568     _VALID_URL = r'https?://(?:www\.)?youtube\.com/feed/history|:ythistory'
2569     _FEED_NAME = 'history'
2570     _PLAYLIST_TITLE = 'Youtube History'
2571
2572
2573 class YoutubeTruncatedURLIE(InfoExtractor):
2574     IE_NAME = 'youtube:truncated_url'
2575     IE_DESC = False  # Do not list
2576     _VALID_URL = r'''(?x)
2577         (?:https?://)?
2578         (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
2579         (?:watch\?(?:
2580             feature=[a-z_]+|
2581             annotation_id=annotation_[^&]+|
2582             x-yt-cl=[0-9]+|
2583             hl=[^&]*|
2584             t=[0-9]+
2585         )?
2586         |
2587             attribution_link\?a=[^&]+
2588         )
2589         $
2590     '''
2591
2592     _TESTS = [{
2593         'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
2594         'only_matching': True,
2595     }, {
2596         'url': 'https://www.youtube.com/watch?',
2597         'only_matching': True,
2598     }, {
2599         'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
2600         'only_matching': True,
2601     }, {
2602         'url': 'https://www.youtube.com/watch?feature=foo',
2603         'only_matching': True,
2604     }, {
2605         'url': 'https://www.youtube.com/watch?hl=en-GB',
2606         'only_matching': True,
2607     }, {
2608         'url': 'https://www.youtube.com/watch?t=2372',
2609         'only_matching': True,
2610     }]
2611
2612     def _real_extract(self, url):
2613         raise ExtractorError(
2614             'Did you forget to quote the URL? Remember that & is a meta '
2615             'character in most shells, so you want to put the URL in quotes, '
2616             'like  youtube-dl '
2617             '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
2618             ' or simply  youtube-dl BaW_jenozKc  .',
2619             expected=True)
2620
2621
2622 class YoutubeTruncatedIDIE(InfoExtractor):
2623     IE_NAME = 'youtube:truncated_id'
2624     IE_DESC = False  # Do not list
2625     _VALID_URL = r'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
2626
2627     _TESTS = [{
2628         'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
2629         'only_matching': True,
2630     }]
2631
2632     def _real_extract(self, url):
2633         video_id = self._match_id(url)
2634         raise ExtractorError(
2635             'Incomplete YouTube ID %s. URL %s looks truncated.' % (video_id, url),
2636             expected=True)