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