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

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