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