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

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