_ 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 .subtitles import SubtitlesInfoExtractor
  15 from ..jsinterp import JSInterpreter
  16 from ..swfinterp import SWFInterpreter
  17 from ..compat import (
  18     compat_chr,
  19     compat_parse_qs,
  20     compat_urllib_parse,
  21     compat_urllib_request,
  22     compat_urlparse,
  23     compat_str,
  24 )
  25 from ..utils import (
  26     clean_html,
  27     ExtractorError,
  28     get_element_by_attribute,
  29     get_element_by_id,
  30     int_or_none,
  31     OnDemandPagedList,
  32     orderedSet,
  33     unescapeHTML,
  34     unified_strdate,
  35     uppercase_escape,
  36 )
  37
  38
  39 class YoutubeBaseInfoExtractor(InfoExtractor):
  40     """Provide base functions for Youtube extractors"""
  41     _LOGIN_URL = 'https://accounts.google.com/ServiceLogin'
  42     _TWOFACTOR_URL = 'https://accounts.google.com/SecondFactor'
  43     _NETRC_MACHINE = 'youtube'
  44     # If True it will raise an error if no login info is provided
  45     _LOGIN_REQUIRED = False
  46
  47     def _set_language(self):
  48         self._set_cookie(
  49             '.youtube.com', 'PREF', 'f1=50000000&hl=en',
  50             # YouTube sets the expire time to about two months
  51             expire_time=time.time() + 2 * 30 * 24 * 3600)
  52
  53     def _login(self):
  54         """
  55         Attempt to log in to YouTube.
  56         True is returned if successful or skipped.
  57         False is returned if login failed.
  58
  59         If _LOGIN_REQUIRED is set and no authentication was provided, an error is raised.
  60         """
  61         (username, password) = self._get_login_info()
  62         # No authentication to be performed
  63         if username is None:
  64             if self._LOGIN_REQUIRED:
  65                 raise ExtractorError('No login info available, needed for using %s.' % self.IE_NAME, expected=True)
  66             return True
  67
  68         login_page = self._download_webpage(
  69             self._LOGIN_URL, None,
  70             note='Downloading login page',
  71             errnote='unable to fetch login page', fatal=False)
  72         if login_page is False:
  73             return
  74
  75         galx = self._search_regex(r'(?s)<input.+?name="GALX".+?value="(.+?)"',
  76                                   login_page, 'Login GALX parameter')
  77
  78         # Log in
  79         login_form_strs = {
  80             'continue': 'https://www.youtube.com/signin?action_handle_signin=true&feature=sign_in_button&hl=en_US&nomobiletemp=1',
  81             'Email': username,
  82             'GALX': galx,
  83             'Passwd': password,
  84
  85             'PersistentCookie': 'yes',
  86             '_utf8': '霱',
  87             'bgresponse': 'js_disabled',
  88             'checkConnection': '',
  89             'checkedDomains': 'youtube',
  90             'dnConn': '',
  91             'pstMsg': '0',
  92             'rmShown': '1',
  93             'secTok': '',
  94             'signIn': 'Sign in',
  95             'timeStmp': '',
  96             'service': 'youtube',
  97             'uilel': '3',
  98             'hl': 'en_US',
  99         }
 100
 101         # Convert to UTF-8 *before* urlencode because Python 2.x's urlencode
 102         # chokes on unicode
 103         login_form = dict((k.encode('utf-8'), v.encode('utf-8')) for k, v in login_form_strs.items())
 104         login_data = compat_urllib_parse.urlencode(login_form).encode('ascii')
 105
 106         req = compat_urllib_request.Request(self._LOGIN_URL, login_data)
 107         login_results = self._download_webpage(
 108             req, None,
 109             note='Logging in', errnote='unable to log in', fatal=False)
 110         if login_results is False:
 111             return False
 112
 113         if re.search(r'id="errormsg_0_Passwd"', login_results) is not None:
 114             raise ExtractorError('Please use your account password and a two-factor code instead of an application-specific password.', expected=True)
 115
 116         # Two-Factor
 117         # TODO add SMS and phone call support - these require making a request and then prompting the user
 118
 119         if re.search(r'(?i)<form[^>]* id="gaia_secondfactorform"', login_results) is not None:
 120             tfa_code = self._get_tfa_info()
 121
 122             if tfa_code is None:
 123                 self._downloader.report_warning('Two-factor authentication required. Provide it with --twofactor <code>')
 124                 self._downloader.report_warning('(Note that only TOTP (Google Authenticator App) codes work at this time.)')
 125                 return False
 126
 127             # Unlike the first login form, secTok and timeStmp are both required for the TFA form
 128
 129             match = re.search(r'id="secTok"\n\s+value=\'(.+)\'/>', login_results, re.M | re.U)
 130             if match is None:
 131                 self._downloader.report_warning('Failed to get secTok - did the page structure change?')
 132             secTok = match.group(1)
 133             match = re.search(r'id="timeStmp"\n\s+value=\'(.+)\'/>', login_results, re.M | re.U)
 134             if match is None:
 135                 self._downloader.report_warning('Failed to get timeStmp - did the page structure change?')
 136             timeStmp = match.group(1)
 137
 138             tfa_form_strs = {
 139                 'continue': 'https://www.youtube.com/signin?action_handle_signin=true&feature=sign_in_button&hl=en_US&nomobiletemp=1',
 140                 'smsToken': '',
 141                 'smsUserPin': tfa_code,
 142                 'smsVerifyPin': 'Verify',
 143
 144                 'PersistentCookie': 'yes',
 145                 'checkConnection': '',
 146                 'checkedDomains': 'youtube',
 147                 'pstMsg': '1',
 148                 'secTok': secTok,
 149                 'timeStmp': timeStmp,
 150                 'service': 'youtube',
 151                 'hl': 'en_US',
 152             }
 153             tfa_form = dict((k.encode('utf-8'), v.encode('utf-8')) for k, v in tfa_form_strs.items())
 154             tfa_data = compat_urllib_parse.urlencode(tfa_form).encode('ascii')
 155
 156             tfa_req = compat_urllib_request.Request(self._TWOFACTOR_URL, tfa_data)
 157             tfa_results = self._download_webpage(
 158                 tfa_req, None,
 159                 note='Submitting TFA code', errnote='unable to submit tfa', fatal=False)
 160
 161             if tfa_results is False:
 162                 return False
 163
 164             if re.search(r'(?i)<form[^>]* id="gaia_secondfactorform"', tfa_results) is not None:
 165                 self._downloader.report_warning('Two-factor code expired. Please try again, or use a one-use backup code instead.')
 166                 return False
 167             if re.search(r'(?i)<form[^>]* id="gaia_loginform"', tfa_results) is not None:
 168                 self._downloader.report_warning('unable to log in - did the page structure change?')
 169                 return False
 170             if re.search(r'smsauth-interstitial-reviewsettings', tfa_results) is not None:
 171                 self._downloader.report_warning('Your Google account has a security notice. Please log in on your web browser, resolve the notice, and try again.')
 172                 return False
 173
 174         if re.search(r'(?i)<form[^>]* id="gaia_loginform"', login_results) is not None:
 175             self._downloader.report_warning('unable to log in: bad username or password')
 176             return False
 177         return True
 178
 179     def _real_initialize(self):
 180         if self._downloader is None:
 181             return
 182         self._set_language()
 183         if not self._login():
 184             return
 185
 186
 187 class YoutubeIE(YoutubeBaseInfoExtractor, SubtitlesInfoExtractor):
 188     IE_DESC = 'YouTube.com'
 189     _VALID_URL = r"""(?x)^
 190                      (
 191                          (?:https?://|//)                                    # http(s):// or protocol-independent URL
 192                          (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/|
 193                             (?:www\.)?deturl\.com/www\.youtube\.com/|
 194                             (?:www\.)?pwnyoutube\.com/|
 195                             (?:www\.)?yourepeat\.com/|
 196                             tube\.majestyc\.net/|
 197                             youtube\.googleapis\.com/)                        # the various hostnames, with wildcard subdomains
 198                          (?:.*?\#/)?                                          # handle anchor (#/) redirect urls
 199                          (?:                                                  # the various things that can precede the ID:
 200                              (?:(?:v|embed|e)/(?!videoseries))                # v/ or embed/ or e/
 201                              |(?:                                             # or the v= param in all its forms
 202                                  (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)?  # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
 203                                  (?:\?|\#!?)                                  # the params delimiter ? or # or #!
 204                                  (?:.*?&)?                                    # any other preceding param (like /?s=tuff&v=xxxx)
 205                                  v=
 206                              )
 207                          ))
 208                          |youtu\.be/                                          # just youtu.be/xxxx
 209                          |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
 210                          )
 211                      )?                                                       # all until now is optional -> you can pass the naked ID
 212                      ([0-9A-Za-z_-]{11})                                      # here is it! the YouTube video ID
 213                      (?!.*?&list=)                                            # combined list/video URLs are handled by the playlist IE
 214                      (?(1).+)?                                                # if we found the ID, everything can follow
 215                      $"""
 216     _NEXT_URL_RE = r'[\?&]next_url=([^&]+)'
 217     _formats = {
 218         '5': {'ext': 'flv', 'width': 400, 'height': 240},
 219         '6': {'ext': 'flv', 'width': 450, 'height': 270},
 220         '13': {'ext': '3gp'},
 221         '17': {'ext': '3gp', 'width': 176, 'height': 144},
 222         '18': {'ext': 'mp4', 'width': 640, 'height': 360},
 223         '22': {'ext': 'mp4', 'width': 1280, 'height': 720},
 224         '34': {'ext': 'flv', 'width': 640, 'height': 360},
 225         '35': {'ext': 'flv', 'width': 854, 'height': 480},
 226         '36': {'ext': '3gp', 'width': 320, 'height': 240},
 227         '37': {'ext': 'mp4', 'width': 1920, 'height': 1080},
 228         '38': {'ext': 'mp4', 'width': 4096, 'height': 3072},
 229         '43': {'ext': 'webm', 'width': 640, 'height': 360},
 230         '44': {'ext': 'webm', 'width': 854, 'height': 480},
 231         '45': {'ext': 'webm', 'width': 1280, 'height': 720},
 232         '46': {'ext': 'webm', 'width': 1920, 'height': 1080},
 233
 234
 235         # 3d videos
 236         '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'preference': -20},
 237         '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'preference': -20},
 238         '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'preference': -20},
 239         '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'preference': -20},
 240         '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'preference': -20},
 241         '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'preference': -20},
 242         '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'preference': -20},
 243
 244         # Apple HTTP Live Streaming
 245         '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'preference': -10},
 246         '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'preference': -10},
 247         '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'preference': -10},
 248         '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'preference': -10},
 249         '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'preference': -10},
 250         '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'preference': -10},
 251         '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'preference': -10},
 252
 253         # DASH mp4 video
 254         '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 255         '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 256         '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 257         '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 258         '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 259         '138': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 260         '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 261         '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 262         '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'fps': 60, 'vcodec': 'h264'},
 263         '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'fps': 60, 'vcodec': 'h264'},
 264         '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'vcodec': 'h264'},
 265
 266         # Dash mp4 audio
 267         '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'vcodec': 'none', 'abr': 48, 'preference': -50},
 268         '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'vcodec': 'none', 'abr': 128, 'preference': -50},
 269         '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'vcodec': 'none', 'abr': 256, 'preference': -50},
 270
 271         # Dash webm
 272         '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
 273         '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
 274         '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
 275         '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
 276         '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
 277         '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'acodec': 'none', 'container': 'webm', 'vcodec': 'VP8', 'preference': -40},
 278         '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'container': 'webm', 'vcodec': 'VP9'},
 279         '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 280         '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 281         '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 282         '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 283         '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 284         '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 285         '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 286         '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 287         '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40},
 288         '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'fps': 60, 'vcodec': 'VP9'},
 289         '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'fps': 60, 'vcodec': 'VP9'},
 290         '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'acodec': 'none', 'preference': -40, 'vcodec': 'VP9'},
 291
 292         # Dash webm audio
 293         '171': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'abr': 128, 'preference': -50},
 294         '172': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'abr': 256, 'preference': -50},
 295
 296         # Dash webm audio with opus inside
 297         '249': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50, 'preference': -50},
 298         '250': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70, 'preference': -50},
 299         '251': {'ext': 'webm', 'vcodec': 'none', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160, 'preference': -50},
 300
 301         # RTMP (unnamed)
 302         '_rtmp': {'protocol': 'rtmp'},
 303     }
 304
 305     IE_NAME = 'youtube'
 306     _TESTS = [
 307         {
 308             'url': 'http://www.youtube.com/watch?v=BaW_jenozKc',
 309             'info_dict': {
 310                 'id': 'BaW_jenozKc',
 311                 'ext': 'mp4',
 312                 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
 313                 'uploader': 'Philipp Hagemeister',
 314                 'uploader_id': 'phihag',
 315                 'upload_date': '20121002',
 316                 '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 .',
 317                 'categories': ['Science & Technology'],
 318                 'like_count': int,
 319                 'dislike_count': int,
 320             }
 321         },
 322         {
 323             'url': 'http://www.youtube.com/watch?v=UxxajLWwzqY',
 324             'note': 'Test generic use_cipher_signature video (#897)',
 325             'info_dict': {
 326                 'id': 'UxxajLWwzqY',
 327                 'ext': 'mp4',
 328                 'upload_date': '20120506',
 329                 'title': 'Icona Pop - I Love It (feat. Charli XCX) [OFFICIAL VIDEO]',
 330                 'description': 'md5:fea86fda2d5a5784273df5c7cc994d9f',
 331                 'uploader': 'Icona Pop',
 332                 'uploader_id': 'IconaPop',
 333             }
 334         },
 335         {
 336             'url': 'https://www.youtube.com/watch?v=07FYdnEawAQ',
 337             'note': 'Test VEVO video with age protection (#956)',
 338             'info_dict': {
 339                 'id': '07FYdnEawAQ',
 340                 'ext': 'mp4',
 341                 'upload_date': '20130703',
 342                 'title': 'Justin Timberlake - Tunnel Vision (Explicit)',
 343                 'description': 'md5:64249768eec3bc4276236606ea996373',
 344                 'uploader': 'justintimberlakeVEVO',
 345                 'uploader_id': 'justintimberlakeVEVO',
 346             }
 347         },
 348         {
 349             'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
 350             'note': 'Embed-only video (#1746)',
 351             'info_dict': {
 352                 'id': 'yZIXLfi8CZQ',
 353                 'ext': 'mp4',
 354                 'upload_date': '20120608',
 355                 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
 356                 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
 357                 'uploader': 'SET India',
 358                 'uploader_id': 'setindia'
 359             }
 360         },
 361         {
 362             'url': 'http://www.youtube.com/watch?v=a9LDPn-MO4I',
 363             'note': '256k DASH audio (format 141) via DASH manifest',
 364             'info_dict': {
 365                 'id': 'a9LDPn-MO4I',
 366                 'ext': 'm4a',
 367                 'upload_date': '20121002',
 368                 'uploader_id': '8KVIDEO',
 369                 'description': '',
 370                 'uploader': '8KVIDEO',
 371                 'title': 'UHDTV TEST 8K VIDEO.mp4'
 372             },
 373             'params': {
 374                 'youtube_include_dash_manifest': True,
 375                 'format': '141',
 376             },
 377         },
 378         # DASH manifest with encrypted signature
 379         {
 380             'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
 381             'info_dict': {
 382                 'id': 'IB3lcPjvWLA',
 383                 'ext': 'm4a',
 384                 'title': 'Afrojack, Spree Wilson - The Spark ft. Spree Wilson',
 385                 'description': 'md5:12e7067fa6735a77bdcbb58cb1187d2d',
 386                 'uploader': 'AfrojackVEVO',
 387                 'uploader_id': 'AfrojackVEVO',
 388                 'upload_date': '20131011',
 389             },
 390             'params': {
 391                 'youtube_include_dash_manifest': True,
 392                 'format': '141',
 393             },
 394         },
 395         # Controversy video
 396         {
 397             'url': 'https://www.youtube.com/watch?v=T4XJQO3qol8',
 398             'info_dict': {
 399                 'id': 'T4XJQO3qol8',
 400                 'ext': 'mp4',
 401                 'upload_date': '20100909',
 402                 'uploader': 'The Amazing Atheist',
 403                 'uploader_id': 'TheAmazingAtheist',
 404                 'title': 'Burning Everyone\'s Koran',
 405                 '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',
 406             }
 407         },
 408         # Normal age-gate video (No vevo, embed allowed)
 409         {
 410             'url': 'http://youtube.com/watch?v=HtVdAasjOgU',
 411             'info_dict': {
 412                 'id': 'HtVdAasjOgU',
 413                 'ext': 'mp4',
 414                 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
 415                 'description': 'md5:eca57043abae25130f58f655ad9a7771',
 416                 'uploader': 'The Witcher',
 417                 'uploader_id': 'WitcherGame',
 418                 'upload_date': '20140605',
 419             },
 420         },
 421         # Age-gate video with encrypted signature
 422         {
 423             'url': 'http://www.youtube.com/watch?v=6kLq3WMV1nU',
 424             'info_dict': {
 425                 'id': '6kLq3WMV1nU',
 426                 'ext': 'mp4',
 427                 'title': 'Dedication To My Ex (Miss That) (Lyric Video)',
 428                 'description': 'md5:33765bb339e1b47e7e72b5490139bb41',
 429                 'uploader': 'LloydVEVO',
 430                 'uploader_id': 'LloydVEVO',
 431                 'upload_date': '20110629',
 432             },
 433         },
 434         # video_info is None (https://github.com/rg3/youtube-dl/issues/4421)
 435         {
 436             'url': '__2ABJjxzNo',
 437             'info_dict': {
 438                 'id': '__2ABJjxzNo',
 439                 'ext': 'mp4',
 440                 'upload_date': '20100430',
 441                 'uploader_id': 'deadmau5',
 442                 'description': 'md5:12c56784b8032162bb936a5f76d55360',
 443                 'uploader': 'deadmau5',
 444                 'title': 'Deadmau5 - Some Chords (HD)',
 445             },
 446             'expected_warnings': [
 447                 'DASH manifest missing',
 448             ]
 449         },
 450         # Olympics (https://github.com/rg3/youtube-dl/issues/4431)
 451         {
 452             'url': 'lqQg6PlCWgI',
 453             'info_dict': {
 454                 'id': 'lqQg6PlCWgI',
 455                 'ext': 'mp4',
 456                 'upload_date': '20120731',
 457                 'uploader_id': 'olympic',
 458                 'description': 'HO09  - Women -  GER-AUS - Hockey - 31 July 2012 - London 2012 Olympic Games',
 459                 'uploader': 'Olympics',
 460                 'title': 'Hockey - Women -  GER-AUS - London 2012 Olympic Games',
 461             },
 462             'params': {
 463                 'skip_download': 'requires avconv',
 464             }
 465         },
 466     ]
 467
 468     def __init__(self, *args, **kwargs):
 469         super(YoutubeIE, self).__init__(*args, **kwargs)
 470         self._player_cache = {}
 471
 472     def report_video_info_webpage_download(self, video_id):
 473         """Report attempt to download video info webpage."""
 474         self.to_screen('%s: Downloading video info webpage' % video_id)
 475
 476     def report_information_extraction(self, video_id):
 477         """Report attempt to extract video information."""
 478         self.to_screen('%s: Extracting video information' % video_id)
 479
 480     def report_unavailable_format(self, video_id, format):
 481         """Report extracted video URL."""
 482         self.to_screen('%s: Format %s not available' % (video_id, format))
 483
 484     def report_rtmp_download(self):
 485         """Indicate the download will use the RTMP protocol."""
 486         self.to_screen('RTMP download detected')
 487
 488     def _signature_cache_id(self, example_sig):
 489         """ Return a string representation of a signature """
 490         return '.'.join(compat_str(len(part)) for part in example_sig.split('.'))
 491
 492     def _extract_signature_function(self, video_id, player_url, example_sig):
 493         id_m = re.match(
 494             r'.*?-(?P<id>[a-zA-Z0-9_-]+)(?:/watch_as3|/html5player)?\.(?P<ext>[a-z]+)$',
 495             player_url)
 496         if not id_m:
 497             raise ExtractorError('Cannot identify player %r' % player_url)
 498         player_type = id_m.group('ext')
 499         player_id = id_m.group('id')
 500
 501         # Read from filesystem cache
 502         func_id = '%s_%s_%s' % (
 503             player_type, player_id, self._signature_cache_id(example_sig))
 504         assert os.path.basename(func_id) == func_id
 505
 506         cache_spec = self._downloader.cache.load('youtube-sigfuncs', func_id)
 507         if cache_spec is not None:
 508             return lambda s: ''.join(s[i] for i in cache_spec)
 509
 510         if player_type == 'js':
 511             code = self._download_webpage(
 512                 player_url, video_id,
 513                 note='Downloading %s player %s' % (player_type, player_id),
 514                 errnote='Download of %s failed' % player_url)
 515             res = self._parse_sig_js(code)
 516         elif player_type == 'swf':
 517             urlh = self._request_webpage(
 518                 player_url, video_id,
 519                 note='Downloading %s player %s' % (player_type, player_id),
 520                 errnote='Download of %s failed' % player_url)
 521             code = urlh.read()
 522             res = self._parse_sig_swf(code)
 523         else:
 524             assert False, 'Invalid player type %r' % player_type
 525
 526         if cache_spec is None:
 527             test_string = ''.join(map(compat_chr, range(len(example_sig))))
 528             cache_res = res(test_string)
 529             cache_spec = [ord(c) for c in cache_res]
 530
 531         self._downloader.cache.store('youtube-sigfuncs', func_id, cache_spec)
 532         return res
 533
 534     def _print_sig_code(self, func, example_sig):
 535         def gen_sig_code(idxs):
 536             def _genslice(start, end, step):
 537                 starts = '' if start == 0 else str(start)
 538                 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
 539                 steps = '' if step == 1 else (':%d' % step)
 540                 return 's[%s%s%s]' % (starts, ends, steps)
 541
 542             step = None
 543             # Quelch pyflakes warnings - start will be set when step is set
 544             start = '(Never used)'
 545             for i, prev in zip(idxs[1:], idxs[:-1]):
 546                 if step is not None:
 547                     if i - prev == step:
 548                         continue
 549                     yield _genslice(start, prev, step)
 550                     step = None
 551                     continue
 552                 if i - prev in [-1, 1]:
 553                     step = i - prev
 554                     start = prev
 555                     continue
 556                 else:
 557                     yield 's[%d]' % prev
 558             if step is None:
 559                 yield 's[%d]' % i
 560             else:
 561                 yield _genslice(start, i, step)
 562
 563         test_string = ''.join(map(compat_chr, range(len(example_sig))))
 564         cache_res = func(test_string)
 565         cache_spec = [ord(c) for c in cache_res]
 566         expr_code = ' + '.join(gen_sig_code(cache_spec))
 567         signature_id_tuple = '(%s)' % (
 568             ', '.join(compat_str(len(p)) for p in example_sig.split('.')))
 569         code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
 570                 '    return %s\n') % (signature_id_tuple, expr_code)
 571         self.to_screen('Extracted signature function:\n' + code)
 572
 573     def _parse_sig_js(self, jscode):
 574         funcname = self._search_regex(
 575             r'\.sig\|\|([a-zA-Z0-9]+)\(', jscode,
 576             'Initial JS player signature function name')
 577
 578         jsi = JSInterpreter(jscode)
 579         initial_function = jsi.extract_function(funcname)
 580         return lambda s: initial_function([s])
 581
 582     def _parse_sig_swf(self, file_contents):
 583         swfi = SWFInterpreter(file_contents)
 584         TARGET_CLASSNAME = 'SignatureDecipher'
 585         searched_class = swfi.extract_class(TARGET_CLASSNAME)
 586         initial_function = swfi.extract_function(searched_class, 'decipher')
 587         return lambda s: initial_function([s])
 588
 589     def _decrypt_signature(self, s, video_id, player_url, age_gate=False):
 590         """Turn the encrypted s field into a working signature"""
 591
 592         if player_url is None:
 593             raise ExtractorError('Cannot decrypt signature without player_url')
 594
 595         if player_url.startswith('//'):
 596             player_url = 'https:' + player_url
 597         try:
 598             player_id = (player_url, self._signature_cache_id(s))
 599             if player_id not in self._player_cache:
 600                 func = self._extract_signature_function(
 601                     video_id, player_url, s
 602                 )
 603                 self._player_cache[player_id] = func
 604             func = self._player_cache[player_id]
 605             if self._downloader.params.get('youtube_print_sig_code'):
 606                 self._print_sig_code(func, s)
 607             return func(s)
 608         except Exception as e:
 609             tb = traceback.format_exc()
 610             raise ExtractorError(
 611                 'Signature extraction failed: ' + tb, cause=e)
 612
 613     def _get_available_subtitles(self, video_id, webpage):
 614         try:
 615             sub_list = self._download_webpage(
 616                 'https://video.google.com/timedtext?hl=en&type=list&v=%s' % video_id,
 617                 video_id, note=False)
 618         except ExtractorError as err:
 619             self._downloader.report_warning('unable to download video subtitles: %s' % compat_str(err))
 620             return {}
 621         lang_list = re.findall(r'name="([^"]*)"[^>]+lang_code="([\w\-]+)"', sub_list)
 622
 623         sub_lang_list = {}
 624         for l in lang_list:
 625             lang = l[1]
 626             if lang in sub_lang_list:
 627                 continue
 628             params = compat_urllib_parse.urlencode({
 629                 'lang': lang,
 630                 'v': video_id,
 631                 'fmt': self._downloader.params.get('subtitlesformat', 'srt'),
 632                 'name': unescapeHTML(l[0]).encode('utf-8'),
 633             })
 634             url = 'https://www.youtube.com/api/timedtext?' + params
 635             sub_lang_list[lang] = url
 636         if not sub_lang_list:
 637             self._downloader.report_warning('video doesn\'t have subtitles')
 638             return {}
 639         return sub_lang_list
 640
 641     def _get_available_automatic_caption(self, video_id, webpage):
 642         """We need the webpage for getting the captions url, pass it as an
 643            argument to speed up the process."""
 644         sub_format = self._downloader.params.get('subtitlesformat', 'srt')
 645         self.to_screen('%s: Looking for automatic captions' % video_id)
 646         mobj = re.search(r';ytplayer.config = ({.*?});', webpage)
 647         err_msg = 'Couldn\'t find automatic captions for %s' % video_id
 648         if mobj is None:
 649             self._downloader.report_warning(err_msg)
 650             return {}
 651         player_config = json.loads(mobj.group(1))
 652         try:
 653             args = player_config['args']
 654             caption_url = args['ttsurl']
 655             timestamp = args['timestamp']
 656             # We get the available subtitles
 657             list_params = compat_urllib_parse.urlencode({
 658                 'type': 'list',
 659                 'tlangs': 1,
 660                 'asrs': 1,
 661             })
 662             list_url = caption_url + '&' + list_params
 663             caption_list = self._download_xml(list_url, video_id)
 664             original_lang_node = caption_list.find('track')
 665             if original_lang_node is None:
 666                 self._downloader.report_warning('Video doesn\'t have automatic captions')
 667                 return {}
 668             original_lang = original_lang_node.attrib['lang_code']
 669             caption_kind = original_lang_node.attrib.get('kind', '')
 670
 671             sub_lang_list = {}
 672             for lang_node in caption_list.findall('target'):
 673                 sub_lang = lang_node.attrib['lang_code']
 674                 params = compat_urllib_parse.urlencode({
 675                     'lang': original_lang,
 676                     'tlang': sub_lang,
 677                     'fmt': sub_format,
 678                     'ts': timestamp,
 679                     'kind': caption_kind,
 680                 })
 681                 sub_lang_list[sub_lang] = caption_url + '&' + params
 682             return sub_lang_list
 683         # An extractor error can be raise by the download process if there are
 684         # no automatic captions but there are subtitles
 685         except (KeyError, ExtractorError):
 686             self._downloader.report_warning(err_msg)
 687             return {}
 688
 689     @classmethod
 690     def extract_id(cls, url):
 691         mobj = re.match(cls._VALID_URL, url, re.VERBOSE)
 692         if mobj is None:
 693             raise ExtractorError('Invalid URL: %s' % url)
 694         video_id = mobj.group(2)
 695         return video_id
 696
 697     def _extract_from_m3u8(self, manifest_url, video_id):
 698         url_map = {}
 699
 700         def _get_urls(_manifest):
 701             lines = _manifest.split('\n')
 702             urls = filter(lambda l: l and not l.startswith('#'),
 703                           lines)
 704             return urls
 705         manifest = self._download_webpage(manifest_url, video_id, 'Downloading formats manifest')
 706         formats_urls = _get_urls(manifest)
 707         for format_url in formats_urls:
 708             itag = self._search_regex(r'itag/(\d+?)/', format_url, 'itag')
 709             url_map[itag] = format_url
 710         return url_map
 711
 712     def _extract_annotations(self, video_id):
 713         url = 'https://www.youtube.com/annotations_invideo?features=1&legacy=1&video_id=%s' % video_id
 714         return self._download_webpage(url, video_id, note='Searching for annotations.', errnote='Unable to download video annotations.')
 715
 716     def _parse_dash_manifest(
 717             self, video_id, dash_manifest_url, player_url, age_gate):
 718         def decrypt_sig(mobj):
 719             s = mobj.group(1)
 720             dec_s = self._decrypt_signature(s, video_id, player_url, age_gate)
 721             return '/signature/%s' % dec_s
 722         dash_manifest_url = re.sub(r'/s/([\w\.]+)', decrypt_sig, dash_manifest_url)
 723         dash_doc = self._download_xml(
 724             dash_manifest_url, video_id,
 725             note='Downloading DASH manifest',
 726             errnote='Could not download DASH manifest')
 727
 728         formats = []
 729         for r in dash_doc.findall('.//{urn:mpeg:DASH:schema:MPD:2011}Representation'):
 730             url_el = r.find('{urn:mpeg:DASH:schema:MPD:2011}BaseURL')
 731             if url_el is None:
 732                 continue
 733             format_id = r.attrib['id']
 734             video_url = url_el.text
 735             filesize = int_or_none(url_el.attrib.get('{http://youtube.com/yt/2012/10/10}contentLength'))
 736             f = {
 737                 'format_id': format_id,
 738                 'url': video_url,
 739                 'width': int_or_none(r.attrib.get('width')),
 740                 'tbr': int_or_none(r.attrib.get('bandwidth'), 1000),
 741                 'asr': int_or_none(r.attrib.get('audioSamplingRate')),
 742                 'filesize': filesize,
 743                 'fps': int_or_none(r.attrib.get('frameRate')),
 744             }
 745             try:
 746                 existing_format = next(
 747                     fo for fo in formats
 748                     if fo['format_id'] == format_id)
 749             except StopIteration:
 750                 f.update(self._formats.get(format_id, {}))
 751                 formats.append(f)
 752             else:
 753                 existing_format.update(f)
 754         return formats
 755
 756     def _real_extract(self, url):
 757         proto = (
 758             'http' if self._downloader.params.get('prefer_insecure', False)
 759             else 'https')
 760
 761         # Extract original video URL from URL with redirection, like age verification, using next_url parameter
 762         mobj = re.search(self._NEXT_URL_RE, url)
 763         if mobj:
 764             url = proto + '://www.youtube.com/' + compat_urllib_parse.unquote(mobj.group(1)).lstrip('/')
 765         video_id = self.extract_id(url)
 766
 767         # Get video webpage
 768         url = proto + '://www.youtube.com/watch?v=%s&gl=US&hl=en&has_verified=1&bpctr=9999999999' % video_id
 769         video_webpage = self._download_webpage(url, video_id)
 770
 771         # Attempt to extract SWF player URL
 772         mobj = re.search(r'swfConfig.*?"(https?:\\/\\/.*?watch.*?-.*?\.swf)"', video_webpage)
 773         if mobj is not None:
 774             player_url = re.sub(r'\\(.)', r'\1', mobj.group(1))
 775         else:
 776             player_url = None
 777
 778         # Get video info
 779         if re.search(r'player-age-gate-content">', video_webpage) is not None:
 780             age_gate = True
 781             # We simulate the access to the video from www.youtube.com/v/{video_id}
 782             # this can be viewed without login into Youtube
 783             url = proto + '://www.youtube.com/embed/%s' % video_id
 784             embed_webpage = self._download_webpage(url, video_id, 'Downloading embed webpage')
 785             data = compat_urllib_parse.urlencode({
 786                 'video_id': video_id,
 787                 'eurl': 'https://youtube.googleapis.com/v/' + video_id,
 788                 'sts': self._search_regex(
 789                     r'"sts"\s*:\s*(\d+)', embed_webpage, 'sts', default=''),
 790             })
 791             video_info_url = proto + '://www.youtube.com/get_video_info?' + data
 792             video_info_webpage = self._download_webpage(
 793                 video_info_url, video_id,
 794                 note='Refetching age-gated info webpage',
 795                 errnote='unable to download video info webpage')
 796             video_info = compat_parse_qs(video_info_webpage)
 797         else:
 798             age_gate = False
 799             try:
 800                 # Try looking directly into the video webpage
 801                 mobj = re.search(r';ytplayer\.config\s*=\s*({.*?});', video_webpage)
 802                 if not mobj:
 803                     raise ValueError('Could not find ytplayer.config')  # caught below
 804                 json_code = uppercase_escape(mobj.group(1))
 805                 ytplayer_config = json.loads(json_code)
 806                 args = ytplayer_config['args']
 807                 # Convert to the same format returned by compat_parse_qs
 808                 video_info = dict((k, [v]) for k, v in args.items())
 809                 if 'url_encoded_fmt_stream_map' not in args:
 810                     raise ValueError('No stream_map present')  # caught below
 811             except ValueError:
 812                 # We fallback to the get_video_info pages (used by the embed page)
 813                 self.report_video_info_webpage_download(video_id)
 814                 for el_type in ['&el=embedded', '&el=detailpage', '&el=vevo', '']:
 815                     video_info_url = (
 816                         '%s://www.youtube.com/get_video_info?&video_id=%s%s&ps=default&eurl=&gl=US&hl=en'
 817                         % (proto, video_id, el_type))
 818                     video_info_webpage = self._download_webpage(
 819                         video_info_url,
 820                         video_id, note=False,
 821                         errnote='unable to download video info webpage')
 822                     video_info = compat_parse_qs(video_info_webpage)
 823                     if 'token' in video_info:
 824                         break
 825         if 'token' not in video_info:
 826             if 'reason' in video_info:
 827                 raise ExtractorError(
 828                     'YouTube said: %s' % video_info['reason'][0],
 829                     expected=True, video_id=video_id)
 830             else:
 831                 raise ExtractorError(
 832                     '"token" parameter not in video info for unknown reason',
 833                     video_id=video_id)
 834
 835         if 'view_count' in video_info:
 836             view_count = int(video_info['view_count'][0])
 837         else:
 838             view_count = None
 839
 840         # Check for "rental" videos
 841         if 'ypc_video_rental_bar_text' in video_info and 'author' not in video_info:
 842             raise ExtractorError('"rental" videos not supported')
 843
 844         # Start extracting information
 845         self.report_information_extraction(video_id)
 846
 847         # uploader
 848         if 'author' not in video_info:
 849             raise ExtractorError('Unable to extract uploader name')
 850         video_uploader = compat_urllib_parse.unquote_plus(video_info['author'][0])
 851
 852         # uploader_id
 853         video_uploader_id = None
 854         mobj = re.search(r'<link itemprop="url" href="http://www.youtube.com/(?:user|channel)/([^"]+)">', video_webpage)
 855         if mobj is not None:
 856             video_uploader_id = mobj.group(1)
 857         else:
 858             self._downloader.report_warning('unable to extract uploader nickname')
 859
 860         # title
 861         if 'title' in video_info:
 862             video_title = video_info['title'][0]
 863         else:
 864             self._downloader.report_warning('Unable to extract video title')
 865             video_title = '_'
 866
 867         # thumbnail image
 868         # We try first to get a high quality image:
 869         m_thumb = re.search(r'<span itemprop="thumbnail".*?href="(.*?)">',
 870                             video_webpage, re.DOTALL)
 871         if m_thumb is not None:
 872             video_thumbnail = m_thumb.group(1)
 873         elif 'thumbnail_url' not in video_info:
 874             self._downloader.report_warning('unable to extract video thumbnail')
 875             video_thumbnail = None
 876         else:   # don't panic if we can't find it
 877             video_thumbnail = compat_urllib_parse.unquote_plus(video_info['thumbnail_url'][0])
 878
 879         # upload date
 880         upload_date = None
 881         mobj = re.search(r'(?s)id="eow-date.*?>(.*?)</span>', video_webpage)
 882         if mobj is None:
 883             mobj = re.search(
 884                 r'(?s)id="watch-uploader-info".*?>.*?(?:Published|Uploaded|Streamed live) on (.*?)</strong>',
 885                 video_webpage)
 886         if mobj is not None:
 887             upload_date = ' '.join(re.sub(r'[/,-]', r' ', mobj.group(1)).split())
 888             upload_date = unified_strdate(upload_date)
 889
 890         m_cat_container = self._search_regex(
 891             r'(?s)<h4[^>]*>\s*Category\s*</h4>\s*<ul[^>]*>(.*?)</ul>',
 892             video_webpage, 'categories', default=None)
 893         if m_cat_container:
 894             category = self._html_search_regex(
 895                 r'(?s)<a[^<]+>(.*?)</a>', m_cat_container, 'category',
 896                 default=None)
 897             video_categories = None if category is None else [category]
 898         else:
 899             video_categories = None
 900
 901         # description
 902         video_description = get_element_by_id("eow-description", video_webpage)
 903         if video_description:
 904             video_description = re.sub(r'''(?x)
 905                 <a\s+
 906                     (?:[a-zA-Z-]+="[^"]+"\s+)*?
 907                     title="([^"]+)"\s+
 908                     (?:[a-zA-Z-]+="[^"]+"\s+)*?
 909                     class="yt-uix-redirect-link"\s*>
 910                 [^<]+
 911                 </a>
 912             ''', r'\1', video_description)
 913             video_description = clean_html(video_description)
 914         else:
 915             fd_mobj = re.search(r'<meta name="description" content="([^"]+)"', video_webpage)
 916             if fd_mobj:
 917                 video_description = unescapeHTML(fd_mobj.group(1))
 918             else:
 919                 video_description = ''
 920
 921         def _extract_count(count_name):
 922             count = self._search_regex(
 923                 r'id="watch-%s"[^>]*>.*?([\d,]+)\s*</span>' % re.escape(count_name),
 924                 video_webpage, count_name, default=None)
 925             if count is not None:
 926                 return int(count.replace(',', ''))
 927             return None
 928         like_count = _extract_count('like')
 929         dislike_count = _extract_count('dislike')
 930
 931         # subtitles
 932         video_subtitles = self.extract_subtitles(video_id, video_webpage)
 933
 934         if self._downloader.params.get('listsubtitles', False):
 935             self._list_available_subtitles(video_id, video_webpage)
 936             return
 937
 938         if 'length_seconds' not in video_info:
 939             self._downloader.report_warning('unable to extract video duration')
 940             video_duration = None
 941         else:
 942             video_duration = int(compat_urllib_parse.unquote_plus(video_info['length_seconds'][0]))
 943
 944         # annotations
 945         video_annotations = None
 946         if self._downloader.params.get('writeannotations', False):
 947             video_annotations = self._extract_annotations(video_id)
 948
 949         def _map_to_format_list(urlmap):
 950             formats = []
 951             for itag, video_real_url in urlmap.items():
 952                 dct = {
 953                     'format_id': itag,
 954                     'url': video_real_url,
 955                     'player_url': player_url,
 956                 }
 957                 if itag in self._formats:
 958                     dct.update(self._formats[itag])
 959                 formats.append(dct)
 960             return formats
 961
 962         if 'conn' in video_info and video_info['conn'][0].startswith('rtmp'):
 963             self.report_rtmp_download()
 964             formats = [{
 965                 'format_id': '_rtmp',
 966                 'protocol': 'rtmp',
 967                 'url': video_info['conn'][0],
 968                 'player_url': player_url,
 969             }]
 970         elif len(video_info.get('url_encoded_fmt_stream_map', [''])[0]) >= 1 or len(video_info.get('adaptive_fmts', [''])[0]) >= 1:
 971             encoded_url_map = video_info.get('url_encoded_fmt_stream_map', [''])[0] + ',' + video_info.get('adaptive_fmts', [''])[0]
 972             if 'rtmpe%3Dyes' in encoded_url_map:
 973                 raise ExtractorError('rtmpe downloads are not supported, see https://github.com/rg3/youtube-dl/issues/343 for more information.', expected=True)
 974             url_map = {}
 975             for url_data_str in encoded_url_map.split(','):
 976                 url_data = compat_parse_qs(url_data_str)
 977                 if 'itag' not in url_data or 'url' not in url_data:
 978                     continue
 979                 format_id = url_data['itag'][0]
 980                 url = url_data['url'][0]
 981
 982                 if 'sig' in url_data:
 983                     url += '&signature=' + url_data['sig'][0]
 984                 elif 's' in url_data:
 985                     encrypted_sig = url_data['s'][0]
 986
 987                     jsplayer_url_json = self._search_regex(
 988                         r'"assets":.+?"js":\s*("[^"]+")',
 989                         embed_webpage if age_gate else video_webpage, 'JS player URL')
 990                     player_url = json.loads(jsplayer_url_json)
 991                     if player_url is None:
 992                         player_url_json = self._search_regex(
 993                             r'ytplayer\.config.*?"url"\s*:\s*("[^"]+")',
 994                             video_webpage, 'age gate player URL')
 995                         player_url = json.loads(player_url_json)
 996
 997                     if self._downloader.params.get('verbose'):
 998                         if player_url is None:
 999                             player_version = 'unknown'
1000                             player_desc = 'unknown'
1001                         else:
1002                             if player_url.endswith('swf'):
1003                                 player_version = self._search_regex(
1004                                     r'-(.+?)(?:/watch_as3)?\.swf$', player_url,
1005                                     'flash player', fatal=False)
1006                                 player_desc = 'flash player %s' % player_version
1007                             else:
1008                                 player_version = self._search_regex(
1009                                     r'html5player-([^/]+?)(?:/html5player)?\.js',
1010                                     player_url,
1011                                     'html5 player', fatal=False)
1012                                 player_desc = 'html5 player %s' % player_version
1013
1014                         parts_sizes = self._signature_cache_id(encrypted_sig)
1015                         self.to_screen('{%s} signature length %s, %s' %
1016                                        (format_id, parts_sizes, player_desc))
1017
1018                     signature = self._decrypt_signature(
1019                         encrypted_sig, video_id, player_url, age_gate)
1020                     url += '&signature=' + signature
1021                 if 'ratebypass' not in url:
1022                     url += '&ratebypass=yes'
1023                 url_map[format_id] = url
1024             formats = _map_to_format_list(url_map)
1025         elif video_info.get('hlsvp'):
1026             manifest_url = video_info['hlsvp'][0]
1027             url_map = self._extract_from_m3u8(manifest_url, video_id)
1028             formats = _map_to_format_list(url_map)
1029         else:
1030             raise ExtractorError('no conn, hlsvp or url_encoded_fmt_stream_map information found in video info')
1031
1032         # Look for the DASH manifest
1033         if self._downloader.params.get('youtube_include_dash_manifest', True):
1034             dash_mpd = video_info.get('dashmpd')
1035             if dash_mpd:
1036                 dash_manifest_url = dash_mpd[0]
1037                 try:
1038                     dash_formats = self._parse_dash_manifest(
1039                         video_id, dash_manifest_url, player_url, age_gate)
1040                 except (ExtractorError, KeyError) as e:
1041                     self.report_warning(
1042                         'Skipping DASH manifest: %r' % e, video_id)
1043                 else:
1044                     formats.extend(dash_formats)
1045
1046         self._sort_formats(formats)
1047
1048         return {
1049             'id': video_id,
1050             'uploader': video_uploader,
1051             'uploader_id': video_uploader_id,
1052             'upload_date': upload_date,
1053             'title': video_title,
1054             'thumbnail': video_thumbnail,
1055             'description': video_description,
1056             'categories': video_categories,
1057             'subtitles': video_subtitles,
1058             'duration': video_duration,
1059             'age_limit': 18 if age_gate else 0,
1060             'annotations': video_annotations,
1061             'webpage_url': proto + '://www.youtube.com/watch?v=%s' % video_id,
1062             'view_count': view_count,
1063             'like_count': like_count,
1064             'dislike_count': dislike_count,
1065             'formats': formats,
1066         }
1067
1068
1069 class YoutubePlaylistIE(YoutubeBaseInfoExtractor):
1070     IE_DESC = 'YouTube.com playlists'
1071     _VALID_URL = r"""(?x)(?:
1072                         (?:https?://)?
1073                         (?:\w+\.)?
1074                         youtube\.com/
1075                         (?:
1076                            (?:course|view_play_list|my_playlists|artist|playlist|watch|embed/videoseries)
1077                            \? (?:.*?&)*? (?:p|a|list)=
1078                         |  p/
1079                         )
1080                         (
1081                             (?:PL|LL|EC|UU|FL|RD)?[0-9A-Za-z-_]{10,}
1082                             # Top tracks, they can also include dots
1083                             |(?:MC)[\w\.]*
1084                         )
1085                         .*
1086                      |
1087                         ((?:PL|LL|EC|UU|FL|RD)[0-9A-Za-z-_]{10,})
1088                      )"""
1089     _TEMPLATE_URL = 'https://www.youtube.com/playlist?list=%s'
1090     _VIDEO_RE = r'href="\s*/watch\?v=(?P<id>[0-9A-Za-z_-]{11})&amp;[^"]*?index=(?P<index>\d+)'
1091     IE_NAME = 'youtube:playlist'
1092     _TESTS = [{
1093         'url': 'https://www.youtube.com/playlist?list=PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re',
1094         'info_dict': {
1095             'title': 'ytdl test PL',
1096             'id': 'PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re',
1097         },
1098         'playlist_count': 3,
1099     }, {
1100         'url': 'https://www.youtube.com/playlist?list=PLtPgu7CB4gbZDA7i_euNxn75ISqxwZPYx',
1101         'info_dict': {
1102             'title': 'YDL_Empty_List',
1103         },
1104         'playlist_count': 0,
1105     }, {
1106         'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
1107         'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
1108         'info_dict': {
1109             'title': '29C3: Not my department',
1110         },
1111         'playlist_count': 95,
1112     }, {
1113         'note': 'issue #673',
1114         'url': 'PLBB231211A4F62143',
1115         'info_dict': {
1116             'title': '[OLD]Team Fortress 2 (Class-based LP)',
1117         },
1118         'playlist_mincount': 26,
1119     }, {
1120         'note': 'Large playlist',
1121         'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
1122         'info_dict': {
1123             'title': 'Uploads from Cauchemar',
1124         },
1125         'playlist_mincount': 799,
1126     }, {
1127         'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
1128         'info_dict': {
1129             'title': 'YDL_safe_search',
1130         },
1131         'playlist_count': 2,
1132     }, {
1133         'note': 'embedded',
1134         'url': 'http://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
1135         'playlist_count': 4,
1136         'info_dict': {
1137             'title': 'JODA15',
1138         }
1139     }, {
1140         'note': 'Embedded SWF player',
1141         'url': 'http://www.youtube.com/p/YN5VISEtHet5D4NEvfTd0zcgFk84NqFZ?hl=en_US&fs=1&rel=0',
1142         'playlist_count': 4,
1143         'info_dict': {
1144             'title': 'JODA7',
1145         }
1146     }, {
1147         'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
1148         'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
1149         'info_dict': {
1150                 'title': 'Uploads from Interstellar Movie',
1151         },
1152         'playlist_mincout': 21,
1153     }]
1154
1155     def _real_initialize(self):
1156         self._login()
1157
1158     def _ids_to_results(self, ids):
1159         return [
1160             self.url_result(vid_id, 'Youtube', video_id=vid_id)
1161             for vid_id in ids]
1162
1163     def _extract_mix(self, playlist_id):
1164         # The mixes are generated from a a single video
1165         # the id of the playlist is just 'RD' + video_id
1166         url = 'https://youtube.com/watch?v=%s&list=%s' % (playlist_id[-11:], playlist_id)
1167         webpage = self._download_webpage(
1168             url, playlist_id, 'Downloading Youtube mix')
1169         search_title = lambda class_name: get_element_by_attribute('class', class_name, webpage)
1170         title_span = (
1171             search_title('playlist-title') or
1172             search_title('title long-title') or
1173             search_title('title'))
1174         title = clean_html(title_span)
1175         ids = orderedSet(re.findall(
1176             r'''(?xs)data-video-username=".*?".*?
1177                        href="/watch\?v=([0-9A-Za-z_-]{11})&amp;[^"]*?list=%s''' % re.escape(playlist_id),
1178             webpage))
1179         url_results = self._ids_to_results(ids)
1180
1181         return self.playlist_result(url_results, playlist_id, title)
1182
1183     def _real_extract(self, url):
1184         # Extract playlist id
1185         mobj = re.match(self._VALID_URL, url)
1186         if mobj is None:
1187             raise ExtractorError('Invalid URL: %s' % url)
1188         playlist_id = mobj.group(1) or mobj.group(2)
1189
1190         # Check if it's a video-specific URL
1191         query_dict = compat_urlparse.parse_qs(compat_urlparse.urlparse(url).query)
1192         if 'v' in query_dict:
1193             video_id = query_dict['v'][0]
1194             if self._downloader.params.get('noplaylist'):
1195                 self.to_screen('Downloading just video %s because of --no-playlist' % video_id)
1196                 return self.url_result(video_id, 'Youtube', video_id=video_id)
1197             else:
1198                 self.to_screen('Downloading playlist %s - add --no-playlist to just download video %s' % (playlist_id, video_id))
1199
1200         if playlist_id.startswith('RD'):
1201             # Mixes require a custom extraction process
1202             return self._extract_mix(playlist_id)
1203         if playlist_id.startswith('TL'):
1204             raise ExtractorError('For downloading YouTube.com top lists, use '
1205                                  'the "yttoplist" keyword, for example "youtube-dl \'yttoplist:music:Top Tracks\'"', expected=True)
1206
1207         url = self._TEMPLATE_URL % playlist_id
1208         page = self._download_webpage(url, playlist_id)
1209         more_widget_html = content_html = page
1210
1211         # Check if the playlist exists or is private
1212         if re.search(r'<div class="yt-alert-message">[^<]*?(The|This) playlist (does not exist|is private)[^<]*?</div>', page) is not None:
1213             raise ExtractorError(
1214                 'The playlist doesn\'t exist or is private, use --username or '
1215                 '--netrc to access it.',
1216                 expected=True)
1217
1218         # Extract the video ids from the playlist pages
1219         ids = []
1220
1221         for page_num in itertools.count(1):
1222             matches = re.finditer(self._VIDEO_RE, content_html)
1223             # We remove the duplicates and the link with index 0
1224             # (it's not the first video of the playlist)
1225             new_ids = orderedSet(m.group('id') for m in matches if m.group('index') != '0')
1226             ids.extend(new_ids)
1227
1228             mobj = re.search(r'data-uix-load-more-href="/?(?P<more>[^"]+)"', more_widget_html)
1229             if not mobj:
1230                 break
1231
1232             more = self._download_json(
1233                 'https://youtube.com/%s' % mobj.group('more'), playlist_id,
1234                 'Downloading page #%s' % page_num,
1235                 transform_source=uppercase_escape)
1236             content_html = more['content_html']
1237             if not content_html.strip():
1238                 # Some webpages show a "Load more" button but they don't
1239                 # have more videos
1240                 break
1241             more_widget_html = more['load_more_widget_html']
1242
1243         playlist_title = self._html_search_regex(
1244             r'(?s)<h1 class="pl-header-title[^"]*">\s*(.*?)\s*</h1>',
1245             page, 'title')
1246
1247         url_results = self._ids_to_results(ids)
1248         return self.playlist_result(url_results, playlist_id, playlist_title)
1249
1250
1251 class YoutubeTopListIE(YoutubePlaylistIE):
1252     IE_NAME = 'youtube:toplist'
1253     IE_DESC = ('YouTube.com top lists, "yttoplist:{channel}:{list title}"'
1254                ' (Example: "yttoplist:music:Top Tracks")')
1255     _VALID_URL = r'yttoplist:(?P<chann>.*?):(?P<title>.*?)$'
1256     _TESTS = [{
1257         'url': 'yttoplist:music:Trending',
1258         'playlist_mincount': 5,
1259         'skip': 'Only works for logged-in users',
1260     }]
1261
1262     def _real_extract(self, url):
1263         mobj = re.match(self._VALID_URL, url)
1264         channel = mobj.group('chann')
1265         title = mobj.group('title')
1266         query = compat_urllib_parse.urlencode({'title': title})
1267         channel_page = self._download_webpage(
1268             'https://www.youtube.com/%s' % channel, title)
1269         link = self._html_search_regex(
1270             r'''(?x)
1271                 <a\s+href="([^"]+)".*?>\s*
1272                 <span\s+class="branded-page-module-title-text">\s*
1273                 <span[^>]*>.*?%s.*?</span>''' % re.escape(query),
1274             channel_page, 'list')
1275         url = compat_urlparse.urljoin('https://www.youtube.com/', link)
1276
1277         video_re = r'data-index="\d+".*?data-video-id="([0-9A-Za-z_-]{11})"'
1278         ids = []
1279         # sometimes the webpage doesn't contain the videos
1280         # retry until we get them
1281         for i in itertools.count(0):
1282             msg = 'Downloading Youtube mix'
1283             if i > 0:
1284                 msg += ', retry #%d' % i
1285
1286             webpage = self._download_webpage(url, title, msg)
1287             ids = orderedSet(re.findall(video_re, webpage))
1288             if ids:
1289                 break
1290         url_results = self._ids_to_results(ids)
1291         return self.playlist_result(url_results, playlist_title=title)
1292
1293
1294 class YoutubeChannelIE(InfoExtractor):
1295     IE_DESC = 'YouTube.com channels'
1296     _VALID_URL = r'https?://(?:youtu\.be|(?:\w+\.)?youtube(?:-nocookie)?\.com)/channel/(?P<id>[0-9A-Za-z_-]+)'
1297     IE_NAME = 'youtube:channel'
1298     _TESTS = [{
1299         'note': 'paginated channel',
1300         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
1301         'playlist_mincount': 91,
1302     }]
1303
1304     def extract_videos_from_page(self, page):
1305         ids_in_page = []
1306         for mobj in re.finditer(r'href="/watch\?v=([0-9A-Za-z_-]+)&?', page):
1307             if mobj.group(1) not in ids_in_page:
1308                 ids_in_page.append(mobj.group(1))
1309         return ids_in_page
1310
1311     def _real_extract(self, url):
1312         channel_id = self._match_id(url)
1313
1314         video_ids = []
1315         url = 'https://www.youtube.com/channel/%s/videos' % channel_id
1316         channel_page = self._download_webpage(url, channel_id)
1317         autogenerated = re.search(r'''(?x)
1318                 class="[^"]*?(?:
1319                     channel-header-autogenerated-label|
1320                     yt-channel-title-autogenerated
1321                 )[^"]*"''', channel_page) is not None
1322
1323         if autogenerated:
1324             # The videos are contained in a single page
1325             # the ajax pages can't be used, they are empty
1326             video_ids = self.extract_videos_from_page(channel_page)
1327             entries = [
1328                 self.url_result(video_id, 'Youtube', video_id=video_id)
1329                 for video_id in video_ids]
1330             return self.playlist_result(entries, channel_id)
1331
1332         def _entries():
1333             more_widget_html = content_html = channel_page
1334             for pagenum in itertools.count(1):
1335
1336                 ids_in_page = self.extract_videos_from_page(content_html)
1337                 for video_id in ids_in_page:
1338                     yield self.url_result(
1339                         video_id, 'Youtube', video_id=video_id)
1340
1341                 mobj = re.search(
1342                     r'data-uix-load-more-href="/?(?P<more>[^"]+)"',
1343                     more_widget_html)
1344                 if not mobj:
1345                     break
1346
1347                 more = self._download_json(
1348                     'https://youtube.com/%s' % mobj.group('more'), channel_id,
1349                     'Downloading page #%s' % (pagenum + 1),
1350                     transform_source=uppercase_escape)
1351                 content_html = more['content_html']
1352                 more_widget_html = more['load_more_widget_html']
1353
1354         return self.playlist_result(_entries(), channel_id)
1355
1356
1357 class YoutubeUserIE(InfoExtractor):
1358     IE_DESC = 'YouTube.com user videos (URL or "ytuser" keyword)'
1359     _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_-]+)'
1360     _TEMPLATE_URL = 'https://gdata.youtube.com/feeds/api/users/%s'
1361     _GDATA_PAGE_SIZE = 50
1362     _GDATA_URL = 'https://gdata.youtube.com/feeds/api/users/%s/uploads?max-results=%d&start-index=%d&alt=json'
1363     IE_NAME = 'youtube:user'
1364
1365     _TESTS = [{
1366         'url': 'https://www.youtube.com/user/TheLinuxFoundation',
1367         'playlist_mincount': 320,
1368         'info_dict': {
1369             'title': 'TheLinuxFoundation',
1370         }
1371     }, {
1372         'url': 'ytuser:phihag',
1373         'only_matching': True,
1374     }]
1375
1376     @classmethod
1377     def suitable(cls, url):
1378         # Don't return True if the url can be extracted with other youtube
1379         # extractor, the regex would is too permissive and it would match.
1380         other_ies = iter(klass for (name, klass) in globals().items() if name.endswith('IE') and klass is not cls)
1381         if any(ie.suitable(url) for ie in other_ies):
1382             return False
1383         else:
1384             return super(YoutubeUserIE, cls).suitable(url)
1385
1386     def _real_extract(self, url):
1387         username = self._match_id(url)
1388
1389         # Download video ids using YouTube Data API. Result size per
1390         # query is limited (currently to 50 videos) so we need to query
1391         # page by page until there are no video ids - it means we got
1392         # all of them.
1393
1394         def download_page(pagenum):
1395             start_index = pagenum * self._GDATA_PAGE_SIZE + 1
1396
1397             gdata_url = self._GDATA_URL % (username, self._GDATA_PAGE_SIZE, start_index)
1398             page = self._download_webpage(
1399                 gdata_url, username,
1400                 'Downloading video ids from %d to %d' % (
1401                     start_index, start_index + self._GDATA_PAGE_SIZE))
1402
1403             try:
1404                 response = json.loads(page)
1405             except ValueError as err:
1406                 raise ExtractorError('Invalid JSON in API response: ' + compat_str(err))
1407             if 'entry' not in response['feed']:
1408                 return
1409
1410             # Extract video identifiers
1411             entries = response['feed']['entry']
1412             for entry in entries:
1413                 title = entry['title']['$t']
1414                 video_id = entry['id']['$t'].split('/')[-1]
1415                 yield {
1416                     '_type': 'url',
1417                     'url': video_id,
1418                     'ie_key': 'Youtube',
1419                     'id': video_id,
1420                     'title': title,
1421                 }
1422         url_results = OnDemandPagedList(download_page, self._GDATA_PAGE_SIZE)
1423
1424         return self.playlist_result(url_results, playlist_title=username)
1425
1426
1427 class YoutubeSearchIE(SearchInfoExtractor):
1428     IE_DESC = 'YouTube.com searches'
1429     _API_URL = 'https://gdata.youtube.com/feeds/api/videos?q=%s&start-index=%i&max-results=50&v=2&alt=jsonc'
1430     _MAX_RESULTS = 1000
1431     IE_NAME = 'youtube:search'
1432     _SEARCH_KEY = 'ytsearch'
1433
1434     def _get_n_results(self, query, n):
1435         """Get a specified number of results for a query"""
1436
1437         video_ids = []
1438         pagenum = 0
1439         limit = n
1440         PAGE_SIZE = 50
1441
1442         while (PAGE_SIZE * pagenum) < limit:
1443             result_url = self._API_URL % (
1444                 compat_urllib_parse.quote_plus(query.encode('utf-8')),
1445                 (PAGE_SIZE * pagenum) + 1)
1446             data_json = self._download_webpage(
1447                 result_url, video_id='query "%s"' % query,
1448                 note='Downloading page %s' % (pagenum + 1),
1449                 errnote='Unable to download API page')
1450             data = json.loads(data_json)
1451             api_response = data['data']
1452
1453             if 'items' not in api_response:
1454                 raise ExtractorError(
1455                     '[youtube] No video results', expected=True)
1456
1457             new_ids = list(video['id'] for video in api_response['items'])
1458             video_ids += new_ids
1459
1460             limit = min(n, api_response['totalItems'])
1461             pagenum += 1
1462
1463         if len(video_ids) > n:
1464             video_ids = video_ids[:n]
1465         videos = [self.url_result(video_id, 'Youtube', video_id=video_id)
1466                   for video_id in video_ids]
1467         return self.playlist_result(videos, query)
1468
1469
1470 class YoutubeSearchDateIE(YoutubeSearchIE):
1471     IE_NAME = YoutubeSearchIE.IE_NAME + ':date'
1472     _API_URL = 'https://gdata.youtube.com/feeds/api/videos?q=%s&start-index=%i&max-results=50&v=2&alt=jsonc&orderby=published'
1473     _SEARCH_KEY = 'ytsearchdate'
1474     IE_DESC = 'YouTube.com searches, newest videos first'
1475
1476
1477 class YoutubeSearchURLIE(InfoExtractor):
1478     IE_DESC = 'YouTube.com search URLs'
1479     IE_NAME = 'youtube:search_url'
1480     _VALID_URL = r'https?://(?:www\.)?youtube\.com/results\?(.*?&)?search_query=(?P<query>[^&]+)(?:[&]|$)'
1481     _TESTS = [{
1482         'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
1483         'playlist_mincount': 5,
1484         'info_dict': {
1485             'title': 'youtube-dl test video',
1486         }
1487     }]
1488
1489     def _real_extract(self, url):
1490         mobj = re.match(self._VALID_URL, url)
1491         query = compat_urllib_parse.unquote_plus(mobj.group('query'))
1492
1493         webpage = self._download_webpage(url, query)
1494         result_code = self._search_regex(
1495             r'(?s)<ol class="item-section"(.*?)</ol>', webpage, 'result HTML')
1496
1497         part_codes = re.findall(
1498             r'(?s)<h3 class="yt-lockup-title">(.*?)</h3>', result_code)
1499         entries = []
1500         for part_code in part_codes:
1501             part_title = self._html_search_regex(
1502                 [r'(?s)title="([^"]+)"', r'>([^<]+)</a>'], part_code, 'item title', fatal=False)
1503             part_url_snippet = self._html_search_regex(
1504                 r'(?s)href="([^"]+)"', part_code, 'item URL')
1505             part_url = compat_urlparse.urljoin(
1506                 'https://www.youtube.com/', part_url_snippet)
1507             entries.append({
1508                 '_type': 'url',
1509                 'url': part_url,
1510                 'title': part_title,
1511             })
1512
1513         return {
1514             '_type': 'playlist',
1515             'entries': entries,
1516             'title': query,
1517         }
1518
1519
1520 class YoutubeShowIE(InfoExtractor):
1521     IE_DESC = 'YouTube.com (multi-season) shows'
1522     _VALID_URL = r'https?://www\.youtube\.com/show/(?P<id>[^?#]*)'
1523     IE_NAME = 'youtube:show'
1524     _TESTS = [{
1525         'url': 'http://www.youtube.com/show/airdisasters',
1526         'playlist_mincount': 3,
1527         'info_dict': {
1528             'id': 'airdisasters',
1529             'title': 'Air Disasters',
1530         }
1531     }]
1532
1533     def _real_extract(self, url):
1534         mobj = re.match(self._VALID_URL, url)
1535         playlist_id = mobj.group('id')
1536         webpage = self._download_webpage(
1537             url, playlist_id, 'Downloading show webpage')
1538         # There's one playlist for each season of the show
1539         m_seasons = list(re.finditer(r'href="(/playlist\?list=.*?)"', webpage))
1540         self.to_screen('%s: Found %s seasons' % (playlist_id, len(m_seasons)))
1541         entries = [
1542             self.url_result(
1543                 'https://www.youtube.com' + season.group(1), 'YoutubePlaylist')
1544             for season in m_seasons
1545         ]
1546         title = self._og_search_title(webpage, fatal=False)
1547
1548         return {
1549             '_type': 'playlist',
1550             'id': playlist_id,
1551             'title': title,
1552             'entries': entries,
1553         }
1554
1555
1556 class YoutubeFeedsInfoExtractor(YoutubeBaseInfoExtractor):
1557     """
1558     Base class for extractors that fetch info from
1559     http://www.youtube.com/feed_ajax
1560     Subclasses must define the _FEED_NAME and _PLAYLIST_TITLE properties.
1561     """
1562     _LOGIN_REQUIRED = True
1563     # use action_load_personal_feed instead of action_load_system_feed
1564     _PERSONAL_FEED = False
1565
1566     @property
1567     def _FEED_TEMPLATE(self):
1568         action = 'action_load_system_feed'
1569         if self._PERSONAL_FEED:
1570             action = 'action_load_personal_feed'
1571         return 'https://www.youtube.com/feed_ajax?%s=1&feed_name=%s&paging=%%s' % (action, self._FEED_NAME)
1572
1573     @property
1574     def IE_NAME(self):
1575         return 'youtube:%s' % self._FEED_NAME
1576
1577     def _real_initialize(self):
1578         self._login()
1579
1580     def _real_extract(self, url):
1581         feed_entries = []
1582         paging = 0
1583         for i in itertools.count(1):
1584             info = self._download_json(
1585                 self._FEED_TEMPLATE % paging,
1586                 '%s feed' % self._FEED_NAME,
1587                 'Downloading page %s' % i,
1588                 transform_source=uppercase_escape)
1589             feed_html = info.get('feed_html') or info.get('content_html')
1590             load_more_widget_html = info.get('load_more_widget_html') or feed_html
1591             m_ids = re.finditer(r'"/watch\?v=(.*?)["&]', feed_html)
1592             ids = orderedSet(m.group(1) for m in m_ids)
1593             feed_entries.extend(
1594                 self.url_result(video_id, 'Youtube', video_id=video_id)
1595                 for video_id in ids)
1596             mobj = re.search(
1597                 r'data-uix-load-more-href="/?[^"]+paging=(?P<paging>\d+)',
1598                 load_more_widget_html)
1599             if mobj is None:
1600                 break
1601             paging = mobj.group('paging')
1602         return self.playlist_result(feed_entries, playlist_title=self._PLAYLIST_TITLE)
1603
1604
1605 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor):
1606     IE_DESC = 'YouTube.com recommended videos, ":ytrec" for short (requires authentication)'
1607     _VALID_URL = r'https?://www\.youtube\.com/feed/recommended|:ytrec(?:ommended)?'
1608     _FEED_NAME = 'recommended'
1609     _PLAYLIST_TITLE = 'Youtube Recommended videos'
1610
1611
1612 class YoutubeWatchLaterIE(YoutubeFeedsInfoExtractor):
1613     IE_DESC = 'Youtube watch later list, ":ytwatchlater" for short (requires authentication)'
1614     _VALID_URL = r'https?://www\.youtube\.com/feed/watch_later|:ytwatchlater'
1615     _FEED_NAME = 'watch_later'
1616     _PLAYLIST_TITLE = 'Youtube Watch Later'
1617     _PERSONAL_FEED = True
1618
1619
1620 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor):
1621     IE_DESC = 'Youtube watch history, ":ythistory" for short (requires authentication)'
1622     _VALID_URL = 'https?://www\.youtube\.com/feed/history|:ythistory'
1623     _FEED_NAME = 'history'
1624     _PERSONAL_FEED = True
1625     _PLAYLIST_TITLE = 'Youtube Watch History'
1626
1627
1628 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor):
1629     IE_NAME = 'youtube:favorites'
1630     IE_DESC = 'YouTube.com favourite videos, ":ytfav" for short (requires authentication)'
1631     _VALID_URL = r'https?://www\.youtube\.com/my_favorites|:ytfav(?:ou?rites)?'
1632     _LOGIN_REQUIRED = True
1633
1634     def _real_extract(self, url):
1635         webpage = self._download_webpage('https://www.youtube.com/my_favorites', 'Youtube Favourites videos')
1636         playlist_id = self._search_regex(r'list=(.+?)["&]', webpage, 'favourites playlist id')
1637         return self.url_result(playlist_id, 'YoutubePlaylist')
1638
1639
1640 class YoutubeSubscriptionsIE(YoutubePlaylistIE):
1641     IE_NAME = 'youtube:subscriptions'
1642     IE_DESC = 'YouTube.com subscriptions feed, "ytsubs" keyword (requires authentication)'
1643     _VALID_URL = r'https?://www\.youtube\.com/feed/subscriptions|:ytsubs(?:criptions)?'
1644     _TESTS = []
1645
1646     def _real_extract(self, url):
1647         title = 'Youtube Subscriptions'
1648         page = self._download_webpage('https://www.youtube.com/feed/subscriptions', title)
1649
1650         # The extraction process is the same as for playlists, but the regex
1651         # for the video ids doesn't contain an index
1652         ids = []
1653         more_widget_html = content_html = page
1654
1655         for page_num in itertools.count(1):
1656             matches = re.findall(r'href="\s*/watch\?v=([0-9A-Za-z_-]{11})', content_html)
1657             new_ids = orderedSet(matches)
1658             ids.extend(new_ids)
1659
1660             mobj = re.search(r'data-uix-load-more-href="/?(?P<more>[^"]+)"', more_widget_html)
1661             if not mobj:
1662                 break
1663
1664             more = self._download_json(
1665                 'https://youtube.com/%s' % mobj.group('more'), title,
1666                 'Downloading page #%s' % page_num,
1667                 transform_source=uppercase_escape)
1668             content_html = more['content_html']
1669             more_widget_html = more['load_more_widget_html']
1670
1671         return {
1672             '_type': 'playlist',
1673             'title': title,
1674             'entries': self._ids_to_results(ids),
1675         }
1676
1677
1678 class YoutubeTruncatedURLIE(InfoExtractor):
1679     IE_NAME = 'youtube:truncated_url'
1680     IE_DESC = False  # Do not list
1681     _VALID_URL = r'''(?x)
1682         (?:https?://)?[^/]+/watch\?(?:
1683             feature=[a-z_]+|
1684             annotation_id=annotation_[^&]+
1685         )?$|
1686         (?:https?://)?(?:www\.)?youtube\.com/attribution_link\?a=[^&]+$
1687     '''
1688
1689     _TESTS = [{
1690         'url': 'http://www.youtube.com/watch?annotation_id=annotation_3951667041',
1691         'only_matching': True,
1692     }, {
1693         'url': 'http://www.youtube.com/watch?',
1694         'only_matching': True,
1695     }]
1696
1697     def _real_extract(self, url):
1698         raise ExtractorError(
1699             'Did you forget to quote the URL? Remember that & is a meta '
1700             'character in most shells, so you want to put the URL in quotes, '
1701             'like  youtube-dl '
1702             '"http://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
1703             ' or simply  youtube-dl BaW_jenozKc  .',
1704             expected=True)