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

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