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