yt_dlp/extractor/youtube.py

   1 # coding: utf-8
   2
   3 from __future__ import unicode_literals
   4
   5 import calendar
   6 import copy
   7 import datetime
   8 import functools
   9 import hashlib
  10 import itertools
  11 import json
  12 import math
  13 import os.path
  14 import random
  15 import re
  16 import sys
  17 import time
  18 import traceback
  19 import threading
  20
  21 from .common import InfoExtractor, SearchInfoExtractor
  22 from ..compat import (
  23     compat_chr,
  24     compat_HTTPError,
  25     compat_parse_qs,
  26     compat_str,
  27     compat_urllib_parse_unquote_plus,
  28     compat_urllib_parse_urlencode,
  29     compat_urllib_parse_urlparse,
  30     compat_urlparse,
  31 )
  32 from ..jsinterp import JSInterpreter
  33 from ..utils import (
  34     bug_reports_message,
  35     clean_html,
  36     datetime_from_str,
  37     dict_get,
  38     error_to_compat_str,
  39     ExtractorError,
  40     float_or_none,
  41     format_field,
  42     int_or_none,
  43     is_html,
  44     join_nonempty,
  45     js_to_json,
  46     mimetype2ext,
  47     network_exceptions,
  48     NO_DEFAULT,
  49     orderedSet,
  50     parse_codecs,
  51     parse_count,
  52     parse_duration,
  53     parse_iso8601,
  54     parse_qs,
  55     qualities,
  56     remove_end,
  57     remove_start,
  58     smuggle_url,
  59     str_or_none,
  60     str_to_int,
  61     strftime_or_none,
  62     traverse_obj,
  63     try_get,
  64     unescapeHTML,
  65     unified_strdate,
  66     unified_timestamp,
  67     unsmuggle_url,
  68     update_url_query,
  69     url_or_none,
  70     urljoin,
  71     variadic,
  72 )
  73
  74
  75 def get_first(obj, keys, **kwargs):
  76     return traverse_obj(obj, (..., *variadic(keys)), **kwargs, get_all=False)
  77
  78
  79 # any clients starting with _ cannot be explicity requested by the user
  80 INNERTUBE_CLIENTS = {
  81     'web': {
  82         'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
  83         'INNERTUBE_CONTEXT': {
  84             'client': {
  85                 'clientName': 'WEB',
  86                 'clientVersion': '2.20211221.00.00',
  87             }
  88         },
  89         'INNERTUBE_CONTEXT_CLIENT_NAME': 1
  90     },
  91     'web_embedded': {
  92         'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
  93         'INNERTUBE_CONTEXT': {
  94             'client': {
  95                 'clientName': 'WEB_EMBEDDED_PLAYER',
  96                 'clientVersion': '1.20211215.00.01',
  97             },
  98         },
  99         'INNERTUBE_CONTEXT_CLIENT_NAME': 56
 100     },
 101     'web_music': {
 102         'INNERTUBE_API_KEY': 'AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30',
 103         'INNERTUBE_HOST': 'music.youtube.com',
 104         'INNERTUBE_CONTEXT': {
 105             'client': {
 106                 'clientName': 'WEB_REMIX',
 107                 'clientVersion': '1.20211213.00.00',
 108             }
 109         },
 110         'INNERTUBE_CONTEXT_CLIENT_NAME': 67,
 111     },
 112     'web_creator': {
 113         'INNERTUBE_API_KEY': 'AIzaSyBUPetSUmoZL-OhlxA7wSac5XinrygCqMo',
 114         'INNERTUBE_CONTEXT': {
 115             'client': {
 116                 'clientName': 'WEB_CREATOR',
 117                 'clientVersion': '1.20211220.02.00',
 118             }
 119         },
 120         'INNERTUBE_CONTEXT_CLIENT_NAME': 62,
 121     },
 122     'android': {
 123         'INNERTUBE_API_KEY': 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w',
 124         'INNERTUBE_CONTEXT': {
 125             'client': {
 126                 'clientName': 'ANDROID',
 127                 'clientVersion': '16.49',
 128             }
 129         },
 130         'INNERTUBE_CONTEXT_CLIENT_NAME': 3,
 131         'REQUIRE_JS_PLAYER': False
 132     },
 133     'android_embedded': {
 134         'INNERTUBE_API_KEY': 'AIzaSyCjc_pVEDi4qsv5MtC2dMXzpIaDoRFLsxw',
 135         'INNERTUBE_CONTEXT': {
 136             'client': {
 137                 'clientName': 'ANDROID_EMBEDDED_PLAYER',
 138                 'clientVersion': '16.49',
 139             },
 140         },
 141         'INNERTUBE_CONTEXT_CLIENT_NAME': 55,
 142         'REQUIRE_JS_PLAYER': False
 143     },
 144     'android_music': {
 145         'INNERTUBE_API_KEY': 'AIzaSyAOghZGza2MQSZkY_zfZ370N-PUdXEo8AI',
 146         'INNERTUBE_CONTEXT': {
 147             'client': {
 148                 'clientName': 'ANDROID_MUSIC',
 149                 'clientVersion': '4.57',
 150             }
 151         },
 152         'INNERTUBE_CONTEXT_CLIENT_NAME': 21,
 153         'REQUIRE_JS_PLAYER': False
 154     },
 155     'android_creator': {
 156         'INNERTUBE_API_KEY': 'AIzaSyD_qjV8zaaUMehtLkrKFgVeSX_Iqbtyws8',
 157         'INNERTUBE_CONTEXT': {
 158             'client': {
 159                 'clientName': 'ANDROID_CREATOR',
 160                 'clientVersion': '21.47',
 161             },
 162         },
 163         'INNERTUBE_CONTEXT_CLIENT_NAME': 14,
 164         'REQUIRE_JS_PLAYER': False
 165     },
 166     # iOS clients have HLS live streams. Setting device model to get 60fps formats.
 167     # See: https://github.com/TeamNewPipe/NewPipeExtractor/issues/680#issuecomment-1002724558
 168     'ios': {
 169         'INNERTUBE_API_KEY': 'AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc',
 170         'INNERTUBE_CONTEXT': {
 171             'client': {
 172                 'clientName': 'IOS',
 173                 'clientVersion': '16.46',
 174                 'deviceModel': 'iPhone14,3',
 175             }
 176         },
 177         'INNERTUBE_CONTEXT_CLIENT_NAME': 5,
 178         'REQUIRE_JS_PLAYER': False
 179     },
 180     'ios_embedded': {
 181         'INNERTUBE_CONTEXT': {
 182             'client': {
 183                 'clientName': 'IOS_MESSAGES_EXTENSION',
 184                 'clientVersion': '16.46',
 185                 'deviceModel': 'iPhone14,3',
 186             },
 187         },
 188         'INNERTUBE_CONTEXT_CLIENT_NAME': 66,
 189         'REQUIRE_JS_PLAYER': False
 190     },
 191     'ios_music': {
 192         'INNERTUBE_API_KEY': 'AIzaSyBAETezhkwP0ZWA02RsqT1zu78Fpt0bC_s',
 193         'INNERTUBE_CONTEXT': {
 194             'client': {
 195                 'clientName': 'IOS_MUSIC',
 196                 'clientVersion': '4.57',
 197             },
 198         },
 199         'INNERTUBE_CONTEXT_CLIENT_NAME': 26,
 200         'REQUIRE_JS_PLAYER': False
 201     },
 202     'ios_creator': {
 203         'INNERTUBE_CONTEXT': {
 204             'client': {
 205                 'clientName': 'IOS_CREATOR',
 206                 'clientVersion': '21.47',
 207             },
 208         },
 209         'INNERTUBE_CONTEXT_CLIENT_NAME': 15,
 210         'REQUIRE_JS_PLAYER': False
 211     },
 212     # mweb has 'ultralow' formats
 213     # See: https://github.com/yt-dlp/yt-dlp/pull/557
 214     'mweb': {
 215         'INNERTUBE_API_KEY': 'AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8',
 216         'INNERTUBE_CONTEXT': {
 217             'client': {
 218                 'clientName': 'MWEB',
 219                 'clientVersion': '2.20211221.01.00',
 220             }
 221         },
 222         'INNERTUBE_CONTEXT_CLIENT_NAME': 2
 223     }
 224 }
 225
 226
 227 def build_innertube_clients():
 228     third_party = {
 229         'embedUrl': 'https://google.com',  # Can be any valid URL
 230     }
 231     base_clients = ('android', 'web', 'ios', 'mweb')
 232     priority = qualities(base_clients[::-1])
 233
 234     for client, ytcfg in tuple(INNERTUBE_CLIENTS.items()):
 235         ytcfg.setdefault('INNERTUBE_API_KEY', 'AIzaSyDCU8hByM-4DrUqRUYnGn-3llEO78bcxq8')
 236         ytcfg.setdefault('INNERTUBE_HOST', 'www.youtube.com')
 237         ytcfg.setdefault('REQUIRE_JS_PLAYER', True)
 238         ytcfg['INNERTUBE_CONTEXT']['client'].setdefault('hl', 'en')
 239         ytcfg['priority'] = 10 * priority(client.split('_', 1)[0])
 240
 241         if client in base_clients:
 242             INNERTUBE_CLIENTS[f'{client}_agegate'] = agegate_ytcfg = copy.deepcopy(ytcfg)
 243             agegate_ytcfg['INNERTUBE_CONTEXT']['client']['clientScreen'] = 'EMBED'
 244             agegate_ytcfg['INNERTUBE_CONTEXT']['thirdParty'] = third_party
 245             agegate_ytcfg['priority'] -= 1
 246         elif client.endswith('_embedded'):
 247             ytcfg['INNERTUBE_CONTEXT']['thirdParty'] = third_party
 248             ytcfg['priority'] -= 2
 249         else:
 250             ytcfg['priority'] -= 3
 251
 252
 253 build_innertube_clients()
 254
 255
 256 class YoutubeBaseInfoExtractor(InfoExtractor):
 257     """Provide base functions for Youtube extractors"""
 258
 259     _RESERVED_NAMES = (
 260         r'channel|c|user|playlist|watch|w|v|embed|e|watch_popup|clip|'
 261         r'shorts|movies|results|search|shared|hashtag|trending|explore|feed|feeds|'
 262         r'browse|oembed|get_video_info|iframe_api|s/player|'
 263         r'storefront|oops|index|account|reporthistory|t/terms|about|upload|signin|logout')
 264
 265     _PLAYLIST_ID_RE = r'(?:(?:PL|LL|EC|UU|FL|RD|UL|TL|PU|OLAK5uy_)[0-9A-Za-z-_]{10,}|RDMM|WL|LL|LM)'
 266
 267     _NETRC_MACHINE = 'youtube'
 268
 269     # If True it will raise an error if no login info is provided
 270     _LOGIN_REQUIRED = False
 271
 272     _INVIDIOUS_SITES = (
 273         # invidious-redirect websites
 274         r'(?:www\.)?redirect\.invidious\.io',
 275         r'(?:(?:www|dev)\.)?invidio\.us',
 276         # Invidious instances taken from https://github.com/iv-org/documentation/blob/master/Invidious-Instances.md
 277         r'(?:www\.)?invidious\.pussthecat\.org',
 278         r'(?:www\.)?invidious\.zee\.li',
 279         r'(?:www\.)?invidious\.ethibox\.fr',
 280         r'(?:www\.)?invidious\.3o7z6yfxhbw7n3za4rss6l434kmv55cgw2vuziwuigpwegswvwzqipyd\.onion',
 281         r'(?:www\.)?osbivz6guyeahrwp2lnwyjk2xos342h4ocsxyqrlaopqjuhwn2djiiyd\.onion',
 282         r'(?:www\.)?u2cvlit75owumwpy4dj2hsmvkq7nvrclkpht7xgyye2pyoxhpmclkrad\.onion',
 283         # youtube-dl invidious instances list
 284         r'(?:(?:www|no)\.)?invidiou\.sh',
 285         r'(?:(?:www|fi)\.)?invidious\.snopyta\.org',
 286         r'(?:www\.)?invidious\.kabi\.tk',
 287         r'(?:www\.)?invidious\.mastodon\.host',
 288         r'(?:www\.)?invidious\.zapashcanon\.fr',
 289         r'(?:www\.)?(?:invidious(?:-us)?|piped)\.kavin\.rocks',
 290         r'(?:www\.)?invidious\.tinfoil-hat\.net',
 291         r'(?:www\.)?invidious\.himiko\.cloud',
 292         r'(?:www\.)?invidious\.reallyancient\.tech',
 293         r'(?:www\.)?invidious\.tube',
 294         r'(?:www\.)?invidiou\.site',
 295         r'(?:www\.)?invidious\.site',
 296         r'(?:www\.)?invidious\.xyz',
 297         r'(?:www\.)?invidious\.nixnet\.xyz',
 298         r'(?:www\.)?invidious\.048596\.xyz',
 299         r'(?:www\.)?invidious\.drycat\.fr',
 300         r'(?:www\.)?inv\.skyn3t\.in',
 301         r'(?:www\.)?tube\.poal\.co',
 302         r'(?:www\.)?tube\.connect\.cafe',
 303         r'(?:www\.)?vid\.wxzm\.sx',
 304         r'(?:www\.)?vid\.mint\.lgbt',
 305         r'(?:www\.)?vid\.puffyan\.us',
 306         r'(?:www\.)?yewtu\.be',
 307         r'(?:www\.)?yt\.elukerio\.org',
 308         r'(?:www\.)?yt\.lelux\.fi',
 309         r'(?:www\.)?invidious\.ggc-project\.de',
 310         r'(?:www\.)?yt\.maisputain\.ovh',
 311         r'(?:www\.)?ytprivate\.com',
 312         r'(?:www\.)?invidious\.13ad\.de',
 313         r'(?:www\.)?invidious\.toot\.koeln',
 314         r'(?:www\.)?invidious\.fdn\.fr',
 315         r'(?:www\.)?watch\.nettohikari\.com',
 316         r'(?:www\.)?invidious\.namazso\.eu',
 317         r'(?:www\.)?invidious\.silkky\.cloud',
 318         r'(?:www\.)?invidious\.exonip\.de',
 319         r'(?:www\.)?invidious\.riverside\.rocks',
 320         r'(?:www\.)?invidious\.blamefran\.net',
 321         r'(?:www\.)?invidious\.moomoo\.de',
 322         r'(?:www\.)?ytb\.trom\.tf',
 323         r'(?:www\.)?yt\.cyberhost\.uk',
 324         r'(?:www\.)?kgg2m7yk5aybusll\.onion',
 325         r'(?:www\.)?qklhadlycap4cnod\.onion',
 326         r'(?:www\.)?axqzx4s6s54s32yentfqojs3x5i7faxza6xo3ehd4bzzsg2ii4fv2iid\.onion',
 327         r'(?:www\.)?c7hqkpkpemu6e7emz5b4vyz7idjgdvgaaa3dyimmeojqbgpea3xqjoid\.onion',
 328         r'(?:www\.)?fz253lmuao3strwbfbmx46yu7acac2jz27iwtorgmbqlkurlclmancad\.onion',
 329         r'(?:www\.)?invidious\.l4qlywnpwqsluw65ts7md3khrivpirse744un3x7mlskqauz5pyuzgqd\.onion',
 330         r'(?:www\.)?owxfohz4kjyv25fvlqilyxast7inivgiktls3th44jhk3ej3i7ya\.b32\.i2p',
 331         r'(?:www\.)?4l2dgddgsrkf2ous66i6seeyi6etzfgrue332grh2n7madpwopotugyd\.onion',
 332         r'(?:www\.)?w6ijuptxiku4xpnnaetxvnkc5vqcdu7mgns2u77qefoixi63vbvnpnqd\.onion',
 333         r'(?:www\.)?kbjggqkzv65ivcqj6bumvp337z6264huv5kpkwuv6gu5yjiskvan7fad\.onion',
 334         r'(?:www\.)?grwp24hodrefzvjjuccrkw3mjq4tzhaaq32amf33dzpmuxe7ilepcmad\.onion',
 335         r'(?:www\.)?hpniueoejy4opn7bc4ftgazyqjoeqwlvh2uiku2xqku6zpoa4bf5ruid\.onion',
 336     )
 337
 338     def _login(self):
 339         """
 340         Attempt to log in to YouTube.
 341         If _LOGIN_REQUIRED is set and no authentication was provided, an error is raised.
 342         """
 343
 344         if (self._LOGIN_REQUIRED
 345                 and self.get_param('cookiefile') is None
 346                 and self.get_param('cookiesfrombrowser') is None):
 347             self.raise_login_required(
 348                 'Login details are needed to download this content', method='cookies')
 349         username, password = self._get_login_info()
 350         if username:
 351             self.report_warning(f'Cannot login to YouTube using username and password. {self._LOGIN_HINTS["cookies"]}')
 352
 353     def _initialize_consent(self):
 354         cookies = self._get_cookies('https://www.youtube.com/')
 355         if cookies.get('__Secure-3PSID'):
 356             return
 357         consent_id = None
 358         consent = cookies.get('CONSENT')
 359         if consent:
 360             if 'YES' in consent.value:
 361                 return
 362             consent_id = self._search_regex(
 363                 r'PENDING\+(\d+)', consent.value, 'consent', default=None)
 364         if not consent_id:
 365             consent_id = random.randint(100, 999)
 366         self._set_cookie('.youtube.com', 'CONSENT', 'YES+cb.20210328-17-p0.en+FX+%s' % consent_id)
 367
 368     def _initialize_pref(self):
 369         cookies = self._get_cookies('https://www.youtube.com/')
 370         pref_cookie = cookies.get('PREF')
 371         pref = {}
 372         if pref_cookie:
 373             try:
 374                 pref = dict(compat_urlparse.parse_qsl(pref_cookie.value))
 375             except ValueError:
 376                 self.report_warning('Failed to parse user PREF cookie' + bug_reports_message())
 377         pref.update({'hl': 'en', 'tz': 'UTC'})
 378         self._set_cookie('.youtube.com', name='PREF', value=compat_urllib_parse_urlencode(pref))
 379
 380     def _real_initialize(self):
 381         self._initialize_pref()
 382         self._initialize_consent()
 383         self._login()
 384
 385     _YT_INITIAL_DATA_RE = r'(?:window\s*\[\s*["\']ytInitialData["\']\s*\]|ytInitialData)\s*=\s*({.+?})\s*;'
 386     _YT_INITIAL_PLAYER_RESPONSE_RE = r'ytInitialPlayerResponse\s*=\s*({.+?})\s*;'
 387     _YT_INITIAL_BOUNDARY_RE = r'(?:var\s+meta|</script|\n)'
 388
 389     def _get_default_ytcfg(self, client='web'):
 390         return copy.deepcopy(INNERTUBE_CLIENTS[client])
 391
 392     def _get_innertube_host(self, client='web'):
 393         return INNERTUBE_CLIENTS[client]['INNERTUBE_HOST']
 394
 395     def _ytcfg_get_safe(self, ytcfg, getter, expected_type=None, default_client='web'):
 396         # try_get but with fallback to default ytcfg client values when present
 397         _func = lambda y: try_get(y, getter, expected_type)
 398         return _func(ytcfg) or _func(self._get_default_ytcfg(default_client))
 399
 400     def _extract_client_name(self, ytcfg, default_client='web'):
 401         return self._ytcfg_get_safe(
 402             ytcfg, (lambda x: x['INNERTUBE_CLIENT_NAME'],
 403                     lambda x: x['INNERTUBE_CONTEXT']['client']['clientName']), compat_str, default_client)
 404
 405     def _extract_client_version(self, ytcfg, default_client='web'):
 406         return self._ytcfg_get_safe(
 407             ytcfg, (lambda x: x['INNERTUBE_CLIENT_VERSION'],
 408                     lambda x: x['INNERTUBE_CONTEXT']['client']['clientVersion']), compat_str, default_client)
 409
 410     def _extract_api_key(self, ytcfg=None, default_client='web'):
 411         return self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_API_KEY'], compat_str, default_client)
 412
 413     def _extract_context(self, ytcfg=None, default_client='web'):
 414         context = get_first(
 415             (ytcfg, self._get_default_ytcfg(default_client)), 'INNERTUBE_CONTEXT', expected_type=dict)
 416         # Enforce language and tz for extraction
 417         client_context = traverse_obj(context, 'client', expected_type=dict, default={})
 418         client_context.update({'hl': 'en', 'timeZone': 'UTC', 'utcOffsetMinutes': 0})
 419         return context
 420
 421     _SAPISID = None
 422
 423     def _generate_sapisidhash_header(self, origin='https://www.youtube.com'):
 424         time_now = round(time.time())
 425         if self._SAPISID is None:
 426             yt_cookies = self._get_cookies('https://www.youtube.com')
 427             # Sometimes SAPISID cookie isn't present but __Secure-3PAPISID is.
 428             # See: https://github.com/yt-dlp/yt-dlp/issues/393
 429             sapisid_cookie = dict_get(
 430                 yt_cookies, ('__Secure-3PAPISID', 'SAPISID'))
 431             if sapisid_cookie and sapisid_cookie.value:
 432                 self._SAPISID = sapisid_cookie.value
 433                 self.write_debug('Extracted SAPISID cookie')
 434                 # SAPISID cookie is required if not already present
 435                 if not yt_cookies.get('SAPISID'):
 436                     self.write_debug('Copying __Secure-3PAPISID cookie to SAPISID cookie')
 437                     self._set_cookie(
 438                         '.youtube.com', 'SAPISID', self._SAPISID, secure=True, expire_time=time_now + 3600)
 439             else:
 440                 self._SAPISID = False
 441         if not self._SAPISID:
 442             return None
 443         # SAPISIDHASH algorithm from https://stackoverflow.com/a/32065323
 444         sapisidhash = hashlib.sha1(
 445             f'{time_now} {self._SAPISID} {origin}'.encode('utf-8')).hexdigest()
 446         return f'SAPISIDHASH {time_now}_{sapisidhash}'
 447
 448     def _call_api(self, ep, query, video_id, fatal=True, headers=None,
 449                   note='Downloading API JSON', errnote='Unable to download API page',
 450                   context=None, api_key=None, api_hostname=None, default_client='web'):
 451
 452         data = {'context': context} if context else {'context': self._extract_context(default_client=default_client)}
 453         data.update(query)
 454         real_headers = self.generate_api_headers(default_client=default_client)
 455         real_headers.update({'content-type': 'application/json'})
 456         if headers:
 457             real_headers.update(headers)
 458         return self._download_json(
 459             'https://%s/youtubei/v1/%s' % (api_hostname or self._get_innertube_host(default_client), ep),
 460             video_id=video_id, fatal=fatal, note=note, errnote=errnote,
 461             data=json.dumps(data).encode('utf8'), headers=real_headers,
 462             query={'key': api_key or self._extract_api_key()})
 463
 464     def extract_yt_initial_data(self, item_id, webpage, fatal=True):
 465         data = self._search_regex(
 466             (r'%s\s*%s' % (self._YT_INITIAL_DATA_RE, self._YT_INITIAL_BOUNDARY_RE),
 467              self._YT_INITIAL_DATA_RE), webpage, 'yt initial data', fatal=fatal)
 468         if data:
 469             return self._parse_json(data, item_id, fatal=fatal)
 470
 471     @staticmethod
 472     def _extract_session_index(*data):
 473         """
 474         Index of current account in account list.
 475         See: https://github.com/yt-dlp/yt-dlp/pull/519
 476         """
 477         for ytcfg in data:
 478             session_index = int_or_none(try_get(ytcfg, lambda x: x['SESSION_INDEX']))
 479             if session_index is not None:
 480                 return session_index
 481
 482     # Deprecated?
 483     def _extract_identity_token(self, ytcfg=None, webpage=None):
 484         if ytcfg:
 485             token = try_get(ytcfg, lambda x: x['ID_TOKEN'], compat_str)
 486             if token:
 487                 return token
 488         if webpage:
 489             return self._search_regex(
 490                 r'\bID_TOKEN["\']\s*:\s*["\'](.+?)["\']', webpage,
 491                 'identity token', default=None, fatal=False)
 492
 493     @staticmethod
 494     def _extract_account_syncid(*args):
 495         """
 496         Extract syncId required to download private playlists of secondary channels
 497         @params response and/or ytcfg
 498         """
 499         for data in args:
 500             # ytcfg includes channel_syncid if on secondary channel
 501             delegated_sid = try_get(data, lambda x: x['DELEGATED_SESSION_ID'], compat_str)
 502             if delegated_sid:
 503                 return delegated_sid
 504             sync_ids = (try_get(
 505                 data, (lambda x: x['responseContext']['mainAppWebResponseContext']['datasyncId'],
 506                        lambda x: x['DATASYNC_ID']), compat_str) or '').split('||')
 507             if len(sync_ids) >= 2 and sync_ids[1]:
 508                 # datasyncid is of the form "channel_syncid||user_syncid" for secondary channel
 509                 # and just "user_syncid||" for primary channel. We only want the channel_syncid
 510                 return sync_ids[0]
 511
 512     @staticmethod
 513     def _extract_visitor_data(*args):
 514         """
 515         Extracts visitorData from an API response or ytcfg
 516         Appears to be used to track session state
 517         """
 518         return get_first(
 519             args, [('VISITOR_DATA', ('INNERTUBE_CONTEXT', 'client', 'visitorData'), ('responseContext', 'visitorData'))],
 520             expected_type=str)
 521
 522     @property
 523     def is_authenticated(self):
 524         return bool(self._generate_sapisidhash_header())
 525
 526     def extract_ytcfg(self, video_id, webpage):
 527         if not webpage:
 528             return {}
 529         return self._parse_json(
 530             self._search_regex(
 531                 r'ytcfg\.set\s*\(\s*({.+?})\s*\)\s*;', webpage, 'ytcfg',
 532                 default='{}'), video_id, fatal=False) or {}
 533
 534     def generate_api_headers(
 535             self, *, ytcfg=None, account_syncid=None, session_index=None,
 536             visitor_data=None, identity_token=None, api_hostname=None, default_client='web'):
 537
 538         origin = 'https://' + (api_hostname if api_hostname else self._get_innertube_host(default_client))
 539         headers = {
 540             'X-YouTube-Client-Name': compat_str(
 541                 self._ytcfg_get_safe(ytcfg, lambda x: x['INNERTUBE_CONTEXT_CLIENT_NAME'], default_client=default_client)),
 542             'X-YouTube-Client-Version': self._extract_client_version(ytcfg, default_client),
 543             'Origin': origin,
 544             'X-Youtube-Identity-Token': identity_token or self._extract_identity_token(ytcfg),
 545             'X-Goog-PageId': account_syncid or self._extract_account_syncid(ytcfg),
 546             'X-Goog-Visitor-Id': visitor_data or self._extract_visitor_data(ytcfg)
 547         }
 548         if session_index is None:
 549             session_index = self._extract_session_index(ytcfg)
 550         if account_syncid or session_index is not None:
 551             headers['X-Goog-AuthUser'] = session_index if session_index is not None else 0
 552
 553         auth = self._generate_sapisidhash_header(origin)
 554         if auth is not None:
 555             headers['Authorization'] = auth
 556             headers['X-Origin'] = origin
 557         return {h: v for h, v in headers.items() if v is not None}
 558
 559     @staticmethod
 560     def _build_api_continuation_query(continuation, ctp=None):
 561         query = {
 562             'continuation': continuation
 563         }
 564         # TODO: Inconsistency with clickTrackingParams.
 565         # Currently we have a fixed ctp contained within context (from ytcfg)
 566         # and a ctp in root query for continuation.
 567         if ctp:
 568             query['clickTracking'] = {'clickTrackingParams': ctp}
 569         return query
 570
 571     @classmethod
 572     def _extract_next_continuation_data(cls, renderer):
 573         next_continuation = try_get(
 574             renderer, (lambda x: x['continuations'][0]['nextContinuationData'],
 575                        lambda x: x['continuation']['reloadContinuationData']), dict)
 576         if not next_continuation:
 577             return
 578         continuation = next_continuation.get('continuation')
 579         if not continuation:
 580             return
 581         ctp = next_continuation.get('clickTrackingParams')
 582         return cls._build_api_continuation_query(continuation, ctp)
 583
 584     @classmethod
 585     def _extract_continuation_ep_data(cls, continuation_ep: dict):
 586         if isinstance(continuation_ep, dict):
 587             continuation = try_get(
 588                 continuation_ep, lambda x: x['continuationCommand']['token'], compat_str)
 589             if not continuation:
 590                 return
 591             ctp = continuation_ep.get('clickTrackingParams')
 592             return cls._build_api_continuation_query(continuation, ctp)
 593
 594     @classmethod
 595     def _extract_continuation(cls, renderer):
 596         next_continuation = cls._extract_next_continuation_data(renderer)
 597         if next_continuation:
 598             return next_continuation
 599
 600         contents = []
 601         for key in ('contents', 'items'):
 602             contents.extend(try_get(renderer, lambda x: x[key], list) or [])
 603
 604         for content in contents:
 605             if not isinstance(content, dict):
 606                 continue
 607             continuation_ep = try_get(
 608                 content, (lambda x: x['continuationItemRenderer']['continuationEndpoint'],
 609                           lambda x: x['continuationItemRenderer']['button']['buttonRenderer']['command']),
 610                 dict)
 611             continuation = cls._extract_continuation_ep_data(continuation_ep)
 612             if continuation:
 613                 return continuation
 614
 615     @classmethod
 616     def _extract_alerts(cls, data):
 617         for alert_dict in try_get(data, lambda x: x['alerts'], list) or []:
 618             if not isinstance(alert_dict, dict):
 619                 continue
 620             for alert in alert_dict.values():
 621                 alert_type = alert.get('type')
 622                 if not alert_type:
 623                     continue
 624                 message = cls._get_text(alert, 'text')
 625                 if message:
 626                     yield alert_type, message
 627
 628     def _report_alerts(self, alerts, expected=True, fatal=True, only_once=False):
 629         errors = []
 630         warnings = []
 631         for alert_type, alert_message in alerts:
 632             if alert_type.lower() == 'error' and fatal:
 633                 errors.append([alert_type, alert_message])
 634             else:
 635                 warnings.append([alert_type, alert_message])
 636
 637         for alert_type, alert_message in (warnings + errors[:-1]):
 638             self.report_warning('YouTube said: %s - %s' % (alert_type, alert_message), only_once=only_once)
 639         if errors:
 640             raise ExtractorError('YouTube said: %s' % errors[-1][1], expected=expected)
 641
 642     def _extract_and_report_alerts(self, data, *args, **kwargs):
 643         return self._report_alerts(self._extract_alerts(data), *args, **kwargs)
 644
 645     def _extract_badges(self, renderer: dict):
 646         badges = set()
 647         for badge in try_get(renderer, lambda x: x['badges'], list) or []:
 648             label = try_get(badge, lambda x: x['metadataBadgeRenderer']['label'], compat_str)
 649             if label:
 650                 badges.add(label.lower())
 651         return badges
 652
 653     @staticmethod
 654     def _get_text(data, *path_list, max_runs=None):
 655         for path in path_list or [None]:
 656             if path is None:
 657                 obj = [data]
 658             else:
 659                 obj = traverse_obj(data, path, default=[])
 660                 if not any(key is ... or isinstance(key, (list, tuple)) for key in variadic(path)):
 661                     obj = [obj]
 662             for item in obj:
 663                 text = try_get(item, lambda x: x['simpleText'], compat_str)
 664                 if text:
 665                     return text
 666                 runs = try_get(item, lambda x: x['runs'], list) or []
 667                 if not runs and isinstance(item, list):
 668                     runs = item
 669
 670                 runs = runs[:min(len(runs), max_runs or len(runs))]
 671                 text = ''.join(traverse_obj(runs, (..., 'text'), expected_type=str, default=[]))
 672                 if text:
 673                     return text
 674
 675     def _get_count(self, data, *path_list):
 676         count_text = self._get_text(data, *path_list) or ''
 677         count = parse_count(count_text)
 678         if count is None:
 679             count = str_to_int(
 680                 self._search_regex(r'^([\d,]+)', re.sub(r'\s', '', count_text), 'count', default=None))
 681         return count
 682
 683     @staticmethod
 684     def _extract_thumbnails(data, *path_list):
 685         """
 686         Extract thumbnails from thumbnails dict
 687         @param path_list: path list to level that contains 'thumbnails' key
 688         """
 689         thumbnails = []
 690         for path in path_list or [()]:
 691             for thumbnail in traverse_obj(data, (*variadic(path), 'thumbnails', ...), default=[]):
 692                 thumbnail_url = url_or_none(thumbnail.get('url'))
 693                 if not thumbnail_url:
 694                     continue
 695                 # Sometimes youtube gives a wrong thumbnail URL. See:
 696                 # https://github.com/yt-dlp/yt-dlp/issues/233
 697                 # https://github.com/ytdl-org/youtube-dl/issues/28023
 698                 if 'maxresdefault' in thumbnail_url:
 699                     thumbnail_url = thumbnail_url.split('?')[0]
 700                 thumbnails.append({
 701                     'url': thumbnail_url,
 702                     'height': int_or_none(thumbnail.get('height')),
 703                     'width': int_or_none(thumbnail.get('width')),
 704                 })
 705         return thumbnails
 706
 707     @staticmethod
 708     def extract_relative_time(relative_time_text):
 709         """
 710         Extracts a relative time from string and converts to dt object
 711         e.g. 'streamed 6 days ago', '5 seconds ago (edited)', 'updated today'
 712         """
 713         mobj = re.search(r'(?P<start>today|yesterday|now)|(?P<time>\d+)\s*(?P<unit>microsecond|second|minute|hour|day|week|month|year)s?\s*ago', relative_time_text)
 714         if mobj:
 715             start = mobj.group('start')
 716             if start:
 717                 return datetime_from_str(start)
 718             try:
 719                 return datetime_from_str('now-%s%s' % (mobj.group('time'), mobj.group('unit')))
 720             except ValueError:
 721                 return None
 722
 723     def _extract_time_text(self, renderer, *path_list):
 724         text = self._get_text(renderer, *path_list) or ''
 725         dt = self.extract_relative_time(text)
 726         timestamp = None
 727         if isinstance(dt, datetime.datetime):
 728             timestamp = calendar.timegm(dt.timetuple())
 729
 730         if timestamp is None:
 731             timestamp = (
 732                 unified_timestamp(text) or unified_timestamp(
 733                     self._search_regex(
 734                         (r'(?:.+|^)(?:live|premieres|ed|ing)(?:\s*on)?\s*(.+\d)', r'\w+[\s,\.-]*\w+[\s,\.-]+20\d{2}'),
 735                         text.lower(), 'time text', default=None)))
 736
 737         if text and timestamp is None:
 738             self.report_warning('Cannot parse localized time text' + bug_reports_message(), only_once=True)
 739         return timestamp, text
 740
 741     def _extract_response(self, item_id, query, note='Downloading API JSON', headers=None,
 742                           ytcfg=None, check_get_keys=None, ep='browse', fatal=True, api_hostname=None,
 743                           default_client='web'):
 744         response = None
 745         last_error = None
 746         count = -1
 747         retries = self.get_param('extractor_retries', 3)
 748         if check_get_keys is None:
 749             check_get_keys = []
 750         while count < retries:
 751             count += 1
 752             if last_error:
 753                 self.report_warning('%s. Retrying ...' % remove_end(last_error, '.'))
 754             try:
 755                 response = self._call_api(
 756                     ep=ep, fatal=True, headers=headers,
 757                     video_id=item_id, query=query,
 758                     context=self._extract_context(ytcfg, default_client),
 759                     api_key=self._extract_api_key(ytcfg, default_client),
 760                     api_hostname=api_hostname, default_client=default_client,
 761                     note='%s%s' % (note, ' (retry #%d)' % count if count else ''))
 762             except ExtractorError as e:
 763                 if isinstance(e.cause, network_exceptions):
 764                     if isinstance(e.cause, compat_HTTPError):
 765                         first_bytes = e.cause.read(512)
 766                         if not is_html(first_bytes):
 767                             yt_error = try_get(
 768                                 self._parse_json(
 769                                     self._webpage_read_content(e.cause, None, item_id, prefix=first_bytes) or '{}', item_id, fatal=False),
 770                                 lambda x: x['error']['message'], compat_str)
 771                             if yt_error:
 772                                 self._report_alerts([('ERROR', yt_error)], fatal=False)
 773                     # Downloading page may result in intermittent 5xx HTTP error
 774                     # Sometimes a 404 is also recieved. See: https://github.com/ytdl-org/youtube-dl/issues/28289
 775                     # We also want to catch all other network exceptions since errors in later pages can be troublesome
 776                     # See https://github.com/yt-dlp/yt-dlp/issues/507#issuecomment-880188210
 777                     if not isinstance(e.cause, compat_HTTPError) or e.cause.code not in (403, 429):
 778                         last_error = error_to_compat_str(e.cause or e.msg)
 779                         if count < retries:
 780                             continue
 781                 if fatal:
 782                     raise
 783                 else:
 784                     self.report_warning(error_to_compat_str(e))
 785                     return
 786
 787             else:
 788                 try:
 789                     self._extract_and_report_alerts(response, only_once=True)
 790                 except ExtractorError as e:
 791                     # YouTube servers may return errors we want to retry on in a 200 OK response
 792                     # See: https://github.com/yt-dlp/yt-dlp/issues/839
 793                     if 'unknown error' in e.msg.lower():
 794                         last_error = e.msg
 795                         continue
 796                     if fatal:
 797                         raise
 798                     self.report_warning(error_to_compat_str(e))
 799                     return
 800                 if not check_get_keys or dict_get(response, check_get_keys):
 801                     break
 802                 # Youtube sometimes sends incomplete data
 803                 # See: https://github.com/ytdl-org/youtube-dl/issues/28194
 804                 last_error = 'Incomplete data received'
 805                 if count >= retries:
 806                     if fatal:
 807                         raise ExtractorError(last_error)
 808                     else:
 809                         self.report_warning(last_error)
 810                         return
 811         return response
 812
 813     @staticmethod
 814     def is_music_url(url):
 815         return re.match(r'https?://music\.youtube\.com/', url) is not None
 816
 817     def _extract_video(self, renderer):
 818         video_id = renderer.get('videoId')
 819         title = self._get_text(renderer, 'title')
 820         description = self._get_text(renderer, 'descriptionSnippet')
 821         duration = parse_duration(self._get_text(
 822             renderer, 'lengthText', ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'text')))
 823         view_count = self._get_count(renderer, 'viewCountText')
 824
 825         uploader = self._get_text(renderer, 'ownerText', 'shortBylineText')
 826         channel_id = traverse_obj(
 827             renderer, ('shortBylineText', 'runs', ..., 'navigationEndpoint', 'browseEndpoint', 'browseId'), expected_type=str, get_all=False)
 828         timestamp, time_text = self._extract_time_text(renderer, 'publishedTimeText')
 829         scheduled_timestamp = str_to_int(traverse_obj(renderer, ('upcomingEventData', 'startTime'), get_all=False))
 830         overlay_style = traverse_obj(
 831             renderer, ('thumbnailOverlays', ..., 'thumbnailOverlayTimeStatusRenderer', 'style'), get_all=False, expected_type=str)
 832         badges = self._extract_badges(renderer)
 833         thumbnails = self._extract_thumbnails(renderer, 'thumbnail')
 834
 835         return {
 836             '_type': 'url',
 837             'ie_key': YoutubeIE.ie_key(),
 838             'id': video_id,
 839             'url': f'https://www.youtube.com/watch?v={video_id}',
 840             'title': title,
 841             'description': description,
 842             'duration': duration,
 843             'view_count': view_count,
 844             'uploader': uploader,
 845             'channel_id': channel_id,
 846             'thumbnails': thumbnails,
 847             #  'upload_date': strftime_or_none(timestamp, '%Y%m%d'),
 848             'live_status': ('is_upcoming' if scheduled_timestamp is not None
 849                             else 'was_live' if 'streamed' in time_text.lower()
 850                             else 'is_live' if overlay_style is not None and overlay_style == 'LIVE' or 'live now' in badges
 851                             else None),
 852             'release_timestamp': scheduled_timestamp,
 853             'availability': self._availability(needs_premium='premium' in badges, needs_subscription='members only' in badges)
 854         }
 855
 856
 857 class YoutubeIE(YoutubeBaseInfoExtractor):
 858     IE_DESC = 'YouTube'
 859     _VALID_URL = r"""(?x)^
 860                      (
 861                          (?:https?://|//)                                    # http(s):// or protocol-independent URL
 862                          (?:(?:(?:(?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie|kids)?\.com|
 863                             (?:www\.)?deturl\.com/www\.youtube\.com|
 864                             (?:www\.)?pwnyoutube\.com|
 865                             (?:www\.)?hooktube\.com|
 866                             (?:www\.)?yourepeat\.com|
 867                             tube\.majestyc\.net|
 868                             %(invidious)s|
 869                             youtube\.googleapis\.com)/                        # the various hostnames, with wildcard subdomains
 870                          (?:.*?\#/)?                                          # handle anchor (#/) redirect urls
 871                          (?:                                                  # the various things that can precede the ID:
 872                              (?:(?:v|embed|e|shorts)/(?!videoseries|live_stream))  # v/ or embed/ or e/ or shorts/
 873                              |(?:                                             # or the v= param in all its forms
 874                                  (?:(?:watch|movie)(?:_popup)?(?:\.php)?/?)?  # preceding watch(_popup|.php) or nothing (like /?v=xxxx)
 875                                  (?:\?|\#!?)                                  # the params delimiter ? or # or #!
 876                                  (?:.*?[&;])??                                # any other preceding param (like /?s=tuff&v=xxxx or ?s=tuff&amp;v=V36LpHqtcDY)
 877                                  v=
 878                              )
 879                          ))
 880                          |(?:
 881                             youtu\.be|                                        # just youtu.be/xxxx
 882                             vid\.plus|                                        # or vid.plus/xxxx
 883                             zwearz\.com/watch|                                # or zwearz.com/watch/xxxx
 884                             %(invidious)s
 885                          )/
 886                          |(?:www\.)?cleanvideosearch\.com/media/action/yt/watch\?videoId=
 887                          )
 888                      )?                                                       # all until now is optional -> you can pass the naked ID
 889                      (?P<id>[0-9A-Za-z_-]{11})                                # here is it! the YouTube video ID
 890                      (?(1).+)?                                                # if we found the ID, everything can follow
 891                      (?:\#|$)""" % {
 892         'invidious': '|'.join(YoutubeBaseInfoExtractor._INVIDIOUS_SITES),
 893     }
 894     _PLAYER_INFO_RE = (
 895         r'/s/player/(?P<id>[a-zA-Z0-9_-]{8,})/player',
 896         r'/(?P<id>[a-zA-Z0-9_-]{8,})/player(?:_ias\.vflset(?:/[a-zA-Z]{2,3}_[a-zA-Z]{2,3})?|-plasma-ias-(?:phone|tablet)-[a-z]{2}_[A-Z]{2}\.vflset)/base\.js$',
 897         r'\b(?P<id>vfl[a-zA-Z0-9_-]+)\b.*?\.js$',
 898     )
 899     _formats = {
 900         '5': {'ext': 'flv', 'width': 400, 'height': 240, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
 901         '6': {'ext': 'flv', 'width': 450, 'height': 270, 'acodec': 'mp3', 'abr': 64, 'vcodec': 'h263'},
 902         '13': {'ext': '3gp', 'acodec': 'aac', 'vcodec': 'mp4v'},
 903         '17': {'ext': '3gp', 'width': 176, 'height': 144, 'acodec': 'aac', 'abr': 24, 'vcodec': 'mp4v'},
 904         '18': {'ext': 'mp4', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 96, 'vcodec': 'h264'},
 905         '22': {'ext': 'mp4', 'width': 1280, 'height': 720, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
 906         '34': {'ext': 'flv', 'width': 640, 'height': 360, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
 907         '35': {'ext': 'flv', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
 908         # itag 36 videos are either 320x180 (BaW_jenozKc) or 320x240 (__2ABJjxzNo), abr varies as well
 909         '36': {'ext': '3gp', 'width': 320, 'acodec': 'aac', 'vcodec': 'mp4v'},
 910         '37': {'ext': 'mp4', 'width': 1920, 'height': 1080, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
 911         '38': {'ext': 'mp4', 'width': 4096, 'height': 3072, 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264'},
 912         '43': {'ext': 'webm', 'width': 640, 'height': 360, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
 913         '44': {'ext': 'webm', 'width': 854, 'height': 480, 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8'},
 914         '45': {'ext': 'webm', 'width': 1280, 'height': 720, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
 915         '46': {'ext': 'webm', 'width': 1920, 'height': 1080, 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8'},
 916         '59': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
 917         '78': {'ext': 'mp4', 'width': 854, 'height': 480, 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264'},
 918
 919
 920         # 3D videos
 921         '82': {'ext': 'mp4', 'height': 360, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
 922         '83': {'ext': 'mp4', 'height': 480, 'format_note': '3D', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -20},
 923         '84': {'ext': 'mp4', 'height': 720, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
 924         '85': {'ext': 'mp4', 'height': 1080, 'format_note': '3D', 'acodec': 'aac', 'abr': 192, 'vcodec': 'h264', 'preference': -20},
 925         '100': {'ext': 'webm', 'height': 360, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 128, 'vcodec': 'vp8', 'preference': -20},
 926         '101': {'ext': 'webm', 'height': 480, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
 927         '102': {'ext': 'webm', 'height': 720, 'format_note': '3D', 'acodec': 'vorbis', 'abr': 192, 'vcodec': 'vp8', 'preference': -20},
 928
 929         # Apple HTTP Live Streaming
 930         '91': {'ext': 'mp4', 'height': 144, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
 931         '92': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
 932         '93': {'ext': 'mp4', 'height': 360, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
 933         '94': {'ext': 'mp4', 'height': 480, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 128, 'vcodec': 'h264', 'preference': -10},
 934         '95': {'ext': 'mp4', 'height': 720, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
 935         '96': {'ext': 'mp4', 'height': 1080, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 256, 'vcodec': 'h264', 'preference': -10},
 936         '132': {'ext': 'mp4', 'height': 240, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 48, 'vcodec': 'h264', 'preference': -10},
 937         '151': {'ext': 'mp4', 'height': 72, 'format_note': 'HLS', 'acodec': 'aac', 'abr': 24, 'vcodec': 'h264', 'preference': -10},
 938
 939         # DASH mp4 video
 940         '133': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'h264'},
 941         '134': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'h264'},
 942         '135': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
 943         '136': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264'},
 944         '137': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264'},
 945         '138': {'ext': 'mp4', 'format_note': 'DASH video', 'vcodec': 'h264'},  # Height can vary (https://github.com/ytdl-org/youtube-dl/issues/4559)
 946         '160': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'h264'},
 947         '212': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'h264'},
 948         '264': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'h264'},
 949         '298': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
 950         '299': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'h264', 'fps': 60},
 951         '266': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'h264'},
 952
 953         # Dash mp4 audio
 954         '139': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 48, 'container': 'm4a_dash'},
 955         '140': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 128, 'container': 'm4a_dash'},
 956         '141': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'abr': 256, 'container': 'm4a_dash'},
 957         '256': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
 958         '258': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'aac', 'container': 'm4a_dash'},
 959         '325': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'dtse', 'container': 'm4a_dash'},
 960         '328': {'ext': 'm4a', 'format_note': 'DASH audio', 'acodec': 'ec-3', 'container': 'm4a_dash'},
 961
 962         # Dash webm
 963         '167': {'ext': 'webm', 'height': 360, 'width': 640, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 964         '168': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 965         '169': {'ext': 'webm', 'height': 720, 'width': 1280, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 966         '170': {'ext': 'webm', 'height': 1080, 'width': 1920, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 967         '218': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 968         '219': {'ext': 'webm', 'height': 480, 'width': 854, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp8'},
 969         '278': {'ext': 'webm', 'height': 144, 'format_note': 'DASH video', 'container': 'webm', 'vcodec': 'vp9'},
 970         '242': {'ext': 'webm', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 971         '243': {'ext': 'webm', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 972         '244': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 973         '245': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 974         '246': {'ext': 'webm', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 975         '247': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 976         '248': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 977         '271': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 978         # itag 272 videos are either 3840x2160 (e.g. RtoitU2A-3E) or 7680x4320 (sLprVF6d7Ug)
 979         '272': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 980         '302': {'ext': 'webm', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
 981         '303': {'ext': 'webm', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
 982         '308': {'ext': 'webm', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
 983         '313': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9'},
 984         '315': {'ext': 'webm', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'vp9', 'fps': 60},
 985
 986         # Dash webm audio
 987         '171': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 128},
 988         '172': {'ext': 'webm', 'acodec': 'vorbis', 'format_note': 'DASH audio', 'abr': 256},
 989
 990         # Dash webm audio with opus inside
 991         '249': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 50},
 992         '250': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 70},
 993         '251': {'ext': 'webm', 'format_note': 'DASH audio', 'acodec': 'opus', 'abr': 160},
 994
 995         # RTMP (unnamed)
 996         '_rtmp': {'protocol': 'rtmp'},
 997
 998         # av01 video only formats sometimes served with "unknown" codecs
 999         '394': {'ext': 'mp4', 'height': 144, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1000         '395': {'ext': 'mp4', 'height': 240, 'format_note': 'DASH video', 'vcodec': 'av01.0.00M.08'},
1001         '396': {'ext': 'mp4', 'height': 360, 'format_note': 'DASH video', 'vcodec': 'av01.0.01M.08'},
1002         '397': {'ext': 'mp4', 'height': 480, 'format_note': 'DASH video', 'vcodec': 'av01.0.04M.08'},
1003         '398': {'ext': 'mp4', 'height': 720, 'format_note': 'DASH video', 'vcodec': 'av01.0.05M.08'},
1004         '399': {'ext': 'mp4', 'height': 1080, 'format_note': 'DASH video', 'vcodec': 'av01.0.08M.08'},
1005         '400': {'ext': 'mp4', 'height': 1440, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1006         '401': {'ext': 'mp4', 'height': 2160, 'format_note': 'DASH video', 'vcodec': 'av01.0.12M.08'},
1007     }
1008     _SUBTITLE_FORMATS = ('json3', 'srv1', 'srv2', 'srv3', 'ttml', 'vtt')
1009
1010     _GEO_BYPASS = False
1011
1012     IE_NAME = 'youtube'
1013     _TESTS = [
1014         {
1015             'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&t=1s&end=9',
1016             'info_dict': {
1017                 'id': 'BaW_jenozKc',
1018                 'ext': 'mp4',
1019                 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1020                 'uploader': 'Philipp Hagemeister',
1021                 'uploader_id': 'phihag',
1022                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/phihag',
1023                 'channel': 'Philipp Hagemeister',
1024                 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1025                 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1026                 'upload_date': '20121002',
1027                 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1028                 'categories': ['Science & Technology'],
1029                 'tags': ['youtube-dl'],
1030                 'duration': 10,
1031                 'view_count': int,
1032                 'like_count': int,
1033                 'availability': 'public',
1034                 'playable_in_embed': True,
1035                 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1036                 'live_status': 'not_live',
1037                 'age_limit': 0,
1038                 'start_time': 1,
1039                 'end_time': 9,
1040                 'channel_follower_count': int
1041             }
1042         },
1043         {
1044             'url': '//www.YouTube.com/watch?v=yZIXLfi8CZQ',
1045             'note': 'Embed-only video (#1746)',
1046             'info_dict': {
1047                 'id': 'yZIXLfi8CZQ',
1048                 'ext': 'mp4',
1049                 'upload_date': '20120608',
1050                 'title': 'Principal Sexually Assaults A Teacher - Episode 117 - 8th June 2012',
1051                 'description': 'md5:09b78bd971f1e3e289601dfba15ca4f7',
1052                 'uploader': 'SET India',
1053                 'uploader_id': 'setindia',
1054                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/setindia',
1055                 'age_limit': 18,
1056             },
1057             'skip': 'Private video',
1058         },
1059         {
1060             'url': 'https://www.youtube.com/watch?v=BaW_jenozKc&v=yZIXLfi8CZQ',
1061             'note': 'Use the first video ID in the URL',
1062             'info_dict': {
1063                 'id': 'BaW_jenozKc',
1064                 'ext': 'mp4',
1065                 'title': 'youtube-dl test video "\'/\\ä↭𝕐',
1066                 'uploader': 'Philipp Hagemeister',
1067                 'uploader_id': 'phihag',
1068                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/phihag',
1069                 'channel': 'Philipp Hagemeister',
1070                 'channel_id': 'UCLqxVugv74EIW3VWh2NOa3Q',
1071                 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCLqxVugv74EIW3VWh2NOa3Q',
1072                 'upload_date': '20121002',
1073                 'description': 'md5:8fb536f4877b8a7455c2ec23794dbc22',
1074                 'categories': ['Science & Technology'],
1075                 'tags': ['youtube-dl'],
1076                 'duration': 10,
1077                 'view_count': int,
1078                 'like_count': int,
1079                 'availability': 'public',
1080                 'playable_in_embed': True,
1081                 'thumbnail': 'https://i.ytimg.com/vi/BaW_jenozKc/maxresdefault.jpg',
1082                 'live_status': 'not_live',
1083                 'age_limit': 0,
1084                 'channel_follower_count': int
1085             },
1086             'params': {
1087                 'skip_download': True,
1088             },
1089         },
1090         {
1091             'url': 'https://www.youtube.com/watch?v=a9LDPn-MO4I',
1092             'note': '256k DASH audio (format 141) via DASH manifest',
1093             'info_dict': {
1094                 'id': 'a9LDPn-MO4I',
1095                 'ext': 'm4a',
1096                 'upload_date': '20121002',
1097                 'uploader_id': '8KVIDEO',
1098                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/8KVIDEO',
1099                 'description': '',
1100                 'uploader': '8KVIDEO',
1101                 'title': 'UHDTV TEST 8K VIDEO.mp4'
1102             },
1103             'params': {
1104                 'youtube_include_dash_manifest': True,
1105                 'format': '141',
1106             },
1107             'skip': 'format 141 not served anymore',
1108         },
1109         # DASH manifest with encrypted signature
1110         {
1111             'url': 'https://www.youtube.com/watch?v=IB3lcPjvWLA',
1112             'info_dict': {
1113                 'id': 'IB3lcPjvWLA',
1114                 'ext': 'm4a',
1115                 'title': 'Afrojack, Spree Wilson - The Spark (Official Music Video) ft. Spree Wilson',
1116                 'description': 'md5:8f5e2b82460520b619ccac1f509d43bf',
1117                 'duration': 244,
1118                 'uploader': 'AfrojackVEVO',
1119                 'uploader_id': 'AfrojackVEVO',
1120                 'upload_date': '20131011',
1121                 'abr': 129.495,
1122                 'like_count': int,
1123                 'channel_id': 'UChuZAo1RKL85gev3Eal9_zg',
1124                 'playable_in_embed': True,
1125                 'channel_url': 'https://www.youtube.com/channel/UChuZAo1RKL85gev3Eal9_zg',
1126                 'view_count': int,
1127                 'track': 'The Spark',
1128                 'live_status': 'not_live',
1129                 'thumbnail': 'https://i.ytimg.com/vi_webp/IB3lcPjvWLA/maxresdefault.webp',
1130                 'channel': 'Afrojack',
1131                 'uploader_url': 'http://www.youtube.com/user/AfrojackVEVO',
1132                 'tags': 'count:19',
1133                 'availability': 'public',
1134                 'categories': ['Music'],
1135                 'age_limit': 0,
1136                 'alt_title': 'The Spark',
1137                 'channel_follower_count': int
1138             },
1139             'params': {
1140                 'youtube_include_dash_manifest': True,
1141                 'format': '141/bestaudio[ext=m4a]',
1142             },
1143         },
1144         # Age-gate videos. See https://github.com/yt-dlp/yt-dlp/pull/575#issuecomment-888837000
1145         {
1146             'note': 'Embed allowed age-gate video',
1147             'url': 'https://youtube.com/watch?v=HtVdAasjOgU',
1148             'info_dict': {
1149                 'id': 'HtVdAasjOgU',
1150                 'ext': 'mp4',
1151                 'title': 'The Witcher 3: Wild Hunt - The Sword Of Destiny Trailer',
1152                 'description': r're:(?s).{100,}About the Game\n.*?The Witcher 3: Wild Hunt.{100,}',
1153                 'duration': 142,
1154                 'uploader': 'The Witcher',
1155                 'uploader_id': 'WitcherGame',
1156                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/WitcherGame',
1157                 'upload_date': '20140605',
1158                 'age_limit': 18,
1159                 'categories': ['Gaming'],
1160                 'thumbnail': 'https://i.ytimg.com/vi_webp/HtVdAasjOgU/maxresdefault.webp',
1161                 'availability': 'needs_auth',
1162                 'channel_url': 'https://www.youtube.com/channel/UCzybXLxv08IApdjdN0mJhEg',
1163                 'like_count': int,
1164                 'channel': 'The Witcher',
1165                 'live_status': 'not_live',
1166                 'tags': 'count:17',
1167                 'channel_id': 'UCzybXLxv08IApdjdN0mJhEg',
1168                 'playable_in_embed': True,
1169                 'view_count': int,
1170                 'channel_follower_count': int
1171             },
1172         },
1173         {
1174             'note': 'Age-gate video with embed allowed in public site',
1175             'url': 'https://youtube.com/watch?v=HsUATh_Nc2U',
1176             'info_dict': {
1177                 'id': 'HsUATh_Nc2U',
1178                 'ext': 'mp4',
1179                 'title': 'Godzilla 2 (Official Video)',
1180                 'description': 'md5:bf77e03fcae5529475e500129b05668a',
1181                 'upload_date': '20200408',
1182                 'uploader_id': 'FlyingKitty900',
1183                 'uploader': 'FlyingKitty',
1184                 'age_limit': 18,
1185                 'availability': 'needs_auth',
1186                 'channel_id': 'UCYQT13AtrJC0gsM1far_zJg',
1187                 'uploader_url': 'http://www.youtube.com/user/FlyingKitty900',
1188                 'channel': 'FlyingKitty',
1189                 'channel_url': 'https://www.youtube.com/channel/UCYQT13AtrJC0gsM1far_zJg',
1190                 'view_count': int,
1191                 'categories': ['Entertainment'],
1192                 'live_status': 'not_live',
1193                 'tags': ['Flyingkitty', 'godzilla 2'],
1194                 'thumbnail': 'https://i.ytimg.com/vi/HsUATh_Nc2U/maxresdefault.jpg',
1195                 'like_count': int,
1196                 'duration': 177,
1197                 'playable_in_embed': True,
1198                 'channel_follower_count': int
1199             },
1200         },
1201         {
1202             'note': 'Age-gate video embedable only with clientScreen=EMBED',
1203             'url': 'https://youtube.com/watch?v=Tq92D6wQ1mg',
1204             'info_dict': {
1205                 'id': 'Tq92D6wQ1mg',
1206                 'title': '[MMD] Adios - EVERGLOW [+Motion DL]',
1207                 'ext': 'mp4',
1208                 'upload_date': '20191227',
1209                 'uploader_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1210                 'uploader': 'Projekt Melody',
1211                 'description': 'md5:17eccca93a786d51bc67646756894066',
1212                 'age_limit': 18,
1213                 'like_count': int,
1214                 'availability': 'needs_auth',
1215                 'uploader_url': 'http://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1216                 'channel_id': 'UC1yoRdFoFJaCY-AGfD9W0wQ',
1217                 'view_count': int,
1218                 'thumbnail': 'https://i.ytimg.com/vi_webp/Tq92D6wQ1mg/sddefault.webp',
1219                 'channel': 'Projekt Melody',
1220                 'live_status': 'not_live',
1221                 'tags': ['mmd', 'dance', 'mikumikudance', 'kpop', 'vtuber'],
1222                 'playable_in_embed': True,
1223                 'categories': ['Entertainment'],
1224                 'duration': 106,
1225                 'channel_url': 'https://www.youtube.com/channel/UC1yoRdFoFJaCY-AGfD9W0wQ',
1226                 'channel_follower_count': int
1227             },
1228         },
1229         {
1230             'note': 'Non-Agegated non-embeddable video',
1231             'url': 'https://youtube.com/watch?v=MeJVWBSsPAY',
1232             'info_dict': {
1233                 'id': 'MeJVWBSsPAY',
1234                 'ext': 'mp4',
1235                 'title': 'OOMPH! - Such Mich Find Mich (Lyrics)',
1236                 'uploader': 'Herr Lurik',
1237                 'uploader_id': 'st3in234',
1238                 'description': 'Fan Video. Music & Lyrics by OOMPH!.',
1239                 'upload_date': '20130730',
1240                 'track': 'Such mich find mich',
1241                 'age_limit': 0,
1242                 'tags': ['oomph', 'such mich find mich', 'lyrics', 'german industrial', 'musica industrial'],
1243                 'like_count': int,
1244                 'playable_in_embed': False,
1245                 'creator': 'OOMPH!',
1246                 'thumbnail': 'https://i.ytimg.com/vi/MeJVWBSsPAY/sddefault.jpg',
1247                 'view_count': int,
1248                 'alt_title': 'Such mich find mich',
1249                 'duration': 210,
1250                 'channel': 'Herr Lurik',
1251                 'channel_id': 'UCdR3RSDPqub28LjZx0v9-aA',
1252                 'categories': ['Music'],
1253                 'availability': 'public',
1254                 'uploader_url': 'http://www.youtube.com/user/st3in234',
1255                 'channel_url': 'https://www.youtube.com/channel/UCdR3RSDPqub28LjZx0v9-aA',
1256                 'live_status': 'not_live',
1257                 'artist': 'OOMPH!',
1258                 'channel_follower_count': int
1259             },
1260         },
1261         {
1262             'note': 'Non-bypassable age-gated video',
1263             'url': 'https://youtube.com/watch?v=Cr381pDsSsA',
1264             'only_matching': True,
1265         },
1266         # video_info is None (https://github.com/ytdl-org/youtube-dl/issues/4421)
1267         # YouTube Red ad is not captured for creator
1268         {
1269             'url': '__2ABJjxzNo',
1270             'info_dict': {
1271                 'id': '__2ABJjxzNo',
1272                 'ext': 'mp4',
1273                 'duration': 266,
1274                 'upload_date': '20100430',
1275                 'uploader_id': 'deadmau5',
1276                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/deadmau5',
1277                 'creator': 'deadmau5',
1278                 'description': 'md5:6cbcd3a92ce1bc676fc4d6ab4ace2336',
1279                 'uploader': 'deadmau5',
1280                 'title': 'Deadmau5 - Some Chords (HD)',
1281                 'alt_title': 'Some Chords',
1282                 'availability': 'public',
1283                 'tags': 'count:14',
1284                 'channel_id': 'UCYEK6xds6eo-3tr4xRdflmQ',
1285                 'view_count': int,
1286                 'live_status': 'not_live',
1287                 'channel': 'deadmau5',
1288                 'thumbnail': 'https://i.ytimg.com/vi_webp/__2ABJjxzNo/maxresdefault.webp',
1289                 'like_count': int,
1290                 'track': 'Some Chords',
1291                 'artist': 'deadmau5',
1292                 'playable_in_embed': True,
1293                 'age_limit': 0,
1294                 'channel_url': 'https://www.youtube.com/channel/UCYEK6xds6eo-3tr4xRdflmQ',
1295                 'categories': ['Music'],
1296                 'album': 'Some Chords',
1297                 'channel_follower_count': int
1298             },
1299             'expected_warnings': [
1300                 'DASH manifest missing',
1301             ]
1302         },
1303         # Olympics (https://github.com/ytdl-org/youtube-dl/issues/4431)
1304         {
1305             'url': 'lqQg6PlCWgI',
1306             'info_dict': {
1307                 'id': 'lqQg6PlCWgI',
1308                 'ext': 'mp4',
1309                 'duration': 6085,
1310                 'upload_date': '20150827',
1311                 'uploader_id': 'olympic',
1312                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/olympic',
1313                 'description': 'HO09  - Women -  GER-AUS - Hockey - 31 July 2012 - London 2012 Olympic Games',
1314                 'uploader': 'Olympics',
1315                 'title': 'Hockey - Women -  GER-AUS - London 2012 Olympic Games',
1316                 'like_count': int,
1317                 'release_timestamp': 1343767800,
1318                 'playable_in_embed': True,
1319                 'categories': ['Sports'],
1320                 'release_date': '20120731',
1321                 'channel': 'Olympics',
1322                 'tags': ['Hockey', '2012-07-31', '31 July 2012', 'Riverbank Arena', 'Session', 'Olympics', 'Olympic Games', 'London 2012', '2012 Summer Olympics', 'Summer Games'],
1323                 'channel_id': 'UCTl3QQTvqHFjurroKxexy2Q',
1324                 'thumbnail': 'https://i.ytimg.com/vi/lqQg6PlCWgI/maxresdefault.jpg',
1325                 'age_limit': 0,
1326                 'availability': 'public',
1327                 'live_status': 'was_live',
1328                 'view_count': int,
1329                 'channel_url': 'https://www.youtube.com/channel/UCTl3QQTvqHFjurroKxexy2Q',
1330                 'channel_follower_count': int
1331             },
1332             'params': {
1333                 'skip_download': 'requires avconv',
1334             }
1335         },
1336         # Non-square pixels
1337         {
1338             'url': 'https://www.youtube.com/watch?v=_b-2C3KPAM0',
1339             'info_dict': {
1340                 'id': '_b-2C3KPAM0',
1341                 'ext': 'mp4',
1342                 'stretched_ratio': 16 / 9.,
1343                 'duration': 85,
1344                 'upload_date': '20110310',
1345                 'uploader_id': 'AllenMeow',
1346                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/AllenMeow',
1347                 'description': 'made by Wacom from Korea | 字幕&加油添醋 by TY\'s Allen | 感謝heylisa00cavey1001同學熱情提供梗及翻譯',
1348                 'uploader': '孫ᄋᄅ',
1349                 'title': '[A-made] 變態妍字幕版 太妍 我就是這樣的人',
1350                 'playable_in_embed': True,
1351                 'channel': '孫ᄋᄅ',
1352                 'age_limit': 0,
1353                 'tags': 'count:11',
1354                 'channel_url': 'https://www.youtube.com/channel/UCS-xxCmRaA6BFdmgDPA_BIw',
1355                 'channel_id': 'UCS-xxCmRaA6BFdmgDPA_BIw',
1356                 'thumbnail': 'https://i.ytimg.com/vi/_b-2C3KPAM0/maxresdefault.jpg',
1357                 'view_count': int,
1358                 'categories': ['People & Blogs'],
1359                 'like_count': int,
1360                 'live_status': 'not_live',
1361                 'availability': 'unlisted',
1362                 'channel_follower_count': int
1363             },
1364         },
1365         # url_encoded_fmt_stream_map is empty string
1366         {
1367             'url': 'qEJwOuvDf7I',
1368             'info_dict': {
1369                 'id': 'qEJwOuvDf7I',
1370                 'ext': 'webm',
1371                 'title': 'Обсуждение судебной практики по выборам 14 сентября 2014 года в Санкт-Петербурге',
1372                 'description': '',
1373                 'upload_date': '20150404',
1374                 'uploader_id': 'spbelect',
1375                 'uploader': 'Наблюдатели Петербурга',
1376             },
1377             'params': {
1378                 'skip_download': 'requires avconv',
1379             },
1380             'skip': 'This live event has ended.',
1381         },
1382         # Extraction from multiple DASH manifests (https://github.com/ytdl-org/youtube-dl/pull/6097)
1383         {
1384             'url': 'https://www.youtube.com/watch?v=FIl7x6_3R5Y',
1385             'info_dict': {
1386                 'id': 'FIl7x6_3R5Y',
1387                 'ext': 'webm',
1388                 'title': 'md5:7b81415841e02ecd4313668cde88737a',
1389                 'description': 'md5:116377fd2963b81ec4ce64b542173306',
1390                 'duration': 220,
1391                 'upload_date': '20150625',
1392                 'uploader_id': 'dorappi2000',
1393                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/dorappi2000',
1394                 'uploader': 'dorappi2000',
1395                 'formats': 'mincount:31',
1396             },
1397             'skip': 'not actual anymore',
1398         },
1399         # DASH manifest with segment_list
1400         {
1401             'url': 'https://www.youtube.com/embed/CsmdDsKjzN8',
1402             'md5': '8ce563a1d667b599d21064e982ab9e31',
1403             'info_dict': {
1404                 'id': 'CsmdDsKjzN8',
1405                 'ext': 'mp4',
1406                 'upload_date': '20150501',  # According to '<meta itemprop="datePublished"', but in other places it's 20150510
1407                 'uploader': 'Airtek',
1408                 'description': 'Retransmisión en directo de la XVIII media maratón de Zaragoza.',
1409                 'uploader_id': 'UCzTzUmjXxxacNnL8I3m4LnQ',
1410                 'title': 'Retransmisión XVIII Media maratón Zaragoza 2015',
1411             },
1412             'params': {
1413                 'youtube_include_dash_manifest': True,
1414                 'format': '135',  # bestvideo
1415             },
1416             'skip': 'This live event has ended.',
1417         },
1418         {
1419             # Multifeed videos (multiple cameras), URL is for Main Camera
1420             'url': 'https://www.youtube.com/watch?v=jvGDaLqkpTg',
1421             'info_dict': {
1422                 'id': 'jvGDaLqkpTg',
1423                 'title': 'Tom Clancy Free Weekend Rainbow Whatever',
1424                 'description': 'md5:e03b909557865076822aa169218d6a5d',
1425             },
1426             'playlist': [{
1427                 'info_dict': {
1428                     'id': 'jvGDaLqkpTg',
1429                     'ext': 'mp4',
1430                     'title': 'Tom Clancy Free Weekend Rainbow Whatever (Main Camera)',
1431                     'description': 'md5:e03b909557865076822aa169218d6a5d',
1432                     'duration': 10643,
1433                     'upload_date': '20161111',
1434                     'uploader': 'Team PGP',
1435                     'uploader_id': 'UChORY56LMMETTuGjXaJXvLg',
1436                     'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UChORY56LMMETTuGjXaJXvLg',
1437                 },
1438             }, {
1439                 'info_dict': {
1440                     'id': '3AKt1R1aDnw',
1441                     'ext': 'mp4',
1442                     'title': 'Tom Clancy Free Weekend Rainbow Whatever (Camera 2)',
1443                     'description': 'md5:e03b909557865076822aa169218d6a5d',
1444                     'duration': 10991,
1445                     'upload_date': '20161111',
1446                     'uploader': 'Team PGP',
1447                     'uploader_id': 'UChORY56LMMETTuGjXaJXvLg',
1448                     'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UChORY56LMMETTuGjXaJXvLg',
1449                 },
1450             }, {
1451                 'info_dict': {
1452                     'id': 'RtAMM00gpVc',
1453                     'ext': 'mp4',
1454                     'title': 'Tom Clancy Free Weekend Rainbow Whatever (Camera 3)',
1455                     'description': 'md5:e03b909557865076822aa169218d6a5d',
1456                     'duration': 10995,
1457                     'upload_date': '20161111',
1458                     'uploader': 'Team PGP',
1459                     'uploader_id': 'UChORY56LMMETTuGjXaJXvLg',
1460                     'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UChORY56LMMETTuGjXaJXvLg',
1461                 },
1462             }, {
1463                 'info_dict': {
1464                     'id': '6N2fdlP3C5U',
1465                     'ext': 'mp4',
1466                     'title': 'Tom Clancy Free Weekend Rainbow Whatever (Camera 4)',
1467                     'description': 'md5:e03b909557865076822aa169218d6a5d',
1468                     'duration': 10990,
1469                     'upload_date': '20161111',
1470                     'uploader': 'Team PGP',
1471                     'uploader_id': 'UChORY56LMMETTuGjXaJXvLg',
1472                     'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UChORY56LMMETTuGjXaJXvLg',
1473                 },
1474             }],
1475             'params': {
1476                 'skip_download': True,
1477             },
1478             'skip': 'Not multifeed anymore',
1479         },
1480         {
1481             # Multifeed video with comma in title (see https://github.com/ytdl-org/youtube-dl/issues/8536)
1482             'url': 'https://www.youtube.com/watch?v=gVfLd0zydlo',
1483             'info_dict': {
1484                 'id': 'gVfLd0zydlo',
1485                 'title': 'DevConf.cz 2016 Day 2 Workshops 1 14:00 - 15:30',
1486             },
1487             'playlist_count': 2,
1488             'skip': 'Not multifeed anymore',
1489         },
1490         {
1491             'url': 'https://vid.plus/FlRa-iH7PGw',
1492             'only_matching': True,
1493         },
1494         {
1495             'url': 'https://zwearz.com/watch/9lWxNJF-ufM/electra-woman-dyna-girl-official-trailer-grace-helbig.html',
1496             'only_matching': True,
1497         },
1498         {
1499             # Title with JS-like syntax "};" (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1500             # Also tests cut-off URL expansion in video description (see
1501             # https://github.com/ytdl-org/youtube-dl/issues/1892,
1502             # https://github.com/ytdl-org/youtube-dl/issues/8164)
1503             'url': 'https://www.youtube.com/watch?v=lsguqyKfVQg',
1504             'info_dict': {
1505                 'id': 'lsguqyKfVQg',
1506                 'ext': 'mp4',
1507                 'title': '{dark walk}; Loki/AC/Dishonored; collab w/Elflover21',
1508                 'alt_title': 'Dark Walk',
1509                 'description': 'md5:8085699c11dc3f597ce0410b0dcbb34a',
1510                 'duration': 133,
1511                 'upload_date': '20151119',
1512                 'uploader_id': 'IronSoulElf',
1513                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/IronSoulElf',
1514                 'uploader': 'IronSoulElf',
1515                 'creator': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1516                 'track': 'Dark Walk',
1517                 'artist': 'Todd Haberman;\nDaniel Law Heath and Aaron Kaplan',
1518                 'album': 'Position Music - Production Music Vol. 143 - Dark Walk',
1519                 'thumbnail': 'https://i.ytimg.com/vi_webp/lsguqyKfVQg/maxresdefault.webp',
1520                 'categories': ['Film & Animation'],
1521                 'view_count': int,
1522                 'live_status': 'not_live',
1523                 'channel_url': 'https://www.youtube.com/channel/UCTSRgz5jylBvFt_S7wnsqLQ',
1524                 'channel_id': 'UCTSRgz5jylBvFt_S7wnsqLQ',
1525                 'tags': 'count:13',
1526                 'availability': 'public',
1527                 'channel': 'IronSoulElf',
1528                 'playable_in_embed': True,
1529                 'like_count': int,
1530                 'age_limit': 0,
1531                 'channel_follower_count': int
1532             },
1533             'params': {
1534                 'skip_download': True,
1535             },
1536         },
1537         {
1538             # Tags with '};' (see https://github.com/ytdl-org/youtube-dl/issues/7468)
1539             'url': 'https://www.youtube.com/watch?v=Ms7iBXnlUO8',
1540             'only_matching': True,
1541         },
1542         {
1543             # Video with yt:stretch=17:0
1544             'url': 'https://www.youtube.com/watch?v=Q39EVAstoRM',
1545             'info_dict': {
1546                 'id': 'Q39EVAstoRM',
1547                 'ext': 'mp4',
1548                 'title': 'Clash Of Clans#14 Dicas De Ataque Para CV 4',
1549                 'description': 'md5:ee18a25c350637c8faff806845bddee9',
1550                 'upload_date': '20151107',
1551                 'uploader_id': 'UCCr7TALkRbo3EtFzETQF1LA',
1552                 'uploader': 'CH GAMER DROID',
1553             },
1554             'params': {
1555                 'skip_download': True,
1556             },
1557             'skip': 'This video does not exist.',
1558         },
1559         {
1560             # Video with incomplete 'yt:stretch=16:'
1561             'url': 'https://www.youtube.com/watch?v=FRhJzUSJbGI',
1562             'only_matching': True,
1563         },
1564         {
1565             # Video licensed under Creative Commons
1566             'url': 'https://www.youtube.com/watch?v=M4gD1WSo5mA',
1567             'info_dict': {
1568                 'id': 'M4gD1WSo5mA',
1569                 'ext': 'mp4',
1570                 'title': 'md5:e41008789470fc2533a3252216f1c1d1',
1571                 'description': 'md5:a677553cf0840649b731a3024aeff4cc',
1572                 'duration': 721,
1573                 'upload_date': '20150127',
1574                 'uploader_id': 'BerkmanCenter',
1575                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/BerkmanCenter',
1576                 'uploader': 'The Berkman Klein Center for Internet & Society',
1577                 'license': 'Creative Commons Attribution license (reuse allowed)',
1578                 'channel_id': 'UCuLGmD72gJDBwmLw06X58SA',
1579                 'channel_url': 'https://www.youtube.com/channel/UCuLGmD72gJDBwmLw06X58SA',
1580                 'like_count': int,
1581                 'age_limit': 0,
1582                 'tags': ['Copyright (Legal Subject)', 'Law (Industry)', 'William W. Fisher (Author)'],
1583                 'channel': 'The Berkman Klein Center for Internet & Society',
1584                 'availability': 'public',
1585                 'view_count': int,
1586                 'categories': ['Education'],
1587                 'thumbnail': 'https://i.ytimg.com/vi_webp/M4gD1WSo5mA/maxresdefault.webp',
1588                 'live_status': 'not_live',
1589                 'playable_in_embed': True,
1590                 'channel_follower_count': int
1591             },
1592             'params': {
1593                 'skip_download': True,
1594             },
1595         },
1596         {
1597             # Channel-like uploader_url
1598             'url': 'https://www.youtube.com/watch?v=eQcmzGIKrzg',
1599             'info_dict': {
1600                 'id': 'eQcmzGIKrzg',
1601                 'ext': 'mp4',
1602                 'title': 'Democratic Socialism and Foreign Policy | Bernie Sanders',
1603                 'description': 'md5:13a2503d7b5904ef4b223aa101628f39',
1604                 'duration': 4060,
1605                 'upload_date': '20151119',
1606                 'uploader': 'Bernie Sanders',
1607                 'uploader_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1608                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1609                 'license': 'Creative Commons Attribution license (reuse allowed)',
1610                 'playable_in_embed': True,
1611                 'tags': 'count:12',
1612                 'like_count': int,
1613                 'channel_id': 'UCH1dpzjCEiGAt8CXkryhkZg',
1614                 'age_limit': 0,
1615                 'availability': 'public',
1616                 'categories': ['News & Politics'],
1617                 'channel': 'Bernie Sanders',
1618                 'thumbnail': 'https://i.ytimg.com/vi_webp/eQcmzGIKrzg/maxresdefault.webp',
1619                 'view_count': int,
1620                 'live_status': 'not_live',
1621                 'channel_url': 'https://www.youtube.com/channel/UCH1dpzjCEiGAt8CXkryhkZg',
1622                 'channel_follower_count': int
1623             },
1624             'params': {
1625                 'skip_download': True,
1626             },
1627         },
1628         {
1629             'url': 'https://www.youtube.com/watch?feature=player_embedded&amp;amp;v=V36LpHqtcDY',
1630             'only_matching': True,
1631         },
1632         {
1633             # YouTube Red paid video (https://github.com/ytdl-org/youtube-dl/issues/10059)
1634             'url': 'https://www.youtube.com/watch?v=i1Ko8UG-Tdo',
1635             'only_matching': True,
1636         },
1637         {
1638             # Rental video preview
1639             'url': 'https://www.youtube.com/watch?v=yYr8q0y5Jfg',
1640             'info_dict': {
1641                 'id': 'uGpuVWrhIzE',
1642                 'ext': 'mp4',
1643                 'title': 'Piku - Trailer',
1644                 'description': 'md5:c36bd60c3fd6f1954086c083c72092eb',
1645                 'upload_date': '20150811',
1646                 'uploader': 'FlixMatrix',
1647                 'uploader_id': 'FlixMatrixKaravan',
1648                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/FlixMatrixKaravan',
1649                 'license': 'Standard YouTube License',
1650             },
1651             'params': {
1652                 'skip_download': True,
1653             },
1654             'skip': 'This video is not available.',
1655         },
1656         {
1657             # YouTube Red video with episode data
1658             'url': 'https://www.youtube.com/watch?v=iqKdEhx-dD4',
1659             'info_dict': {
1660                 'id': 'iqKdEhx-dD4',
1661                 'ext': 'mp4',
1662                 'title': 'Isolation - Mind Field (Ep 1)',
1663                 'description': 'md5:f540112edec5d09fc8cc752d3d4ba3cd',
1664                 'duration': 2085,
1665                 'upload_date': '20170118',
1666                 'uploader': 'Vsauce',
1667                 'uploader_id': 'Vsauce',
1668                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/Vsauce',
1669                 'series': 'Mind Field',
1670                 'season_number': 1,
1671                 'episode_number': 1,
1672                 'thumbnail': 'https://i.ytimg.com/vi_webp/iqKdEhx-dD4/maxresdefault.webp',
1673                 'tags': 'count:12',
1674                 'view_count': int,
1675                 'availability': 'public',
1676                 'age_limit': 0,
1677                 'channel': 'Vsauce',
1678                 'episode': 'Episode 1',
1679                 'categories': ['Entertainment'],
1680                 'season': 'Season 1',
1681                 'channel_id': 'UC6nSFpj9HTCZ5t-N3Rm3-HA',
1682                 'channel_url': 'https://www.youtube.com/channel/UC6nSFpj9HTCZ5t-N3Rm3-HA',
1683                 'like_count': int,
1684                 'playable_in_embed': True,
1685                 'live_status': 'not_live',
1686                 'channel_follower_count': int
1687             },
1688             'params': {
1689                 'skip_download': True,
1690             },
1691             'expected_warnings': [
1692                 'Skipping DASH manifest',
1693             ],
1694         },
1695         {
1696             # The following content has been identified by the YouTube community
1697             # as inappropriate or offensive to some audiences.
1698             'url': 'https://www.youtube.com/watch?v=6SJNVb0GnPI',
1699             'info_dict': {
1700                 'id': '6SJNVb0GnPI',
1701                 'ext': 'mp4',
1702                 'title': 'Race Differences in Intelligence',
1703                 'description': 'md5:5d161533167390427a1f8ee89a1fc6f1',
1704                 'duration': 965,
1705                 'upload_date': '20140124',
1706                 'uploader': 'New Century Foundation',
1707                 'uploader_id': 'UCEJYpZGqgUob0zVVEaLhvVg',
1708                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCEJYpZGqgUob0zVVEaLhvVg',
1709             },
1710             'params': {
1711                 'skip_download': True,
1712             },
1713             'skip': 'This video has been removed for violating YouTube\'s policy on hate speech.',
1714         },
1715         {
1716             # itag 212
1717             'url': '1t24XAntNCY',
1718             'only_matching': True,
1719         },
1720         {
1721             # geo restricted to JP
1722             'url': 'sJL6WA-aGkQ',
1723             'only_matching': True,
1724         },
1725         {
1726             'url': 'https://invidio.us/watch?v=BaW_jenozKc',
1727             'only_matching': True,
1728         },
1729         {
1730             'url': 'https://redirect.invidious.io/watch?v=BaW_jenozKc',
1731             'only_matching': True,
1732         },
1733         {
1734             # from https://nitter.pussthecat.org/YouTube/status/1360363141947944964#m
1735             'url': 'https://redirect.invidious.io/Yh0AhrY9GjA',
1736             'only_matching': True,
1737         },
1738         {
1739             # DRM protected
1740             'url': 'https://www.youtube.com/watch?v=s7_qI6_mIXc',
1741             'only_matching': True,
1742         },
1743         {
1744             # Video with unsupported adaptive stream type formats
1745             'url': 'https://www.youtube.com/watch?v=Z4Vy8R84T1U',
1746             'info_dict': {
1747                 'id': 'Z4Vy8R84T1U',
1748                 'ext': 'mp4',
1749                 'title': 'saman SMAN 53 Jakarta(Sancety) opening COFFEE4th at SMAN 53 Jakarta',
1750                 'description': 'md5:d41d8cd98f00b204e9800998ecf8427e',
1751                 'duration': 433,
1752                 'upload_date': '20130923',
1753                 'uploader': 'Amelia Putri Harwita',
1754                 'uploader_id': 'UCpOxM49HJxmC1qCalXyB3_Q',
1755                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCpOxM49HJxmC1qCalXyB3_Q',
1756                 'formats': 'maxcount:10',
1757             },
1758             'params': {
1759                 'skip_download': True,
1760                 'youtube_include_dash_manifest': False,
1761             },
1762             'skip': 'not actual anymore',
1763         },
1764         {
1765             # Youtube Music Auto-generated description
1766             'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
1767             'info_dict': {
1768                 'id': 'MgNrAu2pzNs',
1769                 'ext': 'mp4',
1770                 'title': 'Voyeur Girl',
1771                 'description': 'md5:7ae382a65843d6df2685993e90a8628f',
1772                 'upload_date': '20190312',
1773                 'uploader': 'Stephen - Topic',
1774                 'uploader_id': 'UC-pWHpBjdGG69N9mM2auIAA',
1775                 'artist': 'Stephen',
1776                 'track': 'Voyeur Girl',
1777                 'album': 'it\'s too much love to know my dear',
1778                 'release_date': '20190313',
1779                 'release_year': 2019,
1780                 'alt_title': 'Voyeur Girl',
1781                 'view_count': int,
1782                 'uploader_url': 'http://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
1783                 'playable_in_embed': True,
1784                 'like_count': int,
1785                 'categories': ['Music'],
1786                 'channel_url': 'https://www.youtube.com/channel/UC-pWHpBjdGG69N9mM2auIAA',
1787                 'channel': 'Stephen',
1788                 'availability': 'public',
1789                 'creator': 'Stephen',
1790                 'duration': 169,
1791                 'thumbnail': 'https://i.ytimg.com/vi_webp/MgNrAu2pzNs/maxresdefault.webp',
1792                 'age_limit': 0,
1793                 'channel_id': 'UC-pWHpBjdGG69N9mM2auIAA',
1794                 'tags': 'count:11',
1795                 'live_status': 'not_live',
1796                 'channel_follower_count': int
1797             },
1798             'params': {
1799                 'skip_download': True,
1800             },
1801         },
1802         {
1803             'url': 'https://www.youtubekids.com/watch?v=3b8nCWDgZ6Q',
1804             'only_matching': True,
1805         },
1806         {
1807             # invalid -> valid video id redirection
1808             'url': 'DJztXj2GPfl',
1809             'info_dict': {
1810                 'id': 'DJztXj2GPfk',
1811                 'ext': 'mp4',
1812                 'title': 'Panjabi MC - Mundian To Bach Ke (The Dictator Soundtrack)',
1813                 'description': 'md5:bf577a41da97918e94fa9798d9228825',
1814                 'upload_date': '20090125',
1815                 'uploader': 'Prochorowka',
1816                 'uploader_id': 'Prochorowka',
1817                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/Prochorowka',
1818                 'artist': 'Panjabi MC',
1819                 'track': 'Beware of the Boys (Mundian to Bach Ke) - Motivo Hi-Lectro Remix',
1820                 'album': 'Beware of the Boys (Mundian To Bach Ke)',
1821             },
1822             'params': {
1823                 'skip_download': True,
1824             },
1825             'skip': 'Video unavailable',
1826         },
1827         {
1828             # empty description results in an empty string
1829             'url': 'https://www.youtube.com/watch?v=x41yOUIvK2k',
1830             'info_dict': {
1831                 'id': 'x41yOUIvK2k',
1832                 'ext': 'mp4',
1833                 'title': 'IMG 3456',
1834                 'description': '',
1835                 'upload_date': '20170613',
1836                 'uploader_id': 'ElevageOrVert',
1837                 'uploader': 'ElevageOrVert',
1838                 'view_count': int,
1839                 'thumbnail': 'https://i.ytimg.com/vi_webp/x41yOUIvK2k/maxresdefault.webp',
1840                 'uploader_url': 'http://www.youtube.com/user/ElevageOrVert',
1841                 'like_count': int,
1842                 'channel_id': 'UCo03ZQPBW5U4UC3regpt1nw',
1843                 'tags': [],
1844                 'channel_url': 'https://www.youtube.com/channel/UCo03ZQPBW5U4UC3regpt1nw',
1845                 'availability': 'public',
1846                 'age_limit': 0,
1847                 'categories': ['Pets & Animals'],
1848                 'duration': 7,
1849                 'playable_in_embed': True,
1850                 'live_status': 'not_live',
1851                 'channel': 'ElevageOrVert',
1852                 'channel_follower_count': int
1853             },
1854             'params': {
1855                 'skip_download': True,
1856             },
1857         },
1858         {
1859             # with '};' inside yt initial data (see [1])
1860             # see [2] for an example with '};' inside ytInitialPlayerResponse
1861             # 1. https://github.com/ytdl-org/youtube-dl/issues/27093
1862             # 2. https://github.com/ytdl-org/youtube-dl/issues/27216
1863             'url': 'https://www.youtube.com/watch?v=CHqg6qOn4no',
1864             'info_dict': {
1865                 'id': 'CHqg6qOn4no',
1866                 'ext': 'mp4',
1867                 'title': 'Part 77   Sort a list of simple types in c#',
1868                 'description': 'md5:b8746fa52e10cdbf47997903f13b20dc',
1869                 'upload_date': '20130831',
1870                 'uploader_id': 'kudvenkat',
1871                 'uploader': 'kudvenkat',
1872                 'channel_id': 'UCCTVrRB5KpIiK6V2GGVsR1Q',
1873                 'like_count': int,
1874                 'uploader_url': 'http://www.youtube.com/user/kudvenkat',
1875                 'channel_url': 'https://www.youtube.com/channel/UCCTVrRB5KpIiK6V2GGVsR1Q',
1876                 'live_status': 'not_live',
1877                 'categories': ['Education'],
1878                 'availability': 'public',
1879                 'thumbnail': 'https://i.ytimg.com/vi/CHqg6qOn4no/sddefault.jpg',
1880                 'tags': 'count:12',
1881                 'playable_in_embed': True,
1882                 'age_limit': 0,
1883                 'view_count': int,
1884                 'duration': 522,
1885                 'channel': 'kudvenkat',
1886                 'channel_follower_count': int
1887             },
1888             'params': {
1889                 'skip_download': True,
1890             },
1891         },
1892         {
1893             # another example of '};' in ytInitialData
1894             'url': 'https://www.youtube.com/watch?v=gVfgbahppCY',
1895             'only_matching': True,
1896         },
1897         {
1898             'url': 'https://www.youtube.com/watch_popup?v=63RmMXCd_bQ',
1899             'only_matching': True,
1900         },
1901         {
1902             # https://github.com/ytdl-org/youtube-dl/pull/28094
1903             'url': 'OtqTfy26tG0',
1904             'info_dict': {
1905                 'id': 'OtqTfy26tG0',
1906                 'ext': 'mp4',
1907                 'title': 'Burn Out',
1908                 'description': 'md5:8d07b84dcbcbfb34bc12a56d968b6131',
1909                 'upload_date': '20141120',
1910                 'uploader': 'The Cinematic Orchestra - Topic',
1911                 'uploader_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
1912                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
1913                 'artist': 'The Cinematic Orchestra',
1914                 'track': 'Burn Out',
1915                 'album': 'Every Day',
1916                 'like_count': int,
1917                 'live_status': 'not_live',
1918                 'alt_title': 'Burn Out',
1919                 'duration': 614,
1920                 'age_limit': 0,
1921                 'view_count': int,
1922                 'channel_url': 'https://www.youtube.com/channel/UCIzsJBIyo8hhpFm1NK0uLgw',
1923                 'creator': 'The Cinematic Orchestra',
1924                 'channel': 'The Cinematic Orchestra',
1925                 'tags': ['The Cinematic Orchestra', 'Every Day', 'Burn Out'],
1926                 'channel_id': 'UCIzsJBIyo8hhpFm1NK0uLgw',
1927                 'availability': 'public',
1928                 'thumbnail': 'https://i.ytimg.com/vi/OtqTfy26tG0/maxresdefault.jpg',
1929                 'categories': ['Music'],
1930                 'playable_in_embed': True,
1931                 'channel_follower_count': int
1932             },
1933             'params': {
1934                 'skip_download': True,
1935             },
1936         },
1937         {
1938             # controversial video, only works with bpctr when authenticated with cookies
1939             'url': 'https://www.youtube.com/watch?v=nGC3D_FkCmg',
1940             'only_matching': True,
1941         },
1942         {
1943             # controversial video, requires bpctr/contentCheckOk
1944             'url': 'https://www.youtube.com/watch?v=SZJvDhaSDnc',
1945             'info_dict': {
1946                 'id': 'SZJvDhaSDnc',
1947                 'ext': 'mp4',
1948                 'title': 'San Diego teen commits suicide after bullying over embarrassing video',
1949                 'channel_id': 'UC-SJ6nODDmufqBzPBwCvYvQ',
1950                 'uploader': 'CBS Mornings',
1951                 'uploader_id': 'CBSThisMorning',
1952                 'upload_date': '20140716',
1953                 'description': 'md5:acde3a73d3f133fc97e837a9f76b53b7',
1954                 'duration': 170,
1955                 'categories': ['News & Politics'],
1956                 'uploader_url': 'http://www.youtube.com/user/CBSThisMorning',
1957                 'view_count': int,
1958                 'channel': 'CBS Mornings',
1959                 'tags': ['suicide', 'bullying', 'video', 'cbs', 'news'],
1960                 'thumbnail': 'https://i.ytimg.com/vi/SZJvDhaSDnc/hqdefault.jpg',
1961                 'age_limit': 18,
1962                 'availability': 'needs_auth',
1963                 'channel_url': 'https://www.youtube.com/channel/UC-SJ6nODDmufqBzPBwCvYvQ',
1964                 'like_count': int,
1965                 'live_status': 'not_live',
1966                 'playable_in_embed': True,
1967                 'channel_follower_count': int
1968             }
1969         },
1970         {
1971             # restricted location, https://github.com/ytdl-org/youtube-dl/issues/28685
1972             'url': 'cBvYw8_A0vQ',
1973             'info_dict': {
1974                 'id': 'cBvYw8_A0vQ',
1975                 'ext': 'mp4',
1976                 'title': '4K Ueno Okachimachi  Street  Scenes  上野御徒町歩き',
1977                 'description': 'md5:ea770e474b7cd6722b4c95b833c03630',
1978                 'upload_date': '20201120',
1979                 'uploader': 'Walk around Japan',
1980                 'uploader_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
1981                 'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
1982                 'duration': 1456,
1983                 'categories': ['Travel & Events'],
1984                 'channel_id': 'UC3o_t8PzBmXf5S9b7GLx1Mw',
1985                 'view_count': int,
1986                 'channel': 'Walk around Japan',
1987                 'tags': ['Ueno Tokyo', 'Okachimachi Tokyo', 'Ameyoko Street', 'Tokyo attraction', 'Travel in Tokyo'],
1988                 'thumbnail': 'https://i.ytimg.com/vi_webp/cBvYw8_A0vQ/hqdefault.webp',
1989                 'age_limit': 0,
1990                 'availability': 'public',
1991                 'channel_url': 'https://www.youtube.com/channel/UC3o_t8PzBmXf5S9b7GLx1Mw',
1992                 'live_status': 'not_live',
1993                 'playable_in_embed': True,
1994                 'channel_follower_count': int
1995             },
1996             'params': {
1997                 'skip_download': True,
1998             },
1999         }, {
2000             # Has multiple audio streams
2001             'url': 'WaOKSUlf4TM',
2002             'only_matching': True
2003         }, {
2004             # Requires Premium: has format 141 when requested using YTM url
2005             'url': 'https://music.youtube.com/watch?v=XclachpHxis',
2006             'only_matching': True
2007         }, {
2008             # multiple subtitles with same lang_code
2009             'url': 'https://www.youtube.com/watch?v=wsQiKKfKxug',
2010             'only_matching': True,
2011         }, {
2012             # Force use android client fallback
2013             'url': 'https://www.youtube.com/watch?v=YOelRv7fMxY',
2014             'info_dict': {
2015                 'id': 'YOelRv7fMxY',
2016                 'title': 'DIGGING A SECRET TUNNEL Part 1',
2017                 'ext': '3gp',
2018                 'upload_date': '20210624',
2019                 'channel_id': 'UCp68_FLety0O-n9QU6phsgw',
2020                 'uploader': 'colinfurze',
2021                 'uploader_id': 'colinfurze',
2022                 'channel_url': r're:https?://(?:www\.)?youtube\.com/channel/UCp68_FLety0O-n9QU6phsgw',
2023                 'description': 'md5:5d5991195d599b56cd0c4148907eec50',
2024                 'duration': 596,
2025                 'categories': ['Entertainment'],
2026                 'uploader_url': 'http://www.youtube.com/user/colinfurze',
2027                 'view_count': int,
2028                 'channel': 'colinfurze',
2029                 'tags': ['Colin', 'furze', 'Terry', 'tunnel', 'underground', 'bunker'],
2030                 'thumbnail': 'https://i.ytimg.com/vi/YOelRv7fMxY/maxresdefault.jpg',
2031                 'age_limit': 0,
2032                 'availability': 'public',
2033                 'like_count': int,
2034                 'live_status': 'not_live',
2035                 'playable_in_embed': True,
2036                 'channel_follower_count': int
2037             },
2038             'params': {
2039                 'format': '17',  # 3gp format available on android
2040                 'extractor_args': {'youtube': {'player_client': ['android']}},
2041             },
2042         },
2043         {
2044             # Skip download of additional client configs (remix client config in this case)
2045             'url': 'https://music.youtube.com/watch?v=MgNrAu2pzNs',
2046             'only_matching': True,
2047             'params': {
2048                 'extractor_args': {'youtube': {'player_skip': ['configs']}},
2049             },
2050         }, {
2051             # shorts
2052             'url': 'https://www.youtube.com/shorts/BGQWPY4IigY',
2053             'only_matching': True,
2054         }, {
2055             'note': 'Storyboards',
2056             'url': 'https://www.youtube.com/watch?v=5KLPxDtMqe8',
2057             'info_dict': {
2058                 'id': '5KLPxDtMqe8',
2059                 'ext': 'mhtml',
2060                 'format_id': 'sb0',
2061                 'title': 'Your Brain is Plastic',
2062                 'uploader_id': 'scishow',
2063                 'description': 'md5:89cd86034bdb5466cd87c6ba206cd2bc',
2064                 'upload_date': '20140324',
2065                 'uploader': 'SciShow',
2066                 'like_count': int,
2067                 'channel_id': 'UCZYTClx2T1of7BRZ86-8fow',
2068                 'channel_url': 'https://www.youtube.com/channel/UCZYTClx2T1of7BRZ86-8fow',
2069                 'view_count': int,
2070                 'thumbnail': 'https://i.ytimg.com/vi/5KLPxDtMqe8/maxresdefault.jpg',
2071                 'playable_in_embed': True,
2072                 'tags': 'count:12',
2073                 'uploader_url': 'http://www.youtube.com/user/scishow',
2074                 'availability': 'public',
2075                 'channel': 'SciShow',
2076                 'live_status': 'not_live',
2077                 'duration': 248,
2078                 'categories': ['Education'],
2079                 'age_limit': 0,
2080                 'channel_follower_count': int
2081             }, 'params': {'format': 'mhtml', 'skip_download': True}
2082         }
2083     ]
2084
2085     @classmethod
2086     def suitable(cls, url):
2087         from ..utils import parse_qs
2088
2089         qs = parse_qs(url)
2090         if qs.get('list', [None])[0]:
2091             return False
2092         return super(YoutubeIE, cls).suitable(url)
2093
2094     def __init__(self, *args, **kwargs):
2095         super(YoutubeIE, self).__init__(*args, **kwargs)
2096         self._code_cache = {}
2097         self._player_cache = {}
2098
2099     def _prepare_live_from_start_formats(self, formats, video_id, live_start_time, url, webpage_url, smuggled_data):
2100         lock = threading.Lock()
2101
2102         is_live = True
2103         start_time = time.time()
2104         formats = [f for f in formats if f.get('is_from_start')]
2105
2106         def refetch_manifest(format_id, delay):
2107             nonlocal formats, start_time, is_live
2108             if time.time() <= start_time + delay:
2109                 return
2110
2111             _, _, prs, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
2112             video_details = traverse_obj(
2113                 prs, (..., 'videoDetails'), expected_type=dict, default=[])
2114             microformats = traverse_obj(
2115                 prs, (..., 'microformat', 'playerMicroformatRenderer'),
2116                 expected_type=dict, default=[])
2117             _, is_live, _, formats = self._list_formats(video_id, microformats, video_details, prs, player_url)
2118             start_time = time.time()
2119
2120         def mpd_feed(format_id, delay):
2121             """
2122             @returns (manifest_url, manifest_stream_number, is_live) or None
2123             """
2124             with lock:
2125                 refetch_manifest(format_id, delay)
2126
2127             f = next((f for f in formats if f['format_id'] == format_id), None)
2128             if not f:
2129                 if not is_live:
2130                     self.to_screen(f'{video_id}: Video is no longer live')
2131                 else:
2132                     self.report_warning(
2133                         f'Cannot find refreshed manifest for format {format_id}{bug_reports_message()}')
2134                 return None
2135             return f['manifest_url'], f['manifest_stream_number'], is_live
2136
2137         for f in formats:
2138             f['protocol'] = 'http_dash_segments_generator'
2139             f['fragments'] = functools.partial(
2140                 self._live_dash_fragments, f['format_id'], live_start_time, mpd_feed)
2141
2142     def _live_dash_fragments(self, format_id, live_start_time, mpd_feed, ctx):
2143         FETCH_SPAN, MAX_DURATION = 5, 432000
2144
2145         mpd_url, stream_number, is_live = None, None, True
2146
2147         begin_index = 0
2148         download_start_time = ctx.get('start') or time.time()
2149
2150         lack_early_segments = download_start_time - (live_start_time or download_start_time) > MAX_DURATION
2151         if lack_early_segments:
2152             self.report_warning(bug_reports_message(
2153                 'Starting download from the last 120 hours of the live stream since '
2154                 'YouTube does not have data before that. If you think this is wrong,'), only_once=True)
2155             lack_early_segments = True
2156
2157         known_idx, no_fragment_score, last_segment_url = begin_index, 0, None
2158         fragments, fragment_base_url = None, None
2159
2160         def _extract_sequence_from_mpd(refresh_sequence):
2161             nonlocal mpd_url, stream_number, is_live, no_fragment_score, fragments, fragment_base_url
2162             # Obtain from MPD's maximum seq value
2163             old_mpd_url = mpd_url
2164             last_error = ctx.pop('last_error', None)
2165             expire_fast = last_error and isinstance(last_error, compat_HTTPError) and last_error.code == 403
2166             mpd_url, stream_number, is_live = (mpd_feed(format_id, 5 if expire_fast else 18000)
2167                                                or (mpd_url, stream_number, False))
2168             if not refresh_sequence:
2169                 if expire_fast and not is_live:
2170                     return False, last_seq
2171                 elif old_mpd_url == mpd_url:
2172                     return True, last_seq
2173             try:
2174                 fmts, _ = self._extract_mpd_formats_and_subtitles(
2175                     mpd_url, None, note=False, errnote=False, fatal=False)
2176             except ExtractorError:
2177                 fmts = None
2178             if not fmts:
2179                 no_fragment_score += 1
2180                 return False, last_seq
2181             fmt_info = next(x for x in fmts if x['manifest_stream_number'] == stream_number)
2182             fragments = fmt_info['fragments']
2183             fragment_base_url = fmt_info['fragment_base_url']
2184             assert fragment_base_url
2185
2186             _last_seq = int(re.search(r'(?:/|^)sq/(\d+)', fragments[-1]['path']).group(1))
2187             return True, _last_seq
2188
2189         while is_live:
2190             fetch_time = time.time()
2191             if no_fragment_score > 30:
2192                 return
2193             if last_segment_url:
2194                 # Obtain from "X-Head-Seqnum" header value from each segment
2195                 try:
2196                     urlh = self._request_webpage(
2197                         last_segment_url, None, note=False, errnote=False, fatal=False)
2198                 except ExtractorError:
2199                     urlh = None
2200                 last_seq = try_get(urlh, lambda x: int_or_none(x.headers['X-Head-Seqnum']))
2201                 if last_seq is None:
2202                     no_fragment_score += 1
2203                     last_segment_url = None
2204                     continue
2205             else:
2206                 should_continue, last_seq = _extract_sequence_from_mpd(True)
2207                 if not should_continue:
2208                     continue
2209
2210             if known_idx > last_seq:
2211                 last_segment_url = None
2212                 continue
2213
2214             last_seq += 1
2215
2216             if begin_index < 0 and known_idx < 0:
2217                 # skip from the start when it's negative value
2218                 known_idx = last_seq + begin_index
2219             if lack_early_segments:
2220                 known_idx = max(known_idx, last_seq - int(MAX_DURATION // fragments[-1]['duration']))
2221             try:
2222                 for idx in range(known_idx, last_seq):
2223                     # do not update sequence here or you'll get skipped some part of it
2224                     should_continue, _ = _extract_sequence_from_mpd(False)
2225                     if not should_continue:
2226                         known_idx = idx - 1
2227                         raise ExtractorError('breaking out of outer loop')
2228                     last_segment_url = urljoin(fragment_base_url, 'sq/%d' % idx)
2229                     yield {
2230                         'url': last_segment_url,
2231                     }
2232                 if known_idx == last_seq:
2233                     no_fragment_score += 5
2234                 else:
2235                     no_fragment_score = 0
2236                 known_idx = last_seq
2237             except ExtractorError:
2238                 continue
2239
2240             time.sleep(max(0, FETCH_SPAN + fetch_time - time.time()))
2241
2242     def _extract_player_url(self, *ytcfgs, webpage=None):
2243         player_url = traverse_obj(
2244             ytcfgs, (..., 'PLAYER_JS_URL'), (..., 'WEB_PLAYER_CONTEXT_CONFIGS', ..., 'jsUrl'),
2245             get_all=False, expected_type=compat_str)
2246         if not player_url:
2247             return
2248         if player_url.startswith('//'):
2249             player_url = 'https:' + player_url
2250         elif not re.match(r'https?://', player_url):
2251             player_url = compat_urlparse.urljoin(
2252                 'https://www.youtube.com', player_url)
2253         return player_url
2254
2255     def _download_player_url(self, video_id, fatal=False):
2256         res = self._download_webpage(
2257             'https://www.youtube.com/iframe_api',
2258             note='Downloading iframe API JS', video_id=video_id, fatal=fatal)
2259         if res:
2260             player_version = self._search_regex(
2261                 r'player\\?/([0-9a-fA-F]{8})\\?/', res, 'player version', fatal=fatal)
2262             if player_version:
2263                 return f'https://www.youtube.com/s/player/{player_version}/player_ias.vflset/en_US/base.js'
2264
2265     def _signature_cache_id(self, example_sig):
2266         """ Return a string representation of a signature """
2267         return '.'.join(compat_str(len(part)) for part in example_sig.split('.'))
2268
2269     @classmethod
2270     def _extract_player_info(cls, player_url):
2271         for player_re in cls._PLAYER_INFO_RE:
2272             id_m = re.search(player_re, player_url)
2273             if id_m:
2274                 break
2275         else:
2276             raise ExtractorError('Cannot identify player %r' % player_url)
2277         return id_m.group('id')
2278
2279     def _load_player(self, video_id, player_url, fatal=True):
2280         player_id = self._extract_player_info(player_url)
2281         if player_id not in self._code_cache:
2282             code = self._download_webpage(
2283                 player_url, video_id, fatal=fatal,
2284                 note='Downloading player ' + player_id,
2285                 errnote='Download of %s failed' % player_url)
2286             if code:
2287                 self._code_cache[player_id] = code
2288         return self._code_cache.get(player_id)
2289
2290     def _extract_signature_function(self, video_id, player_url, example_sig):
2291         player_id = self._extract_player_info(player_url)
2292
2293         # Read from filesystem cache
2294         func_id = 'js_%s_%s' % (
2295             player_id, self._signature_cache_id(example_sig))
2296         assert os.path.basename(func_id) == func_id
2297
2298         cache_spec = self._downloader.cache.load('youtube-sigfuncs', func_id)
2299         if cache_spec is not None:
2300             return lambda s: ''.join(s[i] for i in cache_spec)
2301
2302         code = self._load_player(video_id, player_url)
2303         if code:
2304             res = self._parse_sig_js(code)
2305
2306             test_string = ''.join(map(compat_chr, range(len(example_sig))))
2307             cache_res = res(test_string)
2308             cache_spec = [ord(c) for c in cache_res]
2309
2310             self._downloader.cache.store('youtube-sigfuncs', func_id, cache_spec)
2311             return res
2312
2313     def _print_sig_code(self, func, example_sig):
2314         if not self.get_param('youtube_print_sig_code'):
2315             return
2316
2317         def gen_sig_code(idxs):
2318             def _genslice(start, end, step):
2319                 starts = '' if start == 0 else str(start)
2320                 ends = (':%d' % (end + step)) if end + step >= 0 else ':'
2321                 steps = '' if step == 1 else (':%d' % step)
2322                 return 's[%s%s%s]' % (starts, ends, steps)
2323
2324             step = None
2325             # Quelch pyflakes warnings - start will be set when step is set
2326             start = '(Never used)'
2327             for i, prev in zip(idxs[1:], idxs[:-1]):
2328                 if step is not None:
2329                     if i - prev == step:
2330                         continue
2331                     yield _genslice(start, prev, step)
2332                     step = None
2333                     continue
2334                 if i - prev in [-1, 1]:
2335                     step = i - prev
2336                     start = prev
2337                     continue
2338                 else:
2339                     yield 's[%d]' % prev
2340             if step is None:
2341                 yield 's[%d]' % i
2342             else:
2343                 yield _genslice(start, i, step)
2344
2345         test_string = ''.join(map(compat_chr, range(len(example_sig))))
2346         cache_res = func(test_string)
2347         cache_spec = [ord(c) for c in cache_res]
2348         expr_code = ' + '.join(gen_sig_code(cache_spec))
2349         signature_id_tuple = '(%s)' % (
2350             ', '.join(compat_str(len(p)) for p in example_sig.split('.')))
2351         code = ('if tuple(len(p) for p in s.split(\'.\')) == %s:\n'
2352                 '    return %s\n') % (signature_id_tuple, expr_code)
2353         self.to_screen('Extracted signature function:\n' + code)
2354
2355     def _parse_sig_js(self, jscode):
2356         funcname = self._search_regex(
2357             (r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2358              r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*encodeURIComponent\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2359              r'\bm=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(h\.s\)\)',
2360              r'\bc&&\(c=(?P<sig>[a-zA-Z0-9$]{2,})\(decodeURIComponent\(c\)\)',
2361              r'(?:\b|[^a-zA-Z0-9$])(?P<sig>[a-zA-Z0-9$]{2,})\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\);[a-zA-Z0-9$]{2}\.[a-zA-Z0-9$]{2}\(a,\d+\)',
2362              r'(?:\b|[^a-zA-Z0-9$])(?P<sig>[a-zA-Z0-9$]{2,})\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
2363              r'(?P<sig>[a-zA-Z0-9$]+)\s*=\s*function\(\s*a\s*\)\s*{\s*a\s*=\s*a\.split\(\s*""\s*\)',
2364              # Obsolete patterns
2365              r'(["\'])signature\1\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2366              r'\.sig\|\|(?P<sig>[a-zA-Z0-9$]+)\(',
2367              r'yt\.akamaized\.net/\)\s*\|\|\s*.*?\s*[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?:encodeURIComponent\s*\()?\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2368              r'\b[cs]\s*&&\s*[adf]\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2369              r'\b[a-zA-Z0-9]+\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2370              r'\bc\s*&&\s*a\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2371              r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\(',
2372              r'\bc\s*&&\s*[a-zA-Z0-9]+\.set\([^,]+\s*,\s*\([^)]*\)\s*\(\s*(?P<sig>[a-zA-Z0-9$]+)\('),
2373             jscode, 'Initial JS player signature function name', group='sig')
2374
2375         jsi = JSInterpreter(jscode)
2376         initial_function = jsi.extract_function(funcname)
2377         return lambda s: initial_function([s])
2378
2379     def _decrypt_signature(self, s, video_id, player_url):
2380         """Turn the encrypted s field into a working signature"""
2381
2382         if player_url is None:
2383             raise ExtractorError('Cannot decrypt signature without player_url')
2384
2385         try:
2386             player_id = (player_url, self._signature_cache_id(s))
2387             if player_id not in self._player_cache:
2388                 func = self._extract_signature_function(
2389                     video_id, player_url, s
2390                 )
2391                 self._player_cache[player_id] = func
2392             func = self._player_cache[player_id]
2393             self._print_sig_code(func, s)
2394             return func(s)
2395         except Exception as e:
2396             raise ExtractorError('Signature extraction failed: ' + traceback.format_exc(), cause=e)
2397
2398     def _decrypt_nsig(self, s, video_id, player_url):
2399         """Turn the encrypted n field into a working signature"""
2400         if player_url is None:
2401             raise ExtractorError('Cannot decrypt nsig without player_url')
2402         if player_url.startswith('//'):
2403             player_url = 'https:' + player_url
2404         elif not re.match(r'https?://', player_url):
2405             player_url = compat_urlparse.urljoin(
2406                 'https://www.youtube.com', player_url)
2407
2408         sig_id = ('nsig_value', s)
2409         if sig_id in self._player_cache:
2410             return self._player_cache[sig_id]
2411
2412         try:
2413             player_id = ('nsig', player_url)
2414             if player_id not in self._player_cache:
2415                 self._player_cache[player_id] = self._extract_n_function(video_id, player_url)
2416             func = self._player_cache[player_id]
2417             self._player_cache[sig_id] = func(s)
2418             self.write_debug(f'Decrypted nsig {s} => {self._player_cache[sig_id]}')
2419             return self._player_cache[sig_id]
2420         except Exception as e:
2421             raise ExtractorError(traceback.format_exc(), cause=e, video_id=video_id)
2422
2423     def _extract_n_function_name(self, jscode):
2424         nfunc, idx = self._search_regex(
2425             r'\.get\("n"\)\)&&\(b=(?P<nfunc>[a-zA-Z0-9$]{3})(?:\[(?P<idx>\d+)\])?\([a-zA-Z0-9]\)',
2426             jscode, 'Initial JS player n function name', group=('nfunc', 'idx'))
2427         if not idx:
2428             return nfunc
2429         return json.loads(js_to_json(self._search_regex(
2430             rf'var {nfunc}\s*=\s*(\[.+?\]);', jscode,
2431             f'Initial JS player n function list ({nfunc}.{idx})')))[int(idx)]
2432
2433     def _extract_n_function(self, video_id, player_url):
2434         player_id = self._extract_player_info(player_url)
2435         func_code = self._downloader.cache.load('youtube-nsig', player_id)
2436
2437         if func_code:
2438             jsi = JSInterpreter(func_code)
2439         else:
2440             jscode = self._load_player(video_id, player_url)
2441             funcname = self._extract_n_function_name(jscode)
2442             jsi = JSInterpreter(jscode)
2443             func_code = jsi.extract_function_code(funcname)
2444             self._downloader.cache.store('youtube-nsig', player_id, func_code)
2445
2446         if self.get_param('youtube_print_sig_code'):
2447             self.to_screen(f'Extracted nsig function from {player_id}:\n{func_code[1]}\n')
2448
2449         return lambda s: jsi.extract_function_from_code(*func_code)([s])
2450
2451     def _extract_signature_timestamp(self, video_id, player_url, ytcfg=None, fatal=False):
2452         """
2453         Extract signatureTimestamp (sts)
2454         Required to tell API what sig/player version is in use.
2455         """
2456         sts = None
2457         if isinstance(ytcfg, dict):
2458             sts = int_or_none(ytcfg.get('STS'))
2459
2460         if not sts:
2461             # Attempt to extract from player
2462             if player_url is None:
2463                 error_msg = 'Cannot extract signature timestamp without player_url.'
2464                 if fatal:
2465                     raise ExtractorError(error_msg)
2466                 self.report_warning(error_msg)
2467                 return
2468             code = self._load_player(video_id, player_url, fatal=fatal)
2469             if code:
2470                 sts = int_or_none(self._search_regex(
2471                     r'(?:signatureTimestamp|sts)\s*:\s*(?P<sts>[0-9]{5})', code,
2472                     'JS player signature timestamp', group='sts', fatal=fatal))
2473         return sts
2474
2475     def _mark_watched(self, video_id, player_responses):
2476         playback_url = get_first(
2477             player_responses, ('playbackTracking', 'videostatsPlaybackUrl', 'baseUrl'),
2478             expected_type=url_or_none)
2479         if not playback_url:
2480             self.report_warning('Unable to mark watched')
2481             return
2482         parsed_playback_url = compat_urlparse.urlparse(playback_url)
2483         qs = compat_urlparse.parse_qs(parsed_playback_url.query)
2484
2485         # cpn generation algorithm is reverse engineered from base.js.
2486         # In fact it works even with dummy cpn.
2487         CPN_ALPHABET = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
2488         cpn = ''.join((CPN_ALPHABET[random.randint(0, 256) & 63] for _ in range(0, 16)))
2489
2490         qs.update({
2491             'ver': ['2'],
2492             'cpn': [cpn],
2493         })
2494         playback_url = compat_urlparse.urlunparse(
2495             parsed_playback_url._replace(query=compat_urllib_parse_urlencode(qs, True)))
2496
2497         self._download_webpage(
2498             playback_url, video_id, 'Marking watched',
2499             'Unable to mark watched', fatal=False)
2500
2501     @staticmethod
2502     def _extract_urls(webpage):
2503         # Embedded YouTube player
2504         entries = [
2505             unescapeHTML(mobj.group('url'))
2506             for mobj in re.finditer(r'''(?x)
2507             (?:
2508                 <iframe[^>]+?src=|
2509                 data-video-url=|
2510                 <embed[^>]+?src=|
2511                 embedSWF\(?:\s*|
2512                 <object[^>]+data=|
2513                 new\s+SWFObject\(
2514             )
2515             (["\'])
2516                 (?P<url>(?:https?:)?//(?:www\.)?youtube(?:-nocookie)?\.com/
2517                 (?:embed|v|p)/[0-9A-Za-z_-]{11}.*?)
2518             \1''', webpage)]
2519
2520         # lazyYT YouTube embed
2521         entries.extend(list(map(
2522             unescapeHTML,
2523             re.findall(r'class="lazyYT" data-youtube-id="([^"]+)"', webpage))))
2524
2525         # Wordpress "YouTube Video Importer" plugin
2526         matches = re.findall(r'''(?x)<div[^>]+
2527             class=(?P<q1>[\'"])[^\'"]*\byvii_single_video_player\b[^\'"]*(?P=q1)[^>]+
2528             data-video_id=(?P<q2>[\'"])([^\'"]+)(?P=q2)''', webpage)
2529         entries.extend(m[-1] for m in matches)
2530
2531         return entries
2532
2533     @staticmethod
2534     def _extract_url(webpage):
2535         urls = YoutubeIE._extract_urls(webpage)
2536         return urls[0] if urls else None
2537
2538     @classmethod
2539     def extract_id(cls, url):
2540         mobj = re.match(cls._VALID_URL, url, re.VERBOSE)
2541         if mobj is None:
2542             raise ExtractorError('Invalid URL: %s' % url)
2543         return mobj.group('id')
2544
2545     def _extract_chapters_from_json(self, data, duration):
2546         chapter_list = traverse_obj(
2547             data, (
2548                 'playerOverlays', 'playerOverlayRenderer', 'decoratedPlayerBarRenderer',
2549                 'decoratedPlayerBarRenderer', 'playerBar', 'chapteredPlayerBarRenderer', 'chapters'
2550             ), expected_type=list)
2551
2552         return self._extract_chapters(
2553             chapter_list,
2554             chapter_time=lambda chapter: float_or_none(
2555                 traverse_obj(chapter, ('chapterRenderer', 'timeRangeStartMillis')), scale=1000),
2556             chapter_title=lambda chapter: traverse_obj(
2557                 chapter, ('chapterRenderer', 'title', 'simpleText'), expected_type=str),
2558             duration=duration)
2559
2560     def _extract_chapters_from_engagement_panel(self, data, duration):
2561         content_list = traverse_obj(
2562             data,
2563             ('engagementPanels', ..., 'engagementPanelSectionListRenderer', 'content', 'macroMarkersListRenderer', 'contents'),
2564             expected_type=list, default=[])
2565         chapter_time = lambda chapter: parse_duration(self._get_text(chapter, 'timeDescription'))
2566         chapter_title = lambda chapter: self._get_text(chapter, 'title')
2567
2568         return next((
2569             filter(None, (
2570                 self._extract_chapters(
2571                     traverse_obj(contents, (..., 'macroMarkersListItemRenderer')),
2572                     chapter_time, chapter_title, duration)
2573                 for contents in content_list
2574             ))), [])
2575
2576     def _extract_chapters(self, chapter_list, chapter_time, chapter_title, duration):
2577         chapters = []
2578         last_chapter = {'start_time': 0}
2579         for idx, chapter in enumerate(chapter_list or []):
2580             title = chapter_title(chapter)
2581             start_time = chapter_time(chapter)
2582             if start_time is None:
2583                 continue
2584             last_chapter['end_time'] = start_time
2585             if start_time < last_chapter['start_time']:
2586                 if idx == 1:
2587                     chapters.pop()
2588                     self.report_warning('Invalid start time for chapter "%s"' % last_chapter['title'])
2589                 else:
2590                     self.report_warning(f'Invalid start time for chapter "{title}"')
2591                     continue
2592             last_chapter = {'start_time': start_time, 'title': title}
2593             chapters.append(last_chapter)
2594         last_chapter['end_time'] = duration
2595         return chapters
2596
2597     def _extract_yt_initial_variable(self, webpage, regex, video_id, name):
2598         return self._parse_json(self._search_regex(
2599             (r'%s\s*%s' % (regex, self._YT_INITIAL_BOUNDARY_RE),
2600              regex), webpage, name, default='{}'), video_id, fatal=False)
2601
2602     def _extract_comment(self, comment_renderer, parent=None):
2603         comment_id = comment_renderer.get('commentId')
2604         if not comment_id:
2605             return
2606
2607         text = self._get_text(comment_renderer, 'contentText')
2608
2609         # note: timestamp is an estimate calculated from the current time and time_text
2610         timestamp, time_text = self._extract_time_text(comment_renderer, 'publishedTimeText')
2611         author = self._get_text(comment_renderer, 'authorText')
2612         author_id = try_get(comment_renderer,
2613                             lambda x: x['authorEndpoint']['browseEndpoint']['browseId'], compat_str)
2614
2615         votes = parse_count(try_get(comment_renderer, (lambda x: x['voteCount']['simpleText'],
2616                                                        lambda x: x['likeCount']), compat_str)) or 0
2617         author_thumbnail = try_get(comment_renderer,
2618                                    lambda x: x['authorThumbnail']['thumbnails'][-1]['url'], compat_str)
2619
2620         author_is_uploader = try_get(comment_renderer, lambda x: x['authorIsChannelOwner'], bool)
2621         is_favorited = 'creatorHeart' in (try_get(
2622             comment_renderer, lambda x: x['actionButtons']['commentActionButtonsRenderer'], dict) or {})
2623         return {
2624             'id': comment_id,
2625             'text': text,
2626             'timestamp': timestamp,
2627             'time_text': time_text,
2628             'like_count': votes,
2629             'is_favorited': is_favorited,
2630             'author': author,
2631             'author_id': author_id,
2632             'author_thumbnail': author_thumbnail,
2633             'author_is_uploader': author_is_uploader,
2634             'parent': parent or 'root'
2635         }
2636
2637     def _comment_entries(self, root_continuation_data, ytcfg, video_id, parent=None, tracker=None):
2638
2639         get_single_config_arg = lambda c: self._configuration_arg(c, [''])[0]
2640
2641         def extract_header(contents):
2642             _continuation = None
2643             for content in contents:
2644                 comments_header_renderer = traverse_obj(content, 'commentsHeaderRenderer')
2645                 expected_comment_count = self._get_count(
2646                     comments_header_renderer, 'countText', 'commentsCount')
2647
2648                 if expected_comment_count:
2649                     tracker['est_total'] = expected_comment_count
2650                     self.to_screen(f'Downloading ~{expected_comment_count} comments')
2651                 comment_sort_index = int(get_single_config_arg('comment_sort') != 'top')  # 1 = new, 0 = top
2652
2653                 sort_menu_item = try_get(
2654                     comments_header_renderer,
2655                     lambda x: x['sortMenu']['sortFilterSubMenuRenderer']['subMenuItems'][comment_sort_index], dict) or {}
2656                 sort_continuation_ep = sort_menu_item.get('serviceEndpoint') or {}
2657
2658                 _continuation = self._extract_continuation_ep_data(sort_continuation_ep) or self._extract_continuation(sort_menu_item)
2659                 if not _continuation:
2660                     continue
2661
2662                 sort_text = str_or_none(sort_menu_item.get('title'))
2663                 if not sort_text:
2664                     sort_text = 'top comments' if comment_sort_index == 0 else 'newest first'
2665                 self.to_screen('Sorting comments by %s' % sort_text.lower())
2666                 break
2667             return _continuation
2668
2669         def extract_thread(contents):
2670             if not parent:
2671                 tracker['current_page_thread'] = 0
2672             for content in contents:
2673                 if not parent and tracker['total_parent_comments'] >= max_parents:
2674                     yield
2675                 comment_thread_renderer = try_get(content, lambda x: x['commentThreadRenderer'])
2676                 comment_renderer = get_first(
2677                     (comment_thread_renderer, content), [['commentRenderer', ('comment', 'commentRenderer')]],
2678                     expected_type=dict, default={})
2679
2680                 comment = self._extract_comment(comment_renderer, parent)
2681                 if not comment:
2682                     continue
2683
2684                 tracker['running_total'] += 1
2685                 tracker['total_reply_comments' if parent else 'total_parent_comments'] += 1
2686                 yield comment
2687
2688                 # Attempt to get the replies
2689                 comment_replies_renderer = try_get(
2690                     comment_thread_renderer, lambda x: x['replies']['commentRepliesRenderer'], dict)
2691
2692                 if comment_replies_renderer:
2693                     tracker['current_page_thread'] += 1
2694                     comment_entries_iter = self._comment_entries(
2695                         comment_replies_renderer, ytcfg, video_id,
2696                         parent=comment.get('id'), tracker=tracker)
2697                     for reply_comment in itertools.islice(comment_entries_iter, min(max_replies_per_thread, max(0, max_replies - tracker['total_reply_comments']))):
2698                         yield reply_comment
2699
2700         # Keeps track of counts across recursive calls
2701         if not tracker:
2702             tracker = dict(
2703                 running_total=0,
2704                 est_total=0,
2705                 current_page_thread=0,
2706                 total_parent_comments=0,
2707                 total_reply_comments=0)
2708
2709         # TODO: Deprecated
2710         # YouTube comments have a max depth of 2
2711         max_depth = int_or_none(get_single_config_arg('max_comment_depth'))
2712         if max_depth:
2713             self._downloader.deprecation_warning(
2714                 '[youtube] max_comment_depth extractor argument is deprecated. Set max replies in the max-comments extractor argument instead.')
2715         if max_depth == 1 and parent:
2716             return
2717
2718         max_comments, max_parents, max_replies, max_replies_per_thread, *_ = map(
2719             lambda p: int_or_none(p, default=sys.maxsize), self._configuration_arg('max_comments', ) + [''] * 4)
2720
2721         continuation = self._extract_continuation(root_continuation_data)
2722         message = self._get_text(root_continuation_data, ('contents', ..., 'messageRenderer', 'text'), max_runs=1)
2723         if message and not parent:
2724             self.report_warning(message, video_id=video_id)
2725
2726         response = None
2727         is_first_continuation = parent is None
2728
2729         for page_num in itertools.count(0):
2730             if not continuation:
2731                 break
2732             headers = self.generate_api_headers(ytcfg=ytcfg, visitor_data=self._extract_visitor_data(response))
2733             comment_prog_str = f"({tracker['running_total']}/{tracker['est_total']})"
2734             if page_num == 0:
2735                 if is_first_continuation:
2736                     note_prefix = 'Downloading comment section API JSON'
2737                 else:
2738                     note_prefix = '    Downloading comment API JSON reply thread %d %s' % (
2739                         tracker['current_page_thread'], comment_prog_str)
2740             else:
2741                 note_prefix = '%sDownloading comment%s API JSON page %d %s' % (
2742                     '       ' if parent else '', ' replies' if parent else '',
2743                     page_num, comment_prog_str)
2744
2745             response = self._extract_response(
2746                 item_id=None, query=continuation,
2747                 ep='next', ytcfg=ytcfg, headers=headers, note=note_prefix,
2748                 check_get_keys='onResponseReceivedEndpoints')
2749
2750             continuation_contents = traverse_obj(
2751                 response, 'onResponseReceivedEndpoints', expected_type=list, default=[])
2752
2753             continuation = None
2754             for continuation_section in continuation_contents:
2755                 continuation_items = traverse_obj(
2756                     continuation_section,
2757                     (('reloadContinuationItemsCommand', 'appendContinuationItemsAction'), 'continuationItems'),
2758                     get_all=False, expected_type=list) or []
2759                 if is_first_continuation:
2760                     continuation = extract_header(continuation_items)
2761                     is_first_continuation = False
2762                     if continuation:
2763                         break
2764                     continue
2765
2766                 for entry in extract_thread(continuation_items):
2767                     if not entry:
2768                         return
2769                     yield entry
2770                 continuation = self._extract_continuation({'contents': continuation_items})
2771                 if continuation:
2772                     break
2773
2774     def _get_comments(self, ytcfg, video_id, contents, webpage):
2775         """Entry for comment extraction"""
2776         def _real_comment_extract(contents):
2777             renderer = next((
2778                 item for item in traverse_obj(contents, (..., 'itemSectionRenderer'), default={})
2779                 if item.get('sectionIdentifier') == 'comment-item-section'), None)
2780             yield from self._comment_entries(renderer, ytcfg, video_id)
2781
2782         max_comments = int_or_none(self._configuration_arg('max_comments', [''])[0])
2783         return itertools.islice(_real_comment_extract(contents), 0, max_comments)
2784
2785     @staticmethod
2786     def _get_checkok_params():
2787         return {'contentCheckOk': True, 'racyCheckOk': True}
2788
2789     @classmethod
2790     def _generate_player_context(cls, sts=None):
2791         context = {
2792             'html5Preference': 'HTML5_PREF_WANTS',
2793         }
2794         if sts is not None:
2795             context['signatureTimestamp'] = sts
2796         return {
2797             'playbackContext': {
2798                 'contentPlaybackContext': context
2799             },
2800             **cls._get_checkok_params()
2801         }
2802
2803     @staticmethod
2804     def _is_agegated(player_response):
2805         if traverse_obj(player_response, ('playabilityStatus', 'desktopLegacyAgeGateReason')):
2806             return True
2807
2808         reasons = traverse_obj(player_response, ('playabilityStatus', ('status', 'reason')), default=[])
2809         AGE_GATE_REASONS = (
2810             'confirm your age', 'age-restricted', 'inappropriate',  # reason
2811             'age_verification_required', 'age_check_required',  # status
2812         )
2813         return any(expected in reason for expected in AGE_GATE_REASONS for reason in reasons)
2814
2815     @staticmethod
2816     def _is_unplayable(player_response):
2817         return traverse_obj(player_response, ('playabilityStatus', 'status')) == 'UNPLAYABLE'
2818
2819     def _extract_player_response(self, client, video_id, master_ytcfg, player_ytcfg, player_url, initial_pr):
2820
2821         session_index = self._extract_session_index(player_ytcfg, master_ytcfg)
2822         syncid = self._extract_account_syncid(player_ytcfg, master_ytcfg, initial_pr)
2823         sts = self._extract_signature_timestamp(video_id, player_url, master_ytcfg, fatal=False) if player_url else None
2824         headers = self.generate_api_headers(
2825             ytcfg=player_ytcfg, account_syncid=syncid, session_index=session_index, default_client=client)
2826
2827         yt_query = {'videoId': video_id}
2828         yt_query.update(self._generate_player_context(sts))
2829         return self._extract_response(
2830             item_id=video_id, ep='player', query=yt_query,
2831             ytcfg=player_ytcfg, headers=headers, fatal=True,
2832             default_client=client,
2833             note='Downloading %s player API JSON' % client.replace('_', ' ').strip()
2834         ) or None
2835
2836     def _get_requested_clients(self, url, smuggled_data):
2837         requested_clients = []
2838         default = ['android', 'web']
2839         allowed_clients = sorted(
2840             [client for client in INNERTUBE_CLIENTS.keys() if client[:1] != '_'],
2841             key=lambda client: INNERTUBE_CLIENTS[client]['priority'], reverse=True)
2842         for client in self._configuration_arg('player_client'):
2843             if client in allowed_clients:
2844                 requested_clients.append(client)
2845             elif client == 'default':
2846                 requested_clients.extend(default)
2847             elif client == 'all':
2848                 requested_clients.extend(allowed_clients)
2849             else:
2850                 self.report_warning(f'Skipping unsupported client {client}')
2851         if not requested_clients:
2852             requested_clients = default
2853
2854         if smuggled_data.get('is_music_url') or self.is_music_url(url):
2855             requested_clients.extend(
2856                 f'{client}_music' for client in requested_clients if f'{client}_music' in INNERTUBE_CLIENTS)
2857
2858         return orderedSet(requested_clients)
2859
2860     def _extract_player_ytcfg(self, client, video_id):
2861         url = {
2862             'web_music': 'https://music.youtube.com',
2863             'web_embedded': f'https://www.youtube.com/embed/{video_id}?html5=1'
2864         }.get(client)
2865         if not url:
2866             return {}
2867         webpage = self._download_webpage(url, video_id, fatal=False, note='Downloading %s config' % client.replace('_', ' ').strip())
2868         return self.extract_ytcfg(video_id, webpage) or {}
2869
2870     def _extract_player_responses(self, clients, video_id, webpage, master_ytcfg):
2871         initial_pr = None
2872         if webpage:
2873             initial_pr = self._extract_yt_initial_variable(
2874                 webpage, self._YT_INITIAL_PLAYER_RESPONSE_RE,
2875                 video_id, 'initial player response')
2876
2877         original_clients = clients
2878         clients = clients[::-1]
2879         prs = []
2880
2881         def append_client(client_name):
2882             if client_name in INNERTUBE_CLIENTS and client_name not in original_clients:
2883                 clients.append(client_name)
2884
2885         # Android player_response does not have microFormats which are needed for
2886         # extraction of some data. So we return the initial_pr with formats
2887         # stripped out even if not requested by the user
2888         # See: https://github.com/yt-dlp/yt-dlp/issues/501
2889         if initial_pr:
2890             pr = dict(initial_pr)
2891             pr['streamingData'] = None
2892             prs.append(pr)
2893
2894         last_error = None
2895         tried_iframe_fallback = False
2896         player_url = None
2897         while clients:
2898             client = clients.pop()
2899             player_ytcfg = master_ytcfg if client == 'web' else {}
2900             if 'configs' not in self._configuration_arg('player_skip'):
2901                 player_ytcfg = self._extract_player_ytcfg(client, video_id) or player_ytcfg
2902
2903             player_url = player_url or self._extract_player_url(master_ytcfg, player_ytcfg, webpage=webpage)
2904             require_js_player = self._get_default_ytcfg(client).get('REQUIRE_JS_PLAYER')
2905             if 'js' in self._configuration_arg('player_skip'):
2906                 require_js_player = False
2907                 player_url = None
2908
2909             if not player_url and not tried_iframe_fallback and require_js_player:
2910                 player_url = self._download_player_url(video_id)
2911                 tried_iframe_fallback = True
2912
2913             try:
2914                 pr = initial_pr if client == 'web' and initial_pr else self._extract_player_response(
2915                     client, video_id, player_ytcfg or master_ytcfg, player_ytcfg, player_url if require_js_player else None, initial_pr)
2916             except ExtractorError as e:
2917                 if last_error:
2918                     self.report_warning(last_error)
2919                 last_error = e
2920                 continue
2921
2922             if pr:
2923                 prs.append(pr)
2924
2925             # creator clients can bypass AGE_VERIFICATION_REQUIRED if logged in
2926             if client.endswith('_agegate') and self._is_unplayable(pr) and self.is_authenticated:
2927                 append_client(client.replace('_agegate', '_creator'))
2928             elif self._is_agegated(pr):
2929                 append_client(f'{client}_agegate')
2930
2931         if last_error:
2932             if not len(prs):
2933                 raise last_error
2934             self.report_warning(last_error)
2935         return prs, player_url
2936
2937     def _extract_formats(self, streaming_data, video_id, player_url, is_live):
2938         itags, stream_ids = {}, []
2939         itag_qualities, res_qualities = {}, {}
2940         q = qualities([
2941             # Normally tiny is the smallest video-only formats. But
2942             # audio-only formats with unknown quality may get tagged as tiny
2943             'tiny',
2944             'audio_quality_ultralow', 'audio_quality_low', 'audio_quality_medium', 'audio_quality_high',  # Audio only formats
2945             'small', 'medium', 'large', 'hd720', 'hd1080', 'hd1440', 'hd2160', 'hd2880', 'highres'
2946         ])
2947         streaming_formats = traverse_obj(streaming_data, (..., ('formats', 'adaptiveFormats'), ...), default=[])
2948
2949         for fmt in streaming_formats:
2950             if fmt.get('targetDurationSec') or fmt.get('drmFamilies'):
2951                 continue
2952
2953             itag = str_or_none(fmt.get('itag'))
2954             audio_track = fmt.get('audioTrack') or {}
2955             stream_id = '%s.%s' % (itag or '', audio_track.get('id', ''))
2956             if stream_id in stream_ids:
2957                 continue
2958
2959             quality = fmt.get('quality')
2960             height = int_or_none(fmt.get('height'))
2961             if quality == 'tiny' or not quality:
2962                 quality = fmt.get('audioQuality', '').lower() or quality
2963             # The 3gp format (17) in android client has a quality of "small",
2964             # but is actually worse than other formats
2965             if itag == '17':
2966                 quality = 'tiny'
2967             if quality:
2968                 if itag:
2969                     itag_qualities[itag] = quality
2970                 if height:
2971                     res_qualities[height] = quality
2972             # FORMAT_STREAM_TYPE_OTF(otf=1) requires downloading the init fragment
2973             # (adding `&sq=0` to the URL) and parsing emsg box to determine the
2974             # number of fragment that would subsequently requested with (`&sq=N`)
2975             if fmt.get('type') == 'FORMAT_STREAM_TYPE_OTF':
2976                 continue
2977
2978             fmt_url = fmt.get('url')
2979             if not fmt_url:
2980                 sc = compat_parse_qs(fmt.get('signatureCipher'))
2981                 fmt_url = url_or_none(try_get(sc, lambda x: x['url'][0]))
2982                 encrypted_sig = try_get(sc, lambda x: x['s'][0])
2983                 if not (sc and fmt_url and encrypted_sig):
2984                     continue
2985                 if not player_url:
2986                     continue
2987                 signature = self._decrypt_signature(sc['s'][0], video_id, player_url)
2988                 sp = try_get(sc, lambda x: x['sp'][0]) or 'signature'
2989                 fmt_url += '&' + sp + '=' + signature
2990
2991             query = parse_qs(fmt_url)
2992             throttled = False
2993             if query.get('n'):
2994                 try:
2995                     fmt_url = update_url_query(fmt_url, {
2996                         'n': self._decrypt_nsig(query['n'][0], video_id, player_url)})
2997                 except ExtractorError as e:
2998                     self.report_warning(
2999                         f'nsig extraction failed: You may experience throttling for some formats\n'
3000                         f'n = {query["n"][0]} ; player = {player_url}\n{e}', only_once=True)
3001                     throttled = True
3002
3003             if itag:
3004                 itags[itag] = 'https'
3005                 stream_ids.append(stream_id)
3006
3007             tbr = float_or_none(
3008                 fmt.get('averageBitrate') or fmt.get('bitrate'), 1000)
3009             language_preference = (
3010                 10 if audio_track.get('audioIsDefault') and 10
3011                 else -10 if 'descriptive' in (audio_track.get('displayName') or '').lower() and -10
3012                 else -1)
3013             dct = {
3014                 'asr': int_or_none(fmt.get('audioSampleRate')),
3015                 'filesize': int_or_none(fmt.get('contentLength')),
3016                 'format_id': itag,
3017                 'format_note': join_nonempty(
3018                     '%s%s' % (audio_track.get('displayName') or '',
3019                               ' (default)' if language_preference > 0 else ''),
3020                     fmt.get('qualityLabel') or quality.replace('audio_quality_', ''),
3021                     throttled and 'THROTTLED', delim=', '),
3022                 'source_preference': -10 if throttled else -1,
3023                 'fps': int_or_none(fmt.get('fps')) or None,
3024                 'height': height,
3025                 'quality': q(quality),
3026                 'tbr': tbr,
3027                 'url': fmt_url,
3028                 'width': int_or_none(fmt.get('width')),
3029                 'language': join_nonempty(audio_track.get('id', '').split('.')[0],
3030                                           'desc' if language_preference < -1 else ''),
3031                 'language_preference': language_preference,
3032             }
3033             mime_mobj = re.match(
3034                 r'((?:[^/]+)/(?:[^;]+))(?:;\s*codecs="([^"]+)")?', fmt.get('mimeType') or '')
3035             if mime_mobj:
3036                 dct['ext'] = mimetype2ext(mime_mobj.group(1))
3037                 dct.update(parse_codecs(mime_mobj.group(2)))
3038             no_audio = dct.get('acodec') == 'none'
3039             no_video = dct.get('vcodec') == 'none'
3040             if no_audio:
3041                 dct['vbr'] = tbr
3042             if no_video:
3043                 dct['abr'] = tbr
3044             if no_audio or no_video:
3045                 dct['downloader_options'] = {
3046                     # Youtube throttles chunks >~10M
3047                     'http_chunk_size': 10485760,
3048                 }
3049                 if dct.get('ext'):
3050                     dct['container'] = dct['ext'] + '_dash'
3051             yield dct
3052
3053         live_from_start = is_live and self.get_param('live_from_start')
3054         skip_manifests = self._configuration_arg('skip')
3055         if not self.get_param('youtube_include_hls_manifest', True):
3056             skip_manifests.append('hls')
3057         get_dash = 'dash' not in skip_manifests and (
3058             not is_live or live_from_start or self._configuration_arg('include_live_dash'))
3059         get_hls = not live_from_start and 'hls' not in skip_manifests
3060
3061         def process_manifest_format(f, proto, itag):
3062             if itag in itags:
3063                 if itags[itag] == proto or f'{itag}-{proto}' in itags:
3064                     return False
3065                 itag = f'{itag}-{proto}'
3066             if itag:
3067                 f['format_id'] = itag
3068                 itags[itag] = proto
3069
3070             f['quality'] = next((
3071                 q(qdict[val])
3072                 for val, qdict in ((f.get('format_id', '').split('-')[0], itag_qualities), (f.get('height'), res_qualities))
3073                 if val in qdict), -1)
3074             return True
3075
3076         for sd in streaming_data:
3077             hls_manifest_url = get_hls and sd.get('hlsManifestUrl')
3078             if hls_manifest_url:
3079                 for f in self._extract_m3u8_formats(hls_manifest_url, video_id, 'mp4', fatal=False):
3080                     if process_manifest_format(f, 'hls', self._search_regex(
3081                             r'/itag/(\d+)', f['url'], 'itag', default=None)):
3082                         yield f
3083
3084             dash_manifest_url = get_dash and sd.get('dashManifestUrl')
3085             if dash_manifest_url:
3086                 for f in self._extract_mpd_formats(dash_manifest_url, video_id, fatal=False):
3087                     if process_manifest_format(f, 'dash', f['format_id']):
3088                         f['filesize'] = int_or_none(self._search_regex(
3089                             r'/clen/(\d+)', f.get('fragment_base_url') or f['url'], 'file size', default=None))
3090                         if live_from_start:
3091                             f['is_from_start'] = True
3092
3093                         yield f
3094
3095     def _extract_storyboard(self, player_responses, duration):
3096         spec = get_first(
3097             player_responses, ('storyboards', 'playerStoryboardSpecRenderer', 'spec'), default='').split('|')[::-1]
3098         base_url = url_or_none(urljoin('https://i.ytimg.com/', spec.pop() or None))
3099         if not base_url:
3100             return
3101         L = len(spec) - 1
3102         for i, args in enumerate(spec):
3103             args = args.split('#')
3104             counts = list(map(int_or_none, args[:5]))
3105             if len(args) != 8 or not all(counts):
3106                 self.report_warning(f'Malformed storyboard {i}: {"#".join(args)}{bug_reports_message()}')
3107                 continue
3108             width, height, frame_count, cols, rows = counts
3109             N, sigh = args[6:]
3110
3111             url = base_url.replace('$L', str(L - i)).replace('$N', N) + f'&sigh={sigh}'
3112             fragment_count = frame_count / (cols * rows)
3113             fragment_duration = duration / fragment_count
3114             yield {
3115                 'format_id': f'sb{i}',
3116                 'format_note': 'storyboard',
3117                 'ext': 'mhtml',
3118                 'protocol': 'mhtml',
3119                 'acodec': 'none',
3120                 'vcodec': 'none',
3121                 'url': url,
3122                 'width': width,
3123                 'height': height,
3124                 'fragments': [{
3125                     'path': url.replace('$M', str(j)),
3126                     'duration': min(fragment_duration, duration - (j * fragment_duration)),
3127                 } for j in range(math.ceil(fragment_count))],
3128             }
3129
3130     def _download_player_responses(self, url, smuggled_data, video_id, webpage_url):
3131         webpage = None
3132         if 'webpage' not in self._configuration_arg('player_skip'):
3133             webpage = self._download_webpage(
3134                 webpage_url + '&bpctr=9999999999&has_verified=1', video_id, fatal=False)
3135
3136         master_ytcfg = self.extract_ytcfg(video_id, webpage) or self._get_default_ytcfg()
3137
3138         player_responses, player_url = self._extract_player_responses(
3139             self._get_requested_clients(url, smuggled_data),
3140             video_id, webpage, master_ytcfg)
3141
3142         return webpage, master_ytcfg, player_responses, player_url
3143
3144     def _list_formats(self, video_id, microformats, video_details, player_responses, player_url):
3145         live_broadcast_details = traverse_obj(microformats, (..., 'liveBroadcastDetails'))
3146         is_live = get_first(video_details, 'isLive')
3147         if is_live is None:
3148             is_live = get_first(live_broadcast_details, 'isLiveNow')
3149
3150         streaming_data = traverse_obj(player_responses, (..., 'streamingData'), default=[])
3151         formats = list(self._extract_formats(streaming_data, video_id, player_url, is_live))
3152
3153         return live_broadcast_details, is_live, streaming_data, formats
3154
3155     def _real_extract(self, url):
3156         url, smuggled_data = unsmuggle_url(url, {})
3157         video_id = self._match_id(url)
3158
3159         base_url = self.http_scheme() + '//www.youtube.com/'
3160         webpage_url = base_url + 'watch?v=' + video_id
3161
3162         webpage, master_ytcfg, player_responses, player_url = self._download_player_responses(url, smuggled_data, video_id, webpage_url)
3163
3164         playability_statuses = traverse_obj(
3165             player_responses, (..., 'playabilityStatus'), expected_type=dict, default=[])
3166
3167         trailer_video_id = get_first(
3168             playability_statuses,
3169             ('errorScreen', 'playerLegacyDesktopYpcTrailerRenderer', 'trailerVideoId'),
3170             expected_type=str)
3171         if trailer_video_id:
3172             return self.url_result(
3173                 trailer_video_id, self.ie_key(), trailer_video_id)
3174
3175         search_meta = ((lambda x: self._html_search_meta(x, webpage, default=None))
3176                        if webpage else (lambda x: None))
3177
3178         video_details = traverse_obj(
3179             player_responses, (..., 'videoDetails'), expected_type=dict, default=[])
3180         microformats = traverse_obj(
3181             player_responses, (..., 'microformat', 'playerMicroformatRenderer'),
3182             expected_type=dict, default=[])
3183         video_title = (
3184             get_first(video_details, 'title')
3185             or self._get_text(microformats, (..., 'title'))
3186             or search_meta(['og:title', 'twitter:title', 'title']))
3187         video_description = get_first(video_details, 'shortDescription')
3188
3189         multifeed_metadata_list = get_first(
3190             player_responses,
3191             ('multicamera', 'playerLegacyMulticameraRenderer', 'metadataList'),
3192             expected_type=str)
3193         if multifeed_metadata_list and not smuggled_data.get('force_singlefeed'):
3194             if self.get_param('noplaylist'):
3195                 self.to_screen('Downloading just video %s because of --no-playlist' % video_id)
3196             else:
3197                 entries = []
3198                 feed_ids = []
3199                 for feed in multifeed_metadata_list.split(','):
3200                     # Unquote should take place before split on comma (,) since textual
3201                     # fields may contain comma as well (see
3202                     # https://github.com/ytdl-org/youtube-dl/issues/8536)
3203                     feed_data = compat_parse_qs(
3204                         compat_urllib_parse_unquote_plus(feed))
3205
3206                     def feed_entry(name):
3207                         return try_get(
3208                             feed_data, lambda x: x[name][0], compat_str)
3209
3210                     feed_id = feed_entry('id')
3211                     if not feed_id:
3212                         continue
3213                     feed_title = feed_entry('title')
3214                     title = video_title
3215                     if feed_title:
3216                         title += ' (%s)' % feed_title
3217                     entries.append({
3218                         '_type': 'url_transparent',
3219                         'ie_key': 'Youtube',
3220                         'url': smuggle_url(
3221                             '%swatch?v=%s' % (base_url, feed_data['id'][0]),
3222                             {'force_singlefeed': True}),
3223                         'title': title,
3224                     })
3225                     feed_ids.append(feed_id)
3226                 self.to_screen(
3227                     'Downloading multifeed video (%s) - add --no-playlist to just download video %s'
3228                     % (', '.join(feed_ids), video_id))
3229                 return self.playlist_result(
3230                     entries, video_id, video_title, video_description)
3231
3232         live_broadcast_details, is_live, streaming_data, formats = self._list_formats(video_id, microformats, video_details, player_responses, player_url)
3233
3234         if not formats:
3235             if not self.get_param('allow_unplayable_formats') and traverse_obj(streaming_data, (..., 'licenseInfos')):
3236                 self.report_drm(video_id)
3237             pemr = get_first(
3238                 playability_statuses,
3239                 ('errorScreen', 'playerErrorMessageRenderer'), expected_type=dict) or {}
3240             reason = self._get_text(pemr, 'reason') or get_first(playability_statuses, 'reason')
3241             subreason = clean_html(self._get_text(pemr, 'subreason') or '')
3242             if subreason:
3243                 if subreason == 'The uploader has not made this video available in your country.':
3244                     countries = get_first(microformats, 'availableCountries')
3245                     if not countries:
3246                         regions_allowed = search_meta('regionsAllowed')
3247                         countries = regions_allowed.split(',') if regions_allowed else None
3248                     self.raise_geo_restricted(subreason, countries, metadata_available=True)
3249                 reason += f'. {subreason}'
3250             if reason:
3251                 self.raise_no_formats(reason, expected=True)
3252
3253         keywords = get_first(video_details, 'keywords', expected_type=list) or []
3254         if not keywords and webpage:
3255             keywords = [
3256                 unescapeHTML(m.group('content'))
3257                 for m in re.finditer(self._meta_regex('og:video:tag'), webpage)]
3258         for keyword in keywords:
3259             if keyword.startswith('yt:stretch='):
3260                 mobj = re.search(r'(\d+)\s*:\s*(\d+)', keyword)
3261                 if mobj:
3262                     # NB: float is intentional for forcing float division
3263                     w, h = (float(v) for v in mobj.groups())
3264                     if w > 0 and h > 0:
3265                         ratio = w / h
3266                         for f in formats:
3267                             if f.get('vcodec') != 'none':
3268                                 f['stretched_ratio'] = ratio
3269                         break
3270         thumbnails = self._extract_thumbnails((video_details, microformats), (..., ..., 'thumbnail'))
3271         thumbnail_url = search_meta(['og:image', 'twitter:image'])
3272         if thumbnail_url:
3273             thumbnails.append({
3274                 'url': thumbnail_url,
3275             })
3276         original_thumbnails = thumbnails.copy()
3277
3278         # The best resolution thumbnails sometimes does not appear in the webpage
3279         # See: https://github.com/ytdl-org/youtube-dl/issues/29049, https://github.com/yt-dlp/yt-dlp/issues/340
3280         # List of possible thumbnails - Ref: <https://stackoverflow.com/a/20542029>
3281         thumbnail_names = [
3282             'maxresdefault', 'hq720', 'sddefault', 'sd1', 'sd2', 'sd3',
3283             'hqdefault', 'hq1', 'hq2', 'hq3', '0',
3284             'mqdefault', 'mq1', 'mq2', 'mq3',
3285             'default', '1', '2', '3'
3286         ]
3287         n_thumbnail_names = len(thumbnail_names)
3288         thumbnails.extend({
3289             'url': 'https://i.ytimg.com/vi{webp}/{video_id}/{name}{live}.{ext}'.format(
3290                 video_id=video_id, name=name, ext=ext,
3291                 webp='_webp' if ext == 'webp' else '', live='_live' if is_live else ''),
3292         } for name in thumbnail_names for ext in ('webp', 'jpg'))
3293         for thumb in thumbnails:
3294             i = next((i for i, t in enumerate(thumbnail_names) if f'/{video_id}/{t}' in thumb['url']), n_thumbnail_names)
3295             thumb['preference'] = (0 if '.webp' in thumb['url'] else -1) - (2 * i)
3296         self._remove_duplicate_formats(thumbnails)
3297         self._downloader._sort_thumbnails(original_thumbnails)
3298
3299         category = get_first(microformats, 'category') or search_meta('genre')
3300         channel_id = str_or_none(
3301             get_first(video_details, 'channelId')
3302             or get_first(microformats, 'externalChannelId')
3303             or search_meta('channelId'))
3304         duration = int_or_none(
3305             get_first(video_details, 'lengthSeconds')
3306             or get_first(microformats, 'lengthSeconds')
3307             or parse_duration(search_meta('duration'))) or None
3308         owner_profile_url = get_first(microformats, 'ownerProfileUrl')
3309
3310         live_content = get_first(video_details, 'isLiveContent')
3311         is_upcoming = get_first(video_details, 'isUpcoming')
3312         if is_live is None:
3313             if is_upcoming or live_content is False:
3314                 is_live = False
3315         if is_upcoming is None and (live_content or is_live):
3316             is_upcoming = False
3317         live_start_time = parse_iso8601(get_first(live_broadcast_details, 'startTimestamp'))
3318         live_end_time = parse_iso8601(get_first(live_broadcast_details, 'endTimestamp'))
3319         if not duration and live_end_time and live_start_time:
3320             duration = live_end_time - live_start_time
3321
3322         if is_live and self.get_param('live_from_start'):
3323             self._prepare_live_from_start_formats(formats, video_id, live_start_time, url, webpage_url, smuggled_data)
3324
3325         formats.extend(self._extract_storyboard(player_responses, duration))
3326
3327         # Source is given priority since formats that throttle are given lower source_preference
3328         # When throttling issue is fully fixed, remove this
3329         self._sort_formats(formats, ('quality', 'res', 'fps', 'hdr:12', 'source', 'codec:vp9.2', 'lang', 'proto'))
3330
3331         info = {
3332             'id': video_id,
3333             'title': video_title,
3334             'formats': formats,
3335             'thumbnails': thumbnails,
3336             # The best thumbnail that we are sure exists. Prevents unnecessary
3337             # URL checking if user don't care about getting the best possible thumbnail
3338             'thumbnail': traverse_obj(original_thumbnails, (-1, 'url')),
3339             'description': video_description,
3340             'upload_date': unified_strdate(
3341                 get_first(microformats, 'uploadDate')
3342                 or search_meta('uploadDate')),
3343             'uploader': get_first(video_details, 'author'),
3344             'uploader_id': self._search_regex(r'/(?:channel|user)/([^/?&#]+)', owner_profile_url, 'uploader id') if owner_profile_url else None,
3345             'uploader_url': owner_profile_url,
3346             'channel_id': channel_id,
3347             'channel_url': format_field(channel_id, template='https://www.youtube.com/channel/%s'),
3348             'duration': duration,
3349             'view_count': int_or_none(
3350                 get_first((video_details, microformats), (..., 'viewCount'))
3351                 or search_meta('interactionCount')),
3352             'average_rating': float_or_none(get_first(video_details, 'averageRating')),
3353             'age_limit': 18 if (
3354                 get_first(microformats, 'isFamilySafe') is False
3355                 or search_meta('isFamilyFriendly') == 'false'
3356                 or search_meta('og:restrictions:age') == '18+') else 0,
3357             'webpage_url': webpage_url,
3358             'categories': [category] if category else None,
3359             'tags': keywords,
3360             'playable_in_embed': get_first(playability_statuses, 'playableInEmbed'),
3361             'is_live': is_live,
3362             'was_live': (False if is_live or is_upcoming or live_content is False
3363                          else None if is_live is None or is_upcoming is None
3364                          else live_content),
3365             'live_status': 'is_upcoming' if is_upcoming else None,  # rest will be set by YoutubeDL
3366             'release_timestamp': live_start_time,
3367         }
3368
3369         pctr = traverse_obj(player_responses, (..., 'captions', 'playerCaptionsTracklistRenderer'), expected_type=dict)
3370         if pctr:
3371             def get_lang_code(track):
3372                 return (remove_start(track.get('vssId') or '', '.').replace('.', '-')
3373                         or track.get('languageCode'))
3374
3375             # Converted into dicts to remove duplicates
3376             captions = {
3377                 get_lang_code(sub): sub
3378                 for sub in traverse_obj(pctr, (..., 'captionTracks', ...), default=[])}
3379             translation_languages = {
3380                 lang.get('languageCode'): self._get_text(lang.get('languageName'), max_runs=1)
3381                 for lang in traverse_obj(pctr, (..., 'translationLanguages', ...), default=[])}
3382
3383             def process_language(container, base_url, lang_code, sub_name, query):
3384                 lang_subs = container.setdefault(lang_code, [])
3385                 for fmt in self._SUBTITLE_FORMATS:
3386                     query.update({
3387                         'fmt': fmt,
3388                     })
3389                     lang_subs.append({
3390                         'ext': fmt,
3391                         'url': update_url_query(base_url, query),
3392                         'name': sub_name,
3393                     })
3394
3395             subtitles, automatic_captions = {}, {}
3396             for lang_code, caption_track in captions.items():
3397                 base_url = caption_track.get('baseUrl')
3398                 if not base_url:
3399                     continue
3400                 lang_name = self._get_text(caption_track, 'name', max_runs=1)
3401                 if caption_track.get('kind') != 'asr':
3402                     if not lang_code:
3403                         continue
3404                     process_language(
3405                         subtitles, base_url, lang_code, lang_name, {})
3406                     if not caption_track.get('isTranslatable'):
3407                         continue
3408                 for trans_code, trans_name in translation_languages.items():
3409                     if not trans_code:
3410                         continue
3411                     if caption_track.get('kind') != 'asr':
3412                         trans_code += f'-{lang_code}'
3413                         trans_name += format_field(lang_name, template=' from %s')
3414                     process_language(
3415                         automatic_captions, base_url, trans_code, trans_name, {'tlang': trans_code})
3416                     if lang_code == f'a-{trans_code}':
3417                         process_language(
3418                             automatic_captions, base_url, f'{trans_code}-orig', f'{trans_name} (Original)', {'tlang': trans_code})
3419             info['automatic_captions'] = automatic_captions
3420             info['subtitles'] = subtitles
3421
3422         parsed_url = compat_urllib_parse_urlparse(url)
3423         for component in [parsed_url.fragment, parsed_url.query]:
3424             query = compat_parse_qs(component)
3425             for k, v in query.items():
3426                 for d_k, s_ks in [('start', ('start', 't')), ('end', ('end',))]:
3427                     d_k += '_time'
3428                     if d_k not in info and k in s_ks:
3429                         info[d_k] = parse_duration(query[k][0])
3430
3431         # Youtube Music Auto-generated description
3432         if video_description:
3433             mobj = re.search(r'(?s)(?P<track>[^·\n]+)·(?P<artist>[^\n]+)\n+(?P<album>[^\n]+)(?:.+?℗\s*(?P<release_year>\d{4})(?!\d))?(?:.+?Released on\s*:\s*(?P<release_date>\d{4}-\d{2}-\d{2}))?(.+?\nArtist\s*:\s*(?P<clean_artist>[^\n]+))?.+\nAuto-generated by YouTube\.\s*$', video_description)
3434             if mobj:
3435                 release_year = mobj.group('release_year')
3436                 release_date = mobj.group('release_date')
3437                 if release_date:
3438                     release_date = release_date.replace('-', '')
3439                     if not release_year:
3440                         release_year = release_date[:4]
3441                 info.update({
3442                     'album': mobj.group('album'.strip()),
3443                     'artist': mobj.group('clean_artist') or ', '.join(a.strip() for a in mobj.group('artist').split('·')),
3444                     'track': mobj.group('track').strip(),
3445                     'release_date': release_date,
3446                     'release_year': int_or_none(release_year),
3447                 })
3448
3449         initial_data = None
3450         if webpage:
3451             initial_data = self._extract_yt_initial_variable(
3452                 webpage, self._YT_INITIAL_DATA_RE, video_id,
3453                 'yt initial data')
3454         if not initial_data:
3455             query = {'videoId': video_id}
3456             query.update(self._get_checkok_params())
3457             initial_data = self._extract_response(
3458                 item_id=video_id, ep='next', fatal=False,
3459                 ytcfg=master_ytcfg, query=query,
3460                 headers=self.generate_api_headers(ytcfg=master_ytcfg),
3461                 note='Downloading initial data API JSON')
3462
3463         try:
3464             # This will error if there is no livechat
3465             initial_data['contents']['twoColumnWatchNextResults']['conversationBar']['liveChatRenderer']['continuations'][0]['reloadContinuationData']['continuation']
3466             info.setdefault('subtitles', {})['live_chat'] = [{
3467                 'url': 'https://www.youtube.com/watch?v=%s' % video_id,  # url is needed to set cookies
3468                 'video_id': video_id,
3469                 'ext': 'json',
3470                 'protocol': 'youtube_live_chat' if is_live or is_upcoming else 'youtube_live_chat_replay',
3471             }]
3472         except (KeyError, IndexError, TypeError):
3473             pass
3474
3475         if initial_data:
3476             info['chapters'] = (
3477                 self._extract_chapters_from_json(initial_data, duration)
3478                 or self._extract_chapters_from_engagement_panel(initial_data, duration)
3479                 or None)
3480
3481             contents = try_get(
3482                 initial_data,
3483                 lambda x: x['contents']['twoColumnWatchNextResults']['results']['results']['contents'],
3484                 list) or []
3485             for content in contents:
3486                 vpir = content.get('videoPrimaryInfoRenderer')
3487                 if vpir:
3488                     stl = vpir.get('superTitleLink')
3489                     if stl:
3490                         stl = self._get_text(stl)
3491                         if try_get(
3492                                 vpir,
3493                                 lambda x: x['superTitleIcon']['iconType']) == 'LOCATION_PIN':
3494                             info['location'] = stl
3495                         else:
3496                             mobj = re.search(r'(.+?)\s*S(\d+)\s*•\s*E(\d+)', stl)
3497                             if mobj:
3498                                 info.update({
3499                                     'series': mobj.group(1),
3500                                     'season_number': int(mobj.group(2)),
3501                                     'episode_number': int(mobj.group(3)),
3502                                 })
3503                     for tlb in (try_get(
3504                             vpir,
3505                             lambda x: x['videoActions']['menuRenderer']['topLevelButtons'],
3506                             list) or []):
3507                         tbr = tlb.get('toggleButtonRenderer') or {}
3508                         for getter, regex in [(
3509                                 lambda x: x['defaultText']['accessibility']['accessibilityData'],
3510                                 r'(?P<count>[\d,]+)\s*(?P<type>(?:dis)?like)'), ([
3511                                     lambda x: x['accessibility'],
3512                                     lambda x: x['accessibilityData']['accessibilityData'],
3513                                 ], r'(?P<type>(?:dis)?like) this video along with (?P<count>[\d,]+) other people')]:
3514                             label = (try_get(tbr, getter, dict) or {}).get('label')
3515                             if label:
3516                                 mobj = re.match(regex, label)
3517                                 if mobj:
3518                                     info[mobj.group('type') + '_count'] = str_to_int(mobj.group('count'))
3519                                     break
3520                     sbr_tooltip = try_get(
3521                         vpir, lambda x: x['sentimentBar']['sentimentBarRenderer']['tooltip'])
3522                     if sbr_tooltip:
3523                         like_count, dislike_count = sbr_tooltip.split(' / ')
3524                         info.update({
3525                             'like_count': str_to_int(like_count),
3526                             'dislike_count': str_to_int(dislike_count),
3527                         })
3528                 vsir = content.get('videoSecondaryInfoRenderer')
3529                 if vsir:
3530                     vor = traverse_obj(vsir, ('owner', 'videoOwnerRenderer'))
3531                     info.update({
3532                         'channel': self._get_text(vor, 'title'),
3533                         'channel_follower_count': self._get_count(vor, 'subscriberCountText')})
3534
3535                     rows = try_get(
3536                         vsir,
3537                         lambda x: x['metadataRowContainer']['metadataRowContainerRenderer']['rows'],
3538                         list) or []
3539                     multiple_songs = False
3540                     for row in rows:
3541                         if try_get(row, lambda x: x['metadataRowRenderer']['hasDividerLine']) is True:
3542                             multiple_songs = True
3543                             break
3544                     for row in rows:
3545                         mrr = row.get('metadataRowRenderer') or {}
3546                         mrr_title = mrr.get('title')
3547                         if not mrr_title:
3548                             continue
3549                         mrr_title = self._get_text(mrr, 'title')
3550                         mrr_contents_text = self._get_text(mrr, ('contents', 0))
3551                         if mrr_title == 'License':
3552                             info['license'] = mrr_contents_text
3553                         elif not multiple_songs:
3554                             if mrr_title == 'Album':
3555                                 info['album'] = mrr_contents_text
3556                             elif mrr_title == 'Artist':
3557                                 info['artist'] = mrr_contents_text
3558                             elif mrr_title == 'Song':
3559                                 info['track'] = mrr_contents_text
3560
3561         fallbacks = {
3562             'channel': 'uploader',
3563             'channel_id': 'uploader_id',
3564             'channel_url': 'uploader_url',
3565         }
3566         for to, frm in fallbacks.items():
3567             if not info.get(to):
3568                 info[to] = info.get(frm)
3569
3570         for s_k, d_k in [('artist', 'creator'), ('track', 'alt_title')]:
3571             v = info.get(s_k)
3572             if v:
3573                 info[d_k] = v
3574
3575         is_private = get_first(video_details, 'isPrivate', expected_type=bool)
3576         is_unlisted = get_first(microformats, 'isUnlisted', expected_type=bool)
3577         is_membersonly = None
3578         is_premium = None
3579         if initial_data and is_private is not None:
3580             is_membersonly = False
3581             is_premium = False
3582             contents = try_get(initial_data, lambda x: x['contents']['twoColumnWatchNextResults']['results']['results']['contents'], list) or []
3583             badge_labels = set()
3584             for content in contents:
3585                 if not isinstance(content, dict):
3586                     continue
3587                 badge_labels.update(self._extract_badges(content.get('videoPrimaryInfoRenderer')))
3588             for badge_label in badge_labels:
3589                 if badge_label.lower() == 'members only':
3590                     is_membersonly = True
3591                 elif badge_label.lower() == 'premium':
3592                     is_premium = True
3593                 elif badge_label.lower() == 'unlisted':
3594                     is_unlisted = True
3595
3596         info['availability'] = self._availability(
3597             is_private=is_private,
3598             needs_premium=is_premium,
3599             needs_subscription=is_membersonly,
3600             needs_auth=info['age_limit'] >= 18,
3601             is_unlisted=None if is_private is None else is_unlisted)
3602
3603         info['__post_extractor'] = self.extract_comments(master_ytcfg, video_id, contents, webpage)
3604
3605         self.mark_watched(video_id, player_responses)
3606
3607         return info
3608
3609
3610 class YoutubeTabBaseInfoExtractor(YoutubeBaseInfoExtractor):
3611
3612     @staticmethod
3613     def passthrough_smuggled_data(func):
3614         def _smuggle(entries, smuggled_data):
3615             for entry in entries:
3616                 # TODO: Convert URL to music.youtube instead.
3617                 # Do we need to passthrough any other smuggled_data?
3618                 entry['url'] = smuggle_url(entry['url'], smuggled_data)
3619                 yield entry
3620
3621         @functools.wraps(func)
3622         def wrapper(self, url):
3623             url, smuggled_data = unsmuggle_url(url, {})
3624             if self.is_music_url(url):
3625                 smuggled_data['is_music_url'] = True
3626             info_dict = func(self, url, smuggled_data)
3627             if smuggled_data and info_dict.get('entries'):
3628                 info_dict['entries'] = _smuggle(info_dict['entries'], smuggled_data)
3629             return info_dict
3630         return wrapper
3631
3632     def _extract_channel_id(self, webpage):
3633         channel_id = self._html_search_meta(
3634             'channelId', webpage, 'channel id', default=None)
3635         if channel_id:
3636             return channel_id
3637         channel_url = self._html_search_meta(
3638             ('og:url', 'al:ios:url', 'al:android:url', 'al:web:url',
3639              'twitter:url', 'twitter:app:url:iphone', 'twitter:app:url:ipad',
3640              'twitter:app:url:googleplay'), webpage, 'channel url')
3641         return self._search_regex(
3642             r'https?://(?:www\.)?youtube\.com/channel/([^/?#&])+',
3643             channel_url, 'channel id')
3644
3645     @staticmethod
3646     def _extract_basic_item_renderer(item):
3647         # Modified from _extract_grid_item_renderer
3648         known_basic_renderers = (
3649             'playlistRenderer', 'videoRenderer', 'channelRenderer', 'showRenderer'
3650         )
3651         for key, renderer in item.items():
3652             if not isinstance(renderer, dict):
3653                 continue
3654             elif key in known_basic_renderers:
3655                 return renderer
3656             elif key.startswith('grid') and key.endswith('Renderer'):
3657                 return renderer
3658
3659     def _grid_entries(self, grid_renderer):
3660         for item in grid_renderer['items']:
3661             if not isinstance(item, dict):
3662                 continue
3663             renderer = self._extract_basic_item_renderer(item)
3664             if not isinstance(renderer, dict):
3665                 continue
3666             title = self._get_text(renderer, 'title')
3667
3668             # playlist
3669             playlist_id = renderer.get('playlistId')
3670             if playlist_id:
3671                 yield self.url_result(
3672                     'https://www.youtube.com/playlist?list=%s' % playlist_id,
3673                     ie=YoutubeTabIE.ie_key(), video_id=playlist_id,
3674                     video_title=title)
3675                 continue
3676             # video
3677             video_id = renderer.get('videoId')
3678             if video_id:
3679                 yield self._extract_video(renderer)
3680                 continue
3681             # channel
3682             channel_id = renderer.get('channelId')
3683             if channel_id:
3684                 yield self.url_result(
3685                     'https://www.youtube.com/channel/%s' % channel_id,
3686                     ie=YoutubeTabIE.ie_key(), video_title=title)
3687                 continue
3688             # generic endpoint URL support
3689             ep_url = urljoin('https://www.youtube.com/', try_get(
3690                 renderer, lambda x: x['navigationEndpoint']['commandMetadata']['webCommandMetadata']['url'],
3691                 compat_str))
3692             if ep_url:
3693                 for ie in (YoutubeTabIE, YoutubePlaylistIE, YoutubeIE):
3694                     if ie.suitable(ep_url):
3695                         yield self.url_result(
3696                             ep_url, ie=ie.ie_key(), video_id=ie._match_id(ep_url), video_title=title)
3697                         break
3698
3699     def _music_reponsive_list_entry(self, renderer):
3700         video_id = traverse_obj(renderer, ('playlistItemData', 'videoId'))
3701         if video_id:
3702             return self.url_result(f'https://music.youtube.com/watch?v={video_id}',
3703                                    ie=YoutubeIE.ie_key(), video_id=video_id)
3704         playlist_id = traverse_obj(renderer, ('navigationEndpoint', 'watchEndpoint', 'playlistId'))
3705         if playlist_id:
3706             video_id = traverse_obj(renderer, ('navigationEndpoint', 'watchEndpoint', 'videoId'))
3707             if video_id:
3708                 return self.url_result(f'https://music.youtube.com/watch?v={video_id}&list={playlist_id}',
3709                                        ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
3710             return self.url_result(f'https://music.youtube.com/playlist?list={playlist_id}',
3711                                    ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
3712         browse_id = traverse_obj(renderer, ('navigationEndpoint', 'browseEndpoint', 'browseId'))
3713         if browse_id:
3714             return self.url_result(f'https://music.youtube.com/browse/{browse_id}',
3715                                    ie=YoutubeTabIE.ie_key(), video_id=browse_id)
3716
3717     def _shelf_entries_from_content(self, shelf_renderer):
3718         content = shelf_renderer.get('content')
3719         if not isinstance(content, dict):
3720             return
3721         renderer = content.get('gridRenderer') or content.get('expandedShelfContentsRenderer')
3722         if renderer:
3723             # TODO: add support for nested playlists so each shelf is processed
3724             # as separate playlist
3725             # TODO: this includes only first N items
3726             for entry in self._grid_entries(renderer):
3727                 yield entry
3728         renderer = content.get('horizontalListRenderer')
3729         if renderer:
3730             # TODO
3731             pass
3732
3733     def _shelf_entries(self, shelf_renderer, skip_channels=False):
3734         ep = try_get(
3735             shelf_renderer, lambda x: x['endpoint']['commandMetadata']['webCommandMetadata']['url'],
3736             compat_str)
3737         shelf_url = urljoin('https://www.youtube.com', ep)
3738         if shelf_url:
3739             # Skipping links to another channels, note that checking for
3740             # endpoint.commandMetadata.webCommandMetadata.webPageTypwebPageType == WEB_PAGE_TYPE_CHANNEL
3741             # will not work
3742             if skip_channels and '/channels?' in shelf_url:
3743                 return
3744             title = self._get_text(shelf_renderer, 'title')
3745             yield self.url_result(shelf_url, video_title=title)
3746         # Shelf may not contain shelf URL, fallback to extraction from content
3747         for entry in self._shelf_entries_from_content(shelf_renderer):
3748             yield entry
3749
3750     def _playlist_entries(self, video_list_renderer):
3751         for content in video_list_renderer['contents']:
3752             if not isinstance(content, dict):
3753                 continue
3754             renderer = content.get('playlistVideoRenderer') or content.get('playlistPanelVideoRenderer')
3755             if not isinstance(renderer, dict):
3756                 continue
3757             video_id = renderer.get('videoId')
3758             if not video_id:
3759                 continue
3760             yield self._extract_video(renderer)
3761
3762     def _rich_entries(self, rich_grid_renderer):
3763         renderer = try_get(
3764             rich_grid_renderer, lambda x: x['content']['videoRenderer'], dict) or {}
3765         video_id = renderer.get('videoId')
3766         if not video_id:
3767             return
3768         yield self._extract_video(renderer)
3769
3770     def _video_entry(self, video_renderer):
3771         video_id = video_renderer.get('videoId')
3772         if video_id:
3773             return self._extract_video(video_renderer)
3774
3775     def _post_thread_entries(self, post_thread_renderer):
3776         post_renderer = try_get(
3777             post_thread_renderer, lambda x: x['post']['backstagePostRenderer'], dict)
3778         if not post_renderer:
3779             return
3780         # video attachment
3781         video_renderer = try_get(
3782             post_renderer, lambda x: x['backstageAttachment']['videoRenderer'], dict) or {}
3783         video_id = video_renderer.get('videoId')
3784         if video_id:
3785             entry = self._extract_video(video_renderer)
3786             if entry:
3787                 yield entry
3788         # playlist attachment
3789         playlist_id = try_get(
3790             post_renderer, lambda x: x['backstageAttachment']['playlistRenderer']['playlistId'], compat_str)
3791         if playlist_id:
3792             yield self.url_result(
3793                 'https://www.youtube.com/playlist?list=%s' % playlist_id,
3794                 ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
3795         # inline video links
3796         runs = try_get(post_renderer, lambda x: x['contentText']['runs'], list) or []
3797         for run in runs:
3798             if not isinstance(run, dict):
3799                 continue
3800             ep_url = try_get(
3801                 run, lambda x: x['navigationEndpoint']['urlEndpoint']['url'], compat_str)
3802             if not ep_url:
3803                 continue
3804             if not YoutubeIE.suitable(ep_url):
3805                 continue
3806             ep_video_id = YoutubeIE._match_id(ep_url)
3807             if video_id == ep_video_id:
3808                 continue
3809             yield self.url_result(ep_url, ie=YoutubeIE.ie_key(), video_id=ep_video_id)
3810
3811     def _post_thread_continuation_entries(self, post_thread_continuation):
3812         contents = post_thread_continuation.get('contents')
3813         if not isinstance(contents, list):
3814             return
3815         for content in contents:
3816             renderer = content.get('backstagePostThreadRenderer')
3817             if not isinstance(renderer, dict):
3818                 continue
3819             for entry in self._post_thread_entries(renderer):
3820                 yield entry
3821
3822     r''' # unused
3823     def _rich_grid_entries(self, contents):
3824         for content in contents:
3825             video_renderer = try_get(content, lambda x: x['richItemRenderer']['content']['videoRenderer'], dict)
3826             if video_renderer:
3827                 entry = self._video_entry(video_renderer)
3828                 if entry:
3829                     yield entry
3830     '''
3831     def _extract_entries(self, parent_renderer, continuation_list):
3832         # continuation_list is modified in-place with continuation_list = [continuation_token]
3833         continuation_list[:] = [None]
3834         contents = try_get(parent_renderer, lambda x: x['contents'], list) or []
3835         for content in contents:
3836             if not isinstance(content, dict):
3837                 continue
3838             is_renderer = traverse_obj(
3839                 content, 'itemSectionRenderer', 'musicShelfRenderer', 'musicShelfContinuation',
3840                 expected_type=dict)
3841             if not is_renderer:
3842                 renderer = content.get('richItemRenderer')
3843                 if renderer:
3844                     for entry in self._rich_entries(renderer):
3845                         yield entry
3846                     continuation_list[0] = self._extract_continuation(parent_renderer)
3847                 continue
3848             isr_contents = try_get(is_renderer, lambda x: x['contents'], list) or []
3849             for isr_content in isr_contents:
3850                 if not isinstance(isr_content, dict):
3851                     continue
3852
3853                 known_renderers = {
3854                     'playlistVideoListRenderer': self._playlist_entries,
3855                     'gridRenderer': self._grid_entries,
3856                     'shelfRenderer': lambda x: self._shelf_entries(x),
3857                     'musicResponsiveListItemRenderer': lambda x: [self._music_reponsive_list_entry(x)],
3858                     'backstagePostThreadRenderer': self._post_thread_entries,
3859                     'videoRenderer': lambda x: [self._video_entry(x)],
3860                     'playlistRenderer': lambda x: self._grid_entries({'items': [{'playlistRenderer': x}]}),
3861                     'channelRenderer': lambda x: self._grid_entries({'items': [{'channelRenderer': x}]}),
3862                 }
3863                 for key, renderer in isr_content.items():
3864                     if key not in known_renderers:
3865                         continue
3866                     for entry in known_renderers[key](renderer):
3867                         if entry:
3868                             yield entry
3869                     continuation_list[0] = self._extract_continuation(renderer)
3870                     break
3871
3872             if not continuation_list[0]:
3873                 continuation_list[0] = self._extract_continuation(is_renderer)
3874
3875         if not continuation_list[0]:
3876             continuation_list[0] = self._extract_continuation(parent_renderer)
3877
3878     def _entries(self, tab, item_id, ytcfg, account_syncid, visitor_data):
3879         continuation_list = [None]
3880         extract_entries = lambda x: self._extract_entries(x, continuation_list)
3881         tab_content = try_get(tab, lambda x: x['content'], dict)
3882         if not tab_content:
3883             return
3884         parent_renderer = (
3885             try_get(tab_content, lambda x: x['sectionListRenderer'], dict)
3886             or try_get(tab_content, lambda x: x['richGridRenderer'], dict) or {})
3887         for entry in extract_entries(parent_renderer):
3888             yield entry
3889         continuation = continuation_list[0]
3890
3891         for page_num in itertools.count(1):
3892             if not continuation:
3893                 break
3894             headers = self.generate_api_headers(
3895                 ytcfg=ytcfg, account_syncid=account_syncid, visitor_data=visitor_data)
3896             response = self._extract_response(
3897                 item_id='%s page %s' % (item_id, page_num),
3898                 query=continuation, headers=headers, ytcfg=ytcfg,
3899                 check_get_keys=('continuationContents', 'onResponseReceivedActions', 'onResponseReceivedEndpoints'))
3900
3901             if not response:
3902                 break
3903             # Extracting updated visitor data is required to prevent an infinite extraction loop in some cases
3904             # See: https://github.com/ytdl-org/youtube-dl/issues/28702
3905             visitor_data = self._extract_visitor_data(response) or visitor_data
3906
3907             known_continuation_renderers = {
3908                 'playlistVideoListContinuation': self._playlist_entries,
3909                 'gridContinuation': self._grid_entries,
3910                 'itemSectionContinuation': self._post_thread_continuation_entries,
3911                 'sectionListContinuation': extract_entries,  # for feeds
3912             }
3913             continuation_contents = try_get(
3914                 response, lambda x: x['continuationContents'], dict) or {}
3915             continuation_renderer = None
3916             for key, value in continuation_contents.items():
3917                 if key not in known_continuation_renderers:
3918                     continue
3919                 continuation_renderer = value
3920                 continuation_list = [None]
3921                 for entry in known_continuation_renderers[key](continuation_renderer):
3922                     yield entry
3923                 continuation = continuation_list[0] or self._extract_continuation(continuation_renderer)
3924                 break
3925             if continuation_renderer:
3926                 continue
3927
3928             known_renderers = {
3929                 'gridPlaylistRenderer': (self._grid_entries, 'items'),
3930                 'gridVideoRenderer': (self._grid_entries, 'items'),
3931                 'gridChannelRenderer': (self._grid_entries, 'items'),
3932                 'playlistVideoRenderer': (self._playlist_entries, 'contents'),
3933                 'itemSectionRenderer': (extract_entries, 'contents'),  # for feeds
3934                 'richItemRenderer': (extract_entries, 'contents'),  # for hashtag
3935                 'backstagePostThreadRenderer': (self._post_thread_continuation_entries, 'contents')
3936             }
3937             on_response_received = dict_get(response, ('onResponseReceivedActions', 'onResponseReceivedEndpoints'))
3938             continuation_items = try_get(
3939                 on_response_received, lambda x: x[0]['appendContinuationItemsAction']['continuationItems'], list)
3940             continuation_item = try_get(continuation_items, lambda x: x[0], dict) or {}
3941             video_items_renderer = None
3942             for key, value in continuation_item.items():
3943                 if key not in known_renderers:
3944                     continue
3945                 video_items_renderer = {known_renderers[key][1]: continuation_items}
3946                 continuation_list = [None]
3947                 for entry in known_renderers[key][0](video_items_renderer):
3948                     yield entry
3949                 continuation = continuation_list[0] or self._extract_continuation(video_items_renderer)
3950                 break
3951             if video_items_renderer:
3952                 continue
3953             break
3954
3955     @staticmethod
3956     def _extract_selected_tab(tabs):
3957         for tab in tabs:
3958             renderer = dict_get(tab, ('tabRenderer', 'expandableTabRenderer')) or {}
3959             if renderer.get('selected') is True:
3960                 return renderer
3961         else:
3962             raise ExtractorError('Unable to find selected tab')
3963
3964     @classmethod
3965     def _extract_uploader(cls, data):
3966         uploader = {}
3967         renderer = cls._extract_sidebar_info_renderer(data, 'playlistSidebarSecondaryInfoRenderer') or {}
3968         owner = try_get(
3969             renderer, lambda x: x['videoOwner']['videoOwnerRenderer']['title']['runs'][0], dict)
3970         if owner:
3971             uploader['uploader'] = owner.get('text')
3972             uploader['uploader_id'] = try_get(
3973                 owner, lambda x: x['navigationEndpoint']['browseEndpoint']['browseId'], compat_str)
3974             uploader['uploader_url'] = urljoin(
3975                 'https://www.youtube.com/',
3976                 try_get(owner, lambda x: x['navigationEndpoint']['browseEndpoint']['canonicalBaseUrl'], compat_str))
3977         return {k: v for k, v in uploader.items() if v is not None}
3978
3979     def _extract_from_tabs(self, item_id, ytcfg, data, tabs):
3980         playlist_id = title = description = channel_url = channel_name = channel_id = None
3981         tags = []
3982
3983         selected_tab = self._extract_selected_tab(tabs)
3984         primary_sidebar_renderer = self._extract_sidebar_info_renderer(data, 'playlistSidebarPrimaryInfoRenderer')
3985         renderer = try_get(
3986             data, lambda x: x['metadata']['channelMetadataRenderer'], dict)
3987         if renderer:
3988             channel_name = renderer.get('title')
3989             channel_url = renderer.get('channelUrl')
3990             channel_id = renderer.get('externalId')
3991         else:
3992             renderer = try_get(
3993                 data, lambda x: x['metadata']['playlistMetadataRenderer'], dict)
3994
3995         if renderer:
3996             title = renderer.get('title')
3997             description = renderer.get('description', '')
3998             playlist_id = channel_id
3999             tags = renderer.get('keywords', '').split()
4000
4001         # We can get the uncropped banner/avatar by replacing the crop params with '=s0'
4002         # See: https://github.com/yt-dlp/yt-dlp/issues/2237#issuecomment-1013694714
4003         def _get_uncropped(url):
4004             return url_or_none((url or '').split('=')[0] + '=s0')
4005
4006         avatar_thumbnails = self._extract_thumbnails(renderer, 'avatar')
4007         if avatar_thumbnails:
4008             uncropped_avatar = _get_uncropped(avatar_thumbnails[0]['url'])
4009             if uncropped_avatar:
4010                 avatar_thumbnails.append({
4011                     'url': uncropped_avatar,
4012                     'id': 'avatar_uncropped',
4013                     'preference': 1
4014                 })
4015
4016         channel_banners = self._extract_thumbnails(
4017             data, ('header', ..., ['banner', 'mobileBanner', 'tvBanner']))
4018         for banner in channel_banners:
4019             banner['preference'] = -10
4020
4021         if channel_banners:
4022             uncropped_banner = _get_uncropped(channel_banners[0]['url'])
4023             if uncropped_banner:
4024                 channel_banners.append({
4025                     'url': uncropped_banner,
4026                     'id': 'banner_uncropped',
4027                     'preference': -5
4028                 })
4029
4030         primary_thumbnails = self._extract_thumbnails(
4031             primary_sidebar_renderer, ('thumbnailRenderer', 'playlistVideoThumbnailRenderer', 'thumbnail'))
4032
4033         if playlist_id is None:
4034             playlist_id = item_id
4035
4036         playlist_stats = traverse_obj(primary_sidebar_renderer, 'stats')
4037         last_updated_unix, _ = self._extract_time_text(playlist_stats, 2)
4038         if title is None:
4039             title = self._get_text(data, ('header', 'hashtagHeaderRenderer', 'hashtag')) or playlist_id
4040         title += format_field(selected_tab, 'title', ' - %s')
4041         title += format_field(selected_tab, 'expandedText', ' - %s')
4042
4043         metadata = {
4044             'playlist_id': playlist_id,
4045             'playlist_title': title,
4046             'playlist_description': description,
4047             'uploader': channel_name,
4048             'uploader_id': channel_id,
4049             'uploader_url': channel_url,
4050             'thumbnails': primary_thumbnails + avatar_thumbnails + channel_banners,
4051             'tags': tags,
4052             'view_count': self._get_count(playlist_stats, 1),
4053             'availability': self._extract_availability(data),
4054             'modified_date': strftime_or_none(last_updated_unix, '%Y%m%d'),
4055             'playlist_count': self._get_count(playlist_stats, 0),
4056             'channel_follower_count': self._get_count(data, ('header', ..., 'subscriberCountText')),
4057         }
4058         if not channel_id:
4059             metadata.update(self._extract_uploader(data))
4060         metadata.update({
4061             'channel': metadata['uploader'],
4062             'channel_id': metadata['uploader_id'],
4063             'channel_url': metadata['uploader_url']})
4064         return self.playlist_result(
4065             self._entries(
4066                 selected_tab, playlist_id, ytcfg,
4067                 self._extract_account_syncid(ytcfg, data),
4068                 self._extract_visitor_data(data, ytcfg)),
4069             **metadata)
4070
4071     def _extract_mix_playlist(self, playlist, playlist_id, data, ytcfg):
4072         first_id = last_id = response = None
4073         for page_num in itertools.count(1):
4074             videos = list(self._playlist_entries(playlist))
4075             if not videos:
4076                 return
4077             start = next((i for i, v in enumerate(videos) if v['id'] == last_id), -1) + 1
4078             if start >= len(videos):
4079                 return
4080             for video in videos[start:]:
4081                 if video['id'] == first_id:
4082                     self.to_screen('First video %s found again; Assuming end of Mix' % first_id)
4083                     return
4084                 yield video
4085             first_id = first_id or videos[0]['id']
4086             last_id = videos[-1]['id']
4087             watch_endpoint = try_get(
4088                 playlist, lambda x: x['contents'][-1]['playlistPanelVideoRenderer']['navigationEndpoint']['watchEndpoint'])
4089             headers = self.generate_api_headers(
4090                 ytcfg=ytcfg, account_syncid=self._extract_account_syncid(ytcfg, data),
4091                 visitor_data=self._extract_visitor_data(response, data, ytcfg))
4092             query = {
4093                 'playlistId': playlist_id,
4094                 'videoId': watch_endpoint.get('videoId') or last_id,
4095                 'index': watch_endpoint.get('index') or len(videos),
4096                 'params': watch_endpoint.get('params') or 'OAE%3D'
4097             }
4098             response = self._extract_response(
4099                 item_id='%s page %d' % (playlist_id, page_num),
4100                 query=query, ep='next', headers=headers, ytcfg=ytcfg,
4101                 check_get_keys='contents'
4102             )
4103             playlist = try_get(
4104                 response, lambda x: x['contents']['twoColumnWatchNextResults']['playlist']['playlist'], dict)
4105
4106     def _extract_from_playlist(self, item_id, url, data, playlist, ytcfg):
4107         title = playlist.get('title') or try_get(
4108             data, lambda x: x['titleText']['simpleText'], compat_str)
4109         playlist_id = playlist.get('playlistId') or item_id
4110
4111         # Delegating everything except mix playlists to regular tab-based playlist URL
4112         playlist_url = urljoin(url, try_get(
4113             playlist, lambda x: x['endpoint']['commandMetadata']['webCommandMetadata']['url'],
4114             compat_str))
4115         if playlist_url and playlist_url != url:
4116             return self.url_result(
4117                 playlist_url, ie=YoutubeTabIE.ie_key(), video_id=playlist_id,
4118                 video_title=title)
4119
4120         return self.playlist_result(
4121             self._extract_mix_playlist(playlist, playlist_id, data, ytcfg),
4122             playlist_id=playlist_id, playlist_title=title)
4123
4124     def _extract_availability(self, data):
4125         """
4126         Gets the availability of a given playlist/tab.
4127         Note: Unless YouTube tells us explicitly, we do not assume it is public
4128         @param data: response
4129         """
4130         is_private = is_unlisted = None
4131         renderer = self._extract_sidebar_info_renderer(data, 'playlistSidebarPrimaryInfoRenderer') or {}
4132         badge_labels = self._extract_badges(renderer)
4133
4134         # Personal playlists, when authenticated, have a dropdown visibility selector instead of a badge
4135         privacy_dropdown_entries = try_get(
4136             renderer, lambda x: x['privacyForm']['dropdownFormFieldRenderer']['dropdown']['dropdownRenderer']['entries'], list) or []
4137         for renderer_dict in privacy_dropdown_entries:
4138             is_selected = try_get(
4139                 renderer_dict, lambda x: x['privacyDropdownItemRenderer']['isSelected'], bool) or False
4140             if not is_selected:
4141                 continue
4142             label = self._get_text(renderer_dict, ('privacyDropdownItemRenderer', 'label'))
4143             if label:
4144                 badge_labels.add(label.lower())
4145                 break
4146
4147         for badge_label in badge_labels:
4148             if badge_label == 'unlisted':
4149                 is_unlisted = True
4150             elif badge_label == 'private':
4151                 is_private = True
4152             elif badge_label == 'public':
4153                 is_unlisted = is_private = False
4154         return self._availability(is_private, False, False, False, is_unlisted)
4155
4156     @staticmethod
4157     def _extract_sidebar_info_renderer(data, info_renderer, expected_type=dict):
4158         sidebar_renderer = try_get(
4159             data, lambda x: x['sidebar']['playlistSidebarRenderer']['items'], list) or []
4160         for item in sidebar_renderer:
4161             renderer = try_get(item, lambda x: x[info_renderer], expected_type)
4162             if renderer:
4163                 return renderer
4164
4165     def _reload_with_unavailable_videos(self, item_id, data, ytcfg):
4166         """
4167         Get playlist with unavailable videos if the 'show unavailable videos' button exists.
4168         """
4169         browse_id = params = None
4170         renderer = self._extract_sidebar_info_renderer(data, 'playlistSidebarPrimaryInfoRenderer')
4171         if not renderer:
4172             return
4173         menu_renderer = try_get(
4174             renderer, lambda x: x['menu']['menuRenderer']['items'], list) or []
4175         for menu_item in menu_renderer:
4176             if not isinstance(menu_item, dict):
4177                 continue
4178             nav_item_renderer = menu_item.get('menuNavigationItemRenderer')
4179             text = try_get(
4180                 nav_item_renderer, lambda x: x['text']['simpleText'], compat_str)
4181             if not text or text.lower() != 'show unavailable videos':
4182                 continue
4183             browse_endpoint = try_get(
4184                 nav_item_renderer, lambda x: x['navigationEndpoint']['browseEndpoint'], dict) or {}
4185             browse_id = browse_endpoint.get('browseId')
4186             params = browse_endpoint.get('params')
4187             break
4188
4189         headers = self.generate_api_headers(
4190             ytcfg=ytcfg, account_syncid=self._extract_account_syncid(ytcfg, data),
4191             visitor_data=self._extract_visitor_data(data, ytcfg))
4192         query = {
4193             'params': params or 'wgYCCAA=',
4194             'browseId': browse_id or 'VL%s' % item_id
4195         }
4196         return self._extract_response(
4197             item_id=item_id, headers=headers, query=query,
4198             check_get_keys='contents', fatal=False, ytcfg=ytcfg,
4199             note='Downloading API JSON with unavailable videos')
4200
4201     def _extract_webpage(self, url, item_id, fatal=True):
4202         retries = self.get_param('extractor_retries', 3)
4203         count = -1
4204         webpage = data = last_error = None
4205         while count < retries:
4206             count += 1
4207             # Sometimes youtube returns a webpage with incomplete ytInitialData
4208             # See: https://github.com/yt-dlp/yt-dlp/issues/116
4209             if last_error:
4210                 self.report_warning('%s. Retrying ...' % last_error)
4211             try:
4212                 webpage = self._download_webpage(
4213                     url, item_id,
4214                     note='Downloading webpage%s' % (' (retry #%d)' % count if count else '',))
4215                 data = self.extract_yt_initial_data(item_id, webpage or '', fatal=fatal) or {}
4216             except ExtractorError as e:
4217                 if isinstance(e.cause, network_exceptions):
4218                     if not isinstance(e.cause, compat_HTTPError) or e.cause.code not in (403, 429):
4219                         last_error = error_to_compat_str(e.cause or e.msg)
4220                         if count < retries:
4221                             continue
4222                 if fatal:
4223                     raise
4224                 self.report_warning(error_to_compat_str(e))
4225                 break
4226             else:
4227                 try:
4228                     self._extract_and_report_alerts(data)
4229                 except ExtractorError as e:
4230                     if fatal:
4231                         raise
4232                     self.report_warning(error_to_compat_str(e))
4233                     break
4234
4235                 if dict_get(data, ('contents', 'currentVideoEndpoint')):
4236                     break
4237
4238                 last_error = 'Incomplete yt initial data received'
4239                 if count >= retries:
4240                     if fatal:
4241                         raise ExtractorError(last_error)
4242                     self.report_warning(last_error)
4243                     break
4244
4245         return webpage, data
4246
4247     def _extract_data(self, url, item_id, ytcfg=None, fatal=True, webpage_fatal=False, default_client='web'):
4248         data = None
4249         if 'webpage' not in self._configuration_arg('skip'):
4250             webpage, data = self._extract_webpage(url, item_id, fatal=webpage_fatal)
4251             ytcfg = ytcfg or self.extract_ytcfg(item_id, webpage)
4252         if not data:
4253             if not ytcfg and self.is_authenticated:
4254                 msg = 'Playlists that require authentication may not extract correctly without a successful webpage download.'
4255                 if 'authcheck' not in self._configuration_arg('skip') and fatal:
4256                     raise ExtractorError(
4257                         msg + ' If you are not downloading private content, or your cookies are only for the first account and channel,'
4258                               ' pass "--extractor-args youtubetab:skip=authcheck" to skip this check',
4259                         expected=True)
4260                 self.report_warning(msg, only_once=True)
4261             data = self._extract_tab_endpoint(url, item_id, ytcfg, fatal=fatal, default_client=default_client)
4262         return data, ytcfg
4263
4264     def _extract_tab_endpoint(self, url, item_id, ytcfg=None, fatal=True, default_client='web'):
4265         headers = self.generate_api_headers(ytcfg=ytcfg, default_client=default_client)
4266         resolve_response = self._extract_response(
4267             item_id=item_id, query={'url': url}, check_get_keys='endpoint', headers=headers, ytcfg=ytcfg, fatal=fatal,
4268             ep='navigation/resolve_url', note='Downloading API parameters API JSON', default_client=default_client)
4269         endpoints = {'browseEndpoint': 'browse', 'watchEndpoint': 'next'}
4270         for ep_key, ep in endpoints.items():
4271             params = try_get(resolve_response, lambda x: x['endpoint'][ep_key], dict)
4272             if params:
4273                 return self._extract_response(
4274                     item_id=item_id, query=params, ep=ep, headers=headers,
4275                     ytcfg=ytcfg, fatal=fatal, default_client=default_client,
4276                     check_get_keys=('contents', 'currentVideoEndpoint'))
4277         err_note = 'Failed to resolve url (does the playlist exist?)'
4278         if fatal:
4279             raise ExtractorError(err_note, expected=True)
4280         self.report_warning(err_note, item_id)
4281
4282     _SEARCH_PARAMS = None
4283
4284     def _search_results(self, query, params=NO_DEFAULT, default_client='web'):
4285         data = {'query': query}
4286         if params is NO_DEFAULT:
4287             params = self._SEARCH_PARAMS
4288         if params:
4289             data['params'] = params
4290
4291         content_keys = (
4292             ('contents', 'twoColumnSearchResultsRenderer', 'primaryContents', 'sectionListRenderer', 'contents'),
4293             ('onResponseReceivedCommands', 0, 'appendContinuationItemsAction', 'continuationItems'),
4294             # ytmusic search
4295             ('contents', 'tabbedSearchResultsRenderer', 'tabs', 0, 'tabRenderer', 'content', 'sectionListRenderer', 'contents'),
4296             ('continuationContents', ),
4297         )
4298         check_get_keys = tuple(set(keys[0] for keys in content_keys))
4299
4300         continuation_list = [None]
4301         for page_num in itertools.count(1):
4302             data.update(continuation_list[0] or {})
4303             search = self._extract_response(
4304                 item_id='query "%s" page %s' % (query, page_num), ep='search', query=data,
4305                 default_client=default_client, check_get_keys=check_get_keys)
4306             slr_contents = traverse_obj(search, *content_keys)
4307             yield from self._extract_entries({'contents': list(variadic(slr_contents))}, continuation_list)
4308             if not continuation_list[0]:
4309                 break
4310
4311
4312 class YoutubeTabIE(YoutubeTabBaseInfoExtractor):
4313     IE_DESC = 'YouTube Tabs'
4314     _VALID_URL = r'''(?x:
4315         https?://
4316             (?:\w+\.)?
4317             (?:
4318                 youtube(?:kids)?\.com|
4319                 %(invidious)s
4320             )/
4321             (?:
4322                 (?P<channel_type>channel|c|user|browse)/|
4323                 (?P<not_channel>
4324                     feed/|hashtag/|
4325                     (?:playlist|watch)\?.*?\blist=
4326                 )|
4327                 (?!(?:%(reserved_names)s)\b)  # Direct URLs
4328             )
4329             (?P<id>[^/?\#&]+)
4330     )''' % {
4331         'reserved_names': YoutubeBaseInfoExtractor._RESERVED_NAMES,
4332         'invidious': '|'.join(YoutubeBaseInfoExtractor._INVIDIOUS_SITES),
4333     }
4334     IE_NAME = 'youtube:tab'
4335
4336     _TESTS = [{
4337         'note': 'playlists, multipage',
4338         'url': 'https://www.youtube.com/c/ИгорьКлейнер/playlists?view=1&flow=grid',
4339         'playlist_mincount': 94,
4340         'info_dict': {
4341             'id': 'UCqj7Cz7revf5maW9g5pgNcg',
4342             'title': 'Igor Kleiner - Playlists',
4343             'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
4344             'uploader': 'Igor Kleiner',
4345             'uploader_id': 'UCqj7Cz7revf5maW9g5pgNcg',
4346             'channel': 'Igor Kleiner',
4347             'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
4348             'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
4349             'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
4350             'uploader_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
4351             'channel_follower_count': int
4352         },
4353     }, {
4354         'note': 'playlists, multipage, different order',
4355         'url': 'https://www.youtube.com/user/igorkle1/playlists?view=1&sort=dd',
4356         'playlist_mincount': 94,
4357         'info_dict': {
4358             'id': 'UCqj7Cz7revf5maW9g5pgNcg',
4359             'title': 'Igor Kleiner - Playlists',
4360             'description': 'md5:be97ee0f14ee314f1f002cf187166ee2',
4361             'uploader_id': 'UCqj7Cz7revf5maW9g5pgNcg',
4362             'uploader': 'Igor Kleiner',
4363             'uploader_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
4364             'tags': ['"критическое', 'мышление"', '"наука', 'просто"', 'математика', '"анализ', 'данных"'],
4365             'channel_id': 'UCqj7Cz7revf5maW9g5pgNcg',
4366             'channel': 'Igor Kleiner',
4367             'channel_url': 'https://www.youtube.com/channel/UCqj7Cz7revf5maW9g5pgNcg',
4368             'channel_follower_count': int
4369         },
4370     }, {
4371         'note': 'playlists, series',
4372         'url': 'https://www.youtube.com/c/3blue1brown/playlists?view=50&sort=dd&shelf_id=3',
4373         'playlist_mincount': 5,
4374         'info_dict': {
4375             'id': 'UCYO_jab_esuFRV4b17AJtAw',
4376             'title': '3Blue1Brown - Playlists',
4377             'description': 'md5:e1384e8a133307dd10edee76e875d62f',
4378             'uploader_id': 'UCYO_jab_esuFRV4b17AJtAw',
4379             'uploader': '3Blue1Brown',
4380             'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
4381             'uploader_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
4382             'channel': '3Blue1Brown',
4383             'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
4384             'tags': ['Mathematics'],
4385             'channel_follower_count': int
4386         },
4387     }, {
4388         'note': 'playlists, singlepage',
4389         'url': 'https://www.youtube.com/user/ThirstForScience/playlists',
4390         'playlist_mincount': 4,
4391         'info_dict': {
4392             'id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
4393             'title': 'ThirstForScience - Playlists',
4394             'description': 'md5:609399d937ea957b0f53cbffb747a14c',
4395             'uploader': 'ThirstForScience',
4396             'uploader_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
4397             'uploader_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
4398             'channel_url': 'https://www.youtube.com/channel/UCAEtajcuhQ6an9WEzY9LEMQ',
4399             'channel_id': 'UCAEtajcuhQ6an9WEzY9LEMQ',
4400             'tags': 'count:13',
4401             'channel': 'ThirstForScience',
4402             'channel_follower_count': int
4403         }
4404     }, {
4405         'url': 'https://www.youtube.com/c/ChristophLaimer/playlists',
4406         'only_matching': True,
4407     }, {
4408         'note': 'basic, single video playlist',
4409         'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
4410         'info_dict': {
4411             'uploader_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
4412             'uploader': 'Sergey M.',
4413             'id': 'PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
4414             'title': 'youtube-dl public playlist',
4415             'description': '',
4416             'tags': [],
4417             'view_count': int,
4418             'modified_date': '20201130',
4419             'channel': 'Sergey M.',
4420             'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
4421             'uploader_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4422             'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4423         },
4424         'playlist_count': 1,
4425     }, {
4426         'note': 'empty playlist',
4427         'url': 'https://www.youtube.com/playlist?list=PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
4428         'info_dict': {
4429             'uploader_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
4430             'uploader': 'Sergey M.',
4431             'id': 'PL4lCao7KL_QFodcLWhDpGCYnngnHtQ-Xf',
4432             'title': 'youtube-dl empty playlist',
4433             'tags': [],
4434             'channel': 'Sergey M.',
4435             'description': '',
4436             'modified_date': '20160902',
4437             'channel_id': 'UCmlqkdCBesrv2Lak1mF_MxA',
4438             'channel_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4439             'uploader_url': 'https://www.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4440         },
4441         'playlist_count': 0,
4442     }, {
4443         'note': 'Home tab',
4444         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/featured',
4445         'info_dict': {
4446             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4447             'title': 'lex will - Home',
4448             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4449             'uploader': 'lex will',
4450             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4451             'channel': 'lex will',
4452             'tags': ['bible', 'history', 'prophesy'],
4453             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4454             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4455             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4456             'channel_follower_count': int
4457         },
4458         'playlist_mincount': 2,
4459     }, {
4460         'note': 'Videos tab',
4461         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos',
4462         'info_dict': {
4463             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4464             'title': 'lex will - Videos',
4465             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4466             'uploader': 'lex will',
4467             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4468             'tags': ['bible', 'history', 'prophesy'],
4469             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4470             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4471             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4472             'channel': 'lex will',
4473             'channel_follower_count': int
4474         },
4475         'playlist_mincount': 975,
4476     }, {
4477         'note': 'Videos tab, sorted by popular',
4478         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/videos?view=0&sort=p&flow=grid',
4479         'info_dict': {
4480             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4481             'title': 'lex will - Videos',
4482             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4483             'uploader': 'lex will',
4484             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4485             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4486             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4487             'channel': 'lex will',
4488             'tags': ['bible', 'history', 'prophesy'],
4489             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4490             'channel_follower_count': int
4491         },
4492         'playlist_mincount': 199,
4493     }, {
4494         'note': 'Playlists tab',
4495         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/playlists',
4496         'info_dict': {
4497             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4498             'title': 'lex will - Playlists',
4499             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4500             'uploader': 'lex will',
4501             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4502             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4503             'channel': 'lex will',
4504             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4505             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4506             'tags': ['bible', 'history', 'prophesy'],
4507             'channel_follower_count': int
4508         },
4509         'playlist_mincount': 17,
4510     }, {
4511         'note': 'Community tab',
4512         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/community',
4513         'info_dict': {
4514             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4515             'title': 'lex will - Community',
4516             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4517             'uploader': 'lex will',
4518             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4519             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4520             'channel': 'lex will',
4521             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4522             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4523             'tags': ['bible', 'history', 'prophesy'],
4524             'channel_follower_count': int
4525         },
4526         'playlist_mincount': 18,
4527     }, {
4528         'note': 'Channels tab',
4529         'url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w/channels',
4530         'info_dict': {
4531             'id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4532             'title': 'lex will - Channels',
4533             'description': 'md5:2163c5d0ff54ed5f598d6a7e6211e488',
4534             'uploader': 'lex will',
4535             'uploader_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4536             'uploader_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4537             'channel': 'lex will',
4538             'channel_url': 'https://www.youtube.com/channel/UCKfVa3S1e4PHvxWcwyMMg8w',
4539             'channel_id': 'UCKfVa3S1e4PHvxWcwyMMg8w',
4540             'tags': ['bible', 'history', 'prophesy'],
4541             'channel_follower_count': int
4542         },
4543         'playlist_mincount': 12,
4544     }, {
4545         'note': 'Search tab',
4546         'url': 'https://www.youtube.com/c/3blue1brown/search?query=linear%20algebra',
4547         'playlist_mincount': 40,
4548         'info_dict': {
4549             'id': 'UCYO_jab_esuFRV4b17AJtAw',
4550             'title': '3Blue1Brown - Search - linear algebra',
4551             'description': 'md5:e1384e8a133307dd10edee76e875d62f',
4552             'uploader': '3Blue1Brown',
4553             'uploader_id': 'UCYO_jab_esuFRV4b17AJtAw',
4554             'channel_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
4555             'uploader_url': 'https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw',
4556             'tags': ['Mathematics'],
4557             'channel': '3Blue1Brown',
4558             'channel_id': 'UCYO_jab_esuFRV4b17AJtAw',
4559             'channel_follower_count': int
4560         },
4561     }, {
4562         'url': 'https://invidio.us/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4563         'only_matching': True,
4564     }, {
4565         'url': 'https://www.youtubekids.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4566         'only_matching': True,
4567     }, {
4568         'url': 'https://music.youtube.com/channel/UCmlqkdCBesrv2Lak1mF_MxA',
4569         'only_matching': True,
4570     }, {
4571         'note': 'Playlist with deleted videos (#651). As a bonus, the video #51 is also twice in this list.',
4572         'url': 'https://www.youtube.com/playlist?list=PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
4573         'info_dict': {
4574             'title': '29C3: Not my department',
4575             'id': 'PLwP_SiAcdui0KVebT0mU9Apz359a4ubsC',
4576             'uploader': 'Christiaan008',
4577             'uploader_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
4578             'description': 'md5:a14dc1a8ef8307a9807fe136a0660268',
4579             'tags': [],
4580             'uploader_url': 'https://www.youtube.com/c/ChRiStIaAn008',
4581             'view_count': int,
4582             'modified_date': '20150605',
4583             'channel_id': 'UCEPzS1rYsrkqzSLNp76nrcg',
4584             'channel_url': 'https://www.youtube.com/c/ChRiStIaAn008',
4585             'channel': 'Christiaan008',
4586         },
4587         'playlist_count': 96,
4588     }, {
4589         'note': 'Large playlist',
4590         'url': 'https://www.youtube.com/playlist?list=UUBABnxM4Ar9ten8Mdjj1j0Q',
4591         'info_dict': {
4592             'title': 'Uploads from Cauchemar',
4593             'id': 'UUBABnxM4Ar9ten8Mdjj1j0Q',
4594             'uploader': 'Cauchemar',
4595             'uploader_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
4596             'channel_url': 'https://www.youtube.com/c/Cauchemar89',
4597             'tags': [],
4598             'modified_date': r're:\d{8}',
4599             'channel': 'Cauchemar',
4600             'uploader_url': 'https://www.youtube.com/c/Cauchemar89',
4601             'view_count': int,
4602             'description': '',
4603             'channel_id': 'UCBABnxM4Ar9ten8Mdjj1j0Q',
4604         },
4605         'playlist_mincount': 1123,
4606         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
4607     }, {
4608         'note': 'even larger playlist, 8832 videos',
4609         'url': 'http://www.youtube.com/user/NASAgovVideo/videos',
4610         'only_matching': True,
4611     }, {
4612         'note': 'Buggy playlist: the webpage has a "Load more" button but it doesn\'t have more videos',
4613         'url': 'https://www.youtube.com/playlist?list=UUXw-G3eDE9trcvY2sBMM_aA',
4614         'info_dict': {
4615             'title': 'Uploads from Interstellar Movie',
4616             'id': 'UUXw-G3eDE9trcvY2sBMM_aA',
4617             'uploader': 'Interstellar Movie',
4618             'uploader_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
4619             'uploader_url': 'https://www.youtube.com/c/InterstellarMovie',
4620             'tags': [],
4621             'view_count': int,
4622             'channel_id': 'UCXw-G3eDE9trcvY2sBMM_aA',
4623             'channel_url': 'https://www.youtube.com/c/InterstellarMovie',
4624             'channel': 'Interstellar Movie',
4625             'description': '',
4626             'modified_date': r're:\d{8}',
4627         },
4628         'playlist_mincount': 21,
4629     }, {
4630         'note': 'Playlist with "show unavailable videos" button',
4631         'url': 'https://www.youtube.com/playlist?list=UUTYLiWFZy8xtPwxFwX9rV7Q',
4632         'info_dict': {
4633             'title': 'Uploads from Phim Siêu Nhân Nhật Bản',
4634             'id': 'UUTYLiWFZy8xtPwxFwX9rV7Q',
4635             'uploader': 'Phim Siêu Nhân Nhật Bản',
4636             'uploader_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
4637             'view_count': int,
4638             'channel': 'Phim Siêu Nhân Nhật Bản',
4639             'tags': [],
4640             'uploader_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
4641             'description': '',
4642             'channel_url': 'https://www.youtube.com/channel/UCTYLiWFZy8xtPwxFwX9rV7Q',
4643             'channel_id': 'UCTYLiWFZy8xtPwxFwX9rV7Q',
4644             'modified_date': r're:\d{8}',
4645         },
4646         'playlist_mincount': 200,
4647         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
4648     }, {
4649         'note': 'Playlist with unavailable videos in page 7',
4650         'url': 'https://www.youtube.com/playlist?list=UU8l9frL61Yl5KFOl87nIm2w',
4651         'info_dict': {
4652             'title': 'Uploads from BlankTV',
4653             'id': 'UU8l9frL61Yl5KFOl87nIm2w',
4654             'uploader': 'BlankTV',
4655             'uploader_id': 'UC8l9frL61Yl5KFOl87nIm2w',
4656             'channel': 'BlankTV',
4657             'channel_url': 'https://www.youtube.com/c/blanktv',
4658             'channel_id': 'UC8l9frL61Yl5KFOl87nIm2w',
4659             'view_count': int,
4660             'tags': [],
4661             'uploader_url': 'https://www.youtube.com/c/blanktv',
4662             'modified_date': r're:\d{8}',
4663             'description': '',
4664         },
4665         'playlist_mincount': 1000,
4666         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
4667     }, {
4668         'note': 'https://github.com/ytdl-org/youtube-dl/issues/21844',
4669         'url': 'https://www.youtube.com/playlist?list=PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
4670         'info_dict': {
4671             'title': 'Data Analysis with Dr Mike Pound',
4672             'id': 'PLzH6n4zXuckpfMu_4Ff8E7Z1behQks5ba',
4673             'uploader_id': 'UC9-y-6csu5WGm29I7JiwpnA',
4674             'uploader': 'Computerphile',
4675             'description': 'md5:7f567c574d13d3f8c0954d9ffee4e487',
4676             'uploader_url': 'https://www.youtube.com/user/Computerphile',
4677             'tags': [],
4678             'view_count': int,
4679             'channel_id': 'UC9-y-6csu5WGm29I7JiwpnA',
4680             'channel_url': 'https://www.youtube.com/user/Computerphile',
4681             'channel': 'Computerphile',
4682         },
4683         'playlist_mincount': 11,
4684     }, {
4685         'url': 'https://invidio.us/playlist?list=PL4lCao7KL_QFVb7Iudeipvc2BCavECqzc',
4686         'only_matching': True,
4687     }, {
4688         'note': 'Playlist URL that does not actually serve a playlist',
4689         'url': 'https://www.youtube.com/watch?v=FqZTN594JQw&list=PLMYEtVRpaqY00V9W81Cwmzp6N6vZqfUKD4',
4690         'info_dict': {
4691             'id': 'FqZTN594JQw',
4692             'ext': 'webm',
4693             'title': "Smiley's People 01 detective, Adventure Series, Action",
4694             'uploader': 'STREEM',
4695             'uploader_id': 'UCyPhqAZgwYWZfxElWVbVJng',
4696             'uploader_url': r're:https?://(?:www\.)?youtube\.com/channel/UCyPhqAZgwYWZfxElWVbVJng',
4697             'upload_date': '20150526',
4698             'license': 'Standard YouTube License',
4699             'description': 'md5:507cdcb5a49ac0da37a920ece610be80',
4700             'categories': ['People & Blogs'],
4701             'tags': list,
4702             'view_count': int,
4703             'like_count': int,
4704         },
4705         'params': {
4706             'skip_download': True,
4707         },
4708         'skip': 'This video is not available.',
4709         'add_ie': [YoutubeIE.ie_key()],
4710     }, {
4711         'url': 'https://www.youtubekids.com/watch?v=Agk7R8I8o5U&list=PUZ6jURNr1WQZCNHF0ao-c0g',
4712         'only_matching': True,
4713     }, {
4714         'url': 'https://www.youtube.com/watch?v=MuAGGZNfUkU&list=RDMM',
4715         'only_matching': True,
4716     }, {
4717         'url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ/live',
4718         'info_dict': {
4719             'id': 'GgL890LIznQ',  # This will keep changing
4720             'ext': 'mp4',
4721             'title': str,
4722             'uploader': 'Sky News',
4723             'uploader_id': 'skynews',
4724             'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/skynews',
4725             'upload_date': r're:\d{8}',
4726             'description': str,
4727             'categories': ['News & Politics'],
4728             'tags': list,
4729             'like_count': int,
4730             'release_timestamp': 1642502819,
4731             'channel': 'Sky News',
4732             'channel_id': 'UCoMdktPbSTixAyNGwb-UYkQ',
4733             'age_limit': 0,
4734             'view_count': int,
4735             'thumbnail': 'https://i.ytimg.com/vi/GgL890LIznQ/maxresdefault_live.jpg',
4736             'playable_in_embed': True,
4737             'release_date': '20220118',
4738             'availability': 'public',
4739             'live_status': 'is_live',
4740             'channel_url': 'https://www.youtube.com/channel/UCoMdktPbSTixAyNGwb-UYkQ',
4741             'channel_follower_count': int
4742         },
4743         'params': {
4744             'skip_download': True,
4745         },
4746         'expected_warnings': ['Ignoring subtitle tracks found in '],
4747     }, {
4748         'url': 'https://www.youtube.com/user/TheYoungTurks/live',
4749         'info_dict': {
4750             'id': 'a48o2S1cPoo',
4751             'ext': 'mp4',
4752             'title': 'The Young Turks - Live Main Show',
4753             'uploader': 'The Young Turks',
4754             'uploader_id': 'TheYoungTurks',
4755             'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/TheYoungTurks',
4756             'upload_date': '20150715',
4757             'license': 'Standard YouTube License',
4758             'description': 'md5:438179573adcdff3c97ebb1ee632b891',
4759             'categories': ['News & Politics'],
4760             'tags': ['Cenk Uygur (TV Program Creator)', 'The Young Turks (Award-Winning Work)', 'Talk Show (TV Genre)'],
4761             'like_count': int,
4762         },
4763         'params': {
4764             'skip_download': True,
4765         },
4766         'only_matching': True,
4767     }, {
4768         'url': 'https://www.youtube.com/channel/UC1yBKRuGpC1tSM73A0ZjYjQ/live',
4769         'only_matching': True,
4770     }, {
4771         'url': 'https://www.youtube.com/c/CommanderVideoHq/live',
4772         'only_matching': True,
4773     }, {
4774         'note': 'A channel that is not live. Should raise error',
4775         'url': 'https://www.youtube.com/user/numberphile/live',
4776         'only_matching': True,
4777     }, {
4778         'url': 'https://www.youtube.com/feed/trending',
4779         'only_matching': True,
4780     }, {
4781         'url': 'https://www.youtube.com/feed/library',
4782         'only_matching': True,
4783     }, {
4784         'url': 'https://www.youtube.com/feed/history',
4785         'only_matching': True,
4786     }, {
4787         'url': 'https://www.youtube.com/feed/subscriptions',
4788         'only_matching': True,
4789     }, {
4790         'url': 'https://www.youtube.com/feed/watch_later',
4791         'only_matching': True,
4792     }, {
4793         'note': 'Recommended - redirects to home page.',
4794         'url': 'https://www.youtube.com/feed/recommended',
4795         'only_matching': True,
4796     }, {
4797         'note': 'inline playlist with not always working continuations',
4798         'url': 'https://www.youtube.com/watch?v=UC6u0Tct-Fo&list=PL36D642111D65BE7C',
4799         'only_matching': True,
4800     }, {
4801         'url': 'https://www.youtube.com/course',
4802         'only_matching': True,
4803     }, {
4804         'url': 'https://www.youtube.com/zsecurity',
4805         'only_matching': True,
4806     }, {
4807         'url': 'http://www.youtube.com/NASAgovVideo/videos',
4808         'only_matching': True,
4809     }, {
4810         'url': 'https://www.youtube.com/TheYoungTurks/live',
4811         'only_matching': True,
4812     }, {
4813         'url': 'https://www.youtube.com/hashtag/cctv9',
4814         'info_dict': {
4815             'id': 'cctv9',
4816             'title': '#cctv9',
4817             'tags': [],
4818         },
4819         'playlist_mincount': 350,
4820     }, {
4821         'url': 'https://www.youtube.com/watch?list=PLW4dVinRY435CBE_JD3t-0SRXKfnZHS1P&feature=youtu.be&v=M9cJMXmQ_ZU',
4822         'only_matching': True,
4823     }, {
4824         'note': 'Requires Premium: should request additional YTM-info webpage (and have format 141) for videos in playlist',
4825         'url': 'https://music.youtube.com/playlist?list=PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
4826         'only_matching': True
4827     }, {
4828         'note': '/browse/ should redirect to /channel/',
4829         'url': 'https://music.youtube.com/browse/UC1a8OFewdjuLq6KlF8M_8Ng',
4830         'only_matching': True
4831     }, {
4832         'note': 'VLPL, should redirect to playlist?list=PL...',
4833         'url': 'https://music.youtube.com/browse/VLPLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
4834         'info_dict': {
4835             'id': 'PLRBp0Fe2GpgmgoscNFLxNyBVSFVdYmFkq',
4836             'uploader': 'NoCopyrightSounds',
4837             'description': 'Providing you with copyright free / safe music for gaming, live streaming, studying and more!',
4838             'uploader_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
4839             'title': 'NCS Releases',
4840             'uploader_url': 'https://www.youtube.com/c/NoCopyrightSounds',
4841             'channel_url': 'https://www.youtube.com/c/NoCopyrightSounds',
4842             'modified_date': r're:\d{8}',
4843             'view_count': int,
4844             'channel_id': 'UC_aEa8K-EOJ3D6gOs7HcyNg',
4845             'tags': [],
4846             'channel': 'NoCopyrightSounds',
4847         },
4848         'playlist_mincount': 166,
4849         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
4850     }, {
4851         'note': 'Topic, should redirect to playlist?list=UU...',
4852         'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
4853         'info_dict': {
4854             'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
4855             'uploader_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
4856             'title': 'Uploads from Royalty Free Music - Topic',
4857             'uploader': 'Royalty Free Music - Topic',
4858             'tags': [],
4859             'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
4860             'channel': 'Royalty Free Music - Topic',
4861             'view_count': int,
4862             'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
4863             'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
4864             'modified_date': r're:\d{8}',
4865             'uploader_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
4866             'description': '',
4867         },
4868         'expected_warnings': [
4869             'The URL does not have a videos tab',
4870             r'[Uu]navailable videos (are|will be) hidden',
4871         ],
4872         'playlist_mincount': 101,
4873     }, {
4874         'note': 'Topic without a UU playlist',
4875         'url': 'https://www.youtube.com/channel/UCtFRv9O2AHqOZjjynzrv-xg',
4876         'info_dict': {
4877             'id': 'UCtFRv9O2AHqOZjjynzrv-xg',
4878             'title': 'UCtFRv9O2AHqOZjjynzrv-xg',
4879             'tags': [],
4880         },
4881         'expected_warnings': [
4882             'the playlist redirect gave error',
4883         ],
4884         'playlist_mincount': 9,
4885     }, {
4886         'note': 'Youtube music Album',
4887         'url': 'https://music.youtube.com/browse/MPREb_gTAcphH99wE',
4888         'info_dict': {
4889             'id': 'OLAK5uy_l1m0thk3g31NmIIz_vMIbWtyv7eZixlH0',
4890             'title': 'Album - Royalty Free Music Library V2 (50 Songs)',
4891             'tags': [],
4892             'view_count': int,
4893             'description': '',
4894             'availability': 'unlisted',
4895             'modified_date': r're:\d{8}',
4896         },
4897         'playlist_count': 50,
4898     }, {
4899         'note': 'unlisted single video playlist',
4900         'url': 'https://www.youtube.com/playlist?list=PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
4901         'info_dict': {
4902             'uploader_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
4903             'uploader': 'colethedj',
4904             'id': 'PLwL24UFy54GrB3s2KMMfjZscDi1x5Dajf',
4905             'title': 'yt-dlp unlisted playlist test',
4906             'availability': 'unlisted',
4907             'tags': [],
4908             'modified_date': '20211208',
4909             'channel': 'colethedj',
4910             'view_count': int,
4911             'description': '',
4912             'uploader_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
4913             'channel_id': 'UC9zHu_mHU96r19o-wV5Qs1Q',
4914             'channel_url': 'https://www.youtube.com/channel/UC9zHu_mHU96r19o-wV5Qs1Q',
4915         },
4916         'playlist_count': 1,
4917     }, {
4918         'note': 'API Fallback: Recommended - redirects to home page. Requires visitorData',
4919         'url': 'https://www.youtube.com/feed/recommended',
4920         'info_dict': {
4921             'id': 'recommended',
4922             'title': 'recommended',
4923             'tags': [],
4924         },
4925         'playlist_mincount': 50,
4926         'params': {
4927             'skip_download': True,
4928             'extractor_args': {'youtubetab': {'skip': ['webpage']}}
4929         },
4930     }, {
4931         'note': 'API Fallback: /videos tab, sorted by oldest first',
4932         'url': 'https://www.youtube.com/user/theCodyReeder/videos?view=0&sort=da&flow=grid',
4933         'info_dict': {
4934             'id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
4935             'title': 'Cody\'sLab - Videos',
4936             'description': 'md5:d083b7c2f0c67ee7a6c74c3e9b4243fa',
4937             'uploader': 'Cody\'sLab',
4938             'uploader_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
4939             'channel': 'Cody\'sLab',
4940             'channel_id': 'UCu6mSoMNzHQiBIOCkHUa2Aw',
4941             'tags': [],
4942             'channel_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
4943             'uploader_url': 'https://www.youtube.com/channel/UCu6mSoMNzHQiBIOCkHUa2Aw',
4944             'channel_follower_count': int
4945         },
4946         'playlist_mincount': 650,
4947         'params': {
4948             'skip_download': True,
4949             'extractor_args': {'youtubetab': {'skip': ['webpage']}}
4950         },
4951     }, {
4952         'note': 'API Fallback: Topic, should redirect to playlist?list=UU...',
4953         'url': 'https://music.youtube.com/browse/UC9ALqqC4aIeG5iDs7i90Bfw',
4954         'info_dict': {
4955             'id': 'UU9ALqqC4aIeG5iDs7i90Bfw',
4956             'uploader_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
4957             'title': 'Uploads from Royalty Free Music - Topic',
4958             'uploader': 'Royalty Free Music - Topic',
4959             'modified_date': r're:\d{8}',
4960             'channel_id': 'UC9ALqqC4aIeG5iDs7i90Bfw',
4961             'description': '',
4962             'channel_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
4963             'tags': [],
4964             'channel': 'Royalty Free Music - Topic',
4965             'view_count': int,
4966             'uploader_url': 'https://www.youtube.com/channel/UC9ALqqC4aIeG5iDs7i90Bfw',
4967         },
4968         'expected_warnings': [
4969             'does not have a videos tab',
4970             r'[Uu]navailable videos (are|will be) hidden',
4971         ],
4972         'playlist_mincount': 101,
4973         'params': {
4974             'skip_download': True,
4975             'extractor_args': {'youtubetab': {'skip': ['webpage']}}
4976         },
4977     }]
4978
4979     @classmethod
4980     def suitable(cls, url):
4981         return False if YoutubeIE.suitable(url) else super(
4982             YoutubeTabIE, cls).suitable(url)
4983
4984     _URL_RE = re.compile(rf'(?P<pre>{_VALID_URL})(?(not_channel)|(?P<tab>/\w+))?(?P<post>.*)$')
4985
4986     @YoutubeTabBaseInfoExtractor.passthrough_smuggled_data
4987     def _real_extract(self, url, smuggled_data):
4988         item_id = self._match_id(url)
4989         url = compat_urlparse.urlunparse(
4990             compat_urlparse.urlparse(url)._replace(netloc='www.youtube.com'))
4991         compat_opts = self.get_param('compat_opts', [])
4992
4993         def get_mobj(url):
4994             mobj = self._URL_RE.match(url).groupdict()
4995             mobj.update((k, '') for k, v in mobj.items() if v is None)
4996             return mobj
4997
4998         mobj, redirect_warning = get_mobj(url), None
4999         # Youtube returns incomplete data if tabname is not lower case
5000         pre, tab, post, is_channel = mobj['pre'], mobj['tab'].lower(), mobj['post'], not mobj['not_channel']
5001         if is_channel:
5002             if smuggled_data.get('is_music_url'):
5003                 if item_id[:2] == 'VL':  # Youtube music VL channels have an equivalent playlist
5004                     item_id = item_id[2:]
5005                     pre, tab, post, is_channel = f'https://www.youtube.com/playlist?list={item_id}', '', '', False
5006                 elif item_id[:2] == 'MP':  # Resolve albums (/[channel/browse]/MP...) to their equivalent playlist
5007                     mdata = self._extract_tab_endpoint(
5008                         f'https://music.youtube.com/channel/{item_id}', item_id, default_client='web_music')
5009                     murl = traverse_obj(mdata, ('microformat', 'microformatDataRenderer', 'urlCanonical'),
5010                                         get_all=False, expected_type=compat_str)
5011                     if not murl:
5012                         raise ExtractorError('Failed to resolve album to playlist')
5013                     return self.url_result(murl, ie=YoutubeTabIE.ie_key())
5014                 elif mobj['channel_type'] == 'browse':  # Youtube music /browse/ should be changed to /channel/
5015                     pre = f'https://www.youtube.com/channel/{item_id}'
5016
5017         original_tab_name = tab
5018         if is_channel and not tab and 'no-youtube-channel-redirect' not in compat_opts:
5019             # Home URLs should redirect to /videos/
5020             redirect_warning = ('A channel/user page was given. All the channel\'s videos will be downloaded. '
5021                                 'To download only the videos in the home page, add a "/featured" to the URL')
5022             tab = '/videos'
5023
5024         url = ''.join((pre, tab, post))
5025         mobj = get_mobj(url)
5026
5027         # Handle both video/playlist URLs
5028         qs = parse_qs(url)
5029         video_id, playlist_id = [qs.get(key, [None])[0] for key in ('v', 'list')]
5030
5031         if not video_id and mobj['not_channel'].startswith('watch'):
5032             if not playlist_id:
5033                 # If there is neither video or playlist ids, youtube redirects to home page, which is undesirable
5034                 raise ExtractorError('Unable to recognize tab page')
5035             # Common mistake: https://www.youtube.com/watch?list=playlist_id
5036             self.report_warning(f'A video URL was given without video ID. Trying to download playlist {playlist_id}')
5037             url = f'https://www.youtube.com/playlist?list={playlist_id}'
5038             mobj = get_mobj(url)
5039
5040         if video_id and playlist_id:
5041             if self.get_param('noplaylist'):
5042                 self.to_screen(f'Downloading just video {video_id} because of --no-playlist')
5043                 return self.url_result(f'https://www.youtube.com/watch?v={video_id}',
5044                                        ie=YoutubeIE.ie_key(), video_id=video_id)
5045             self.to_screen(f'Downloading playlist {playlist_id}; add --no-playlist to just download video {video_id}')
5046
5047         data, ytcfg = self._extract_data(url, item_id)
5048
5049         tabs = traverse_obj(data, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs'), expected_type=list)
5050         if tabs:
5051             selected_tab = self._extract_selected_tab(tabs)
5052             selected_tab_name = selected_tab.get('title', '').lower()
5053             if selected_tab_name == 'home':
5054                 selected_tab_name = 'featured'
5055             requested_tab_name = mobj['tab'][1:]
5056             if 'no-youtube-channel-redirect' not in compat_opts:
5057                 if requested_tab_name == 'live':
5058                     # Live tab should have redirected to the video
5059                     raise ExtractorError('The channel is not currently live', expected=True)
5060                 if requested_tab_name not in ('', selected_tab_name):
5061                     redirect_warning = f'The channel does not have a {requested_tab_name} tab'
5062                     if not original_tab_name:
5063                         if item_id[:2] == 'UC':
5064                             # Topic channels don't have /videos. Use the equivalent playlist instead
5065                             pl_id = f'UU{item_id[2:]}'
5066                             pl_url = f'https://www.youtube.com/playlist?list={pl_id}'
5067                             try:
5068                                 data, ytcfg = self._extract_data(pl_url, pl_id, ytcfg=ytcfg, fatal=True, webpage_fatal=True)
5069                             except ExtractorError:
5070                                 redirect_warning += ' and the playlist redirect gave error'
5071                             else:
5072                                 item_id, url, selected_tab_name = pl_id, pl_url, requested_tab_name
5073                                 redirect_warning += f'. Redirecting to playlist {pl_id} instead'
5074                         if selected_tab_name and selected_tab_name != requested_tab_name:
5075                             redirect_warning += f'. {selected_tab_name} tab is being downloaded instead'
5076                     else:
5077                         raise ExtractorError(redirect_warning, expected=True)
5078
5079         if redirect_warning:
5080             self.to_screen(redirect_warning)
5081         self.write_debug(f'Final URL: {url}')
5082
5083         # YouTube sometimes provides a button to reload playlist with unavailable videos.
5084         if 'no-youtube-unavailable-videos' not in compat_opts:
5085             data = self._reload_with_unavailable_videos(item_id, data, ytcfg) or data
5086         self._extract_and_report_alerts(data, only_once=True)
5087         tabs = traverse_obj(data, ('contents', 'twoColumnBrowseResultsRenderer', 'tabs'), expected_type=list)
5088         if tabs:
5089             return self._extract_from_tabs(item_id, ytcfg, data, tabs)
5090
5091         playlist = traverse_obj(
5092             data, ('contents', 'twoColumnWatchNextResults', 'playlist', 'playlist'), expected_type=dict)
5093         if playlist:
5094             return self._extract_from_playlist(item_id, url, data, playlist, ytcfg)
5095
5096         video_id = traverse_obj(
5097             data, ('currentVideoEndpoint', 'watchEndpoint', 'videoId'), expected_type=str) or video_id
5098         if video_id:
5099             if mobj['tab'] != '/live':  # live tab is expected to redirect to video
5100                 self.report_warning(f'Unable to recognize playlist. Downloading just video {video_id}')
5101             return self.url_result(f'https://www.youtube.com/watch?v={video_id}',
5102                                    ie=YoutubeIE.ie_key(), video_id=video_id)
5103
5104         raise ExtractorError('Unable to recognize tab page')
5105
5106
5107 class YoutubePlaylistIE(InfoExtractor):
5108     IE_DESC = 'YouTube playlists'
5109     _VALID_URL = r'''(?x)(?:
5110                         (?:https?://)?
5111                         (?:\w+\.)?
5112                         (?:
5113                             (?:
5114                                 youtube(?:kids)?\.com|
5115                                 %(invidious)s
5116                             )
5117                             /.*?\?.*?\blist=
5118                         )?
5119                         (?P<id>%(playlist_id)s)
5120                      )''' % {
5121         'playlist_id': YoutubeBaseInfoExtractor._PLAYLIST_ID_RE,
5122         'invidious': '|'.join(YoutubeBaseInfoExtractor._INVIDIOUS_SITES),
5123     }
5124     IE_NAME = 'youtube:playlist'
5125     _TESTS = [{
5126         'note': 'issue #673',
5127         'url': 'PLBB231211A4F62143',
5128         'info_dict': {
5129             'title': '[OLD]Team Fortress 2 (Class-based LP)',
5130             'id': 'PLBB231211A4F62143',
5131             'uploader': 'Wickman',
5132             'uploader_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
5133             'description': 'md5:8fa6f52abb47a9552002fa3ddfc57fc2',
5134             'view_count': int,
5135             'uploader_url': 'https://www.youtube.com/user/Wickydoo',
5136             'modified_date': r're:\d{8}',
5137             'channel_id': 'UCKSpbfbl5kRQpTdL7kMc-1Q',
5138             'channel': 'Wickman',
5139             'tags': [],
5140             'channel_url': 'https://www.youtube.com/user/Wickydoo',
5141         },
5142         'playlist_mincount': 29,
5143     }, {
5144         'url': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
5145         'info_dict': {
5146             'title': 'YDL_safe_search',
5147             'id': 'PLtPgu7CB4gbY9oDN3drwC3cMbJggS7dKl',
5148         },
5149         'playlist_count': 2,
5150         'skip': 'This playlist is private',
5151     }, {
5152         'note': 'embedded',
5153         'url': 'https://www.youtube.com/embed/videoseries?list=PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
5154         'playlist_count': 4,
5155         'info_dict': {
5156             'title': 'JODA15',
5157             'id': 'PL6IaIsEjSbf96XFRuNccS_RuEXwNdsoEu',
5158             'uploader': 'milan',
5159             'uploader_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
5160             'description': '',
5161             'channel_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
5162             'tags': [],
5163             'modified_date': '20140919',
5164             'view_count': int,
5165             'channel': 'milan',
5166             'channel_id': 'UCEI1-PVPcYXjB73Hfelbmaw',
5167             'uploader_url': 'https://www.youtube.com/channel/UCEI1-PVPcYXjB73Hfelbmaw',
5168         },
5169         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
5170     }, {
5171         'url': 'http://www.youtube.com/embed/_xDOZElKyNU?list=PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
5172         'playlist_mincount': 654,
5173         'info_dict': {
5174             'title': '2018 Chinese New Singles (11/6 updated)',
5175             'id': 'PLsyOSbh5bs16vubvKePAQ1x3PhKavfBIl',
5176             'uploader': 'LBK',
5177             'uploader_id': 'UC21nz3_MesPLqtDqwdvnoxA',
5178             'description': 'md5:da521864744d60a198e3a88af4db0d9d',
5179             'channel': 'LBK',
5180             'view_count': int,
5181             'channel_url': 'https://www.youtube.com/c/愛低音的國王',
5182             'tags': [],
5183             'uploader_url': 'https://www.youtube.com/c/愛低音的國王',
5184             'channel_id': 'UC21nz3_MesPLqtDqwdvnoxA',
5185             'modified_date': r're:\d{8}',
5186         },
5187         'expected_warnings': [r'[Uu]navailable videos (are|will be) hidden'],
5188     }, {
5189         'url': 'TLGGrESM50VT6acwMjAyMjAxNw',
5190         'only_matching': True,
5191     }, {
5192         # music album playlist
5193         'url': 'OLAK5uy_m4xAFdmMC5rX3Ji3g93pQe3hqLZw_9LhM',
5194         'only_matching': True,
5195     }]
5196
5197     @classmethod
5198     def suitable(cls, url):
5199         if YoutubeTabIE.suitable(url):
5200             return False
5201         from ..utils import parse_qs
5202         qs = parse_qs(url)
5203         if qs.get('v', [None])[0]:
5204             return False
5205         return super(YoutubePlaylistIE, cls).suitable(url)
5206
5207     def _real_extract(self, url):
5208         playlist_id = self._match_id(url)
5209         is_music_url = YoutubeBaseInfoExtractor.is_music_url(url)
5210         url = update_url_query(
5211             'https://www.youtube.com/playlist',
5212             parse_qs(url) or {'list': playlist_id})
5213         if is_music_url:
5214             url = smuggle_url(url, {'is_music_url': True})
5215         return self.url_result(url, ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
5216
5217
5218 class YoutubeYtBeIE(InfoExtractor):
5219     IE_DESC = 'youtu.be'
5220     _VALID_URL = r'https?://youtu\.be/(?P<id>[0-9A-Za-z_-]{11})/*?.*?\blist=(?P<playlist_id>%(playlist_id)s)' % {'playlist_id': YoutubeBaseInfoExtractor._PLAYLIST_ID_RE}
5221     _TESTS = [{
5222         'url': 'https://youtu.be/yeWKywCrFtk?list=PL2qgrgXsNUG5ig9cat4ohreBjYLAPC0J5',
5223         'info_dict': {
5224             'id': 'yeWKywCrFtk',
5225             'ext': 'mp4',
5226             'title': 'Small Scale Baler and Braiding Rugs',
5227             'uploader': 'Backus-Page House Museum',
5228             'uploader_id': 'backuspagemuseum',
5229             'uploader_url': r're:https?://(?:www\.)?youtube\.com/user/backuspagemuseum',
5230             'upload_date': '20161008',
5231             'description': 'md5:800c0c78d5eb128500bffd4f0b4f2e8a',
5232             'categories': ['Nonprofits & Activism'],
5233             'tags': list,
5234             'like_count': int,
5235             'age_limit': 0,
5236             'playable_in_embed': True,
5237             'thumbnail': 'https://i.ytimg.com/vi_webp/yeWKywCrFtk/maxresdefault.webp',
5238             'channel': 'Backus-Page House Museum',
5239             'channel_id': 'UCEfMCQ9bs3tjvjy1s451zaw',
5240             'live_status': 'not_live',
5241             'view_count': int,
5242             'channel_url': 'https://www.youtube.com/channel/UCEfMCQ9bs3tjvjy1s451zaw',
5243             'availability': 'public',
5244             'duration': 59,
5245         },
5246         'params': {
5247             'noplaylist': True,
5248             'skip_download': True,
5249         },
5250     }, {
5251         'url': 'https://youtu.be/uWyaPkt-VOI?list=PL9D9FC436B881BA21',
5252         'only_matching': True,
5253     }]
5254
5255     def _real_extract(self, url):
5256         mobj = self._match_valid_url(url)
5257         video_id = mobj.group('id')
5258         playlist_id = mobj.group('playlist_id')
5259         return self.url_result(
5260             update_url_query('https://www.youtube.com/watch', {
5261                 'v': video_id,
5262                 'list': playlist_id,
5263                 'feature': 'youtu.be',
5264             }), ie=YoutubeTabIE.ie_key(), video_id=playlist_id)
5265
5266
5267 class YoutubeLivestreamEmbedIE(InfoExtractor):
5268     IE_DESC = 'YouTube livestream embeds'
5269     _VALID_URL = r'https?://(?:\w+\.)?youtube\.com/embed/live_stream/?\?(?:[^#]+&)?channel=(?P<id>[^&#]+)'
5270     _TESTS = [{
5271         'url': 'https://www.youtube.com/embed/live_stream?channel=UC2_KI6RB__jGdlnK6dvFEZA',
5272         'only_matching': True,
5273     }]
5274
5275     def _real_extract(self, url):
5276         channel_id = self._match_id(url)
5277         return self.url_result(
5278             f'https://www.youtube.com/channel/{channel_id}/live',
5279             ie=YoutubeTabIE.ie_key(), video_id=channel_id)
5280
5281
5282 class YoutubeYtUserIE(InfoExtractor):
5283     IE_DESC = 'YouTube user videos; "ytuser:" prefix'
5284     IE_NAME = 'youtube:user'
5285     _VALID_URL = r'ytuser:(?P<id>.+)'
5286     _TESTS = [{
5287         'url': 'ytuser:phihag',
5288         'only_matching': True,
5289     }]
5290
5291     def _real_extract(self, url):
5292         user_id = self._match_id(url)
5293         return self.url_result(
5294             'https://www.youtube.com/user/%s/videos' % user_id,
5295             ie=YoutubeTabIE.ie_key(), video_id=user_id)
5296
5297
5298 class YoutubeFavouritesIE(YoutubeBaseInfoExtractor):
5299     IE_NAME = 'youtube:favorites'
5300     IE_DESC = 'YouTube liked videos; ":ytfav" keyword (requires cookies)'
5301     _VALID_URL = r':ytfav(?:ou?rite)?s?'
5302     _LOGIN_REQUIRED = True
5303     _TESTS = [{
5304         'url': ':ytfav',
5305         'only_matching': True,
5306     }, {
5307         'url': ':ytfavorites',
5308         'only_matching': True,
5309     }]
5310
5311     def _real_extract(self, url):
5312         return self.url_result(
5313             'https://www.youtube.com/playlist?list=LL',
5314             ie=YoutubeTabIE.ie_key())
5315
5316
5317 class YoutubeSearchIE(YoutubeTabBaseInfoExtractor, SearchInfoExtractor):
5318     IE_DESC = 'YouTube search'
5319     IE_NAME = 'youtube:search'
5320     _SEARCH_KEY = 'ytsearch'
5321     _SEARCH_PARAMS = 'EgIQAQ%3D%3D'  # Videos only
5322     _TESTS = [{
5323         'url': 'ytsearch5:youtube-dl test video',
5324         'playlist_count': 5,
5325         'info_dict': {
5326             'id': 'youtube-dl test video',
5327             'title': 'youtube-dl test video',
5328         }
5329     }]
5330
5331
5332 class YoutubeSearchDateIE(YoutubeTabBaseInfoExtractor, SearchInfoExtractor):
5333     IE_NAME = YoutubeSearchIE.IE_NAME + ':date'
5334     _SEARCH_KEY = 'ytsearchdate'
5335     IE_DESC = 'YouTube search, newest videos first'
5336     _SEARCH_PARAMS = 'CAISAhAB'  # Videos only, sorted by date
5337     _TESTS = [{
5338         'url': 'ytsearchdate5:youtube-dl test video',
5339         'playlist_count': 5,
5340         'info_dict': {
5341             'id': 'youtube-dl test video',
5342             'title': 'youtube-dl test video',
5343         }
5344     }]
5345
5346
5347 class YoutubeSearchURLIE(YoutubeTabBaseInfoExtractor):
5348     IE_DESC = 'YouTube search URLs with sorting and filter support'
5349     IE_NAME = YoutubeSearchIE.IE_NAME + '_url'
5350     _VALID_URL = r'https?://(?:www\.)?youtube\.com/(?:results|search)\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
5351     _TESTS = [{
5352         'url': 'https://www.youtube.com/results?baz=bar&search_query=youtube-dl+test+video&filters=video&lclk=video',
5353         'playlist_mincount': 5,
5354         'info_dict': {
5355             'id': 'youtube-dl test video',
5356             'title': 'youtube-dl test video',
5357         }
5358     }, {
5359         'url': 'https://www.youtube.com/results?search_query=python&sp=EgIQAg%253D%253D',
5360         'playlist_mincount': 5,
5361         'info_dict': {
5362             'id': 'python',
5363             'title': 'python',
5364         }
5365
5366     }, {
5367         'url': 'https://www.youtube.com/results?q=test&sp=EgQIBBgB',
5368         'only_matching': True,
5369     }]
5370
5371     def _real_extract(self, url):
5372         qs = parse_qs(url)
5373         query = (qs.get('search_query') or qs.get('q'))[0]
5374         return self.playlist_result(self._search_results(query, qs.get('sp', (None,))[0]), query, query)
5375
5376
5377 class YoutubeMusicSearchURLIE(YoutubeTabBaseInfoExtractor):
5378     IE_DESC = 'YouTube music search URLs with selectable sections (Eg: #songs)'
5379     IE_NAME = 'youtube:music:search_url'
5380     _VALID_URL = r'https?://music\.youtube\.com/search\?([^#]+&)?(?:search_query|q)=(?:[^&]+)(?:[&#]|$)'
5381     _TESTS = [{
5382         'url': 'https://music.youtube.com/search?q=royalty+free+music',
5383         'playlist_count': 16,
5384         'info_dict': {
5385             'id': 'royalty free music',
5386             'title': 'royalty free music',
5387         }
5388     }, {
5389         'url': 'https://music.youtube.com/search?q=royalty+free+music&sp=EgWKAQIIAWoKEAoQAxAEEAkQBQ%3D%3D',
5390         'playlist_mincount': 30,
5391         'info_dict': {
5392             'id': 'royalty free music - songs',
5393             'title': 'royalty free music - songs',
5394         },
5395         'params': {'extract_flat': 'in_playlist'}
5396     }, {
5397         'url': 'https://music.youtube.com/search?q=royalty+free+music#community+playlists',
5398         'playlist_mincount': 30,
5399         'info_dict': {
5400             'id': 'royalty free music - community playlists',
5401             'title': 'royalty free music - community playlists',
5402         },
5403         'params': {'extract_flat': 'in_playlist'}
5404     }]
5405
5406     _SECTIONS = {
5407         'albums': 'EgWKAQIYAWoKEAoQAxAEEAkQBQ==',
5408         'artists': 'EgWKAQIgAWoKEAoQAxAEEAkQBQ==',
5409         'community playlists': 'EgeKAQQoAEABagoQChADEAQQCRAF',
5410         'featured playlists': 'EgeKAQQoADgBagwQAxAJEAQQDhAKEAU==',
5411         'songs': 'EgWKAQIIAWoKEAoQAxAEEAkQBQ==',
5412         'videos': 'EgWKAQIQAWoKEAoQAxAEEAkQBQ==',
5413     }
5414
5415     def _real_extract(self, url):
5416         qs = parse_qs(url)
5417         query = (qs.get('search_query') or qs.get('q'))[0]
5418         params = qs.get('sp', (None,))[0]
5419         if params:
5420             section = next((k for k, v in self._SECTIONS.items() if v == params), params)
5421         else:
5422             section = compat_urllib_parse_unquote_plus((url.split('#') + [''])[1]).lower()
5423             params = self._SECTIONS.get(section)
5424             if not params:
5425                 section = None
5426         title = join_nonempty(query, section, delim=' - ')
5427         return self.playlist_result(self._search_results(query, params, default_client='web_music'), title, title)
5428
5429
5430 class YoutubeFeedsInfoExtractor(InfoExtractor):
5431     """
5432     Base class for feed extractors
5433     Subclasses must define the _FEED_NAME property.
5434     """
5435     _LOGIN_REQUIRED = True
5436     _TESTS = []
5437
5438     @property
5439     def IE_NAME(self):
5440         return 'youtube:%s' % self._FEED_NAME
5441
5442     def _real_extract(self, url):
5443         return self.url_result(
5444             f'https://www.youtube.com/feed/{self._FEED_NAME}', ie=YoutubeTabIE.ie_key())
5445
5446
5447 class YoutubeWatchLaterIE(InfoExtractor):
5448     IE_NAME = 'youtube:watchlater'
5449     IE_DESC = 'Youtube watch later list; ":ytwatchlater" keyword (requires cookies)'
5450     _VALID_URL = r':ytwatchlater'
5451     _TESTS = [{
5452         'url': ':ytwatchlater',
5453         'only_matching': True,
5454     }]
5455
5456     def _real_extract(self, url):
5457         return self.url_result(
5458             'https://www.youtube.com/playlist?list=WL', ie=YoutubeTabIE.ie_key())
5459
5460
5461 class YoutubeRecommendedIE(YoutubeFeedsInfoExtractor):
5462     IE_DESC = 'YouTube recommended videos; ":ytrec" keyword'
5463     _VALID_URL = r'https?://(?:www\.)?youtube\.com/?(?:[?#]|$)|:ytrec(?:ommended)?'
5464     _FEED_NAME = 'recommended'
5465     _LOGIN_REQUIRED = False
5466     _TESTS = [{
5467         'url': ':ytrec',
5468         'only_matching': True,
5469     }, {
5470         'url': ':ytrecommended',
5471         'only_matching': True,
5472     }, {
5473         'url': 'https://youtube.com',
5474         'only_matching': True,
5475     }]
5476
5477
5478 class YoutubeSubscriptionsIE(YoutubeFeedsInfoExtractor):
5479     IE_DESC = 'YouTube subscriptions feed; ":ytsubs" keyword (requires cookies)'
5480     _VALID_URL = r':ytsub(?:scription)?s?'
5481     _FEED_NAME = 'subscriptions'
5482     _TESTS = [{
5483         'url': ':ytsubs',
5484         'only_matching': True,
5485     }, {
5486         'url': ':ytsubscriptions',
5487         'only_matching': True,
5488     }]
5489
5490
5491 class YoutubeHistoryIE(YoutubeFeedsInfoExtractor):
5492     IE_DESC = 'Youtube watch history; ":ythis" keyword (requires cookies)'
5493     _VALID_URL = r':ythis(?:tory)?'
5494     _FEED_NAME = 'history'
5495     _TESTS = [{
5496         'url': ':ythistory',
5497         'only_matching': True,
5498     }]
5499
5500
5501 class YoutubeTruncatedURLIE(InfoExtractor):
5502     IE_NAME = 'youtube:truncated_url'
5503     IE_DESC = False  # Do not list
5504     _VALID_URL = r'''(?x)
5505         (?:https?://)?
5506         (?:\w+\.)?[yY][oO][uU][tT][uU][bB][eE](?:-nocookie)?\.com/
5507         (?:watch\?(?:
5508             feature=[a-z_]+|
5509             annotation_id=annotation_[^&]+|
5510             x-yt-cl=[0-9]+|
5511             hl=[^&]*|
5512             t=[0-9]+
5513         )?
5514         |
5515             attribution_link\?a=[^&]+
5516         )
5517         $
5518     '''
5519
5520     _TESTS = [{
5521         'url': 'https://www.youtube.com/watch?annotation_id=annotation_3951667041',
5522         'only_matching': True,
5523     }, {
5524         'url': 'https://www.youtube.com/watch?',
5525         'only_matching': True,
5526     }, {
5527         'url': 'https://www.youtube.com/watch?x-yt-cl=84503534',
5528         'only_matching': True,
5529     }, {
5530         'url': 'https://www.youtube.com/watch?feature=foo',
5531         'only_matching': True,
5532     }, {
5533         'url': 'https://www.youtube.com/watch?hl=en-GB',
5534         'only_matching': True,
5535     }, {
5536         'url': 'https://www.youtube.com/watch?t=2372',
5537         'only_matching': True,
5538     }]
5539
5540     def _real_extract(self, url):
5541         raise ExtractorError(
5542             'Did you forget to quote the URL? Remember that & is a meta '
5543             'character in most shells, so you want to put the URL in quotes, '
5544             'like  youtube-dl '
5545             '"https://www.youtube.com/watch?feature=foo&v=BaW_jenozKc" '
5546             ' or simply  youtube-dl BaW_jenozKc  .',
5547             expected=True)
5548
5549
5550 class YoutubeClipIE(InfoExtractor):
5551     IE_NAME = 'youtube:clip'
5552     IE_DESC = False  # Do not list
5553     _VALID_URL = r'https?://(?:www\.)?youtube\.com/clip/'
5554
5555     def _real_extract(self, url):
5556         self.report_warning('YouTube clips are not currently supported. The entire video will be downloaded instead')
5557         return self.url_result(url, 'Generic')
5558
5559
5560 class YoutubeTruncatedIDIE(InfoExtractor):
5561     IE_NAME = 'youtube:truncated_id'
5562     IE_DESC = False  # Do not list
5563     _VALID_URL = r'https?://(?:www\.)?youtube\.com/watch\?v=(?P<id>[0-9A-Za-z_-]{1,10})$'
5564
5565     _TESTS = [{
5566         'url': 'https://www.youtube.com/watch?v=N_708QY7Ob',
5567         'only_matching': True,
5568     }]
5569
5570     def _real_extract(self, url):
5571         video_id = self._match_id(url)
5572         raise ExtractorError(
5573             'Incomplete YouTube ID %s. URL %s looks truncated.' % (video_id, url),
5574             expected=True)