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