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